★【STL】报表统计

Description
小Q的妈妈是一个出纳，经常需要做一些统计报表的工作。今天是妈妈的生日，小Q希望可以帮妈妈分担一些工作，作为她的生日礼物之一。经过仔细观察，小Q发现统计一张报表实际上是维护一个非负整数数列，并且进行一些查询操作。在最开始的时候，有一个长度为N的整数序列，并且有以下三种操作： INSERT i k 在原数列的第i个元素后面添加一个新元素k； 如果原数列的第i个元素已经添加了若干元素，则添加在这些元素的最后（见下面的例子） MIN_GAP 查询相邻两个元素的之间差值（绝对值）的最小值 MIN_SORT_GAP 查询所有元素中最接近的两个元素的差值（绝对值） 例如一开始的序列为 5 3 1 执行操作INSERT 2 9将得到： 5 3 9 1 此时MIN_GAP为2，MIN_SORT_GAP为2。 再执行操作INSERT 2 6将得到： 5 3 9 6 1 注意这个时候原序列的第2个元素后面已经添加了一个9，此时添加的6应加在9的后面。这个时候MIN_GAP为2，MIN_SORT_GAP为1。于是小Q写了一个程序，使得程序可以自动完成这些操作，但是他发现对于一些大的报表他的程序运行得很慢，你能帮助他改进程序么？
Input
第一行包含两个整数N，M，分别表示原数列的长度以及操作的次数。第二行为N个整数，为初始序列。接下来的M行每行一个操作，即“INSERT i k”，“MIN_GAP”，“MIN_SORT_GAP”中的一种（无多余空格或者空行）。
Output
对于每一个“MIN_GAP”和“MIN_SORT_GAP”命令，输出一行答案即可。
Sample Input
3 5
5 3 1
INSERT 2 9
MIN_SORT_GAP
INSERT 2 6
MIN_GAP
MIN_SORT_GAP
Sample Output
2
2
1
HINT

对于30%的数据，N ≤ 1000 , M ≤ 5000
对于100%的数据，N , M ≤500000
对于所有的数据，序列内的整数不超过5*108。

用一个STL multiset(g)维护当前列表中有哪些数，以便每插入一个数找到它的前驱和后继，从而更新MIN_SORT_GAP的答案。

再用一个STL nultiset(S)维护所有相邻的数的差，以便找到这个最小的差（MIN_GAP）并且还可保证插入一个数之后将原来已经不再相邻的结点的差值从S中删掉。

Accode：

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <set>
#include <cmath>

using std::multiset; using std::min;
const int maxN = 500010;
const int INF = 0x3f3f3f3f;
multiset <int> S, g;
multiset <int>::iterator iter;
int s[maxN][2]; char str[20];
//用s来记录初始列表以及在次插入的最后一个数，
//因为这时其余的数并不重要。
int Min[maxN], n, m, ans = INF;
//用Min记录每个列表内部的最小相邻差
//（即并不记录它的末尾与下一个列表的相邻差）。
bool flag = 1;

inline int getint()
{
int res = 0; char tmp; bool sgn = 1;
do tmp = getchar();
while (!isdigit(tmp) && tmp - '-');
if (tmp == '-') {tmp = getchar(); sgn = 0;}
do res = (res << 3) + (res << 1) + tmp - '0';
while (isdigit(tmp = getchar()));
return sgn ? res : -res;
} //数据中有负数，所以一定要考虑符号。

int main()
{
freopen("form.in", "r", stdin);
freopen("form.out", "w", stdout);
n = getint(); m = getint();
for (int i = 1; i < n + 1; Min[i++] = INF)
g.insert(s[i][1] = *s[i] = getint());
for (int tmp = *(iter = g.begin())++;
iter != g.end(); tmp = *iter++)
ans = min(ans, *iter - tmp);
for (int i = 1; i < n; ++i)
S.insert(abs(*s[i] - *s[i + 1]));
for (int i, x, tmp; m--; )
switch (scanf("%s", str), strlen(str))
{
case 6:
i = getint(), x = getint();
if (ans > 0)
//如果此时MIN_SORT_GAP的值已经等于0，
//那么以后都不再对g进行插入操作，直接回答即可。
{
if ((iter = g.lower_bound(x)) != g.end())
ans = min(ans, *iter - x);
//一定要保证x有后继才能更新。
if (iter != g.begin())
ans = min(ans, x - *--iter);
//一定要保证x有前驱才能更新。
g.insert(x);
}
if (flag)
//如果此时某一列表的Min值已经为0，
//那么就不插入直接输出询问结果。
{
if (i < n)
S.erase(S.find(abs(s[i][1] - *s[i + 1])));
//删除已经失效的元素相邻差。
//一定要保证i不为最后一个列表才进行次操作，
//并且只能删除S中的一个值。
if ((tmp = abs(x - s[i][1])) < Min[i])
{
if (Min[i] < INF)
S.erase(S.find(Min[i]));
//这句可以不要，但是为了效率可以加上。
S.insert(Min[i] = tmp);
} //更新该列表的Min值。
if (i < n)
S.insert(abs((s[i][1] = x) - *s[i + 1]));
//将新得到的该列表尾部与下一列表首部之差加入S，
//一定要保证i不为最后一个列表才进行此操作。
}
flag = flag && Min[i];
break;
case 7: printf("%d\n", *S.begin()); break;
case 12: printf("%d\n", ans); break;
}
return 0;
}

