[BZOJ4016][FJOI2014]最短路径树问题(dijkstra+点分治)

4016: [FJOI2014]最短路径树问题

Time Limit: 5 Sec  Memory Limit: 512 MB
Submit: 1796  Solved: 625
[Submit][Status][Discuss]

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&
lt;=10000)，表示Ai和Bi间有一条长度为Ci的边。数据保证输入的是连通的无向图。

 

 

Output

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

 

Sample Input

6 6 4
1 2 1
2 3 1
3 4 1
2 5 1
3 6 1
5 6 1

Sample Output

3 4

HINT

对于所有数据n<=30000,m<=60000，2<=K<=n。

数据保证最短路径树上至少存在一条长度为K的路径。

2016.12.7新加数据一组by - wyx-150137

Source

这题的题目已经告诉我们该怎么做了，先用dijkstra（或者spfa）找出最短路径图存在vector里，然后以字典序的优先原则dfs建出最短路径树，最后在树上点分治就好了。

写的时候头是晕的，加上数组很多，错误百出。

代码用时:2h

 #include<cstdio>
 #include<queue>
 #include<vector>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 #define For(i,x) for (int i=h[x],k; i; i=nxt[i])
 using namespace std;

 const int N=,inf=;
 int n,m,K,u,v,w,rt,sm,sum,mx,ans,num,vi[N],vv[N],dep[N],vis[N],d[N],s[N],sz[N],dis[N],sf[N],sg[N],f[N],g[N];
 struct P{ int x,v; };
 bool operator<(P a,P b){ return a.v>b.v; }
 priority_queue<P>Q;
 vector<int>V[N];

 struct E{
     int cnt,nxt[N<<],to[N<<],val[N<<],h[N];
     void add(int u,int v,int w){ nxt[++cnt]=h[u]; to[cnt]=v; val[cnt]=w; h[u]=cnt; }
     void dijkstra(){
         rep(i,,n) d[i]=inf; d[]=; Q.push((P){,});
         while (!Q.empty()){
             int x=Q.top().x; Q.pop();
             if (vi[x]) continue; vi[x]=;
             For(i,x) if (d[k=to[i]]+val[i]==d[x]) V[k].push_back(i^);
             For(i,x) if (d[k=to[i]]>d[x]+val[i]) d[k]=d[x]+val[i],Q.push((P){k,d[k]});
         }
     }

     void getroot(int x,int fa){
         sz[x]=; s[x]=;
         For(i,x) if (!vis[k=to[i]] && k!=fa) getroot(k,x),sz[x]+=sz[k],s[x]=max(s[x],sz[k]);
         s[x]=max(s[x],sum-sz[x]);
         if (s[x]<s[rt]) rt=x;
     }

     void getdeep(int x,int fa){
         For(i,x) if (!vis[k=to[i]] && k!=fa){
             dep[k]=dep[x]+; dis[k]=dis[x]+val[i]; mx=max(mx,dep[k]);
             if (dis[k]>f[dep[k]]) f[dep[k]]=dis[k],sf[dep[k]]=;
                 else if (dis[k]==f[dep[k]]) sf[dep[k]]++;
             getdeep(k,x);
         }
     }

     void que(int x){
         vis[x]=; int sm=;
         For(i,x) if (!vis[k=to[i]]){
             mx=dep[k]=; dis[k]=f[]=val[i]; sf[]=; getdeep(to[i],x);
             rep(j,,min(mx,K)){
                 if (ans<f[j]+g[K-j]) ans=f[j]+g[K-j],num=sf[j]*sg[K-j];
                 else if (ans==f[j]+g[K-j]) num+=sf[j]*sg[K-j];
             }
             rep(j,,min(mx,K)){
                 if (g[j]<f[j]) g[j]=f[j],sg[j]=sf[j];
                 else if (g[j]==f[j]) sg[j]+=sf[j];
             }
             rep(j,,mx) f[j]=-inf,sf[j]=;
             sm=max(sm,mx);
         }
         rep(i,,min(sm,K)) g[i]=-inf,sg[i]=;
         For(i,x) if (!vis[k=to[i]]) rt=,sum=sz[k],getroot(k,x),que(rt);
     }
 }G,G1;
 bool cmp(int a,int b){ return G.to[a]<G.to[b]; }

 void dfs(int x){
     sort(V[x].begin(),V[x].end(),cmp);
     rep(i,,(int)V[x].size()-) if (!vv[G.to[V[x][i]]])
         vv[G.to[V[x][i]]]=,G1.add(x,G.to[V[x][i]],G.val[V[x][i]]),G1.add(G.to[V[x][i]],x,G.val[V[x][i]]),dfs(G.to[V[x][i]]);
 }

 int main(){
     freopen("bzoj4016.in","r",stdin);
     freopen("bzoj4016.out","w",stdout);
     scanf("%d%d%d",&n,&m,&K); G.cnt=G1.cnt=; K--;
     rep(i,,m) scanf("%d%d%d",&u,&v,&w),G.add(u,v,w),G.add(v,u,w);
     G.dijkstra(); vv[]= ; dfs();
     g[]=; sg[]=; s[]=inf; sum=n; G1.getroot(,); G1.que(rt);
     printf("%d %d\n",ans,num);
     return ;
 }