【POJ 3580】 SuperMemo

【题目链接】

【算法】

本题也是Splay区间操作的模板题，不过要比BZOJ 3223要稍微复杂一些，做完此题后，我终于对Splay有了更深入的理解，有“拨开云雾见青天”的感觉

本题还是有许多细节的，笔者花了5h才通过了此题

【代码】

#include <algorithm>

#include <bitset>

#include <cctype>

#include <cerrno>

#include <clocale>

#include <cmath>

#include <complex>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <limits>

#include <list>

#include <map>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <utility>

#include <vector>

#include <cwchar>

#include <cwctype>

#include <stack>

#include <limits.h>

using namespace std;

#define MAXN 100000

const int INF = 2e9;

int i,N,M,d,P,x,y,t;

int a[MAXN+];

string opt;

template <typename T> inline void read(T &x) {

        int f=; x=;

        char c = getchar();

        for (; !isdigit(c); c = getchar()) { if (c == '-') f = -f; }

        for (; isdigit(c); c = getchar()) x = x *  + c - '';

        x *= f;

}

template <typename T> inline void write(T x) {

    if (x < ) { putchar('-'); x = -x; }

    if (x > ) write(x/);

    putchar(x%+'');

}

template <typename T> inline void writeln(T x) {

    write(x);

    puts("");

}

struct Splay {

        int root,total;

        struct Node {

                int fa,son[],size,add,Min,val;

                bool rev;

        } Tree[MAXN*+];

        inline bool get(int x) {

                return Tree[Tree[x].fa].son[] == x;

        }

        inline void build(int index,int l,int r) {

                int mid = (l + r) >> ;

                Tree[index].size = ;

                Tree[index].add = Tree[index].rev = ;

                Tree[index].val = Tree[index].Min = a[mid];

                if (l == r) return;

                if (l < mid) {

                        ++total;

                        Tree[index].son[] = total;

                        Tree[total].fa = index;

                        build(total,l,mid-);

                        Tree[index].size += Tree[Tree[index].son[]].size;

                        Tree[index].Min = min(Tree[index].Min,Tree[Tree[index].son[]].Min);

                }

                if (mid < r) {

                        ++total;

                        Tree[index].son[] = total;

                        Tree[total].fa = index;

                        build(total,mid+,r);

                        Tree[index].size += Tree[Tree[index].son[]].size;

                        Tree[index].Min = min(Tree[index].Min,Tree[Tree[index].son[]].Min);

                }

        }

        inline void new_node(int index,int x,int f) {

                Tree[index].rev = ;

                Tree[index].size = ;

                Tree[index].val = Tree[index].Min = x;

                Tree[index].add = ;

                Tree[index].fa = f;

                Tree[index].son[] = Tree[index].son[] = ;

        }

        inline int query_pos(int x) {

                int index = root;

                while (true) {

                        pushdown(index);

                        if (x > Tree[Tree[index].son[]].size) {

                                x -= Tree[Tree[index].son[]].size;

                                if (x == ) return index;

                                --x;

                                index = Tree[index].son[];

                        } else index = Tree[index].son[];

                }

        }

        inline void pushdown(int index) {

                if (Tree[index].rev) {

                        swap(Tree[index].son[],Tree[index].son[]);

                        Tree[Tree[index].son[]].rev ^= ;

                        Tree[Tree[index].son[]].rev ^= ;

                        Tree[index].rev = ;

                }

                if (Tree[index].add) {

                        Tree[Tree[index].son[]].val += Tree[index].add;

                        Tree[Tree[index].son[]].val += Tree[index].add;

                        Tree[Tree[index].son[]].add += Tree[index].add;

                        Tree[Tree[index].son[]].add += Tree[index].add;

                        Tree[Tree[index].son[]].Min += Tree[index].add;

                        Tree[Tree[index].son[]].Min += Tree[index].add;

                        Tree[index].add = ;

                }

        }

        inline void update(int index) {

                Tree[index].size = Tree[Tree[index].son[]].size + Tree[Tree[index].son[]].size + ;

                Tree[index].Min = Tree[index].val;

                if (Tree[index].son[]) Tree[index].Min = min(Tree[index].Min,Tree[Tree[index].son[]].Min);

                if (Tree[index].son[]) Tree[index].Min = min(Tree[index].Min,Tree[Tree[index].son[]].Min);

        }

