Codeforces 650D. Zip-line (动态LIS) （可持久化线段树 或 离线+树状数组）

题意： 给定一个长度为n的数列，和m个询问，每个询问的格式是：将原数组的第a个数改成b之后，数组的最长上升子序列（LIS）的长度。

做法：可持久化线段树  或  离线+树状数组

令 h[ ] 为原数组，LIS_L[ i ] 表示以 i 结尾的LIS长度，LIS_R[ i ] 表示以 i 开头的LIS长度。这俩数组用普通LIS算法O(nlog2(n))求出。

然后来分析一下询问怎么处理：

在 h[a]=b之后，整个数列的LIS分两部分，一是包含b的LIS和不包含b的LIS。

包含b的LIS： 

1. 在 i < a 且 h[ i ] < b 的所有LIS_L[ i ]中求最大值，这是可以接在b之前的最大LIS长度。

2. 在 i > a 且 h[ i ] > b 的所有LIS_R[ i ]中求最大值，这是可以接在b之后的最大LIS长度。

所以包含b的LIS长度就是上面两个长度之和再加上一。

不包含b的LIS：

假设原数组的LIS长度为k，挖掉下标为a的这个数之后，有两种情况。

1. 所有的LIS都包括h[a]（这里是指原数组的h[a]）,这时新LIS长度为 k - 1.

2.至少有一个LIS不包括h[a]，这时LIS长度不受影响，仍为k。

对上面两个值求最大值，就是询问的答案。

所以问题就只剩下了两个：

问题一：对于包含b的LIS，如何快速求出那两个值。

问题二：对于不包含b的LIS，怎么判断是否所有的LIS都经过h[a]。

问题一： 可持久化线段树      或者    离线+树状数组 

要求的值：在 i < a 且 h[ i ] < b 的所有LIS_L[ i ]中求最大值。

可持久化线段树：

注意到这里有两个限制条件，h[ i ] < b 这个条件，可以将所有数值离散化，然后将所有LIS_L的值都加入进去，

不过，每个LIS_L[ i ]加入的横坐标是h[i]对应的排名，这样通过线段树的区间查询，就可以找到h[ i ] < b 的所有LIS_L值。

问题在于第一个条件，要求 i < a ，也就是说，随便给一个i，要知道前 i 个数形成的上述线段树，明显用可持久化线段树。

直接建n棵树，对每个 i 值建立前 i 个值形成的线段树。空间复杂度O(nlog2(n)),时间复杂度O(nlog2(n))。

问题解决，R那边对称着写一写就好了。

离线+树状数组：

上面的解法中，h[ i ] < b这条件是靠线段树区间询问来解决的，而 i < a 这个条件是利用了可持久化数据结构。

另一种解决 i < a 这个条件的做法就是将询问离线，也就是说，在每个 i 上，记录有多少个询问需要前 i 个LIS_L组成的线段树。

在依次将元素加入线段树的同时，遇到可以计算的询问，就计算，这样的话，只需要普通的线段树来维护最大值就行了。

然后维护最大值用树状数组会更快，所以就直接离线+树状数组解决。

从左到右扫描一遍，再从右往左扫描一遍，就计算完毕。

问题二：

首先一个结论：如果一个数h[a]存在于多个LIS中，那么它在多个LIS中的排名是一样的，比如它在某个LIS中是第二个数，那么它在所有LIS中都是第二个数。

用数组pos[ i ] 来存每个数在LIS中的位置，0表示不在LIS中。

如果LIS_L[ i ] + LIS_R[ i ] = k + 1 那么，这个数就在LIS中，并且位置是 LIS_L[ i ]。

否则，不在LIS中。

然后用Count数组，对所有的位置进行统计，Count[ j ] 表示有多少个数可以担任位置 j 。

这样处理完之后，对于i来说，只要 Count[ pos[ i ] ] 等于 1，就表示所有LIS都经过这个数，所以拿走之后LIS长度为 k - 1.

否则，LIS长度为 k 。

两个问题都解决了，这题也就做出来了。

终于又碰到一题可以用可持久化线段树了，真是不容易。虽然这题每段代码都是左写一遍右写一遍，但是还是写的很爽。

数组开小了一点点WA了好几次，只小了一点点，所以越界了一点点但是没有访问到非法内存，所以仍然报的是WA而不是RE。

可持久化线段树(1933ms  201968KB)：

