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.

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.

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

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

POJ Monthly--2007.11.25, Yang Yi

View Code

/*
 * POJ 3468 A Simple Problem with Integers
 * 經典的線段樹題目，用splay tree來作為入門題
 * 成段更新+區間求和
 * 題目給定了n個數A1,A2,...An，有以下兩種操作
 * C a b c:把c加入到Aa,Aa+1,..Ab中
 * Q a b:查詢Aa,Aa+1,..Ab的和
 * 需要的變量：pre,ch,size(這三個基本都要),key(保存結點的值),sum(子樹值和),add(增量的標記)
 * (一般標記類，正確的做法都是要先更新掉該點，標記是標記沒有更新子結點)
 */

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define Key_value ch[ch[root][1]][0]
const int MAXN=100010;
int pre[MAXN],ch[MAXN][2],size[MAXN],root,tot1;//父結點、左右孩子、子樹規模、根結點、結點數量
int key[MAXN];//該點的值
int add[MAXN];//增量的延遲標記
long long sum[MAXN];//子樹的和
int s[MAXN],tot2;//內存池、內存池容量（這題用不到，如果有刪除操作，內存不夠可以這樣

int a[MAXN];//初始的數組，建樹時候用
int n,q;
//debug部分
void Treavel(int x)
{
    if(x)
    {
        Treavel(ch[x][0]);
        printf("結點%2d:左兒子 %2d 右兒子 %2d 父結點 %2d size=%2d,key=%2d add=%2d sum=%I64d\n",x,ch[x][0],ch[x][1],pre[x],size[x],key[x],add[x],sum[x]);
        Treavel(ch[x][1]);
    }
}
void debug()
{
    printf("root:%d\n",root);
    Treavel(root);
}
//以上是debug
void NewNode(int &r,int father,int k)//一個是調用的時候注意變量順序，還有r必須引用&
{
    if(tot2)r=s[tot2--];//取得時候是tot2--,那么存的時候就要是++tot2
    else r=++tot1;
    pre[r]=father;
    size[r]=1;//這個不能忘記 ,一定是1，否則可能出錯
    key[r]=k;
    add[r]=0;
    sum[r]=0;
    ch[r][0]=ch[r][1]=0;
}
//給r為根的子樹增加值，一定把當前結點的全部更新掉，再加個延遲標記表示兒子結點沒有更新
void Update_Add(int r,int ADD)
{
    if(r==0)return;
    add[r]+=ADD;
    key[r]+=ADD;
    sum[r]+=(long long)ADD*size[r];
}
//通過孩子結點更新父親結點
void Push_Up(int r)
{
    size[r]=size[ch[r][0]]+size[ch[r][1]]+1;
    sum[r]=sum[ch[r][0]]+sum[ch[r][1]]+key[r];
}
//將延遲標記更新到孩子結點
void Push_Down(int r)
{
    if(add[r])
    {
        Update_Add(ch[r][0],add[r]);
        Update_Add(ch[r][1],add[r]);
        add[r]=0;
    }
}
//建樹
//先建立中間結點，再兩端的方法
void Build(int &x,int l,int r,int father)
{
    if(l>r)return;
    int mid=(l+r)/2;
    NewNode(x,father,a[mid]);
    Build(ch[x][0],l,mid-1,x);
    Build(ch[x][1],mid+1,r,x);
    Push_Up(x);
}
//初始化，前后各加一個king結點
void Init()
{
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    root=tot1=tot2=0;
    ch[root][0]=ch[root][1]=pre[root]=size[root]=add[root]=sum[root]=0;
    key[root]=0;
    NewNode(root,0,-1);
    NewNode(ch[root][1],root,-1);//頭尾各加入一個空位
    Build(Key_value,1,n,ch[root][1]);
    Push_Up(ch[root][1]);
    Push_Up(root);
}
//旋轉，0為左旋，1為右旋  該部分基本固定
void Rotate(int x,int kind)
{
    int y=pre[x];
    Push_Down(y);
    Push_Down(x);//先把y的標記向下傳遞，再把x的標記往下傳遞
    ch[y][!kind]=ch[x][kind];
    pre[ch[x][kind]]=y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=x;
    pre[x]=pre[y];
    ch[x][kind]=y;
    pre[y]=x;
    Push_Up(y);//維護y結點
}
//Splay調整，將結點r調整到goal下面
void Splay(int r,int goal)
{
    Push_Down(r);
    while(pre[r]!=goal)
    {
        if(pre[pre[r]]==goal)
            Rotate(r,ch[pre[r]][0]==r);
        else
        {
            int y=pre[r];
            int kind=ch[pre[y]][0]==y;
            if(ch[y][kind]==r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    Push_Up(r);
    if(goal==0)root=r;
}
//得到第k個結點
int Get_Kth(int r,int k)
{
    Push_Down(r);
    int t=size[ch[r][0]]+1;
    if(t==k)return r;
    if(t>k)return Get_Kth(ch[r][0],k);
    else return Get_Kth(ch[r][1],k-t);
}
int Get_Min(int r)
{
    Push_Down(r);
    while(ch[r][0])
    {
        r=ch[r][0];
        Push_Down(r);
    }
    return r;
}
int Get_Max(int r)
{
    Push_Down(r);
    while(ch[r][1])
    {
        r=ch[r][1];
        Push_Down(r);
    }
    return r;
}
//區間增加一個值
//注意因為在前面增加了個結點，所以把第l個結點旋轉到根結點，第r+2個結點旋轉到根結點的右孩子，
//那么Key_value(ch[ch[root][1]][0]剛好就是區間[l,r]
void ADD(int l,int r,int D)
{
    Splay(Get_Kth(root,l),0);//第l個點到根結點
    Splay(Get_Kth(root,r+2),root);//第r+2個點到根結點的右孩子
    Update_Add(Key_value,D);
    Push_Up(ch[root][1]);
    Push_Up(root);
}
//查詢區間的和
long long Query_Sum(int l,int r)
{
    Splay(Get_Kth(root,l),0);//第l個點到根結點
    Splay(Get_Kth(root,r+2),root);//第r+2個點到根結點的右孩子
    return sum[Key_value];
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(scanf("%d%d",&n,&q)==2)
    {
        Init();//這個不能忘記
        while(q--)
        {
            char op[20];
            int x,y,z;
            scanf("%s",op);
            if(op[0]=='Q')
            {
                scanf("%d%d",&x,&y);
                printf("%I64d\n",Query_Sum(x,y));
            }
            else
            {
                scanf("%d%d%d",&x,&y,&z);
                ADD(x,y,z);
            }
        }
    }
    return 0;
}

2、營業額統計（一個一個數插入，找出和這個數最接近的）

營業額統計

Description

營業額統計 Tiger最近被公司升任為營業部經理，他上任后接受公司交給的第一項任務便是統計並分析公司成立以來的營業情況。 Tiger拿出了公司的賬本，賬本上記錄了公司成立以來每天的營業額。分析營業情況是一項相當復雜的工作。由於節假日，大減價或者是其他情況的時候，營業額會出現一定的波動，當然一定的波動是能夠接受的，但是在某些時候營業額突變得很高或是很低，這就證明公司此時的經營狀況出現了問題。經濟管理學上定義了一種最小波動值來衡量這種情況：該天的最小波動值當最小波動值越大時，就說明營業情況越不穩定。而分析整個公司的從成立到現在營業情況是否穩定，只需要把每一天的最小波動值加起來就可以了。你的任務就是編寫一個程序幫助Tiger來計算這一個值。第一天的最小波動值為第一天的營業額。 l 輸入輸出要求

Input

第一行為正整數，表示該公司從成立一直到現在的天數，接下來的n行每行有一個正整數，表示第i天公司的營業額。

Output

輸出文件僅有一個正整數，即Sigma(每天最小的波動值) 。結果小於2^31 。

Sample Input

6

5

1

2

5

4

6

Sample Output

12

Hint

結果說明：5+|1-5|+|2-1|+|5-5|+|4-5|+|6-5|=5+4+1+0+1+1=12

這道題目很其他的比起來太簡單了。。。

隨便寫、、

View Code

/*
 * 這題的意思就是每插入一個數，累加和前面插入的數的差值。第一個數加本身。
 * 用splay tree找尋前驅和后繼。
 * 但是這題的splay tree按照key值得大小建立。
 * 我的做法是把這個數插入進去，找前驅和后繼，其中一個就是最接近的了。
 * 這樣做有了重復的元素，但是沒有影響的
 * 這種題目用STL的set 、 SBT等都很好過了
 */
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int MAXN=1000010;
int pre[MAXN],ch[MAXN][2],key[MAXN];
int root,tot1;

void NewNode(int &r,int father,int k)
{
    r=++tot1;
    pre[r]=father;
    ch[r][0]=ch[r][1]=0;
    key[r]=k;
}
void Init()
{
    root=tot1=0;
    ch[root][0]=ch[root][1]=key[root]=pre[root]=0;
}
//旋轉
void Rotate(int x,int kind)
{
    int y=pre[x];
    ch[y][!kind]=ch[x][kind];
    pre[ch[x][kind]]=y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=x;
    pre[x]=pre[y];
    ch[x][kind]=y;
    pre[y]=x;
}
//Splay調整
void Splay(int r,int goal)
{
    while(pre[r]!=goal)
    {
        if(pre[pre[r]]==goal)
            Rotate(r,ch[pre[r]][0]==r);
        else
        {
            int y=pre[r];
            int kind=ch[pre[y]][0]==y;
            if(ch[y][kind]==r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    if(goal==0)root=r;
}
void Insert(int k)//插入一個值為k的結點
{
    int r=root;
    if(r==0)
    {
        NewNode(root,0,k);
        return;
    }
    while(ch[r][key[r]<k])
    {
        r=ch[r][key[r]<k];
    }
    NewNode(ch[r][key[r]<k],r,k);
    Splay(ch[r][key[r]<k],0);
}
int Get_Min(int r)
{
    while(ch[r][0])
    {
        r=ch[r][0];
    }
    return r;
}
int Get_Max(int r)
{
    while(ch[r][1])
    {
        r=ch[r][1];
    }
    return r;
}
int main()
{
    int n;
    scanf("%d",&n);
    int num;
    int ans=0;
    for(int i=1;i<=n;i++)
    {
        if(scanf("%d",&num)==EOF)num=0;
        Insert(num);
        if(i==1)
        {
            ans+=num;
        }
        else
        {
            int tmp=INF;
            if(ch[root][0])
                tmp=min(tmp,key[root]-key[Get_Max(ch[root][0])]);
            if(ch[root][1])
                tmp=min(tmp,key[Get_Min(ch[root][1])]-key[root]);
            ans+=tmp;
        }
    }
    printf("%d\n",ans);
    return 0;
}

3、HDU 1890 Robotic Sort（區間反轉、刪除根結點）

Robotic Sort

Time Limit: 6000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1403 Accepted Submission(s): 592

Problem Description

Somewhere deep in the Czech Technical University buildings, there are laboratories for examining mechanical and electrical properties of various materials. In one of yesterday’s presentations, you have seen how was one of the laboratories changed into a new multimedia lab. But there are still others, serving to their original purposes.

In this task, you are to write software for a robot that handles samples in such a laboratory. Imagine there are material samples lined up on a running belt. The samples have different heights, which may cause troubles to the next processing unit. To eliminate such troubles, we need to sort the samples by their height into the ascending order.

Reordering is done by a mechanical robot arm, which is able to pick up any number of consecutive samples and turn them round, such that their mutual order is reversed. In other words, one robot operation can reverse the order of samples on positions between A and B.

A possible way to sort the samples is to find the position of the smallest one (P1) and reverse the order between positions 1 and P1, which causes the smallest sample to become first. Then we find the second one on position P and reverse the order between 2 and P2. Then the third sample is located etc.

The picture shows a simple example of 6 samples. The smallest one is on the 4th position, therefore, the robot arm reverses the first 4 samples. The second smallest sample is the last one, so the next robot operation will reverse the order of five samples on positions 2–6. The third step will be to reverse the samples 3–4, etc.

Your task is to find the correct sequence of reversal operations that will sort the samples using the above algorithm. If there are more samples with the same height, their mutual order must be preserved: the one that was given first in the initial order must be placed before the others in the final order too.

Input

The input consists of several scenarios. Each scenario is described by two lines. The first line contains one integer number N , the number of samples, 1 ≤ N ≤ 100 000. The second line lists exactly N space-separated positive integers, they specify the heights of individual samples and their initial order.

The last scenario is followed by a line containing zero.

Output

For each scenario, output one line with exactly N integers P1 , P1 , . . . PN ,separated by a space.
Each Pi must be an integer (1 ≤ Pi ≤ N ) giving the position of the i-th sample just before the i-th reversal operation.

Note that if a sample is already on its correct position Pi , you should output the number Pi anyway, indicating that the “interval between Pi and Pi ” (a single sample) should be reversed.

Sample Input

6 3 4 5 1 6 2 4 3 3 2 1 0

Sample Output

4 6 4 5 6 6 4 2 4 4

Source

2008 “Shun Yu Cup” Zhejiang Collegiate Programming Contest - Warm Up（2）

Recommend

linle

主要是想法比較好，反正和刪除是很典型的操作了。

反轉的splay時候一定要先push_down下去，再判斷。

View Code

/*
 * HDU 1890 Robotic Sort
 * 這題就是對 n個不同的數的排序過程，通過旋轉將第i到的數放在正確的位置，題目就是輸出每次旋轉前第i大的數的位置。
 * 這題的意思就是直接按照結點編號1-n建立一顆樹。每個數代表初始位置的那個點，記錄下每個數對應的點。
 * 每一次就是把第i大的數旋轉到根結點。刪除這個點然后旋轉左區間。
 * 其實也可以用區間模擬，不刪除的做法。
 * 操作有：反轉、刪除根結點
 * 需要的變量:pre,ch,size,rev;
 */
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN=100010;
int pre[MAXN],ch[MAXN][2],size[MAXN],rev[MAXN];
int root,tot1;
int n;
void NewNode(int &r,int father,int k)
{
    r=k;
    pre[r]=father;
    ch[r][0]=ch[r][1]=0;
    size[r]=1;
    rev[r]=0;
}
//反轉的更新
void Update_Rev(int r)
{
    if(!r)return;
    swap(ch[r][0],ch[r][1]);
    rev[r]^=1;
}
void Push_Up(int r)
{
    size[r]=size[ch[r][0]]+size[ch[r][1]]+1;
}
void Push_Down(int r)
{
    if(rev[r])
    {
        Update_Rev(ch[r][0]);
        Update_Rev(ch[r][1]);
        rev[r]=0;
    }
}
void Build(int &x,int l,int r,int father)
{
    if(l>r)return;
    int mid=(l+r)/2;
    NewNode(x,father,mid);
    Build(ch[x][0],l,mid-1,x);
    Build(ch[x][1],mid+1,r,x);
    Push_Up(x);//這個不用忘記
}
void Init()
{
    root=tot1=0;
    ch[root][0]=ch[root][1]=size[root]=rev[root]=0;
    Build(root,1,n,0);
}
//旋轉，基本固定
void Rotate(int x,int kind)
{
    int y=pre[x];
    Push_Down(y);
    Push_Down(x);
    ch[y][!kind]=ch[x][kind];
    pre[ch[x][kind]]=y;
    if(pre[y])
        ch[pre[y]][ch[pre[y]][1]==y]=x;
    pre[x]=pre[y];
    ch[x][kind]=y;
    pre[y]=x;
    Push_Up(y);
}
//Splay調整
void Splay(int r,int goal)
{
    Push_Down(r);
    while(pre[r]!=goal)
    {
        if(pre[pre[r]]==goal)
        {
            //這題有反轉操作，需要先push_down,在判斷左右孩子
            Push_Down(pre[r]);
            Push_Down(r);
            Rotate(r,ch[pre[r]][0]==r);
        }

        else
        {
            //這題有反轉操作，需要先push_down,在判斷左右孩子
            Push_Down(pre[pre[r]]);
            Push_Down(pre[r]);
            Push_Down(r);
            int y=pre[r];
            int kind=(ch[pre[y]][0]==y);
            //兩個方向不同，則先左旋再右旋
            if(ch[y][kind]==r)
            {
                Rotate(r,!kind);
                Rotate(r,kind);
            }
            //兩個方向相同，相同方向連續兩次
            else
            {
                Rotate(y,kind);
                Rotate(r,kind);
            }
        }
    }
    Push_Up(r);
    if(goal==0)root=r;
}
int Get_Min(int r)
{
    Push_Down(r);
    while(ch[r][0])
    {
        r=ch[r][0];
        Push_Down(r);
    }
    return r;
}
int Get_Max(int r)
{
    Push_Down(r);
    while(ch[r][1])
    {
        r=ch[r][1];
        Push_Down(r);
    }
    return r;
}
//刪除根結點
void Remove()
{
    if(ch[root][0]==0)//沒有左孩子
    {
        root=ch[root][1];
        pre[root]=0;
    }
    else
    {
        int m=Get_Max(ch[root][0]);
        Splay(m,root);
        ch[m][1]=ch[root][1];
        pre[ch[root][1]]=m;
        root=m;
        pre[root]=0;
        Push_Up(root);//要更新
    }
}
struct Node
{
    int id,num;
}a[MAXN];
bool cmp(Node n1,Node n2)
{
    if(n1.num!=n2.num)return n1.num<n2.num;
    else return n1.id<n2.id;
}
int main()
{
    while(scanf("%d",&n)==1&&n)
    {
        Init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i].num);
            a[i].id=i;
        }
        sort(a+1,a+1+n,cmp);
        for(int i=1;i<n;i++)
        {
            Splay(a[i].id,0);
            Update_Rev(ch[root][0]);
            printf("%d ",i+size[ch[root][0]]);
            Remove();
        }
        printf("%d\n",n);
    }
    return 0;
}

Your friend, Jackson is invited to a TV show called SuperMemo in which the participant is told to play a memorizing game. At first, the host tells the participant a sequence of numbers, {A₁, A₂, ... A_n}. Then the host performs a series of operations and queries on the sequence which consists:

ADD x y D: Add D to each number in sub-sequence {A_x ... A_y}. For example, performing "ADD 2 4 1" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5, 5}
REVERSE x y: reverse the sub-sequence {A_x ... A_y}. For example, performing "REVERSE 2 4" on {1, 2, 3, 4, 5} results in {1, 4, 3, 2, 5}
REVOLVE x y T: rotate sub-sequence {A_x ... A_y} T times. For example, performing "REVOLVE 2 4 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 2, 5}
INSERT x P: insert P after A_x. For example, performing "INSERT 2 4" on {1, 2, 3, 4, 5} results in {1, 2, 4, 3, 4, 5}
DELETE x: delete A_x. For example, performing "DELETE 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5}
MIN x y: query the participant what is the minimum number in sub-sequence {A_x ... A_y}. For example, the correct answer to "MIN 2 4" on {1, 2, 3, 4, 5} is 2

To make the show more interesting, the participant is granted a chance to turn to someone else that means when Jackson feels difficult in answering a query he may call you for help. You task is to watch the TV show and write a program giving the correct answer to each query in order to assist Jackson whenever he calls.

The first line contains n (n ≤ 100000).

The following n lines describe the sequence.

Then follows M (M ≤ 100000), the numbers of operations and queries.

The following M lines describe the operations and queries.

For each "MIN" query, output the correct answer.

Time Limit: 5000MS		Memory Limit: 131072K
Total Submissions: 41977		Accepted: 12207
Case Time Limit: 2000MS

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 5839		Accepted: 1884
Case Time Limit: 2000MS

Splay Tree（伸展樹總結）

Robotic Sort

Play with Chain

Queue-jumpers

免責聲明！