[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个点的路径最长为多长，第二个整数表示这样的不同的最长路径有多少条。

 

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

首先求字典序最小的最短路树，考虑将边拆成两条单向边，然后按终点从大到小排序，按序插入链式前向星中，保证找到的第一条最短路就是字典序最小的。

点分就比较裸了，记深度为 $i$ 时最大的路径长度为 $sum_i$ ，长度为 $sum_i$ ，且深度为 $i$ 的路径数为 $cnt_i$ 直接转移就好了。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 using namespace std;
 struct ZYYS
 {
   int u,v,d;
 }E[];
 struct Node
 {
   int next,to,d;
 }edge[];
 int num,head[],dist[],pre[],pred[];
 int size[],maxsize[],minsize,root,w[],k,ans,dep_max,n,m,cnt,c[];
 bool vis[];
 bool cmp(ZYYS a,ZYYS b)
 {
   if (a.u==b.u) return a.v>b.v;
   return a.u<b.u;
 }
 void add(int u,int v,int d)
 {
   num++;
   edge[num].next=head[u];
   head[u]=num;
   edge[num].to=v;
   edge[num].d=d;
 }
 void SPFA()
 {int i;
   queue<int>Q;
   memset(dist,/,sizeof(dist));
   Q.push();
   dist[]=;
   while (Q.empty()==)
     {
       int u=Q.front();
       Q.pop();
       vis[u]=;
       for (i=head[u];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (dist[v]>dist[u]+edge[i].d)
         {
           pre[v]=u;
           pred[v]=edge[i].d;
           dist[v]=dist[u]+edge[i].d;
           if (vis[v]==)
         {
           vis[v]=;
           Q.push(v);
         }
         }
     }
     }
 }
 void get_size(int x,int pa)
 {int i;
   size[x]=;
   maxsize[x]=;
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v==pa||vis[v]) continue;
       get_size(v,x);
       size[x]+=size[v];
       maxsize[x]=max(maxsize[x],size[v]);
     }
 }
 void get_root(int x,int pa,int r)
 {int i;
   maxsize[x]=max(size[r]-size[x],maxsize[x]);
   if (maxsize[x]<minsize)
     {
       minsize=maxsize[x];
       root=x;
     }
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v==pa||vis[v]) continue;
       get_root(v,x,r);
     }
 }
 void get_ans(int x,int pa,int dis,int dep)
 {int i;
   if (c[k--dep]&&w[k--dep]+dis==ans)
     cnt+=c[k--dep];
   else if (c[k--dep]&&ans<w[k--dep]+dis)
     ans=w[k--dep]+dis,cnt=c[k--dep];
   dep_max=max(dep_max,dep);
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v==pa||vis[v]||dep==k-) continue;
       get_ans(v,x,dis+edge[i].d,dep+);
     }
 }
 void get_update(int x,int pa,int dis,int dep)
 {int i;
   if (dis>w[dep]) w[dep]=dis,c[dep]=;
   else if (dis==w[dep]) c[dep]++;
   dep_max=max(dep_max,dep);
   for (i=head[x];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (v==pa||vis[v]||dep==k-) continue;
       get_update(v,x,dis+edge[i].d,dep+);
     }
 }
 void slove(int x)
 {int i;
   minsize=2e9;
   get_size(x,);
   get_root(x,,x);
   vis[root]=;
   dep_max=;
   c[]=;
   for (i=head[root];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (vis[v]) continue;
       get_ans(v,root,edge[i].d,);
       get_update(v,root,edge[i].d,);
     }
   for (i=;i<=dep_max;i++)
     w[i]=,c[i];
   for (i=head[root];i;i=edge[i].next)
     {
       int v=edge[i].to;
       if (vis[v]==)
     slove(v);
     }
 }
 int main()
 {int i,u,v,d;
   cin>>n>>m>>k;
   for (i=;i<=m;i++)
     {
       scanf("%d%d%d",&u,&v,&d);
       E[*i-].u=u,E[*i-].v=v,E[*i-].d=d;
       E[*i].u=v;E[*i].v=u,E[*i].d=d;
     }
   sort(E+,E+*m+,cmp);
   for (i=;i<=*m;i++)
     {
       add(E[i].u,E[i].v,E[i].d);
     }
   SPFA();
   memset(head,,sizeof(head));
   num=;
   for (i=;i<=n;i++)
     add(i,pre[i],pred[i]),add(pre[i],i,pred[i]);
   slove();
   cout<<ans<<' '<<cnt<<endl;
 }