        inline void splay(int x,int pos) {

                int f;

                for (f = Tree[x].fa; (f = Tree[x].fa) != pos; rotate(x)) {

                        if (Tree[f].fa != pos)

                                rotate(get(f) == get(x) ? (f) : (x));

                }

                if (!pos) root = x;

        }

        inline void rotate(int x) {

                int f = Tree[x].fa,g = Tree[f].fa,

                tmpx = get(x),tmpf = get(f);

                pushdown(f); pushdown(x);

                if (!f) return;

                Tree[f].son[tmpx] = Tree[x].son[tmpx^];

                if (Tree[x].son[tmpx^]) Tree[Tree[x].son[tmpx^]].fa = f;

                Tree[x].son[tmpx^] = f;

                Tree[f].fa = x;

                Tree[x].fa = g;

                if (g) Tree[g].son[tmpf] = x;

                update(f);

                update(x);

        }

        inline void Insert(int p,int val) {

                int x = query_pos(p),

                        y = query_pos(p+);

                splay(x,); splay(y,root);

                new_node(++total,val,Tree[root].son[]);

                Tree[Tree[root].son[]].son[] = total;

                update(Tree[root].son[]);

                update(root);

        }

        inline void erase(int p) {

                int x = query_pos(p-),

                        y = query_pos(p+);

                splay(x,); splay(y,root);

                Tree[Tree[root].son[]].son[] = ;

                update(Tree[root].son[]);

                update(root);

        }

        inline void add(int l,int r,int v) {

                int x = query_pos(l-),

                        y = query_pos(r+);

                splay(x,); splay(y,root);

                Tree[Tree[Tree[root].son[]].son[]].val += v;

                Tree[Tree[Tree[root].son[]].son[]].add += v;

                Tree[Tree[Tree[root].son[]].son[]].Min += v;

                update(Tree[root].son[]);

                update(root);

        }

        inline void reverse(int l,int r) {

                int x = query_pos(l-),

                        y = query_pos(r+);

                splay(x,); splay(y,root);

                Tree[Tree[Tree[root].son[]].son[]].rev ^= ;

        }

        inline int query_min(int l,int r) {

                int x = query_pos(l-),

                        y = query_pos(r+);

                splay(x,); splay(y,root);

                return Tree[Tree[Tree[root].son[]].son[]].Min;

        }

        inline void revolve(int l,int r,int t) {

                int x = query_pos(r-t),

                        y = query_pos(r+);

                splay(x,); splay(y,root);

                int tmp = Tree[Tree[root].son[]].son[];

                Tree[Tree[root].son[]].son[] = ;

                update(Tree[root].son[]);

                update(root);

                x = query_pos(l-);

                y = query_pos(l);

                splay(x,); splay(y,root);

                Tree[Tree[root].son[]].son[] = tmp;

                Tree[tmp].fa = Tree[root].son[];

                update(Tree[root].son[]);

                update(root);

        }

} T;

int main() {

        read(N);

        T.root = T.total = ;

        for (i = ; i <= N + ; i++) read(a[i]);

        a[] = a[N+] = INF;

        T.build(,,N+);

        read(M);

        while (M--) {

                cin >> opt;

                if (opt[] == 'A') {

                        read(x); read(y); read(d);

                        if (x > y) swap(x,y);

                        T.add(x+,y+,d);

                } else if (opt[] == 'R' && opt[] == 'E' && opt[] == 'V' && opt[] == 'E'){

                        read(x); read(y);

                        if (x > y) swap(x,y);

                        T.reverse(x+,y+);

                } else if (opt[] == 'R' && opt[] == 'E' && opt[] == 'V' && opt[] == 'O') {

                        read(x); read(y); read(t);

                        if (x > y) swap(x,y);

                        t = (t % (y - x + ) + y - x + ) % (y - x + );

                        if (!t) continue;

                        T.revolve(x+,y+,t);

                } else if (opt[] == 'I') {

                        read(x); read(P);

                        T.Insert(x+,P);

                } else if (opt[] == 'D') {

                        read(x);

                        T.erase(x+);

                } else if (opt[] == 'M') {

                        read(x); read(y);

                        if (x > y) swap(x,y);

                        writeln(T.query_min(x+,y+));

                }

        }

        return ;

}

