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[][N];
 int f[N], g[N];

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

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

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

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

     Run();
     return ;
 }