CodeForces 722C. Destroying Array（逆向思维）

传送门 http://codeforces.com/problemset/problem/722/C

题目大意：
输入一个n长的数组，和一组1-n的排列b[1..n]，输出n行数：其中第i行代表从数组中删除第b[i]个数，剩下的“间断数组”中连续部分的和的最大值。
这样说有点绕口，举个例子。

例如：

1 3 2 5
3 4 1 2

第一次删除第三个数2，剩下[1,3] [5]两段，和值分别为4，5，最大值为5；
第二次删除第四个数5，剩下[1,3]一段，和值为4，最大值为4；
第三次删除第一个数1，剩下[3]，和值为3，最大值3；
第四次删除第二个数2，剩下空集，和值为0

所以输出

5
4
3
0

题目分析：

这道题跟之前遇到过的一道题一样，正向思维很难解决，那么从后往前思考就变成了：
每次加入一个数，并计算当前连续序列的和的最大值。

这就简单了，挺裸的并查集~~~用一个sum数组维护每一个不相交集合的和值就可以了，每次合并的时候都看看是否合并出更大和值的集合，动态维护最大值即可~
和值那块写的不太好，sum数组最理想的是代表子树的和~

就是需要注意一下有时候需要把两边的集合都连进去，有时候只要并一边~还有结果可能爆int，这里wa了好几发~

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
ll a[100005];
int p[100005];
int f[100005]; // 记录每个节点的父亲
//int Rank[100005];// 记录每个节点所在集合的高度,做路径压缩
ll sum[100005];// 记录每个节点所在集合的和
ll ans[100005];//记录最终答案
bool vis[100005];//记录每个点是不是在集合里面
ll m=0;//动态更新每个树根的最大值
int find(int x) {
    //return x==f[x]?x:f[x]=find(f[x]);
    return x==f[x]?x:find(f[x]);
}
void Union(int i,int j) {
    i=find(i);
    j=find(j);
    sum[i]=sum[j]=sum[i]+sum[j];
    // if(Rank[i]>Rank[j]) {
    //     f[j]=i;
    //     Rank[j]++;
    // }
    // else {
    //     f[i]=j;
    //     Rank[i]++;
    // }
    f[i]=j;
}
int main() {
    memset(vis,0,sizeof(vis));
    memset(Rank,0,sizeof(Rank));
    memset(sum,0,sizeof(sum));
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%I64d",&a[i]);
    for(int i=1;i<=n;i++)
        scanf("%d",&p[i]);
    ans[n]=0;
    for(int i=1;i<=n;i++)
        f[i]=i;
    for(int i=n;i>1;i--) {
        int id=p[i];//当前要加入集合的id
        sum[id]=a[id];
        if(vis[id-1])
            Union(id-1,id);
        if(vis[id+1])
            Union(id+1,id);
        if(sum[id]>m)
            m=sum[id];
        vis[id]=1;
        ans[i-1]=m;
    }
    for(int i=1;i<=n;i++) {
        printf("%I64d\n", ans[i]);
    }
}

需要注意的是，这里我删掉了路径压缩部分，提交的时间反而比加了路径压缩快~所以有时候时间复杂度并不能说明一切（路径压缩的并查集时间复杂度为$O(n\alpha(n))$,普通的最坏情况是$O(nlogn)$)

说到时间复杂度，需要记住的是不要仅仅看几层循环，要看这段代码对输入规模n到底进行了多少次操作，也可以通过递推式利用主定理求解。例如回溯法求解N皇后里面是一层循环里面调用下一层搜索，有的同学会认为复杂度是$O(n^2)$或者是$O(n)$,但其实他是对n的全排列进行遍历，故复杂度是$O(n!)$,或者利用递推式$T(n)=nT(n-1)$解出。