码迷,mamicode.com
首页 > 其他好文 > 详细

【BZOJ1500】【块状链表】SuperMemo

时间:2015-03-10 21:13:49      阅读:162      评论:0      收藏:0      [点我收藏+]

标签:

Description

技术分享

Input

输入文件的第1行包含两个数N和M,N表示初始时数列中数的个数,M表示要进行的操作数目。第2行包含N个数字,描述初始时的数列。以下M行,每行一条命令,格式参见问题描述中的表格。

Output

对于输入数据中的GET-SUM和MAX-SUM操作,向输出文件依次打印结果,每个答案(数字)占一行。

Sample Input

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

Sample Output

-1
10
1
10

HINT

 

技术分享

 

Source

【分析】
发现大家都是用splay做的,觉得用块状链表好像也可以做,结果真的可以....,捣鼓了一个下午,终于弄出来了.....
其实想好了还是很简单的(那你还做了一个下午,太弱了)。
用论文上的方法进行删除和添加数值,虽然效率有点低下,但是对付这道题还是够了。
因为没有牵涉到合并,因此不会涉及到标记的合并等等。
其实牵涉到了也没关系.....update一下就可以暴力合并,复杂度不会上升。
技术分享
  1 #include <iostream>
  2 #include <cstdio>
  3 #include <algorithm>
  4 #include <cstring>
  5 #include <vector>
  6 #include <utility>
  7 #include <iomanip>
  8 #include <string>
  9 #include <cmath>
 10 #include <queue>
 11 #include <assert.h>
 12 #include <map>
 13 #include <ctime>
 14 #include <cstdlib>
 15 
 16 const int MAXN = 500001;
 17 const int INF = 10000000;
 18 const int SIZE = 1200; 
 19 using namespace std;
 20 struct Node{
 21        int shu[SIZE+2];
 22        int size, sum, samen;
 23        int lmax, rmax, mmax;
 24        Node *l, *r;
 25        bool turn, same;
 26        
 27        Node(){//构造函数 
 28              size = sum = samen = same = 0;
 29              lmax = rmax = mmax = -INF;
 30              l = r = NULL;
 31              turn = 1;
 32        }
 33        //对于两个较小的数列合并也要update 
 34        void update(){
 35             if (same){//是否改为同样的 
 36                for (int i = 1; i <= size; i++) shu[i] = samen;
 37                turn = 1;same = 0;
 38                return;
 39             }
 40             if (!turn){//反转序列 
 41                for (int i = 1; i <= (size>>1);i++) swap(shu[i], shu[size - i + 1]);
 42                swap(lmax, rmax);
 43                turn = 1;
 44             }
 45        }
 46        void Count(){
 47             update();
 48             int t = 0;
 49             sum = 0;
 50             rmax = lmax = mmax = -INF;
 51             //序列中间的一段和 
 52             for (int i = 1; i <= size; i++){
 53                 sum += shu[i];
 54                 t = max(t + shu[i], shu[i]);
 55                 mmax = max(t, mmax);
 56             }
 57             t = 0;
 58             for (int i = 1; i <= size; i++) {t += shu[i]; lmax = max(lmax, t);}t = 0;
 59             for (int i = size; i >= 1; i--) {t += shu[i]; rmax = max(rmax, t);}
 60        }
 61 };
 62 //块状链表
 63 struct Block{
 64        Node *head, *p;
 65        int dir;
 66        
 67        Block(){head = new Node;}
 68        void find(int x){//移动到x所在的块,顺便压缩路径 
 69             int tmp = 0; 
 70             p = head;
 71             while (p->size + tmp < x){
 72                   tmp += p->size;
 73                   if (p->size == 0){
 74                      p = p->l;
 75                      p->r = p->r->r;
 76                      if (p->r != NULL) p->r->l = p; 
 77                   }
 78                   p = p->r;
 79             }
 80             dir = x - tmp;
 81        }
 82        //将a分成a和b两个块 
 83        Node *NEW(Node *&a){
 84             Node *b = new Node;
 85             b->r = a->r;
 86             b->l = a;
 87             if (a->r != NULL) a->r->l = b;
 88             a->r = b;
 89             return b;
 90        }
 91        void Insert(int pos,int size,int *data){ //插入操作
 92             Node *p2;
 93             find(pos);
 94             p->update();
 95             //如果指向中间,就分裂,注意这一段在开头也同样可以操作! 
 96             if (dir != p->size){
 97                //这种操作与普通的块状链表有点不一样,但是更加便于理解 
 98                p2 = NEW(p); 
 99                memcpy(&p2->shu[1], &p->shu[dir + 1], sizeof(int) * (p->size - dir));
100                
101                p2->size = p->size - dir;
102                p->size = dir; 
103                
104                p2->Count();
105                p->Count();
106             } 
107             int i = 1;//插入数列
108             while (i <= size){
109                   int tmp = min(1200 - p->size, size - i + 1);
110                   memcpy(&p->shu[p->size + 1], &data[i], sizeof(int)*tmp);
111                   i += tmp;
112                   p->size += tmp;
113                   if (size >= i){//创建新的列表再加入 
114                      p->Count();
115                      p2 = NEW(p);
116                      p = p2;
117                   }
118             } 
119             p->Count();
120        }
121        void Delete(int pos,int num){
122             Node *p2;
123             find(pos);
124             while (num > 0){
125                   if ((dir == 1) && (num >= p->size)){ 
126                      //删除一个块 
127                      num -= p->size;
128                      if (p->l != NULL) p->l->r = p->r;
129                      else head = p->r;//不然就是表头 
130                      if (p->r != NULL) p->r->l = p->l;
131                      p2 = p;
132                      p = p->r; 
133                      delete p2;
134                   }else{//暴力删除直到一个块 
135                      p->update();
136                      //tmp记录能删除的最远位置 
137                      int tmp = min(dir + num - 1, p->size);
138                      num -= tmp - dir + 1;
139                      for (int i = 1; i <= p->size - tmp; i++) p->shu[dir + i - 1] = p->shu[tmp + i];
140                      p->size -= tmp - dir + 1;
141                      p->Count();
142                      p = p->r;
143                      dir = 1;
144                   }
145             }
146        }
147        //反转操作 
148        void Reverse(int pos, int num){
149             Node *ap,*bp,*cp,*dp;
150             Node *p2;
151             bool first=true;
152             int tmp;
153             find(pos);
154              
155             if (p->size >= dir + num - 1){//直接暴力 
156                p->update();
157                for (int i = 1; i <= (num >> 1); i++) swap(p->shu[dir + num - i], p->shu[dir + i - 1]);
158                p->Count();
159                return;
160             }
161             if (dir > 1){//拆第一块 
162                p->update();
163                num -= p->size - dir + 1;
164                p2 = NEW(p);
165                memcpy(&p2->shu[1], &p->shu[dir], sizeof(int)*(p->size-dir+1));
166                p2->size = p->size - dir + 1;
167                p->size = dir - 1;
168                
169                ap = p2;
170                cp = p;
171                p2->Count();
172                p->Count();
173                p = p2->r; 
174             }else{
175                ap = p;
176                cp = ap->l;
177             }
178             while (num > p->size){
179                   num -= p->size;
180                   p = p->r;
181             }
182             //最后一块也要拆 
183             if (num != p->size){
184                p->update();
185                p2 = NEW(p);
186                memcpy(&p2->shu[1],&p->shu[num+1],sizeof(int)*(p->size-num));
187                p2->size = p->size - num;
188                p->size = num;
189                
190                bp = p;
191                dp = p2;
192                p2->Count();
193                p->Count();
194             }else{
195                //简单的反转一下 
196                bp = p;
197                dp = p->r;
198             }
199             //从开头开始大反转 
200             p = ap;
201             while (1){
202                   swap(p->l, p->r);
203                   p->turn = !p->turn;
204                   swap(p->lmax, p->rmax);
205                   if (p == bp) break;
206                   p = p->l;//注意因为已经换了所以是向左走 
207             }
208             //将整个块倒转 
209             if (cp != NULL) cp->r = bp;
210             else head = bp;
211             ap->r = dp;
212             bp->l = cp;
213             if (dp != NULL) {dp->l = ap;}
214        }
215        //使一段序列变成相同的值 
216        void MakeSame(int pos,int num,int val){
217             find(pos);
218             while (num > 0){
219                   if  ((dir == 1) && (num >= p->size)){
220                       //整块操作 
221                       p->same = 1;
222                       p->samen = val;
223                       p->sum = p->size * val;
224                       p->mmax = max(val, p->sum);//注意因为val可能是负数,所以要这样写 
225                       p->rmax = p->lmax = p->mmax;
226                       num -= p->size;
227                       p = p->r;
228                   }else{
229                       p->update();//暴力操作 
230                       int tmp = min(dir + num - 1, p->size);
231                       for (int i = dir; i <= tmp; i++) p->shu[i] = val;
232                       p->Count();
233                       num -= tmp - dir + 1;
234                       p = p->r;
235                       dir = 1;
236                   }
237             } 
238        } 
239        //区间和 
240        int GetSum(int pos,int x){
241            int tmp = 0;
242            find(pos);
243            while (x > 0){
244                  if ((dir == 1) && (x >= p->size)){
245                     tmp += p->sum;
246                     x -= p->size;
247                     p = p->r; 
248                  }else{ //暴力 
249                     p->Count();
250                     int t = min(dir + x - 1, p->size);
251                     for (int i = dir; i <= t; i++) tmp += p->shu[i];
252                     x -= t - dir + 1;
253                     p = p->r;
254                     dir = 1;
255                  }
256            }
257            return tmp;
258        }
259        //区间最大值 
260        int MaxSum(){
261            int Ans = -INF, last = -INF;
262            p = head;
263            while (p != NULL){
264                  if (p->size != 0){
265                     int tmp;
266                     tmp = max(last + p->sum, max(p->rmax, p->sum));
267                     Ans = max(Ans, max(last + p->lmax, max(tmp, p->mmax)));
268                     last = tmp;
269                  }
270                  p = p->r;
271            }
272            return Ans;
273        }
274 }A;
275 
276 int m, pos;
277 int n,tmp, data[MAXN];
278 char str[20];
279 
280 void init(){
281     scanf("%d%d", &n, &m);
282     for (int i = 1; i <= n; i++) scanf("%d", &data[i]);
283     tmp = 0;
284     A.Insert(tmp, n, data);
285 } 
286 void work(){
287     for (int i = 1; i <= m; i++){
288         scanf("%s", str);
289         if (str[2] != X) scanf("%d%d", &pos, &n);
290         if (str[2] == S){
291            for (int i = 1; i <= n; i++) scanf("%d", &data[i]);
292            A.Insert(pos, n, data);
293         }else if (str[2] == L) A.Delete(pos, n);
294         else if (str[2] == K) {
295              int tmp;
296              scanf("%d", &tmp);
297              A.MakeSame(pos, n, tmp);
298         }else if (str[2] == T) printf("%d\n", A.GetSum(pos, n));
299         else if (str[2] == V) A.Reverse(pos,n);
300         else if (str[2] == X) printf("%d\n", A.MaxSum());
301     }
302 }
303 
304 int main(){
305     #ifdef LOCAL
306     freopen("data.txt", "r", stdin);
307     freopen("out.txt", "w", stdout);
308     #endif
309     init();
310     work();
311     return 0;
312 }
View Code

 

【BZOJ1500】【块状链表】SuperMemo

标签:

原文地址:http://www.cnblogs.com/hoskey/p/4328294.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!