【BZOJ4016】【FJOI2014】最短路径树问题

题意：

Description

给一个包含n个点，m条边的无向连通图。从顶点1出发，往其余所有点分别走一次并返回。

往某一个点走时，选择总长度最短的路径走。若有多条长度最短的路径，则选择经过的顶点序列字典序最小的那条路径(如路径A为1,32,11，路径B为1,3,2,11，路径B字典序较小。注意是序列的字典序的最小，而非路径中节点编号相连的字符串字典序最小)。到达该点后按原路返回，然后往其他点走，直到所有点都走过。

可以知道，经过的边会构成一棵最短路径树。请问，在这棵最短路径树上，最长的包含K个点的简单路径长度为多长？长度为该最长长度的不同路径有多少条？

这里的简单路径是指：对于一个点最多只经过一次的路径。不同路径是指路径两端端点至少有一个不同，点A到点B的路径和点B到点A视为同一条路径。

Input

第一行输入三个正整数n,m，K，表示有n个点m条边，要求的路径需要经过K个点。接下来输入m行，每行三个正整数Ai,Bi,Ci(1<=Ai,Bi<=n,1<=Ci<=10000)，表示Ai和Bi间有一条长度为Ci的边。数据保证输入的是连通的无向图。

Output

输出一行两个整数，以一个空格隔开，第一个整数表示包含K个点的路径最长为多长，第二个整数表示这样的不同的最长路径有多少条。

n<=30000,m<=60000，2<=K<=n

题解：

一眼题啊。。。SBFA写挂能怪谁QAQ

先把最小路径树建出来，然后就是点分治经典问题了；

关于最小路径树：

先以1为源点跑一边最短路，然后把对最短路没有贡献的边去掉，再按照字典序dfs一次把非树边去掉（有可能有多个最短路）即可。

代码：

 #include<algorithm>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<cmath>
 #include<queue>
 #define inf 2147483647
 #define eps 1e-9
 using namespace std;
 typedef long long ll;
 struct edge{
     int v,w,next;
 }a[],_a[],__a[];
 struct _edge{
     int u,v,w;
     friend bool operator <(_edge a,_edge b){
         return a.u==b.u?a.v>b.v:a.u<b.u;
     }
 }e[];
 int n,m,k,u,v,w,ans=,anss,rt,S,tot=,_tot=,__tot=,siz[],mx[],head[],_head[],__head[],f[],g[],_f[],_g[],dis[];
 bool used[],vis[];
 void add(int u,int v,int w){
     a[++tot].v=v;
     a[tot].w=w;
     a[tot].next=head[u];
     head[u]=tot;
 }
 void _add(int u,int v,int w){
     _a[++_tot].v=v;
     _a[_tot].w=w;
     _a[_tot].next=_head[u];
     _head[u]=_tot;
 }
 void __add(int u,int v,int w){
     __a[++__tot].v=v;
     __a[__tot].w=w;
     __a[__tot].next=__head[u];
     __head[u]=__tot;
 }
 void spfa(){
     queue<int>q;
     bool isin[];
     memset(isin,,sizeof(isin));
     q.push();
     isin[]=true;
     dis[]=;
     while(!q.empty()){
         int u=q.front();
         q.pop();
         isin[u]=false;
         for(int tmp=_head[u];tmp!=-;tmp=_a[tmp].next){
             int v=_a[tmp].v;
             if(dis[v]>dis[u]+_a[tmp].w){
                 dis[v]=dis[u]+_a[tmp].w;
                 if(!isin[v]){
                     isin[v]=true;
                     q.push(v);
                 }
             }
         }
     }
     sort(e+,e+m*+);
     for(int i=;i<=m*;i++){
         if(dis[e[i].v]==dis[e[i].u]+e[i].w){
             __add(e[i].u,e[i].v,e[i].w);
         }
     }
 }
 void build(int u){
     used[u]=true;
     for(int tmp=__head[u];tmp!=-;tmp=__a[tmp].next){
         int v=__a[tmp].v,w=__a[tmp].w;
         if(!used[v]){
             //printf("%d %d %d\n",u,v,w);
             add(u,v,w);
             add(v,u,w);
             build(v);
         }
     }
 }
 void dfsrt(int u,int fa){
     siz[u]=;
     mx[u]=;
     for(int tmp=head[u];tmp!=-;tmp=a[tmp].next){
         int v=a[tmp].v;
         if(v!=fa&&!vis[v]){
             dfsrt(v,u);
             mx[u]=max(mx[u],siz[v]);
             siz[u]+=siz[v];
         }
     }
     mx[u]=max(mx[u],S-siz[u]);
     if(mx[u]<mx[rt])rt=u;
 }
 void dfs(int u,int fa,int dpt,int ww){
     if(dpt>k)return;
     if(ww>_f[dpt]){
         _f[dpt]=ww;
         _g[dpt]=;
     }else if(ww==_f[dpt]){
         _g[dpt]++;
     }
     for(int tmp=head[u];tmp!=-;tmp=a[tmp].next){
         int v=a[tmp].v;
         if(v!=fa&&!vis[v]){
             dfs(v,u,dpt+,ww+a[tmp].w);
         }
     }
 }
 void divide(int u){
     f[]=,g[]=;
     for(int i=;i<=k;i++)f[i]=g[i]=;
     vis[u]=true;
     for(int tmp=head[u];tmp!=-;tmp=a[tmp].next){
         int v=a[tmp].v,w=a[tmp].w;
         if(!vis[v]){
             for(int i=;i<=k;i++)_f[i]=_g[i]=;
             dfs(v,,,w);
             for(int i=;i<=k;i++){
                 if(ans<f[k-i]+_f[i]){
                     ans=f[k-i]+_f[i];
                     anss=g[k-i]*_g[i];
                 }else if(ans==f[k-i]+_f[i]){
                     anss+=g[k-i]*_g[i];
                 }
             }
             for(int i=;i<=k;i++){
                 if(f[i]<_f[i]){
                     f[i]=_f[i];
                     g[i]=_g[i];
                 }else if(f[i]==_f[i]){
                     g[i]+=_g[i];
                 }
             }
         }
     }
     for(int tmp=head[u];tmp!=-;tmp=a[tmp].next){
         int v=a[tmp].v;
         if(!vis[v]){
             rt=,S=siz[v];
             dfsrt(v,);
             divide(rt);
         }
     }
 }
 int main(){
     memset(dis,0x3f,sizeof(dis));
     memset(head,-,sizeof(head));
     memset(_head,-,sizeof(_head));
     memset(__head,-,sizeof(__head));
     memset(used,,sizeof(used));
     memset(vis,,sizeof(vis));
     scanf("%d%d%d",&n,&m,&k);
     k--;
     for(int i=;i<=m;i++){
         scanf("%d%d%d",&u,&v,&w);
         _add(u,v,w);
         _add(v,u,w);
         e[i*-]=(_edge){u,v,w};
         e[i*]=(_edge){v,u,w};
     }
     spfa();
     build();
     mx[rt=]=,S=n;
     dfsrt(,);
     divide(rt);
     printf("%d %d",ans,anss);
     return ;
 }

PS：BZOJ数据极水，我写了SPFA+没判字典序都过了