【POJ 3580】 SuperMemo的更多相关文章

【POJ 3580】SuperMemo Splay
题意给定$n$个数,$m$个询问,每次在$[L,R]$区间加上一个数,或者反转一个区间$[L,R]$,或者循环右移区间$[L,R]$共$T$次,或者在第$x$个数后插入一个数$p$,或者删除第$x$ ...
bzoj 2295: 【POJ Challenge】我爱你啊
2295: [POJ Challenge]我爱你啊 Time Limit: 1 Sec Memory Limit: 128 MB Description ftiasch是个十分受女生欢迎的同学,所以 ...
【链表】BZOJ 2288: 【POJ Challenge】生日礼物
2288: [POJ Challenge]生日礼物 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 382 Solved: 111[Submit][S ...
BZOJ2288: 【POJ Challenge】生日礼物
2288: [POJ Challenge]生日礼物 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 284 Solved: 82[Submit][St ...
BZOJ2293: 【POJ Challenge】吉他英雄
2293: [POJ Challenge]吉他英雄 Time Limit: 1 Sec Memory Limit: 128 MBSubmit: 80 Solved: 59[Submit][Stat ...
BZOJ2287: 【POJ Challenge】消失之物
2287: [POJ Challenge]消失之物 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 254 Solved: 140[Submit][S ...
BZOJ2295: 【POJ Challenge】我爱你啊
2295: [POJ Challenge]我爱你啊 Time Limit: 1 Sec Memory Limit: 128 MBSubmit: 126 Solved: 90[Submit][Sta ...
BZOJ2296: 【POJ Challenge】随机种子
2296: [POJ Challenge]随机种子 Time Limit: 1 Sec Memory Limit: 128 MBSec Special JudgeSubmit: 114 Solv ...
BZOJ2292: 【POJ Challenge 】永远挑战
2292: [POJ Challenge ]永远挑战 Time Limit: 10 Sec Memory Limit: 128 MBSubmit: 513 Solved: 201[Submit][ ...

随机推荐

使用Crypto对数据进行加密解密
注释都在代码里: 先撸客户端: from Crypto.Cipher import AES import base64,requests class Message(object): def __in ...
Maven自动部署（SCM-SVN/Git）（maven-scm-plugin/maven-release-plugin插件的使用）
以下内容引用自https://ayayui.gitbooks.io/tutorialspoint-maven/content/book/maven_deployment_automation.html ...
Limitations of Forms Personalization (文档 ID 420518.1)
In this Document Purpose Scope Details Diagnostics & Utilities Community: References A ...
Android ZXing 二维码、条形码扫描介绍
本帖最后由 Shims 于 2013-11-9 12:39 编辑最近公司的Android项目需要用到摄像头做条码或二维码的扫描,Google一下,发现一个开源的 ZXing项目.它提供二维码和条形码 ...
hdoj-1856-More is better【并查集】
More is better Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 327680/102400 K (Java/Others) To ...
python中pymysql使用
python中pymysql使用 https://blog.csdn.net/johline/article/details/69549131 import pymysql # 连接数据库 conne ...
mahout in Action2.2-聚类介绍-K-means聚类算法
聚类介绍本章包含 1 实战操作了解聚类 2.了解相似性概念 3 使用mahout执行一个简单的聚类实例 4.用于聚类的各种不同的距离測算方法作为人类,我们倾向于与志同道合的人合作-"鸟的 ...
第04章-VTK基础（2）
[译者:这个系列教程是以Kitware公司出版的<VTK User's Guide -11th edition>一书作的中文翻译(出版时间2010年,ISBN: 978-1-930934- ...
javascript读取和改动原型特别须要注意的事儿，由于原型的读写不具有对等性
对于从原型对象继承而来的成员,其读和写具有内在的不正确等性.比方有一个对象A,假设它的原型对象是B.B的原型对象是null.假设我们须要读取A对象的name属性值,那么JS会优先在A中查找.假设找到了 ...
2016-1-8 windows 7下安装mysql及其配置和运用
绪言最近学习了一下mysql的相关用法,以及vs2010结合mysql的使用. 遇到的问题:1.安装mysql 5.6 绿色免安装版本,出现mysql server not connect loca ...

【POJ 3580】 SuperMemo

【POJ 3580】 SuperMemo的更多相关文章

随机推荐

热门专题