ACM: Copying Data 线段树-成段更新-解题报告

Copying Data
Time Limit:2000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u
 
Description
We often have to copy large volumes of information. Such operation can take up many computer resources. Therefore, in this problem you are advised to come up with a way to copy some part of a number array into another one, quickly.

More formally, you've got two arrays of integers a1, a2, ..., an and b1, b2, ..., bn of length n. Also, you've got m queries of two types:

Copy the subsegment of array a of length k, starting from position x, into array b, starting from position y, that is, execute by + q = ax + q for all integer q(0 ≤ q < k). The given operation is correct — both subsegments do not touch unexistent elements.
Determine the value in position x of array b, that is, find value bx.
For each query of the second type print the result — the value of the corresponding element of array b.

Input
The first line contains two space-separated integers n and m(1 ≤ n, m ≤ 105) — the number of elements in the arrays and the number of queries, correspondingly. The second line contains an array of integers a1, a2, ..., an(|ai| ≤ 109). The third line contains an array of integers b1, b2, ..., bn(|bi| ≤ 109).

Next m lines contain the descriptions of the queries. The i-th line first contains integer ti — the type of the i-th query (1 ≤ ti ≤ 2). If ti = 1, then the i-th query means the copying operation. If ti = 2, then the i-th query means taking the value in array b. If ti = 1, then the query type is followed by three integers xi, yi, ki(1 ≤ xi, yi, ki ≤ n) — the parameters of the copying query. If ti = 2, then the query type is followed by integer xi(1 ≤ xi ≤ n) — the position in array b.

All numbers in the lines are separated with single spaces. It is guaranteed that all the queries are correct, that is, the copying borders fit into the borders of arrays a and b.


Output
For each second type query print the result on a single line.

Sample Input

Input
5 10
1 2 0 -1 3
3 1 5 -2 0
2 5
1 3 3 3
2 5
2 4
2 1
1 2 1 4
2 1
2 4
1 4 2 1
2 2

Output
0
3
-1
3
2
3
-1

这个题目很无语，读题读了块一个小时，发现不知道怎么去成段替换觉得用lazy不适合，后来日天大神跟我讲了一下用lazy的方法，秒懂。

但是写着写着发现有点乱了思路，又重新写了一遍写了1个小时，过了样例后WA了一次，不知道调哪里，然后自己跟着题目注释，突然发现lazy的变化规律越来越清晰。

果然思路混乱就去打注释才是最好的方法！

下面是写了我一个下午加晚上的题目的AC代码：

 

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

#include"iostream" #include"algorithm" #include"cstdio" #include"cmath" #include"cstring" #define MX 110000 #define INF 0x3f3f3f3f #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 using namespace std; /*   题目没看懂百度了题意和思路： 给你两个数字序列a[]和lazy[]，有两种操作， 一种是把起点为xi,长度为k的a[]的一段复制给以yi为起点，长度为k的lazy[] 还有一种操作是询问当前lazy[x]的数字是什么。   思路： 这道题可以用线段树成段更新做，属于染色一类线段树题目 可以这么想，对于任意一个数，记录它有没有被a[]的其中一段覆盖了 如果被覆盖了，可以记录它被覆盖的a[]的那段的起点st以及lazy[]被覆盖的起点ed 如果被覆盖，那么最后结果就是a[x1+ed-st]。   st表示这一线段是否被a[]数组覆盖，如果没有覆盖，那么st=0 如果覆盖，那么被a[]覆盖的区间范围是a[st]~a[st+k-1],ed同理,只不过记录的是lazy[]的开始位置。   对于操作1，输入x1,y1,k,只要使得区间[y1,y1+k-1]的st变成x1,ed变成y1. 对于操作2，输入x1,在线段树中寻找，如果这一点(即[x1,x1])的st是0，就输出c[x1]，否则输出a[x1+ed-st].   */   int a[MX],b[MX]; int st1,st2; int k; struct tree {     int l,r,st,ed; } lazy[MX<<2];     void Build(int l,int r,int rt) {     lazy[rt].l=l;       //标记每个的位置     lazy[rt].r=r;     lazy[rt].st=lazy[rt].ed=0;      //清空左右标记     if(l==r)return;     int m=(l+r)>>1;     Build(lson);     Build(rson); }   void PushDown(int rt){     if(lazy[rt].st!=-1) {       //如果节点发生的变化         lazy[rt<<1].st=lazy[rt<<1|1].st=lazy[rt].st;    //标记下移         lazy[rt<<1].ed=lazy[rt<<1|1].ed=lazy[rt].ed;         lazy[rt].st=lazy[rt].ed=-1;     } }   void UpData(int x1,int y1,int l,int r,int rt) {     if(lazy[rt].st==x1 && lazy[rt].ed==y1)return;   //如果节点的变化重复，直接返回     if(lazy[rt].l==l && lazy[rt].r==r) {        //如果查询到了目标的lazy点         lazy[rt].st=x1;                 //将lazy点的左右端点更新         lazy[rt].ed=y1;         return;     }     PushDown(rt);     int m=(lazy[rt].l+lazy[rt].r)>>1;     if(r<=m) UpData(x1,y1,l,r,rt<<1);          //如果中点在右边，向左查询更新     else if(l>m) UpData(x1,y1,l,r,rt<<1|1);    //如果中点在左边，向右查询更新     else {         UpData(x1,y1,lson);        //如果中点在中间，向两边去更新         UpData(x1,y1,rson);     } }     void Query(int x,int rt) {     if(lazy[rt].st!=-1) {         st1=lazy[rt].st; //【一开始用的是 tree 类型函数返回 一个节点，蜜汁出错。最后还是换成全局整型来标记。】         st2=lazy[rt].ed;         return;     }     int m=(lazy[rt].l+lazy[rt].r)>>1;     if(x<=m) Query(x,rt<<1);            else Query(x,rt<<1|1); }     int main() {     int n,m,op,x,x1,y1;     while(~scanf("%d%d",&n,&m)) {         for(int i=1; i<=n; i++) {             scanf("%d",&a[i]);         }         for(int i=1; i<=n; i++) {             scanf("%d",&b[i]);         }         Build(1,n,1);         while(m--) {             scanf("%d",&op);             if(op==1) {                 scanf("%d%d%d",&x1,&y1,&k);                 UpData(x1,y1,y1,y1+k-1,1);             } else if(op==2) {                 scanf("%d",&x);                 st1=st2=0;                 Query(x,1);                 if(st1==0) {                     printf("%d\n",b[x]);//如果这点没有标记，则说明没有移动过这点，输出b[aa]；                 } else {                     printf("%d\n",a[x-st2+st1]);//否则这点就移动过输出移动区间后的值也就是a[aa-Q.ed+Q.st]；                 }             }         }     }     return 0; }