H - The LCIS on the Tree HDU - 4718

The LCIS on the Tree

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 1615    Accepted Submission(s): 457

题目链接

https://vjudge.net/problem/UVA-12655

Problem Description

For a sequence S₁, S₂, ... , S_N, and a pair of integers (i, j), if 1 <= i <= j <= N and S_i < S_i+1 < S_i+2 < ... < S_j-1 < S_j , then the sequence S_i, S_i+1, ... , S_j is a CIS (Continuous Increasing Subsequence). The longest CIS of a sequence is called the LCIS (Longest Continuous Increasing Subsequence).
Now
we consider a tree rooted at node 1. Nodes have values. We have Q
queries, each with two nodes u and v. You have to find the shortest path
from u to v. And write down each nodes' value on the path, from u to v,
inclusive. Then you will get a sequence, and please show us the length
of its LCIS.

 

Input

The first line has a number T (T <= 10) , indicating the number of test cases.
For each test case, the first line is a number N (N <= 10⁵), the number of nodes in the tree.
The second line comes with N numbers v1, v2, v3 ... , v_N, describing the value of node 1 to node N. (1 <= v_i <= 10⁹)
The third line comes with N - 1 numbers p₂, p₃, p₄ ... , p_N, describing the father nodes of node 2 to node N. Node 1 is the root and will have no father.
Then comes a number Q, it is the number of queries. (Q <= 10⁵)
For next Q lines, each with two numbers u and v. As described above.

 

Output

For test case X, output "Case #X:" at the first line.
Then output Q lines, each with an answer to the query.
There should be a blank line *BETWEEN* each test case.

 

Sample Input

1
5
1 2 3 4 5
1 1 3 3
3
1 5
4 5
2 5

 

Sample Output

Case #1:
3
2
3

题意

在一棵树上，每次求一条路径最长连续上升子序列。

题解

一开始看错题，以为求最长上升子序列，然后想了好久毫无思路，一看题解发现原来我看错题了。

连续的话就不难了。

树链剖分，然后线段树记录一下该区间最长上升子序列，左端点开始的最长上升子序列长度，右端点。。。

反正就是考虑如果知道左子树和右子树的信息，如何合并。显然合并就是中间可能延长，其他的都一样。

但是在树上，x-->lca(x,y)　和　lca(x,y)-->是不一样的，x-->lca(x,y)需要求最长下降子序列，然后就是一对细节需要处理，具体看代码吧。

