zoj 3765 块状链表 OR splay

最新推荐文章于 2018-08-17 09:48:24 发布
最新推荐文章于 2018-08-17 09:48:24 发布
阅读量122 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/huoxiayu/p/4736490.html
版权

各种操作o(╯□╰)o...不过都挺简单，不需要lazy标记。

方法1：块状链表

块状链表太强大了，区间操作实现起来简单暴力，效率比splay稍微慢一点，内存开销小很多。

  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdio>
  4 using namespace std;
  5 
  6 const int N = 900;
  7 const int LOW = 260;
  8 const int UP = 320;
  9 int sz[N];
 10 int next[N];
 11 int g[N][2];
 12 int n, m, ps, bl;
 13 
 14 struct B
 15 {
 16     int v, s;
 17 } b[N][N];
 18 
 19 int gcd( int x, int y )
 20 {
 21     if ( y ) return gcd( y, x % y );
 22     return x;
 23 }
 24 
 25 void update( int cur, int stu )
 26 {
 27     g[cur][stu] = 0;
 28     for ( int i = 0; i < sz[cur]; i++ )
 29     {
 30         if ( b[cur][i].s == stu )
 31         {
 32             g[cur][stu] = gcd( g[cur][stu], b[cur][i].v );
 33         }
 34     }
 35 }
 36 
 37 void spilt( int cur )
 38 {
 39     int tmp = next[cur];
 40     int ncur = bl++;
 41     next[cur] = ncur;
 42     next[ncur] = tmp;
 43     for ( int i = sz[cur] / 2; i < sz[cur]; i++ )
 44     {
 45         b[ncur][sz[ncur]++] = b[cur][i];
 46     }
 47     sz[cur] = sz[cur] / 2;
 48     update( cur, 0 );
 49     update( cur, 1 );
 50     update( ncur, 0 );
 51     update( ncur, 1 );
 52 }
 53 
 54 void insert( int pos, int val, int stu )
 55 {
 56     int cur = 0, p = sz[cur];
 57     while ( p < pos + 1 && next[cur] != -1 )
 58     {
 59         cur = next[cur];
 60         p += sz[cur];
 61     }
 62     if ( p < pos + 1 )
 63     {
 64         pos = p;
 65     }
 66     p -= sz[cur];
 67     pos -= p;
 68     for ( int j = sz[cur] - 1; j >= pos; j-- )
 69     {
 70         b[cur][j + 1] = b[cur][j];
 71     }
 72     b[cur][pos].v = val;
 73     b[cur][pos].s = stu;
 74     sz[cur]++;
 75     if ( sz[cur] > UP )
 76     {
 77         spilt(cur);
 78     }
 79     else
 80     {
 81         g[cur][stu] = gcd( g[cur][stu], val );
 82     }
 83 }
 84 
 85 void remove( int pos )
 86 {
 87     int cur = 0, p = sz[cur];
 88     while ( p < pos + 1 && next[cur] != -1 )
 89     {
 90         cur = next[cur];
 91         p += sz[cur];
 92     }   
 93     if ( p < pos + 1 )
 94     {
 95         return ;
 96     }
 97     else
 98     {
 99         p -= sz[cur];
100         pos -= p;
101         int tt = b[cur][pos].s;
102         for ( int j = pos; j < sz[cur] - 1; j++ )
103         {
104             b[cur][j] = b[cur][j + 1];
105         }
106         sz[cur]--;
107         update( cur, tt );
108     }
109 }
110 
111 void reverse( int pos )
112 {
113     int cur = 0, p = sz[cur];
114     while ( p < pos + 1 && next[cur] != -1 )
115     {
116         cur = next[cur];
117         p += sz[cur];
118     }   
119     if ( p < pos + 1 )
120     {
121         return ;
122     }
123     else
124     {
125         p -= sz[cur];
126         pos -= p;
127         int tt = b[cur][pos].s;
128         b[cur][pos].s ^= 1;
129         update( cur, tt );
130         g[cur][tt ^ 1] = gcd( g[cur][tt ^ 1], b[cur][pos].v );
131     }
132 }
133 
134 void modify( int pos, int val )
135 {
136     int cur = 0, p = sz[cur];
137     while ( p < pos + 1 && next[cur] != -1 )
138     {
139         cur = next[cur];
140         p += sz[cur];
141     }   
142     if ( p < pos + 1 )
143     {
144         return ;
145     }
146     else
147     {
148         p -= sz[cur];
149         pos -= p;
150         b[cur][pos].v = val;
151         update( cur, b[cur][pos].s );
152     }
153 }
154 
155 int query( int l, int r, int stu )
156 {
157     int cur = 0, p = sz[cur];
158     while ( p < l + 1 && next[cur] != -1 )
159     {
160         cur = next[cur];
161         p += sz[cur];
162     }        
163     p -= sz[cur];
164     l -= p;  
165     int ncur = 0, q = sz[ncur];
166     while ( q < r + 1 && next[ncur] != -1 )
167     {
168         ncur = next[ncur];
169         q += sz[ncur];
170     }        
171     q -= sz[ncur];
172     r -= q;  
173     int ans = 0;
174     if ( cur != ncur )
175     {
176         for ( int i = next[cur]; i != ncur; i = next[i] )
177         {
178             if ( g[i][stu] == 0 ) continue;
179             ans = gcd( ans, g[i][stu] );
180         }
181         for ( int j = l; j < sz[cur]; j++ )
182         {
183             if ( b[cur][j].s == stu )
184             {
185                 ans = gcd( ans, b[cur][j].v ); 
186             }
187         }
188         for ( int j = 0; j <= r; j++ )
189         {
190             if ( b[ncur][j].s == stu )
191             {
192                 ans = gcd( ans, b[ncur][j].v );
193             }
194         }
195     }
196     else
197     {
198         for ( int j = l; j <= r; j++ )
199         {
200             if ( b[cur][j].s == stu )
201             {
202                 ans = gcd( ans, b[cur][j].v );
203             }
204         }
205     }
206     if ( ans == 0 ) ans = -1;
207     return ans;
208 }
209 
210 int main ()
211 {
212     while ( scanf("%d%d", &n, &m) != EOF )
213     {
214         ps = LOW;
215         memset( sz, 0, sizeof(sz) );
216         memset( next, -1, sizeof(next) );
217         memset( g, 0, sizeof(g) );
218         for ( int i = 0; i < n; i++ )
219         {
220             int la = i / ps, lb = i % ps;
221             scanf("%d%d", &b[la][lb].v, &b[la][lb].s);
222         }
223         int k = 0;
224         while ( ( k + 1 ) * ps < n ) k++;
225         for ( int i = 0; i < k; i++ )
226         {
227             sz[i] = ps;
228             next[i] = i + 1;
229         }
230         sz[k] = n - k * ps;
231         for ( int i = 0; i <= k; i++ )
232         {
233             g[i][0] = g[i][1] = 0;
234             for ( int j = 0; j < sz[i]; j++ )
235             {
236                 int ss = b[i][j].s;
237                 g[i][ss] = gcd( g[i][ss], b[i][j].v );
238             }
239         }
240         bl = k + 1;
241         char op[2];
242         int num1, num2, num3;
243         while ( m-- )
244         {
245             scanf("%s", op);
246             if ( op[0] == 'Q' )
247             {
248                 scanf("%d%d%d", &num1, &num2, &num3);
249                 num1--;
250                 num2--;
251                 printf("%d\n", query( num1, num2, num3 ));
252             }
253             else if ( op[0] == 'I' )
254             {
255                 scanf("%d%d%d", &num1, &num2, &num3);
256                 insert( num1, num2, num3 );
257             }
258             else if ( op[0] == 'D' )
259             {
260                 scanf("%d", &num1);
261                 num1--;
262                 remove(num1);
263             }
264             else if ( op[0] == 'R' )
265             {
266                 scanf("%d", &num1);
267                 num1--;
268                 reverse(num1);      
269             }
270             else if ( op[0] == 'M' )
271             {
272                 scanf("%d%d", &num1, &num2);
273                 num1--;
274                 modify( num1, num2 );
275             }
276         }
277     }
278     return 0;
279 }

