ccpc2020秦皇島Kingdom‘s Power（貪心）

題意

題意是在樹的根節點有無數個軍隊。每週可以命令僅一隻軍隊沿一條邊移動。文最短多久可以佔領整棵樹。

題解

這個我是貪心做的。可以發現，如果從某個葉子A走向下一個葉子B，如果lca(A,B)到A的距離比更到lca的距離大的話，就不能從A往回走，要再來一支新的軍隊。有幾個貪心的原則。

• 首先明確的是，當某隻軍隊佔領某個葉子結點後，他如果有多種從某個公共祖先去別的葉子結點， 且進入那些葉子結點就回不上去（由於太深）的走法，此時有幾種選取下一個葉子的方法且互不相交，應該選哪個呢？應該選公共祖先最遠離根的那個。應為如果公共祖先更高就會繞路變多，走的距離變大。
• 要儘可能先走深度淺的。這樣更容易走更多的回馬槍，避免重新派軍隊的浪費。根據這個原則每棵子樹最後一個佔領的結點應該是這棵字樹深度最大的點。
• 如果有公共祖先相同的兩棵樹，現在他們上面都有比較深的葉子，走到一顆子樹就不可能回到另一棵樹的話，這個實際上隨便選一棵樹走就行，步數是一樣的。

所以直接把每個節點的各個子節點，按最大深度升序排序，完了能得到一個葉子結點序列。只要依次處理，看走到下一個葉子要不要派新軍隊。

AC程式碼

我的排序加樹剖1980ms卡過了。但往上有線性dp的做法。

#include <bits/stdc++.h>
using namespace std;
const int NN=1000100;
const int oo=2e9+10;
//int sum[NN*4],maxn[NN*4];
//int a[NN],w[NN];
int top[NN],siz[NN],son[NN],fath[NN],deep[NN];
vector <int> con[NN];
int cnt,pos[NN];
// void up(int cur){
// 	sum[cur]=sum[cur<<1]+sum[cur<<1|1];
// 	maxn[cur]=max(maxn[cur<<1],maxn[cur<<1|1]);
// }
int n;
int cntleav=0;
int leav[NN];
int minheight[NN];
bool cmp_minheight(int x,int y){
    return minheight[x]<minheight[y];
}
void dfs1(int cur,int fa){
	deep[cur]=deep[fa]+1;
	siz[cur]=1;
	son[cur]=0;
	fath[cur]=fa;
	int maxnn=0;
	int numson=con[cur].size();
	minheight[cur]=0;
	if(numson==0)minheight[cur]=0;
	for(int i=0;i<numson;i++){
		int nex=con[cur][i];
		if(nex!=fa){
			dfs1(nex,cur);
			minheight[cur]=max(minheight[cur],minheight[nex]+1);
			siz[cur]+=siz[nex];
			if(siz[nex]>maxnn){
				maxnn=siz[nex];
				son[cur]=nex;
			}
		}
	}
}
void dfs2(int cur,int fa,int k){
	top[cur]=k;
	pos[cur]=++cnt;
	//a[pos[cur]]=w[cur];
	if(son[cur])dfs2(son[cur],cur,k);
	int numson=con[cur].size();
	for(int i=0;i<numson;i++){
		int nex=con[cur][i];
		if(nex!=fa&&nex!=son[cur]){
			dfs2(nex,cur,nex);
		}
	}
}
void dfsl(int cur,int fa){
	//a[pos[cur]]=w[cur];
	int numson=con[cur].size();
	if(numson==0)leav[++cntleav]=cur;
	for(int i=0;i<numson;i++){
		int nex=con[cur][i];
		if(nex!=fa){
			dfsl(nex,cur);
		}
	}
}
int lca(int u,int v){
	int ans=0;
	while(top[u]!=top[v]){
		if(deep[top[u]]<deep[top[v]])swap(u,v);
		//ans=max(ans,ask_max(1,1,n,pos[top[u]],pos[u]) );
        ans+=pos[u]-pos[top[u]]+1;
		u=fath[top[u]];
	}
	if(deep[u]<deep[v])swap(u,v);
	return v;
}
int main()
{
    int t;scanf("%d",&t);
    for(int z=1;z<=t;z++){
        int n;scanf("%d",&n);
        for(int i=1;i<=n;i++)con[i].clear();
        for(int i=2;i<=n;i++){
            int x;scanf("%d",&x);
            con[x].push_back(i);
        }
        cnt=0;cntleav=0;
        dfs1(1,0);
        for(int i=1;i<=n;i++){
            //printf("%d\n",minheight[i]);
            sort(con[i].begin(),con[i].end(),cmp_minheight);

        }
        dfsl(1,0);
        dfs2(1,0,1);
        int neww=1;
        long long ans=0;
        int lastfa=0;
        for(int i=1;i<=cntleav;i++){
                //printf("*%d\n",leav[i]);
            if(neww==1)ans+=deep[leav[i]]-1;
            else ans+=deep[leav[i-1]]+deep[leav[i]]-(deep[lastfa]<<1);

            if(i==cntleav)break;
            int lcfa=lca(leav[i],leav[i+1]);
            if(deep[leav[i]]-deep[lcfa]>deep[lcfa]-1){
                neww=1;
            }
            else{//printf("*%d\n",deep[leav[i]]-deep[lcfa]);
                neww=0;
            }lastfa=lcfa;
        }
        printf("Case #%d: ",z);
        printf("%lld\n",ans);
    }
    return 0;
}