【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\n",f
[k]);
for(int i=1;i<=n;++i)
{
dep[i]=0;
head[i]=0;
}
}
return 0;
}