Splay模板

  1 //poj3580

  2 //#pragma comment(linker,"/STACK:102400000,102400000")

  3 #include <cstdio>

  4 #include <set>

  5 #include <map>

  6 #include <ctime>

  7 #include <cctype>

  8 #include <string>

  9 #include <cstring>

 10 #include <cstdlib>

 11 #include <cmath>

 12 #include <assert.h>

 13 #include <algorithm>

 14 #include <iostream>

 15 #include <climits>

 16 #include <queue>

 17 #include <vector>

 18 

 19 #define dte(x) cout << #x << " = " << x << endl;

 20 #define scaf2(x,y) scaf(x);scaf(y);

 21 #define mkp make_pair

 22   

 23 using namespace std;

 24 template<typename T>inline void scaf(T&v)

 25 {

 26     char ch = getchar();

 27     for(; ch < '0' || ch > '9'; ch = getchar());

 28     for(v = 0; ch >= '0' && ch <= '9'; ch = getchar()) v = (v << 1) +(v << 3) + ch - '0';

 29 }

 30 typedef long long LL;

 31 typedef unsigned long long ULL;

 32 typedef pair <int, int> PII;

 33 const int maxN = 2e5 + 10;

 34 const LL mod = 1e9 + 7;

 35 const double eps = 1e-9;

 36 const LL oo = ~ 0U >> 2;

 37 

 38 int inn[maxN];

 39 

 40 struct SplayTree

 41 {

 42     static const int smaxN = 4e5 + 10;

 43     #define keyNode chird[chird[root][1]][0]

 44     int item[smaxN];

 45     int parent[smaxN];

 46     int sz[smaxN];

 47     int chird[smaxN][2];

 48     

 49     int root, vtot;

 50     

 51     SplayTree()

 52     {

 53         root = vtot = 0;

 54         item[0] = -1;

 55         parent[0] = sz[0] = chird[0][0] = chird[0][1] = 0;

 56     }

 57     

 58     void Rotate(const int& x, const int& lr)

 59     {//lr - > 0: leftRotate 1: rightRotate

 60         int y = parent[x];

 61         pushDown(y); pushDown(x);

 62         chird[y][! lr] = chird[x][lr];

 63         if (chird[x][lr]) parent[chird[x][lr]] = y;

 64         parent[x] = parent[y];

 65         if (parent[y])

 66         {

 67             if (chird[parent[y]][0] == y) chird[parent[y]][0] = x;

 68             else chird[parent[y]][1] = x;

 69         }

 70         chird[x][lr] = y; parent[y] = x;

 71         pushUp(y);

 72     }

 73     

 74     void Splay(int x, const int& target)

 75     {//Splay x to target't chird -- target must be x's ancestor

 76         for (pushDown(x); parent[x] != target;)

 77         {

 78             if (parent[parent[x]] == target)/*x's father's father is target -> rotate x to x's father*/

 79             {

 80                 if (chird[parent[x]][0] == x) Rotate(x, 1);

 81                 else Rotate(x, 0);

 82             }else

 83             {

 84                 int y = parent[x], z = parent[parent[x]];

 85                 if (chird[z][0] == y)/*y is z's lson*/

 86                 {

 87                     if (chird[y][0] == x) Rotate(y, 1), Rotate(x, 1);//yi zi xing

 88                     else Rotate(x, 0), Rotate(x, 1);//zhi zi xing

 89                 }else

 90                 {

 91                     if (chird[y][0] == x) Rotate(x, 1), Rotate(x, 0);//zhi

 92                     else Rotate(y, 0), Rotate(x, 0);//yi

 93                 }

 94             }

 95         }

 96         pushUp(x);

 97         if (!target) root = x;

 98     }

 99     

100     int Search(const int& target)

101     {

102         int x = root;

103         while (x)

104         {

105             if (item[x] == target) break;

106             if (item[x] > target) x = chird[x][0];

107             else x = chird[x][1];

108         }

109         if (x) Splay(x, 0);

110         return x;

111     }

112     

113     void Insert(const int& target, const int& _id)

114     {

115 //        if (Search(target)) return;//exist?

116         int x = root, y = 0, lr;

117         while (x)

118         {

119             y = x; ++ sz[y];

120             if (item[x] > target) x = chird[x][0];

121             else x = chird[x][1];

122         }

123         if (item[y] > target) lr = 0;

124         else lr = 1;

125         sz[x = ++ vtot] = 1;

126         parent[x] = y; chird[y][lr] = x;

127         item[x] = target;

128         chird[x][0] = chird[x][1] = 0;

129         Splay(x, 0);

130     }

131     

132     void Delete(const int& target)

133     {

134         int x = Search(target);

135         if (!x) return;//no exist

136         int lc = chird[x][0], rc = chird[x][1];

137         sz[x] = parent[lc] = parent[rc] = chird[x][0] = chird[x][1] = 0;

138         if (!lc) root = rc;

139         else

140         {

141             for (pushDown(lc); chird[lc][1]; pushDown(lc)) lc = chird[lc][1];

142             Splay(lc, 0);

143             parent[rc] = lc;

144             chird[lc][1] = rc;

145             pushUp(root);

146         }

147     }

148     

149     int findParent(const int& target)

150     {

151         int x = root, ret = 0;

152         while (x)

153         {

154             if (target <= item[x]) x = chird[x][0];

155             else ret = x, x = chird[x][1];

156         }

157         if (ret) Splay(ret, 0);

158         return ret;

159     }

160     

161     int findSuccessor(const int& target)

162     {

163         int x = root, ret = 0;

164         while (x)

165         {

166             if (target >= item[x]) x = chird[x][1];

167             else ret = x, x = chird[x][0];

168         }

169         if (ret) Splay(ret, 0);

170         return ret;

171     }

172     

173     int findKth(int k, const int& target)

174     {

175         int x = root;

176         while (x)

177         {

178             pushDown(x);

179              int y = sz[chird[x][0]];

180             if (y == k) break;

181             if (y > k) x = chird[x][0];

182             else x = chird[x][1], k -= y + 1;

183         }

184         if (x) Splay(x, target);

185         return x;//item[x]???

186     }

187     

188     void Treaval(const int& x, int& num)

189     {

190         if (x)

191         {

192             pushDown(x);

193             Treaval(chird[x][0], num);

194             printf("%d", item[x]);

195             if (-- num) putchar(32);

196             else putchar(10);

197             Treaval(chird[x][1], num);

198         }

199     }

200     

201     void outPut(int n)

202     {

203         int m = n;

204         findKth(0, 0);

205         Treaval(root, m);

206     }

207     

208     void newNode(int& x, const int& val, const int& father)

209     {

210         item[x = ++ vtot] = val; sz[x] = 1; parent[x] = father; 

211         minVal[x] = val; rev[x] = false; addLazy[x] = 0;

212         chird[x][0] = chird[x][1] = 0;

213     }

214     

215     void buildSplay(int n)

216     {

217         root = vtot = 0;

218         item[0] = 0; rev[0] = 0; addLazy[0] = 0; minVal[0] = oo;

219         parent[0] = sz[0] = chird[0][0] = chird[0][1] = 0;

220         newNode(root, oo, 0);//ex node?

221         newNode(chird[root][1], oo, root);

222         buildTree(keyNode, 1, n, chird[root][1]);

223         pushUp(chird[root][1]);

224         pushUp(root);

225     }

226     

227     void buildTree(int& x, const int& l, const int& r, const int& father)

228     {

229         if (l > r) return;

230         int mid = l + r >> 1;

231         newNode(x, inn[mid], father);

232         buildTree(chird[x][0], l, mid - 1, x);

233         buildTree(chird[x][1], mid + 1, r, x);

234         pushUp(x);

235     }

236     

237     void pushUp(const int& x)

238     {

239         sz[x] = sz[chird[x][0]] + sz[chird[x][1]] + 1;

240         minVal[x] = item[x];

241         if (chird[x][0]) minVal[x] = min(minVal[x], minVal[chird[x][0]]);

242         if (chird[x][1]) minVal[x] = min(minVal[x], minVal[chird[x][1]]);;

243     }

244     

245     void pushDown(const int& x)

246     {

247         if (rev[x])

248         {

249             int lc = chird[x][0], rc = chird[x][1];

250             swap(chird[x][0], chird[x][1]);

251             if (lc) rev[lc] ^= 1;

252             if (rc) rev[rc] ^= 1;

253             rev[x] ^= 1;

254         }

255         if (addLazy[x])

256         {

257             if (chird[x][0])

258             {

259                 item[chird[x][0]] += addLazy[x];

260                 minVal[chird[x][0]] += addLazy[x];

261                 addLazy[chird[x][0]] += addLazy[x];

262             }

263             if (chird[x][1])

264             {

265                 item[chird[x][1]] += addLazy[x];

266                 minVal[chird[x][1]] += addLazy[x];

267                 addLazy[chird[x][1]] += addLazy[x];

268             }

269             addLazy[x] = 0;

270         }

271     }

272     

273     void add(const int& l, const int& r, const int& v)

274     {

275         findKth(l - 1, 0); findKth(r + 1, root);

276         item[keyNode] += v;

277         addLazy[keyNode] += v;

278         minVal[keyNode] += v;

279         Splay(keyNode, 0);

280     }

281     

282     void insVal(const int& l, const int& v)

283     {

284         findKth(l, 0); findKth(l + 1, root);

285         if (keyNode) while (1);

286         newNode(keyNode, v, chird[root][1]);

287         Splay(keyNode, 0);

288     }

289     

290     void del(const int& target)

291     {

292         findKth(target, 0);

293         pushDown(root);

294         int x = root;

295         int lc = chird[x][0], rc = chird[x][1];

296         sz[x] = parent[lc] = parent[rc] = chird[x][0] = chird[x][1] = 0;

297         if (!lc) root = rc;

298         else

299         {

300             for (pushDown(lc); chird[lc][1]; pushDown(lc)) lc = chird[lc][1];

301             Splay(lc, 0);

302             parent[rc] = lc;

303             chird[lc][1] = rc;

304             pushUp(root);

305         }

306     }

307     

308     int getMin(const int& l, const int& r)

309     {

310         findKth(l - 1, 0); findKth(r + 1, root);

311         return minVal[keyNode];

312     }

313     

314     void Reverse(const int& l, const int& r)

315     {

316         findKth(l - 1, 0); findKth(r + 1, root);

317         rev[keyNode] ^= 1;

318         Splay(keyNode, 0);

319     }

320     

321     void Revolve(const int& l, const int& r, const int& v)

322     {

323         int rr = r - v;

324         int ll = rr + 1;

325         findKth(ll - 1, 0); findKth(r + 1, root);

326         int x = keyNode; keyNode = 0; parent[x] = 0;

327         pushUp(chird[root][1]); pushUp(root);

328         findKth(l - 1, 0); findKth(l, root);

329         keyNode = x;

330         parent[keyNode] = chird[root][1];

331         pushUp(chird[root][1]); pushUp(root);

332         Splay(keyNode, 0);

333     }

334     

335     int minVal[smaxN];

336     int addLazy[smaxN];

337     bool rev[smaxN];

338 }spt;