手打Size Balanced Tree（超时）：

#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <string>

const int maxN = 500010, INF = 0x3f3f3f3f;
class SBT
{
private:
int key[maxN << 2], sz[maxN << 2], T;
int lc[maxN << 2], rc[maxN << 2], tot;
void Zig(int &T)
{
int tmp = lc[T]; lc[T] = rc[tmp];
rc[tmp] = T; sz[tmp] = sz[T];
sz[T] = sz[lc[T]] + sz[rc[T]] + 1;
T = tmp; return;
}
void Zag(int &T)
{
int tmp = rc[T]; rc[T] = lc[tmp];
lc[tmp] = T; sz[tmp] = sz[T];
sz[T] = sz[lc[T]] + sz[rc[T]] + 1;
T = tmp; return;
}
void maintain(int &T, bool flag)
{
if (!T || !lc[T] && !rc[T]) return;
if (!flag)
{
if (sz[lc[lc[T]]] > sz[rc[T]]) Zig(T);
else if (sz[rc[lc[T]]] > sz[rc[T]])
{Zag(lc[T]); Zig(T);}
else return;
}
else
{
if (sz[rc[rc[T]]] > sz[lc[T]]) Zag(T);
else if (sz[lc[rc[T]]] > sz[lc[T]])
{Zig(rc[T]); Zag(T);}
else return;
}
maintain(lc[T], 0); maintain(rc[T], 1);
maintain(T, 0); maintain(T, 1);
return;
}
void Ins(int &T, int v)
{
if (!T)
{sz[T = ++tot] = 1; key[T] = v; return;}
++sz[T];
if (v < key[T]) Ins(lc[T], v);
else Ins(rc[T], v);
maintain(T, v >= key[T]);
return;
}
int Del(int &T, int v)
{
--sz[T];
if (v == key[T]
|| v < key[T] && !lc[T]
|| v > key[T] && !rc[T])
{
int tmp = key[T];
if (!lc[T] || !rc[T]) T = lc[T] + rc[T];
else key[T] = Del(lc[T], key[T]);
return tmp;
}
if (v < key[T]) return Del(lc[T], v);
else return Del(rc[T], v);
}
int pred(int &T, int v, int ans)
{
if (!T) return ans;
if (key[T] < v && key[T] > ans) ans = key[T];
if (v < key[T]) return pred(lc[T], v, ans);
else return pred(rc[T], v, ans);
}
int succ(int &T, int v, int ans)
{
if (!T) return ans;
if (!(key[T] < v) && key[T] < ans) ans = key[T];
if (v < key[T]) return succ(lc[T], v, ans);
else return succ(rc[T], v, ans);
}
int min(int T) {return lc[T] ? min(lc[T]) : key[T];}
int max(int T) {return rc[T] ? max(rc[T]) : key[T];}
public:
SBT(): tot(0), T(0)
{
memset(key, 0, sizeof key);
memset(lc, 0, sizeof lc);
memset(rc, 0, sizeof rc);
memset(sz, 0, sizeof sz);
}
void Ins(int v) {Ins(T, v); return;}
void Del(int v) {Del(T, v); return;}
int pred(int v) {return pred(T, v, ~INF);}
int succ(int v) {return succ(T, v, INF);}
int min() {return min(T);}
int max() {return max(T);}
} S, g; char str[20];
int s[maxN][2], Min[maxN], n, m, ans = INF;

inline int getint()
{
int res = 0; char tmp; bool sgn = 1;
do tmp = getchar();
while (!isdigit(tmp) && tmp - '-');
if (tmp == '-') {sgn = 0; tmp = getchar();}
do res = (res << 3) + (res << 1) + tmp - '0';
while (isdigit(tmp = getchar()));
return sgn ? res : -res;
}

int main()
{
freopen("form.in", "r", stdin);
freopen("form.out", "w", stdout);
n = getint(), m = getint();
for (int i = 1; i < n + 1; ++i)
{
*s[i] = s[i][1] = getint();
int pre = g.pred(*s[i]),
suc = g.succ(*s[i]);
ans = std::min(ans, suc - *s[i]);
ans = std::min(ans, *s[i] - pre);
g.Ins(*s[i]);
}
for (int i = 1; i < n; ++i)
S.Ins(abs(*s[i] - *s[i + 1]));
memset(Min, 0x3f, sizeof Min);
bool flag = 1;
for (int i, val, tmp; m; --m)
switch (scanf("%s", str), strlen(str))
{
case 6:
i = getint(), val = getint();
if (ans > 0)
{
int pre = g.pred(val), suc = g.succ(val);
if (val - pre < ans) ans = val - pre;
if (suc - val < ans) ans = suc - val;
g.Ins(val);
}
if (flag)
{
if (i < n) S.Del(abs(s[i][1] - *s[i + 1]));
if ((tmp = abs(s[i][1] - val)) < Min[i])
{
if (!tmp) {flag = 0; break;}
if (Min[i] < INF) S.Del(Min[i]);
S.Ins(Min[i] = tmp);
}
s[i][1] = val;
if (i < n) S.Ins(abs(val - *s[i + 1]));
}
break;
case 7: printf("%d\n", S.min()); break;
case 12: printf("%d\n", ans); break;
}
return 0;
}