[FJOI 2014]最短路径树问题

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的路径。

题解

看错题意，以为是求包含 $k$ 个点的简单路径共多少条。调了好久...

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

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

 //It is made by Awson on 2018.1.4
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <queue>
 #include <stack>
 #include <cstdio>
 #include <string>
 #include <vector>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define LD long double
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 using namespace std;
 const int N = ;
 const int M = ;
 const int INF = ~0u>>;

 int n, m, k;
 struct tt {
     int to, next, cost;
 }edge[(N<<)+];
 int path[N+], top, ans1, ans2;
 void add(int u, int v, int c) {
     edge[++top].to = v;
     edge[top].next = path[u];
     edge[top].cost = c;
     path[u] = top;
 }

 namespace SPFA {
     int a, b, c;
     struct ss {
     int u, v, c;
     ss() {}
     ss(int _u, int _v, int _c) {
         u = _u, v = _v, c = _c;
     }
     bool operator < (const ss &b) const {
         return v > b.v;
     }
     }w[(M<<)+];
     struct sss {
     int to, next, cost;
     }edge[(M<<)+];
     int path[N+], top, tot, pre[N+], vis[N+], prec[N+];
     LL dist[N+];
     void add_e(int u, int v, int c) {
     edge[++top].to = v;
     edge[top].cost = c;
     edge[top].next = path[u];
     path[u] = top;
     }
     void spfa() {
     memset(dist, /, sizeof(dist)); dist[] = ;
     queue<int>Q; Q.push(); vis[] = ;
     while (!Q.empty()) {
         int u = Q.front(); Q.pop(); vis[u] = ;
         for (int i = path[u]; i; i = edge[i].next)
         if (dist[edge[i].to] > dist[u]+edge[i].cost) {
             dist[edge[i].to] = dist[u]+edge[i].cost;
             pre[edge[i].to] = u, prec[edge[i].to] = edge[i].cost;
             if (!vis[edge[i].to]) {
             vis[edge[i].to] = ; Q.push(edge[i].to);
             }
         }
     }
     }
     void main() {
     scanf("%d%d%d", &n, &m, &k);
     for (int i = ; i <= m; i++) {
         scanf("%d%d%d", &a, &b, &c);
         w[++tot] = ss(a, b, c), w[++tot] = ss(b, a, c);
     }
     sort(w+, w++tot);
     for (int i = ; i <= tot; i++) add_e(w[i].u, w[i].v, w[i].c);
     spfa();
     for (int i = ; i <= n; i++) add(pre[i], i, prec[i]), add(i, pre[i], prec[i]);
     }
 }
 namespace Point_divide {
     int size[N+], mx[N+], minsize, root, vis[N+], cnt[N+], sum[N+];
     void get_size(int o, int fa) {
     size[o] = , mx[o] = ;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) {
         get_size(edge[i].to, o);
         size[o] += size[edge[i].to];
         mx[o] = Max(mx[o], size[edge[i].to]);
         }
     }
     void get_root(int o, int rt, int fa) {
     mx[o] = Max(mx[o], size[rt]-size[o]);
     if (mx[o] < minsize) minsize = mx[o], root = o;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_root(edge[i].to, rt, o);
     }
     void get_ans(int o, int fa, int dep, int cost) {
     if (dep >= k) return;
     if (cnt[k--dep] && ans1 < cost+sum[k--dep]) ans1 = cost+sum[k--dep], ans2 = cnt[k--dep];
     else if (cnt[k--dep] && ans1 == cost+sum[k--dep]) ans2 += cnt[k--dep];
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_ans(edge[i].to, o, dep+, cost+edge[i].cost);
     }
     void get_update(int o, int fa, int dep, int cost) {
     if (dep >= k) return;
     if (sum[dep] < cost) sum[dep] = cost, cnt[dep] = ;
     else if (sum[dep] == cost) ++cnt[dep];
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_update(edge[i].to, o, dep+, cost+edge[i].cost);
     }
     void get_clean(int o, int fa, int dep) {
     if (dep >= k) return;
     cnt[dep] = , sum[dep] = ;
     for (int i = path[o]; i; i = edge[i].next)
         if (edge[i].to != fa && !vis[edge[i].to]) get_clean(edge[i].to, o, dep+);
     }
     void work(int o) {
     minsize = INF;
     get_size(o, ), get_root(o, o, );
     vis[root] = ; cnt[] = ;
     for (int i = path[root]; i; i = edge[i].next)
         if (!vis[edge[i].to]) get_ans(edge[i].to, root, , edge[i].cost), get_update(edge[i].to, root, , edge[i].cost);
     cnt[] = ;
     for (int i = path[root]; i; i = edge[i].next)
         if (!vis[edge[i].to]) get_clean(edge[i].to, root, );
     for (int i = path[root]; i; i = edge[i].next)
         if (!vis[edge[i].to]) work(edge[i].to);
     }
     void main() {work(); }
 }
 void work() {
     SPFA::main();
     Point_divide::main();
     printf("%d %d\n", ans1, ans2);
 }
 int main() {
     work();
     return ;
 }