方法2：splay

写起来也不算特别长。

  1 #include <iostream>
  2 #include <cstring>
  3 #include <cstdio>
  4 using namespace std;
  5 
  6 const int N = 200002;
  7 int v[N];
  8 int s[N];
  9 int n, m;
 10 
 11 int gcd( int x, int y )
 12 {
 13     if ( y ) return gcd( y, x % y );
 14     return x;
 15 }
 16 
 17 struct Node 
 18 {
 19     Node * ch[2];
 20     int g[2];
 21     int val;
 22     int stu;
 23     int rank;
 24     int sz;
 25 
 26     int cmp( int x ) const 
 27     {
 28         if ( x == rank ) return -1;
 29         return x < rank ? 0 : 1;
 30     }
 31 
 32     void maintain()
 33     {
 34         sz = rank = 1;
 35         g[0] = g[1] = 0;
 36         g[stu] = val;
 37         if ( ch[0] != NULL )
 38         {
 39             sz += ch[0]->sz;
 40             rank += ch[0]->sz;
 41             if ( ch[0]->g[0] ) g[0] = gcd( g[0], ch[0]->g[0] );
 42             if ( ch[0]->g[1] ) g[1] = gcd( g[1], ch[0]->g[1] );
 43         }
 44         if ( ch[1] != NULL )
 45         {
 46             sz += ch[1]->sz;
 47             if ( ch[1]->g[0] ) g[0] = gcd( g[0], ch[1]->g[0] );
 48             if ( ch[1]->g[1] ) g[1] = gcd( g[1], ch[1]->g[1] );
 49         }
 50     }
 51 } * root;
 52 
 53 void rotate( Node * & o, int d )
 54 {
 55     Node * k = o->ch[d ^ 1];
 56     o->ch[d ^ 1] = k->ch[d];
 57     k->ch[d] = o;
 58     o->maintain();
 59     k->maintain();
 60     o = k;
 61 }
 62 
 63 void splay( Node * & o, int k )
 64 {
 65     int d = o->cmp(k);
 66     if ( d != -1 )
 67     {
 68         if ( d == 1 ) k -= o->rank;
 69         Node * p = o->ch[d];
 70         int d2 = p->cmp(k);
 71         if ( d2 != -1 )
 72         {
 73             int k2 = ( d2 == 0 ? k : k - p->rank );    
 74             splay( p->ch[d2], k2 );
 75             if ( d == d2 )
 76             {
 77                 rotate( o, d ^ 1 );
 78             }
 79             else
 80             {
 81                 rotate( o->ch[d], d );
 82             }
 83         }
 84         rotate( o, d ^ 1 );
 85     }
 86 }
 87 
 88 Node * build( int l, int r )
 89 {
 90     if ( l > r ) return NULL;
 91     Node * o = new Node();
 92     int mid = ( l + r ) >> 1;
 93     o->sz = r - l + 1;
 94     o->val = v[mid];
 95     o->stu = s[mid];
 96     o->rank = mid - l + 1;
 97     o->g[0] = o->g[1] = 0;
 98     o->g[o->stu] = o->val;
 99     o->ch[0] = build( l, mid - 1 );
100     o->ch[1] = build( mid + 1, r );
101     o->maintain();
102     return o;
103 }
104 
105 int query( int l, int r, int stu )
106 {
107     splay( root, l );
108     splay( root->ch[1], r - l + 2 );
109     return root->ch[1]->ch[0]->g[stu];
110 }
111 
112 void insert( int k, int vv, int ss )
113 {
114     splay( root, k );
115     splay( root->ch[1], 1 );
116     Node * & o = root->ch[1]->ch[0];
117     o = new Node();
118     o->sz = o->rank = 1;
119     o->g[0] = o->g[1] = 0;
120     o->val = vv;
121     o->stu = ss;
122     o->g[ss] = vv;
123     root->ch[1]->maintain();
124     root->maintain();
125 }
126 
127 void remove( int k )
128 {
129     splay( root, k );
130     splay( root->ch[1], 2 );
131     root->ch[1]->ch[0] = NULL;
132     root->ch[1]->maintain();
133     root->maintain();
134 }
135 
136 void reverse( int k )
137 {
138     splay( root, k );
139     root->stu ^= 1;
140     root->maintain();
141 }
142 
143 void modify( int k, int vv )
144 {
145     splay( root, k );
146     root->val = vv;
147     root->maintain();
148 }
149 
150 int main ()
151 {
152     while ( scanf("%d%d", &n, &m) != EOF )
153     {
154         for ( int i = 1; i <= n; i++ )
155         {
156             scanf("%d%d", v + i, s + i);
157         }
158         root = build( 0, n + 1 );
159         char cmd[11];
160         int a, b, c;
161         while ( m-- )
162         {
163             scanf("%s", cmd);
164             if ( cmd[0] == 'Q' )
165             {
166                 scanf("%d%d%d", &a, &b, &c);
167                 int tmp = query( a, b, c );
168                 if ( !tmp ) tmp = -1;
169                 printf("%d\n", tmp);
170             }
171             else if ( cmd[0] == 'I' )
172             {
173                 scanf("%d%d%d", &a, &b, &c);
174                 a++;
175                 insert( a, b, c );
176             }
177             else if ( cmd[0] == 'D' )
178             {
179                 scanf("%d", &a);
180                 remove(a);
181             }
182             else if ( cmd[0] == 'R' )
183             {
184                 scanf("%d", &a);
185                 a++;
186                 reverse(a);
187             }
188             else if ( cmd[0] == 'M' )
189             {
190                 scanf("%d%d", &a, &b);
191                 a++;
192                 modify( a, b );
193             }
194         }
195     }
196     return 0;
197 }

 

