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

建最短路树的时候，优先队列加一条限制，当花费相同的时候id小的排前面

这样建出来的最短路树就是符合题意的

再考虑点分治

因为不满足前缀加减性，那么考虑按序遍历即可

考虑如何同时维护最大值及其个数

判断当前值是大于还是等于已经存的值

如果大于 替换掉，次数置为1

如果等于 次数++

#include <bits/stdc++.h>
using namespace std;

#define INF 0x3f3f3f3f
#define N 60010
#define pii pair <int, int>
int n, m, k;
struct Graph
{
    struct node
    {
        int to, nx, w;
        node() {}
        node(int to, int nx, int w) : to(to), nx(nx), w(w) {}
    }a[N << 1];
    int head[N], pos;
    void init()
    {
        memset(head, 0, sizeof head);
        pos = 0;
    }
    void add(int u, int v, int w)
    {
        a[++pos] = node(v, head[u], w); head[u] = pos;
        a[++pos] = node(u, head[v], w); head[v] = pos;
    }
}G[2];
#define erp(G, u) for (int it = G.head[u], v = G.a[it].to, w = G.a[it].w; it; it = G.a[it].nx, v = G.a[it].to, w = G.a[it].w)

struct node
{
    int u, w, fa, v;
    node() {}
    node(int u, int w, int fa, int v) : u(u), w(w), fa(fa), v(v) {}
    bool operator < (const node &other) const
    {
        if (w != other.w) return w > other.w;
        return u > other.u; 
    }
};
int dist[N], used[N];
void Dijkstra()
{
    for (int i = 1; i <= n; ++i) dist[i] = INF, used[i] = false;
    dist[1] = 0; priority_queue <node> q; q.push(node(1, 0, -1, 0));
    while (!q.empty())
    {
        int u = q.top().u;
        if (used[u])
        {
            q.pop();
            continue;
        }
        if (u != 1)
            G[1].add(q.top().fa, u, q.top().v);
        q.pop();
        used[u] = true;
        erp(G[0], u) if (!used[v] && dist[v] > dist[u] + w)
        {
            dist[v] = dist[u] + w;
            q.push(node(v, dist[v], u, w));
        }
    }
}

int vis[N];
int sum, root, sze[N], f[N];
void getroot(int u, int fa)
{
    f[u] = 0, sze[u] = 1;
    erp(G[1], u) if (v != fa && !vis[v])
    {
        getroot(v, u);
        sze[u] += sze[v];
        f[u] = max(f[u], sze[v]);
    }
    f[u] = max(f[u], sum - sze[u]);
    if (f[u] < f[root]) root = u;
}  

int deep[N], res[2]; pii t[N]; 
void getdeep(int u, int fa)
{
    if (deep[u] <= k)
    {
        int tmp = dist[u] + t[k - deep[u] + 1].first;
        if (tmp == res[0]) res[1] += t[k - deep[u] + 1].second;
        else if (tmp > res[0]) res[0] = tmp, res[1] = 1;
    }
    erp(G[1], u) if (v != fa && !vis[v])
    {
        deep[v] = deep[u] + 1;
        dist[v] = dist[u] + w;
        getdeep(v, u);
    }
}

void add(int u, int fa, int flag)
{
    if (deep[u] <= k)
    {
        if (flag)
        {
            if (dist[u] == t[deep[u]].first) ++t[deep[u]].second;
            else if (dist[u] > t[deep[u]].first) t[deep[u]] = pii(dist[u], 1);
        }
        else t[deep[u]] = pii(0, 0);
    }
    erp(G[1], u) if (v != fa && !vis[v])
        add(v, u, flag);
}

void solve(int u) 
{
    vis[u] = 1;
    t[1] = pii(0, 1);
    erp(G[1], u) if (!vis[v]) 
    {
        deep[v] = 2, dist[v] = w;   
        getdeep(v, u); add(v, u, 1);  
    }
    erp(G[1], u) if (!vis[v])
        add(v, u, 0);  
    erp(G[1], u) if (!vis[v])
    {
        sum = f[0] = sze[v]; root = 0;
        getroot(v, 0);
        solve(root);
    }
}

void Run()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF) 
    {
        G[0].init(); G[1].init();
        memset(res, 0, sizeof res);
        memset(vis, 0, sizeof vis);
        for (int i = 1, u, v, w; i <= m; ++i)
        {
            scanf("%d%d%d", &u, &v, &w);
            G[0].add(u, v, w);
        }
        Dijkstra();
        sum = f[0] = n; root = 0;
        getroot(1, 0); 
        solve(root);
        printf("%d %d
", res[0], res[1]); 
    }
}

int main()
{
    #ifdef LOCAL
        freopen("Test.in", "r", stdin);
    #endif 

    Run();
    return 0;
}