339 

340 int main()

341 {

342 //    freopen("ok.out", "w", stdout);

343     int n, i, m;

344     int l, r, v;

345     char opt[10];

346 //    scaf(n);

347     scanf("%d", &n);

348     for (i = 1; i <= n; ++ i)

349 //        scaf(inn[i]);

350         scanf("%d", &inn[i]);

351     spt.buildSplay(n);

352 //    scaf(m);

353     scanf("%d", &m);

354     while (m --)

355     {

356         scanf("%s", opt);

357 //        printf("%s\n", opt);

358         if ('A' == opt[0])

359         {

360 //            scaf2(l, r); scaf(v);

361             scanf("%d%d%d", &l, &r, &v);

362             spt.add(l, r, v);

363         }else if ('I' == opt[0])

364         {

365 //            scaf2(l, v);

366             scanf("%d%d", &l, &v);

367             spt.insVal(l, v);

368         }else if ('D' == opt[0])

369         {

370 //            scaf(v);

371             scanf("%d", &v);

372              spt.del(v);

373 //             spt.outPut(spt.sz[spt.root]);

374         }else if ('M' == opt[0])

375         {

376 //            scaf2(l, r);

377             scanf("%d%d", &l, &r);

378             printf("%d\n", spt.getMin(l, r));

379         }else if ('E' == opt[3])

380         {

381 //            scaf2(l, r);

382             scanf("%d%d", &l, &r);

383             spt.Reverse(l, r);

384 //            spt.outPut(spt.sz[spt.root]);

385         }else

386         {

387 //            scaf2(l, r); scaf(v);

388             scanf("%d%d%d", &l, &r, &v);

389             int len = r - l + 1;

390             v = (v % len + len) % len;

391             if (v) spt.Revolve(l, r, v);

392         }

393         spt.findKth(0, 0);

394 //        spt.outPut(spt.sz[spt.root]);

395 //        printf("%d\n", spt.sz[spt.root]);

396     }

397     return 0;

398 }