转载于:https://www.cnblogs.com/huoxiayu/p/4736490.html

poj3580:SuperMemo（块状链表/Splay）
DZYO的博客
07-17 399
传送门 题意： 题目要求实现一种数据结构，支持6种操作： add x,y D：第x个数到第y个数之间的数每个加D； reverse x y：第x个数到第y个数之间全部数翻转； revolve x y T：第x个数到第y个数之间的数，向后循环流动T次，即后面T个数变成这段子序列的最前面T个，前面的被挤到后面。 Insert x P：在第x个数后面插入一个数P。 Delete x：删除第x个数
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
Codevs_P1743 反转卡片(块状链表+SplayTree)
BeiYu
02-05 605
传送门 时间限制: 2 s 空间限制: 256000 KB 题目等级 : 大师 Master 题目描述 Description 【dzy493941464|yywyzdzr原创】 小A将N张卡片整齐地排成一排，其中每张卡片上写了1~N的一个整数，每张卡片上的数各不相同。 比如下图是N=5的一种情况：3 4 2 1 5 接下来你需要按小A的要求反转卡片，使得左数第一张卡片上的数字
zoj3765
a5199519的博客
01-03 102
题解： splay维护 注意是gcd 代码： #include<bits/stdc++.h> using namespace std; #define Key_value ch[ch[root][1]][0] const int N=300010; char op[100]; int pre[N],ch[N][2],key[N],size[N],root...
zoj 3765
weixin_30735745的博客
03-04 99
一道区间更新、查询的题； 但是线段树不能做插入； 后来才知道用splay； splay用来做区间查询的话，先将l-1旋转到根节点，然后把r+1旋转到根节点的右节点； 这样的话，根节点的右节点的左子树就是我们要的区间； 我的代码是网上大神的代码改了一下过来的，存着做模板； #include<cstdio> #include<cstring> #i...
Lights ZOJ - 3765
sunyutian1998的博客
08-17 171
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3765 模板题 熟悉基本操作 每次收口袋之后 记得把口袋里的区间splay到根节点 否则慢的出奇 #include &lt;bits/stdc++.h&gt; using namespace std; int getgcd(int a,int b); struct ...
zoj.rar_zoj_zoj4041
09-23
链表、数组、树、图、堆等数据结构各有优势，根据题目需求选择合适的数据结构是优化解法的重要手段。 4. **错误处理**：在提交代码前，确保程序能够处理各种边界条件和异常情况，避免因输入不合法导致的程序崩溃。 ...
zoj.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar
09-24
标题中的"ZOJ.gz_ ZOJ_ZOJ 1016_max flow_zoj 1045_zoj.rar" 提到了两个ZOJ（Zhejiang Online Judge）的题目，分别是1016和1045，这两个数字通常代表在线编程竞赛中的题目编号。这些题目通常涉及到算法和数据结构的...
ZOJ 4016 Mergeable Stack 模拟,链表
noone0的博客
08-05 200
题意:初始有n个空的栈,Q次操作. 操作1:将v压入第i个栈的栈顶. 操作2:弹出第i个栈的栈顶,并输出该栈顶的值. 操作3:将第t个栈的所有元素移到第s个栈的顶部. 移动后s变为:E(s,1)..E(s,S),E(t,1)..E(t,S) n,Q&lt;=3e5.v&lt;=1e9 模拟以上操作. 设hd[i],ed[i]分别为第i个栈的开头和结尾的编号, sz[i]为第i个栈的大小. val[...
ZOJ.zip_Jugs A_ZOJ NTA_zoj acm_zoj acm 1216_zoj code
09-20
【ZOJ.zip】是一个压缩包，里面包含了与ZOJ（Zhejiang Online Judge）相关的ACM（International Collegiate Programming Contest）题解。ZOJ是一个在线编程竞赛平台，它为参赛者提供了一系列算法题目进行练习，以...
ZOJ 3765 Lights
Ignorance Panda
03-04 566
比赛的时候过的是N年前的代码，还是单旋，比完赛重新敲了个双旋的，感觉这个数据有点水... #include #include #include #include #define maxn 300010 using namespace std; struct SplayTree{ int next[2],pre,key,num,work; int Gopen,Gclose
ZOJ 3765 splay
u013268685的专栏(有一种幸福叫AC，有一种期待叫AK)
12-01 1154
B - Lights Time Limit:8000MS     Memory Limit:131072KB     64bit IO Format:%lld & %llu Submit Status Description Now you have N lights in a line. Don't worry - the lights don't have co
ZOJ--3765--Lights【伸展树】
阳光照耀圣西罗
03-08 674
浙大月赛的题目，天真的我都用链表写了。。。然后内存分配搓了一运行就崩溃。后来百度得知是伸展树（从没听过），用数组和链表做的话，可能都有样例会卡时间造成TLE，百度了一个模板，暂时当作模板用，等多做几道伸展树再搞自己的模板 #include #include #include #include #include using namespace std; #define MAXN 3000
ZOJ 3765 —— Lights（伸展树）
hongrock的专栏
03-03 1052
题目：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3765 昨天比赛的时候，别人都把这题KO我却只能干瞪眼，虽然感觉是伸展树，可是之前一直没真正去学这东西。 事后学了下这个东西马上回去ZOJ把这题QJ了！ 伸展树（Splay Tree）这东西太神奇啦！ 我是看cxlove大牛的文章学习的：http://blog.
【splay tree】 ZOJ 3765 Lights
yysys
08-02 553
有五种操作，
伸展树zoj3765
龙崎的专栏
12-02 482
Lights Time Limit: 8 Seconds      Memory Limit: 131072 KB Now you have N lights in a line. Don't worry - the lights don't have color. The only status they have is on and off. And, each ligh
ZOJ 3765 Lights (伸展树)
JayYe的专栏
03-03 1787
伸展树裸题，做了几题后已经不需要调了，像前几次经常调个好久。。听说可持久化treap更好用，调起来方便，下次学一下。 code： #include #include using namespace std; #define lson x->ch[0] #define rson x->ch[1] #define ket (root->ch[1]->ch[0]) con
zoj 3765 Lights splay
Broken Wings
03-02 725
N个灯摆成一排，每个灯有一个权值和一个状态，现在有以下操作： Q l r sta :查询第l个到第r个中状态为sta的灯的权值的最大公约数。 I i x sta : 在第i个灯后面插入一个权值为x状态为sta的灯。 D i：删除第i个灯 M i x ：将第i个灯的权值变成x R i：改变第i个灯的状态。 对每一个查询，输出一个答案。 又是插入又是删除，而且key值又可以合并成一段处理
zoj 3765 Lights（Splay）
ok_again的专栏
03-05 1061
由于数组开小了，一直TLE。。。检查了一下午，都要哭了，题目没啥好说的，就是一个入门级别的Splay Tree。只有插入，删除，修改操作。 #include #include #include #include #include #define LL long long #define CLR(a, b) memset(a, b, memset(a)) using namespace std;
Zoj4041题解及运行程序代码分析
zoj4041这道题目可能涉及到特定的算法（如动态规划、图搜索等）和数据结构（如链表、树、图等），编写出正确的题解源代码需要运用这些知识点。 10. 学术诚信：在参与编程竞赛和使用在线评测系统时，学术诚信是一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值