POJ3468-A Simple Problem with Integers

最新推荐文章于 2022-12-09 12:45:57 发布

最新推荐文章于 2022-12-09 12:45:57 发布 · 255 阅读

POJ 同时被 3 个专栏收录

159 篇文章

订阅专栏

----线段树

83 篇文章

订阅专栏

----Splay

2 篇文章

订阅专栏

本文介绍了一种使用线段树和伸展树解决区间加法及区间求和问题的方法。通过两个具体的实现案例，展示了如何高效地处理这类问题，并提供源代码以供读者学习和参考。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A Simple Problem with Integers

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 103367		Accepted: 32295
Case Time Limit: 2000MS

Description

You have N integers, A₁, A₂, ... , A_N. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A₁, A₂, ... , A_N. -1000000000 ≤ A_i ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of A_a, A_a₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of A_a, A_a₊₁, ... , A_b.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output

Hint

The sums may exceed the range of 32-bit integers.

Source

POJ Monthly--2007.11.25, Yang Yi

题意：给定N个数的序列，有Q个操作。操作分两种：1、将某个区间内的所有数都加上某个数。2、计算某个区间的所有数之和并输出。

解题思路：线段树。单点更新会TLE，只能区间更新，每个节点加一个延迟标记来记录增量

线段树：

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <queue>
#include <vector>
#include <set>
#include <stack>
#include <map>
#include <climits>

using namespace std;

#define LL long long
const int INF=0x3f3f3f3f;
const int MAXN=100001;
int a[MAXN];

struct node
{
    int l,r;
    LL flag,sum;
}b[MAXN*4];

