HDU4871 Shortest-path tree (树分治)

/**
题意：n个点m条边的图，以1为根节点生成一棵最短路树，要求1到每个点的最短路字典序最小。之后，
在最短路树上，找一个有k个点的简单路径，问这样的简单路径最长是多少，共有多少条。

思路：树分治，生成最短路树后，找出每一层的重心，k个点的最长路径要么经过重心，要么没经过重心，
没经过重心的递归解决，经过重心的，假设重心是x， 剩余的子树为x1, x2, ..., xn，假设目前求到经过
重心的共有k个点的路径的长度最长为len， 那么处理子树xi的节点vxi时候，一遍dfs子树xi可以求出vxi到
重心x的距离dis和总共的节点数totv，那么右端点为vxi的最长路径为xlen = dis + rec[k-totv].dis，其中
rec[i]记录x1..xi-1中的子树节点到重心经过的节点数为i的 最长距离 和 节点个数， 那么：
1. xlen < len 继续
2. xlen = len, 路径条数 += rec[k - totv].totv
3. xlen > len, len更新为xlen， 路径条数置为rec[k - totv].totv
然后用xi子树的节点信息更新rec数组， 处理xi+1
*/

#include<bits/stdc++.h>
const int maxn = 3e4 + 10;
const int INF = 1e9 + 10;
using namespace std;

typedef pair<int, int> P;
vector<P> G[maxn], g[maxn];
int n, m, T, vis[maxn], k;
int dis[maxn], sz[maxn], bel[maxn];
P operation[maxn], rec[maxn];

void dfs(int u, int fa, int c) {
    vis[u] = 1;
    if(fa) { g[u].push_back(P(fa, c)); g[fa].push_back(P(u, c)); }
    for(int i = 0; i < G[u].size(); i++) {
        int nxt = G[u][i].first, cost = G[u][i].second;
        if(dis[nxt] != dis[u] + cost || vis[nxt]) continue;
        dfs(nxt, u, cost);
    }
}

void dijkstra(int s) {
    for(int i = 0; i <= n; i++) { dis[i] = INF; vis[i] = 0; }
    priority_queue<P, vector<P>, greater<P> > que;
    dis[s] = 0; que.push(P(0, s));
    while(!que.empty()) {
        P p = que.top(); que.pop();
        int now = p.second, di = p.first;
        if(di > dis[now]) continue;
        for(int i = 0; i < G[now].size(); i++) {
            P e = G[now][i];
            int to = e.first, cost = e.second;
            if(dis[to] <= dis[now] + cost) continue;
            dis[to] = dis[now] + cost;
            que.push(P(dis[to], to));
        }
    }
    dfs(1, 0, 0);
    for(int i = 0; i <= n; i++) vis[i] = 0;
}

int calculate_size(int x, int fa) {
    sz[x] = 1;
    for(int i = 0; i < g[x].size(); i++) {
        int to = g[x][i].first;
        if(to == fa || vis[to]) continue;
        sz[x] += calculate_size(to, x);
    }
    return sz[x];
}

P find_zx(int x, int fa, int t) {
    P res(INF, -1); int m = 0;
    for(int i = 0; i < g[x].size(); i++) {
        int to = g[x][i].first;
        if(to == fa || vis[to]) continue;
        res = min(res, find_zx(to, x, t));
        m = max(m, sz[to]);
    }
    m = max(m, t - sz[x]);
    return min(res, P(m, x));
}

int max_step(int x, int fa, int tot, int dist, int flag, int &cnt) {
    rec[cnt] = P(0, 0); tot++; int step = tot;
    bel[cnt] = flag; operation[cnt++] = P(tot, dist);
    for(int i = 0; i < g[x].size(); i++) {
        int to = g[x][i].first, w = g[x][i].second;
        if(to == fa || vis[to]) continue;
        step = max(step, max_step(to, x, tot, dist + w, flag, cnt));
    }
    return step;
}

P solve(int x) {
    int tot_size = calculate_size(x, 0);
    int zx = find_zx(x, 0, tot_size).second;
    vis[zx] = 1; P ans(0, 0);
    for(int i = 0; i < g[zx].size(); i++) {
        int to = g[zx][i].first;
        if(vis[to]) continue;
        P res = solve(to);
        if(ans.first > res.first) continue;
        if(ans.first < res.first) ans = res;
        else ans.second += res.second;
    }
    int cnt = 1, step = 1, flag = 1;
    bel[cnt] = 0; rec[cnt] = P(0, 0); operation[cnt++] = P(1, 0);
    for(int i = 0; i < g[zx].size(); i++) {
        int to = g[zx][i].first, w = g[zx][i].second;
        if(vis[to]) continue;
        step = max(max_step(to, zx, 1, w, flag++, cnt), step);
    }
    rec[cnt] = P(0, 0);
    for(int from = 1, to = 1; from < cnt; ) {
        while(to < cnt && bel[to] == bel[from]) {
            P now = operation[to]; to++;
            int tot = now.first, val = now.second;
            int rv = k + 1 - tot;
            if(rv < 1 || rv > step) continue;
            P nxt = rec[rv];
            int totv = nxt.second, dist = nxt.first;
            if(dist + val < ans.first || !nxt.second) continue;
            if(dist + val == ans.first) ans.second += totv;
            else ans = P(dist + val, totv);
        }
        while(from < to) {
            P now = operation[from]; from++;
            int tot = now.first, val = now.second;
            if(tot > k || rec[tot].first > val) continue;
            if(rec[tot].first == val) rec[tot].second++;
            else rec[tot] = P(val, 1);
        }
    }
    vis[zx] = 0; return ans;
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d %d", &n, &m, &k);
        for(int i = 0; i < maxn; i++) { G[i].clear(); g[i].clear(); }
        while(m--) {
            int u, v, c; scanf("%d %d %d", &u, &v, &c);
            G[u].push_back(P(v, c));
            G[v].push_back(P(u, c));
        }
        for(int i = 1; i <= n; i++) sort(G[i].begin(), G[i].end());
        dijkstra(1);
        P ans = solve(1);
        printf("%d %d\n", ans.first, ans.second);
    }
    return 0;
}