HDU4871 Shortest-path tree（最短路径树 + 树的点分治）

题目大概要先求一张边有权的图的根为1的最短路径树，要满足根到各点路径序列的字典序最小；然后求这棵最短路径树包含k个结点的最长路径的长度和个数。

首先先构造出这棵字典序最小的最短路径树。。好吧，我太傻逼了，不会。。保证邻接表存储邻接点有序的前提下，就能按字典序DFS一遍，在O(N+E)的时间复杂度上构造出来了。

然后就是统计路径最长长度和方案数，树上路径问题当然就是树分治了。

不多谈。。%￥……￥%……￥……连续写了200多行然后一直出数据调了2个多小时才AC。。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 #define INF (1<<30)
 #define MAXN 33333
 #define MAXM 66666*2

 struct Edge{
     int v,w,next;
 }edge[MAXM];
 int NE,head[MAXN];
 void addEdge(int u,int v,int w){
     edge[NE].v=v; edge[NE].w=w;
     edge[NE].next=head[u]; head[u]=NE++;
 }

 int d[MAXN];
 bool vis[MAXN];
 void SPFA(int n){
     for(int i=; i<=n; ++i){
         d[i]=INF; vis[i]=;
     }
     d[]=; vis[]=;
     queue<int> que;
     que.push();
     while(!que.empty()){
         int u=que.front(); que.pop();
         for(int i=head[u]; i!=-; i=edge[i].next){
             int v=edge[i].v;
             if(d[v]>d[u]+edge[i].w){
                 d[v]=d[u]+edge[i].w;
                 if(!vis[v]){
                     vis[v]=;
                     que.push(v);
                 }
             }
         }
         vis[u]=;
     }
 }

 struct Node{
     int u,v,w;
     bool operator<(const Node &nd)const{
         if(u==nd.u) return nd.v<v;
         return u<nd.u;
     }
 }node[MAXM];
 int cnt;

 void dfs(int u){
     vis[u]=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v] || d[u]+edge[i].w!=d[v]) continue;
         node[cnt].u=u; node[cnt].v=v; node[cnt].w=edge[i].w;
         ++cnt;
         dfs(v);
     }
 }

 int size[MAXN];
 void getsize(int u,int fa){
     size[u]=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v] || v==fa) continue;
         getsize(v,u);
         size[u]+=size[v];
     }
 }
 int mini,cen;
 void getcen(int u,int fa,int &tot){
     int res=tot-size[u];
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v] || v==fa) continue;
         res=max(res,size[v]);
         getcen(v,u,tot);
     }
     if(res<mini){
         mini=res;
         cen=u;
     }
 }
 int getcen(int u){
     getsize(u,u);
     mini=INF;
     getcen(u,u,size[u]);
     return cen;
 }

 int k;
 int a_val[MAXN],a_cnt[MAXN],a_rec[MAXN],an,b_val[MAXN],b_cnt[MAXN],b_rec[MAXN],bn;
 bool tag[MAXN];
 int ans_val,ans_cnt;
 void conqur_dfs(int u,int fa,int val,int tot){
     if(b_val[tot]<val){
         b_val[tot]=val;
         b_cnt[tot]=;
         if(!tag[tot]){
             tag[tot]=;
             b_rec[bn++]=tot;
         }
     }else if(b_val[tot]==val){
         ++b_cnt[tot];
     }
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v] || v==fa) continue;
         conqur_dfs(v,u,val+edge[i].w,tot+);
     }
 }
 void conqur(int u){
     an=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v]) continue;
         bn=;
         conqur_dfs(v,v,edge[i].w,);
         for(int j=; j<bn; ++j){
             if(b_rec[j]==k-){
                 if(b_val[b_rec[j]]>ans_val){
                     ans_val=b_val[b_rec[j]];
                     ans_cnt=b_cnt[b_rec[j]];
                 }else if(b_val[b_rec[j]]==ans_val){
                     ans_cnt+=b_cnt[b_rec[j]];
                 }
             }else if(b_rec[j]<k-){
                 int tmp=k--b_rec[j];
                 if(a_cnt[tmp]==) continue;
                 if(b_val[b_rec[j]]+a_val[tmp]>ans_val){
                     ans_val=b_val[b_rec[j]]+a_val[tmp];
                     ans_cnt=b_cnt[b_rec[j]]*a_cnt[tmp];
                 }else if(b_val[b_rec[j]]+a_val[tmp]==ans_val){
                     ans_cnt+=b_cnt[b_rec[j]]*a_cnt[tmp];
                 }
             }
         }
         for(int j=; j<bn; ++j){
             int tmp=b_rec[j];
             tag[tmp]=;
             a_rec[an++]=tmp;
             if(a_val[tmp]<b_val[tmp]){
                 a_val[tmp]=b_val[tmp];
                 a_cnt[tmp]=b_cnt[tmp];
             }else if(a_val[tmp]==b_val[tmp]){
                 a_cnt[tmp]+=b_cnt[tmp];
             }
             b_val[tmp]=;
             b_cnt[tmp]=;
         }
     }
     for(int i=; i<an; ++i){
         a_val[a_rec[i]]=;
         a_cnt[a_rec[i]]=;
     }
 }

 void divide(int u){
     u=getcen(u);
     vis[u]=;
     conqur(u);
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v]) continue;
         divide(v);
     }
 }

 int main(){
     int t,n,m,a,b,c;
     scanf("%d",&t);
     while(t--){
         NE=;
         memset(head,-,sizeof(head));
         scanf("%d%d%d",&n,&m,&k);
         for(int i=; i<m; ++i){
             scanf("%d%d%d",&a,&b,&c);
             node[i<<].u=a; node[i<<].v=b; node[i<<].w=c;
             node[i<<|].u=b; node[i<<|].v=a; node[i<<|].w=c;
         }
         sort(node,node+(m<<));
         for(int i=; i<(m<<); ++i){
             addEdge(node[i].u,node[i].v,node[i].w);
         }
         SPFA(n);
         cnt=;
         memset(vis,,sizeof(vis));
         dfs();
         NE=;
         memset(head,-,sizeof(head));
         for(int i=; i<cnt; ++i){
             addEdge(node[i].u,node[i].v,node[i].w);
             addEdge(node[i].v,node[i].u,node[i].w);
         }
         memset(vis,,sizeof(vis));
         ans_val=; ans_cnt=;
         divide();
         printf("%d %d\n",ans_val,ans_cnt);
     }
     return ;
 }