void build(int k,int l,int r)
{
    b[k].l=l,b[k].r=r,b[k].flag=0;
    if(l==r)
    {
        b[k].sum=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    b[k].sum=b[k<<1].sum+b[k<<1|1].sum;
}

long long query(int k,int l,int r)
{
    if(b[k].l>=l&&b[k].r<=r) return b[k].sum;
    if(b[k].flag)
    {
        b[k<<1].flag+=b[k].flag;
        b[k<<1|1].flag+=b[k].flag;
        b[k<<1].sum+=b[k].flag*(b[k<<1].r-b[k<<1].l+1);
        b[k<<1|1].sum+=b[k].flag*(b[k<<1|1].r-b[k<<1|1].l+1);
        b[k].flag=0;
    }
    int mid=(b[k].l+b[k].r)>>1;
    LL ans=0;
    if(mid>=l) ans+=query(k<<1,l,r);
    if(mid<r) ans+=query(k<<1|1,l,r);
    return ans;
}

void update(int k,int l,int r,long long v)
{
    if(b[k].l>=l&&b[k].r<=r)
    {
        b[k].flag+=v;
        b[k].sum+=v*(b[k].r-b[k].l+1);
        return;
    }
    if(b[k].flag)
    {
        b[k<<1].flag+=b[k].flag;
        b[k<<1|1].flag+=b[k].flag;
        b[k<<1].sum+=b[k].flag*(b[k<<1].r-b[k<<1].l+1);
        b[k<<1|1].sum+=b[k].flag*(b[k<<1|1].r-b[k<<1|1].l+1);
        b[k].flag=0;
    }
    int mid=(b[k].l+b[k].r)>>1;
    if(mid>=l) update(k<<1,l,r,v);
    if(mid<r) update(k<<1|1,l,r,v);
    b[k].sum=b[k<<1].sum+b[k<<1|1].sum;
}

int main()
{
    int n,q;
    while(~scanf("%d %d",&n,&q))
    {
        for (int i=1;i<=n;i++) scanf("%d",&a[i]);
        build(1,1,n);
        string s;
        int l,r;
        LL v;
        while(q--)
        {
            cin>>s;
            scanf("%d %d",&l,&r);
            if(s=="Q") printf("%lld\n", query(1,l,r));
            else
            {
                scanf("%lld",&v);
                if(v) update(1,l,r,v);
            }
        }
    }
    return 0;
}

Splay（练手题）：

#include <iostream>     
#include <cstdio>     
#include <cstring>     
#include <string>     
#include <algorithm>     
#include <map>     
#include <set>     
#include <stack>     
#include <queue>     
#include <vector>     
#include <bitset>     
#include <functional>  

using namespace std;

#define LL long long  

const int maxn = 2e5 + 10;
int n, m, l, r, v, root, a[maxn];
char ch[10];

struct Splays
{
	const static int maxn = 2e5 + 10;
	const static int INF = 0x7FFFFFFF;
	int son[maxn][2], fa[maxn], tot;
	int val[maxn], id[maxn], cnt[maxn], lazy[maxn];
	LL sum[maxn];

	int Node(int k, int f, int v)
	{
		son[tot][0] = son[tot][1] = lazy[tot] = 0;
		fa[tot] = f, val[tot] = sum[tot] = v;
		cnt[tot] = 1, id[tot] = k;
		return tot++;
	}

	void clear()
	{
		son[0][0] = son[0][1] = fa[0] = lazy[0] = val[0] = sum[0] = cnt[0] = id[0] = 0;
		tot = 1;
	}

	void rotate(int k, int p)
	{
		int y = fa[k];
		son[y][!p] = son[k][p], fa[son[k][p]] = y;
		if (fa[y]) son[fa[y]][y == son[fa[y]][1]] = k;
		fa[k] = fa[y], fa[y] = k, son[k][p] = y;
		cnt[k] = cnt[y], cnt[y] = cnt[son[y][0]] + cnt[son[y][1]] + 1;
		sum[k] = sum[y], sum[y] = sum[son[y][0]] + sum[son[y][1]] + val[y];
	}

	void Splay(int k, int p)
	{
		for (int f = fa[p]; fa[k] != f;)
		{
			if (fa[fa[k]] == f) { rotate(k, k == son[fa[k]][0]); return; }
			int y = (k == son[fa[k]][0]), z = (fa[k] == son[fa[fa[k]]][0]);
			y^z ? (rotate(k, y), rotate(k, z)) : (rotate(fa[k], z), rotate(k, y));
		}
	}

	void build(int &k, int l, int r, int f)
	{
		if (l > r) return;
		int mid = l + r >> 1;
		k = Node(mid, f, a[mid]);
		build(son[k][0], l, mid - 1, k);
		build(son[k][1], mid + 1, r, k);
		cnt[k] += cnt[son[k][0]] + cnt[son[k][1]];
		sum[k] += sum[son[k][0]] + sum[son[k][1]];
	}

	void Push(int k)
	{
		if (son[k][0]) lazy[son[k][0]] += lazy[k], sum[son[k][0]] += 1LL * lazy[k] * cnt[son[k][0]];
		if (son[k][1]) lazy[son[k][1]] += lazy[k], sum[son[k][1]] += 1LL * lazy[k] * cnt[son[k][1]];
		val[k] += lazy[k], lazy[k] = 0;
	}

	void update(int &k, int p)
	{
		for (int i = k; i; i = son[i][id[i] < p])
		{
			if (lazy[i]) Push(i);
			if (id[i] == p)
			{
				Splay(i, k), k = i;
				break;
			}
		}
	}

	void change(int &k, int l, int r, int v)
	{
		update(k, l - 1);
		update(son[k][1], r + 1);
		lazy[son[son[k][1]][0]] += v;
		sum[son[son[k][1]][0]] += 1LL * v * cnt[son[son[k][1]][0]];
		sum[son[k][1]] += 1LL * v * cnt[son[son[k][1]][0]];
		sum[k] += 1LL * v * cnt[son[son[k][1]][0]];
	}

	void find(int &k, int l, int r)
	{
		update(k, l - 1);
		update(son[k][1], r + 1);
		printf("%lld\n", sum[son[son[k][1]][0]]);
	}
}solve;

int main()
{
	while (~scanf("%d%d", &n, &m))
	{
		solve.clear();
		a[0] = a[n + 1] = root = 0;
		for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
		solve.build(root, 0, n + 1, 0);
		while (m--)
		{
			scanf("%s%d%d", ch, &l, &r);
			if (ch[0] == 'Q') solve.find(root, l, r);
			else
			{
				scanf("%d", &v);
				solve.change(root, l, r, v);
			}
		}
	}
	return 0;
}