/* 1933 ms201968 KB  */ #include <iostream>#include <cstdio>#include <cmath>#include <cstring>#include <algorithm>#define out(i) <<#i<<"="<<(i)<<"  "#define OUT1(a1) cout out(a1) <<endl#define OUT2(a1,a2) cout out(a1) out(a2) <<endl#define OUT3(a1,a2,a3) cout out(a1) out(a2) out(a3)<<endl#define maxn 400007using namespace std;//离散化 int Rank[maxn],Rn;void SetRank(int n){sort(Rank+1,Rank+n+1);Rn = 1;for(int i=2;i<=n;++i)if(Rank[i]^Rank[i-1])Rank[++Rn]=Rank[i];}int GetRank(int x){int L=1,R=Rn,M;//[L,R] first >= xwhile(L^R){M = (L+R)>>1;if(Rank[M] < x) L = M + 1;else R = M;}return L;}int GetRank_R(int x){int L=1,R=Rn,M;//[L,R] first > xwhile(L^R){M = (L+R)>>1;if(Rank[M] <= x) L = M + 1;else R = M;}return L;}//题目数据 int n,m,a,b,k;int h[maxn];//LIS部分int LIS_L[maxn],LIS_R[maxn],Len[maxn],Ln;int Test_L(int v){int L=0,R=Ln+1,M;//[L,R)  last < vwhile(L + 1 < R){M = (L + R) >> 1;if(Len[M] < v) L = M;else R = M;}return L;}int Test_R(int v){int L=0,R=Ln+1,M;//[L,R) last > vwhile(L + 1 < R){M = (L + R) >> 1;if(Len[M] > v) L = M;else R = M;}return L;}void LIS(){Len[0]=Ln=0;for(int i=1;i<=n;++i){LIS_L[i] = Test_L(h[i]) + 1;if(Ln < LIS_L[i]) Len[++Ln] = h[i];else Len[LIS_L[i]]=min(Len[LIS_L[i]],h[i]);}k = Ln;//记录最长LIS Len[0]=1000000001;Ln=0;for(int i=n;i>=1;--i){LIS_R[i] = Test_R(h[i]) + 1;if(Ln < LIS_R[i]) Len[++Ln] = h[i];else Len[LIS_R[i]]=max(Len[LIS_R[i]],h[i]);}}//主席树部分int LPS_L[maxn*20],LPS_R[maxn*20],LPS_V[maxn*20],LPS_T[maxn],LPS_TP;void LPS_Add(int &rt,int l,int r,int x,int v){++LPS_TP;LPS_L[LPS_TP]=LPS_L[rt];LPS_R[LPS_TP]=LPS_R[rt];LPS_V[LPS_TP]=max(LPS_V[rt],v);rt = LPS_TP;if(l==r) return;int m = (l + r) >> 1;if(x <= m) LPS_Add(LPS_L[rt],l,m,x,v);else       LPS_Add(LPS_R[rt],m+1,r,x,v);}void LPS_Build(){LPS_L[0]=LPS_R[0]=LPS_V[0]=LPS_T[0]=LPS_TP=0;for(int i=1;i<=n;++i){LPS_Add(LPS_T[i]=LPS_T[i-1],1,Rn,GetRank(h[i]),LIS_L[i]);}}int LPS_Query(int rt,int l,int r,int x){if(l == r) return LPS_V[rt];int m = (l + r) >> 1;if(x <= m) return LPS_Query(LPS_L[rt],l,m,x);else return max(LPS_V[LPS_L[rt]],LPS_Query(LPS_R[rt],m+1,r,x));}int RPS_L[maxn*20],RPS_R[maxn*20],RPS_V[maxn*20],RPS_T[maxn],RPS_TP;void RPS_Add(int &rt,int l,int r,int x,int v){++RPS_TP;RPS_L[RPS_TP]=RPS_L[rt];RPS_R[RPS_TP]=RPS_R[rt];RPS_V[RPS_TP]=max(RPS_V[rt],v);rt = RPS_TP;if(l==r) return;int m = (l + r) >> 1;if(x <= m) RPS_Add(RPS_L[rt],l,m,x,v);else       RPS_Add(RPS_R[rt],m+1,r,x,v);}void RPS_Build(){RPS_L[n+1]=RPS_R[n+1]=RPS_V[n+1]=RPS_T[n+1]=RPS_TP=0;for(int i=n;i>=1;--i){RPS_Add(RPS_T[i]=RPS_T[i+1],1,Rn,GetRank(h[i]),LIS_R[i]);}}int RPS_Query(int rt,int l,int r,int x){if(l == r) return RPS_V[rt];int m = (l + r) >> 1;if(x <= m) return max(RPS_Query(RPS_L[rt],l,m,x),RPS_V[RPS_R[rt]]); else return RPS_Query(RPS_R[rt],m+1,r,x);}int Count[maxn];//每种位置的数的数量int pos[maxn];//第i个数在LIS中的位置，0表示不在LIS中 int main(void){while(~scanf("%d%d",&n,&m)){for(int i=1;i<=n;++i) scanf("%d",&h[i]),Rank[i]=h[i];//离散化Rank[n+1]=0;Rank[n+2]=1000000001;SetRank(n+2);//建立LIS数组 LIS();//建主席树 LPS_Build();RPS_Build();memset(Count,0,sizeof(Count));for(int i=1;i<=n;++i){int L = LIS_L[i],R = LIS_R[i]; if(L+R==k+1){Count[pos[i]=L]++;}else pos[i]=0;} for(int i=1;i<=m;++i){scanf("%d%d",&a,&b);int _L = a - 1, _R = a + 1;int ANS1=1+LPS_Query(LPS_T[_L],1,Rn,GetRank(b)-1)+RPS_Query(RPS_T[_R],1,Rn,GetRank_R(b));int ANS2=Count[pos[a]]^1?k:k-1;printf("%d\n",max(ANS1,ANS2));}}return 0;}

