BZOJ：3832: [Poi2014]Rally

题意：

给出$DAG$，询问删掉哪个点之后最长路径最短

思路：

我们令$f[x]$表示从最远的点到达它的距离，$g[x]$表示它能够到达最远的点的距离

那么对于$(x -> y)$一条边来说，它所在的最长路径就是 $f[x] + 1 + g[y]$

我们按照拓扑序依次删点

我们发现此时删去一个点，那么可能存在的最长的路径是

和它同一层的点所在的路径，以及它前一层的点所在的路径，以及它后一层的点所在的路径

因为它只会影响到它前一层的点和后一层的点

那么我们删去它所有入边的贡献，以及它本身的$g[x]$的贡献

再更新答案后

我们加入它出边的贡献，以及它本身的$f[x]$的贡献

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

#define N 500010
int n, m;
vector <int> G[2][N];
int f[N], g[N];

namespace SEG
{
    int cnt[N << 3], Max[N << 3];
    void build(int id, int l, int r)
    {
        cnt[id] = Max[id] = 0;
        if (l == r)
            return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int pos, int v)
    {
        if (pos == 0) return;
        if (l == r)
        {
            cnt[id] += v;
            if (cnt[id] > 0) Max[id] = pos;
            else Max[id] = 0; 
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, v);
        else update(id << 1 | 1, mid + 1, r, pos, v);
        Max[id] = max(Max[id << 1], Max[id << 1 | 1]); 
    }
}

int id[N], d[2][N];
void Toposort()
{
    id[0] = 0;
    memset(f, 0, sizeof f);
    memset(g, 0, sizeof g);
    queue <int> q;
    for (int i = 1; i <= n; ++i)
        if (d[0][i] == 0)
            q.push(i);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        id[++id[0]] = u;
        for (int v, it = 0, len = G[0][u].size(); it < len; ++it)
        {
            v = G[0][u][it];
            if (--d[0][v] == 0)
            {
                f[v] = f[u] + 1;
                q.push(v); 
            }
        }
    }
    for (int i = 1; i <= n; ++i)
        if (d[1][i] == 0)
            q.push(i);
    while (!q.empty())
    {
        int u = q.front(); q.pop();
        for (int v, it = 0, len = G[1][u].size(); it < len; ++it)
        {
            v = G[1][u][it];
            if (--d[1][v] == 0)
            {
                g[v] = g[u] + 1;
                q.push(v);
            }
        }
    }
}



void Run()
{
    while (scanf("%d%d", &n, &m) != EOF)
    {
        for (int i = 1; i <= n; ++i)
            G[0][i].clear(), G[1][i].clear();
        memset(d, 0, sizeof d);
        SEG::build(1, 1, m); 
        for (int i = 1, u, v; i <= m; ++i)
        {
            scanf("%d%d", &u, &v);
            G[0][u].push_back(v); ++d[0][v];
            G[1][v].push_back(u); ++d[1][u];
        }
        Toposort();
        for (int i = 1; i <= n; ++i)
            SEG::update(1, 1, m, g[i], 1);
        int Min = (int)1e9, pos = -1;
        for (int x, i = 1; i <= n; ++i)
        {
            x = id[i];
            for (int v, it = 0, len = G[1][x].size(); it < len; ++it)
            {
                v = G[1][x][it];
                SEG::update(1, 1, m, f[v] + 1 + g[x], -1);
            }
            SEG::update(1, 1, m, g[x], -1); 
            int now = SEG::Max[1]; 
            if (now < Min)
            {
                Min = now;
                pos = x;
            }
            SEG::update(1, 1, m, f[x], 1);
            for (int v, it = 0, len = G[0][x].size(); it < len; ++it)
            {
                v = G[0][x][it];
                SEG::update(1, 1, m, f[x] + 1 + g[v], 1);
            }
        }
        printf("%d %d
", pos, Min);
    }
}

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

    Run();
    return 0;
}