[FJOI2014]最短路径树问题【生成树+点分治】

BZOJ-4016

---

  这道题…… 让我认识到了我的点分治有一处极大的漏洞，就是我们在分治的时候需要存下来的是目前子树的所有的节点数，再往下分治的，我一直没有存，所以最后的复杂度就不会是了，而是更高了，所以复杂度过不去，一直T，竟然没反思过我的点分治是存在漏洞的，一直在看优先队列优化的Dijkstra是不是哪里写错了…… 呜呜呜。

  首先就是去处理这棵生成树，然后就是分别考虑两棵子树，以及最容易忽略的根节点向下推的值即可，注意在写点分治的分治操作的时候别忘了保留目前整颗子树的节点数。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-6
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef double lb;
typedef unsigned long long ull;
typedef long long ll;
const int maxN = 3e4 + 7, maxE = 6e4 + 7;
int N, M, K, cnt, head[maxN], ans_E, ans_N;
struct Path
{
    int v, val;
    Path(int _v=0, int _w=0):v(_v), val(_w) {}
    friend bool operator < (Path e1, Path e2) { return e1.v < e2.v; }
};
vector<Path> E[maxN];
struct Eddge
{
    int nex, to, val;
    Eddge(int a=-1, int b=0, int c=0):nex(a), to(b), val(c) {}
}edge[maxE<<1];
inline void addEddge(int u, int v, int w)
{
    edge[cnt] = Eddge(head[u], v, w);
    head[u] = cnt++;
}
inline void _add(int u, int v, int w) { addEddge(u, v, w); addEddge(v, u, w); }
struct node
{
    int id, val;
    node(int a=0, int b=0):id(a), val(b) {}
    friend bool operator < (node e1, node e2) { return e1.val == e2.val ? e1.id > e2.id : e1.val > e2.val; }
};
int dis[maxN], pre[maxN], len[maxN];
priority_queue<node> Q;
inline void Dijkstra()
{
    while(!Q.empty()) Q.pop();
    for(int i=2; i<=N; i++) dis[i] = INF;
    Q.push(node(1, 0)); dis[1] = 0;
    node now;
    int u;
    while(!Q.empty())
    {
        now = Q.top(); Q.pop();
        if(dis[now.id] < now.val) continue;
        u = now.id;
        int siz = (int)E[u].size();
        for(int i=0, v, w; i<siz; i++)
        {
            v = E[u][i].v; w = E[u][i].val;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = dis[u] + w;
                pre[v] = u; len[v] = w;
                Q.push(node(v, dis[v]));
            }
        }
    }
}
bool vis[maxN];
int siz[maxN], son[maxN], mx = INF, all, rt;
void findroot(int u, int fa)
{
    siz[u] = 1; son[u] = 0;
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v] || v == fa) continue;
        findroot(v, u);
        siz[u] += siz[v];
        if(siz[v] > son[u]) son[u] = siz[v];
    }
    son[u] = max(son[u], all - siz[u]);
    if(son[u] < mx) { mx = son[u]; rt = u; }
}
int sdis[maxN], sum[maxN];
void get_dis(int u, int fa, int deep, int dis)
{
    if(deep == K - 1)
    {
        if(ans_E == dis) ans_N++;
        else if(ans_E < dis)
        {
            ans_E = dis;
            ans_N = 1;
        }
        return;
    }
    if(sdis[K - 1 - deep] != -INF)
    {
        if(ans_E == sdis[K - 1 - deep] + dis)
        {
            ans_N += sum[K - 1 - deep];
        }
        else if(ans_E < sdis[K - 1 - deep] + dis)
        {
            ans_E = sdis[K - 1 - deep] + dis;
            ans_N = sum[K - 1 - deep];
        }
    }
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v] || v == fa) continue;
        get_dis(v, u, deep + 1, dis + edge[i].val);
    }
}
void get_s(int u, int fa, int deep, int dis)
{
    if(deep == K - 1) return;
    if(sdis[deep] == dis) sum[deep]++;
    else if(sdis[deep] < dis)
    {
        sdis[deep] = dis;
        sum[deep] = 1;
    }
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v] || v == fa) continue;
        get_s(v, u, deep + 1, dis + edge[i].val);
    }
}
void divide(int u)
{
    vis[u] = true;
    int totsiz = all;
    for(int i=1; i<K; i++) sdis[i] = -INF;
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v]) continue;
        get_dis(v, u, 1, edge[i].val);
        get_s(v, u, 1, edge[i].val);
    }
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(vis[v]) continue;
        mx = INF; rt = 0;
        all = siz[v] > siz[u] ? totsiz - siz[u] : siz[v];
        findroot(v, 0);
        divide(rt);
    }
}
inline void init()
{
    cnt = ans_E = ans_N = 0; all = N;
    for(int i=1; i<=N; i++) head[i] = -1;
    for(int i=1; i<=N; i++) vis[i] = false;
    for(int i=1; i<=N; i++) E[i].clear();
}
int main()
{
    scanf("%d%d%d", &N, &M, &K);
    init();
    for(int i=1, u, v, w; i<=M; i++)
    {
        scanf("%d%d%d", &u, &v, &w);
        E[u].push_back(Path(v, w));
        E[v].push_back(Path(u, w));
    }
    for(int i=1; i<=N; i++) sort(E[i].begin(), E[i].end());
    Dijkstra();
    for(int i=2; i<=N; i++) _add(pre[i], i, len[i]);
    findroot(1, 0);
    divide(rt);
    printf("%d %d\n", ans_E, ans_N);
    return 0;
}
/*
6 6 4
1 2 1
2 3 1
3 4 1
2 5 1
3 6 1
5 6 1
*/