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

随机推荐

commons.apache
1.ToStringBuilder //对象及其属性一行显示 System.out.println(ToStringBuilder.reflectionToString(u)); System.out ...
centos6安装概述
1.1.选择安装类型:[Install or upgrade an existing system]安装或升级现有系统 1.2.介质校验:[Skip]跳过介质校验,校验时间较长 1.3.语言选择:[E ...
Java屏幕截图工具捕获屏幕
原文:http://www.open-open.com/code/view/1420037709781 import java.awt.BorderLayout; import java.awt.Co ...
Oracle版本–EBS R12.1.1
select * from v$version; Oracle Database 11g Enterprise Edition Release 11.1.0.7.0 - 64bit Productio ...
scss - 语法
1.在一个样式导入另一个样式(@import "example.css") 2.scss单行注释不会显示出来 3.强大的变量(定义后,全局可使用) 4.全局默认变量(加!defau ...
python实现QQ机器人(自己主动登录，获取群消息，发送群消息)
一次偶然的机会我看见了一个群里的一个QQ号总是依据你所发的消息自己主动回复,当时非常感觉到奇妙.我知道能够模拟登录站点,没想到居然也能模拟登录QQ,首先自己想到的就是怎样实现模拟登录PC端的QQ, 開 ...
Effective C++ 条款13/14 以对象管理资源 || 在资源管理类中小心拷贝行为
三.资源管理资源就是一旦你使用了它,将来不用的时候必须归还系统.C++中最常用的资源就是动态内存分配.其实,资源还有文件描述符.互斥器.图形界面中的字形.画刷.数据库连接.socket ...
Intel MIC
http://en.wikipedia.org/wiki/Intel_MIC Intel MIC From Wikipedia, the free encyclopedia Intel Man ...
this、call和apply、bind
this关键字: JavaScript的this关键字,总是指向一个对象,具体指向哪个对象,是根据运行时函数指向环境动态绑定的.简单来说,this就是谁调用指向谁.具体使用中,this的指向,大致可以 ...
从.Net版本演变看String和StringBuilder性能之争
在C#中string关键字的映射实际上指向.NET基类System.String.System.String是一个功能非常强大且用途非常广泛的基类,所以我们在用C#string的时候实际就是在用.NE ...

【POJ 3580】 SuperMemo

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

随机推荐

热门专题