离线+树状数组（873 ms 39200 KB）：

/*  873 ms<span style="white-space:pre"></span>39200 KB */ #include <iostream>#include <cstdio>#include <cmath>#include <cstring>#include <algorithm>#include <list>#define out(i) <<#i<<"="<<(i)<<"  "#define OUT1(a1) cout out(a1) <<endl#define OUT2(a1,a2) cout out(a1) out(a2) <<endl#define OUT3(a1,a2,a3) cout out(a1) out(a2) out(a3)<<endl#define maxn 400007using namespace std;struct Node{int id,v;Node(){}Node(int id,int v):id(id),v(v){}};list<Node> List[maxn];//离散化 int Rank[maxn<<1],Rn;void SetRank(int n){sort(Rank+1,Rank+n+1);Rn = 1;for(int i=2;i<=n;++i)if(Rank[i]^Rank[i-1])Rank[++Rn]=Rank[i];}int GetRank(int x){int L=1,R=Rn,M;//[L,R] first >= xwhile(L^R){M = (L+R)>>1;if(Rank[M] < x) L = M + 1;else R = M;}return L;}//题目数据 int n,m,a[maxn],b[maxn],k;int h[maxn];//LIS部分int LIS_L[maxn],LIS_R[maxn],Len[maxn],Ln;int Test_L(int v){int L=0,R=Ln+1,M;//[L,R)  last < vwhile(L + 1 < R){M = (L + R) >> 1;if(Len[M] < v) L = M;else R = M;}return L;}int Test_R(int v){int L=0,R=Ln+1,M;//[L,R) last > vwhile(L + 1 < R){M = (L + R) >> 1;if(Len[M] > v) L = M;else R = M;}return L;}void LIS(){Len[0]=Ln=0;for(int i=1;i<=n;++i){LIS_L[i] = Test_L(h[i]) + 1;if(Ln < LIS_L[i]) Len[++Ln] = h[i];else Len[LIS_L[i]]=min(Len[LIS_L[i]],h[i]);}k = Ln;//记录最长LIS Len[0]=1000000001;Ln=0;for(int i=n;i>=1;--i){LIS_R[i] = Test_R(h[i]) + 1;if(Ln < LIS_R[i]) Len[++Ln] = h[i];else Len[LIS_R[i]]=max(Len[LIS_R[i]],h[i]);}}//树状数组int BIT_L[maxn<<1],BIT_R[maxn<<1];void Add_L(int x,int v){while(x <= Rn){BIT_L[x]=max(BIT_L[x],v);x+=x&-x;}}int Query_L(int x){int ANS = 0;while(x > 0){ANS = max(ANS,BIT_L[x]);x-=x&-x;}return ANS;}void Add_R(int x,int v){while(x > 0){BIT_R[x]=max(BIT_R[x],v);x-=x&-x;}}int Query_R(int x){int ANS = 0;while(x <= Rn){ANS = max(ANS,BIT_R[x]);x+=x&-x;}return ANS;}int Count[maxn];//每种位置的数的数量int pos[maxn];//第i个数在LIS中的位置，0表示不在LIS中 int L[maxn],R[maxn];//记录左右的答案 int main(void){while(~scanf("%d%d",&n,&m)){for(int i=1;i<=n;++i) scanf("%d",&h[i]),Rank[i]=h[i],List[i].clear();//读取询问for(int i=1;i<=m;++i){scanf("%d%d",&a[i],&b[i]);List[a[i]].push_back(Node(i,b[i]));Rank[n+i]=b[i];}//离散化Rank[n+m+1]=0;Rank[n+m+2]=1000000001;SetRank(n+m+2);//建立LIS数组 LIS();//计算Count和pos memset(Count,0,sizeof(Count));for(int i=1;i<=n;++i){int L = LIS_L[i],R = LIS_R[i]; if(L+R==k+1){++Count[pos[i]=L];}else pos[i]=0;}//开始计算memset(BIT_L,0,sizeof(BIT_L));for(int i=1;i<=n;++i){for(list<Node>::iterator it=List[i].begin();it!=List[i].end();++it){L[it->id]=Query_L(GetRank(it->v)-1);}Add_L(GetRank(h[i]),LIS_L[i]);}memset(BIT_R,0,sizeof(BIT_R));for(int i=n;i>=1;--i){for(list<Node>::iterator it=List[i].begin();it!=List[i].end();++it){R[it->id]=Query_R(GetRank(it->v)+1);}Add_R(GetRank(h[i]),LIS_R[i]);}for(int i=1;i<=m;++i){int ANS1 = 1 + L[i]+R[i];int ANS2 = Count[pos[a[i]]]!=1?k:k-1;printf("%d\n",max(ANS1,ANS2));}}return 0;}