【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][ ...

随机推荐

1.关于无rospy.spin()调用多次callback 2. subscrib后面语句和callback函数运行顺序
#!/usr/bin/env python import rospy from bzrobot_msgs.msg import bzr_WheelLinearVels #from threading ...
java设计模式图
一.什么是设计模式 ...
Spring的依赖注入概述
以下内容引用自http://wiki.jikexueyuan.com/project/spring/dependency-injection.html: 每个基于Java应用程序都有几个对象,这些对象 ...
Angular 组件通讯、生命周期钩子小结
本文为原创,转载请注明出处: cnzt 文章:cnzt-p http://www.cnblogs.com/zt-blog/p/7986858.html http://www.cnblogs ...
QVector的内存分配策略
我们都知道 STL std::vector 作为动态数组在所分配的内存被填满时.假设继续加入数据,std::vector 会另外申请一个大小当前容量两倍的区域(假设 n > size 则申请 n ...
jobject和jclass
jclass和jobject的迷惑第一次使用JNI,实例引用(jobject)和类引用(jclass)让人觉得很困惑.实例引用与一个数组和java.lang.Object类或它的子类的实例对应.类引用 ...
关于从 coding 拉项目的操作
介绍:coding是托管代码的仓库 sourceTree 是把代码提交到coding的界面化工具 1.通过百度登录coding账号
HBuilder开发App教程06-首页
实战前面几节基本是一些概念的普及, 正如前面提到的,本教程会以滴石作为范例进行解说, 有兴趣的能够先行下载体验一下.或者下载源代码研究下. 新建项目打开HBuilder,在项目管理器中右键--新建 ...
Js两种post方式（转）
第一种提交post的方式是传统方式,判断浏览器进行post请求. <SCRIPT stype=text/javascript> var xmlobj; //定义XMLHttpRequest ...
GitHub 上值得关注的 iOS 开源项目
GitHub 上值得关注的 iOS 开源项目原文链接:http://www.jianshu.com/p/e5dfe1a09611 GitHub 上值得关注的 iOS 开源项目 —— 由红旗下的蛋 ...

【POJ 3580】 SuperMemo

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

随机推荐

热门专题