【Tarjan】【LCA】【动态规划】【推导】hdu6065 RXD, tree and sequence

划分出来的每个区间的答案，其实就是连续两个的lca的最小值。

即5 2 3 4 这个区间的答案是min（dep（lca（5,2）），dep（lca（2,3），dep（lca（3,4））））。

于是dp即可，f（i，j）表示前i个数，划分成j段的最优值。

只有三种决策，要么不取，继承f（i-1，j），要么将其自己作为某段的最小值，转移自f（i-1，j-1），要么将其与其前位的lca作为某段的最小值，转移自f（i-2，j-1）。

如果用tarjan预处理相邻的lca的话，复杂度是O（n*K）。

比std不知道高明到哪里去了。234ms。

UPDATE: 靠，换成动态求lca以后，明明多了一个log，变成140ms了。

#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef pair<int,int> Point;
vector<vector<int> >f;
vector<Point>ask[300005];
int a[300005],head[300005],to[600005],nxt[600005],lca[300005];
int n,k,u,v,en;
void add(int u,int v)
{
    nxt[++en]=head[u];
    head[u]=en;
    to[en]=v;
}
int FA[300005],ans[300005],dep[300005];
bool VIS[300005];
int find(int x){
	return x==FA[x] ? x : FA[x]=find(FA[x]);
}
void LCA(int u,int nowdeep)
{
    ans[u]=u;
    dep[u]=nowdeep;
    for(int i=head[u];i;i=nxt[i]) if(!dep[to[i]])
      {
        LCA(to[i],nowdeep+1);
        int f1=find(u),f2=find(to[i]);
        FA[f1]=f2;
        ans[find(u)]=u;
      }
    VIS[u]=true;
    for(int i=0;i<ask[u].size();i++)
      if(VIS[ask[u][i].first]){
      	lca[ask[u][i].second]=ans[find(ask[u][i].first)];
      }
}
int main()
{
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        f.assign(n+1,vector<int>(k+1,0));
        memset(VIS,0,sizeof(VIS));
        for(int i=1;i<=n;++i){
        	ask[i].clear();
        	FA[i]=i;
        }
        en=0;
        for(int i=1;i<=n;++i)
        {
            scanf("%d",&a[i]);
        }
        for(int i=2;i<=n;++i){
        	ask[a[i-1]].push_back(make_pair(a[i],i));
        	ask[a[i]].push_back(make_pair(a[i-1],i));
        }
        for(int i=1;i<n;++i)
        {
            scanf("%d%d",&u,&v);
            add(u,v);
            add(v,u);
        }
        LCA(1,1);
        for(int i=2;i<=n;++i)
            lca[i]=dep[lca[i]];
        for(int i=1;i<=n;++i)
        {
            int top=min(i,k);
            for(int j=0;j<=top;++j)
            {
                int nowans=99999999;
                if(j>0&&i>0)
                    nowans=min(nowans,f[i-1][j-1]+dep[a[i]]);
                if(i-2>=0&&j-1>=0&&j-1<=i-2)
                    nowans=min(nowans,f[i-2][j-1]+lca[i]);
                if(j<=i-1)
                    nowans=min(nowans,f[i-1][j]);
                f[i][j]=nowans;
            }
        }
        printf("%d
",f[n][k]);
        for(int i=1;i<=n;++i)
        {
        	dep[i]=0;
            head[i]=0;
        }
    }
    return 0;
}