代码

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 #define N 500050
 struct Tree{int l,r,lb,rb,lI,rI,lD,rD,Imx,Dmx;}tr[N<<];
 struct Edge{int from,to,s;}edges[N<<];
 int n,m,cas,w[N];
 int tot,last[N];
 int cnt,fa[N],dp[N],size[N],son[N],rk[N],kth[N],top[N];
 template<typename T>void read(T&x)
 {
   ll k=; char c=getchar();
   x=;
   while(!isdigit(c)&&c!=EOF)k^=c=='-',c=getchar();
   if (c==EOF)exit();
   while(isdigit(c))x=x*+c-'',c=getchar();
   x=k?-x:x;
 }
 void read_char(char &c)
 {while(!isalpha(c=getchar())&&c!=EOF);}
 void AddEdge(int x,int y)
 {
   edges[++tot]=Edge{x,y,last[x]};
   last[x]=tot;
 }
 void dfs1(int x,int pre)
 {
   fa[x]=pre;
   dp[x]=dp[pre]+;
   size[x]=;
   son[x]=;
   for(int i=last[x];i;i=edges[i].s)
     {
       Edge &e=edges[i];
       if (e.to==pre)continue;
       dfs1(e.to,x);
       size[x]+=size[e.to];
       if(size[e.to]>size[son[x]])son[x]=e.to;
     }
 }
 void dfs2(int x,int y)
 {
   rk[x]=++cnt;
   kth[cnt]=x;
   top[x]=y;
   if (son[x]==)return;
   dfs2(son[x],y);
   for(int i=last[x];i;i=edges[i].s)
     {
       Edge &e=edges[i];
       if (e.to==fa[x]||e.to==son[x])continue;
       dfs2(e.to,e.to);
     }
 }
 void init(Tree &a){a=Tree{,,,,,,,,,};}
 template<typename T>void he(T &c,T a, T b)
 {
   if (a.Imx==){c=b;return;}
   if (b.Imx==){c=a;return;}
   c.l=a.l; c.r=b.r;
   int lena=a.r-a.l+,lenb=b.r-b.l+;
   c.lb=a.lb; c.rb=b.rb;
   c.lI=lena==a.lI&&a.rb<b.lb?lena+b.lI:a.lI;
   c.lD=lena==a.lD&&a.rb>b.lb?lena+b.lD:a.lD;
   c.rI=lenb==b.rI&&a.rb<b.lb?lenb+a.rI:b.rI;
   c.rD=lenb==b.rD&&a.rb>b.lb?lenb+a.rD:b.rD;
   c.Imx=max(a.Imx,b.Imx);
   c.Imx=max(c.Imx,a.rb<b.lb?a.rI+b.lI:);
   c.Dmx=max(a.Dmx,b.Dmx);
   c.Dmx=max(c.Dmx,a.rb>b.lb?a.rD+b.lD:);
 }
 void bt(int x,int l,int r)
 {
   tr[x].l=l; tr[x].r=r;
   if (l==r)
     {
       tr[x]={l,r,w[kth[l]],w[kth[l]],,,,,,};
       return;
     }
   int mid=(l+r)>>;
   bt(x<<,l,mid);
   bt(x<<|,mid+,r);
   he(tr[x],tr[x<<],tr[x<<|]);
 }
 Tree query(int x,int l,int r)
 {
   if (l<=tr[x].l&&tr[x].r<=r)
     return tr[x];
   int mid=(tr[x].l+tr[x].r)>>;
   Tree tp1,tp2,tp; init(tp1); init(tp2);
   if (l<=mid)tp1=query(x<<,l,r);
   if (mid<r)tp2=query(x<<|,l,r);
   he(tp,tp1,tp2);
   return tp;
 }
 int get_max(int x,int y)
 {
   int fx=top[x],fy=top[y],ans=;
   Tree tpx,tpy,tp;
   init(tpx); init(tpy);
   while(fx!=fy)
     {
       if (dp[fx]>dp[fy])
     {
       tp=query(,rk[fx],rk[x]);
       he(tpx,tp,tpx);
       x=fa[fx]; fx=top[x];
     }
       else
     {
       tp=query(,rk[fy],rk[y]);
       he(tpy,tp,tpy);
       y=fa[fy]; fy=top[y];
     }
     }
   if (dp[x]>dp[y])
     {
       tp=query(,rk[y],rk[x]);
       he(tpx,tp,tpx);
     }
   else
     {
       tp=query(,rk[x],rk[y]);
       he(tpy,tp,tpy);
     }
   ans=max(tpx.Dmx,tpy.Imx);
   ans=max(ans,tpx.lb<tpy.lb?tpx.lD+tpy.lI:);
   return ans;
 }
 void work()
 {
   if (cas)printf("\n");
   printf("Case #%d:\n",++cas);
   read(n);
   for(int i=;i<=n;i++)read(w[i]);
   for(int i=;i<=n;i++)
     {
       int x;
       read(x);
       AddEdge(x,i);
     }
   dfs1(,);
   dfs2(,);
   bt(,,n);
   read(m);
   for(int i=;i<=m;i++)
     {
       int x,y;
       read(x); read(y);
       printf("%d\n",get_max(x,y));
     }
 }
 void clear()
 {
   cnt=; tot=;
   memset(last,,sizeof(last));
 }
 int main()
 {
 #ifndef ONLINE_JUDGE
   freopen("aa.in","r",stdin);
 #endif
   int q;
   read(q);
   while(q--)
     {
       clear();
       work();
     }
 }