LNOI2013最小距离之和题解

http://codevs.cn/problem/2011/

• 题目描述 Description
  DQ星球的世界末日就要到了，可是诺亚方舟还没有制造完成。为了制造诺亚方舟这个星球上的所有国家都站在统一战线。现在一共有n个国家，一个国家到另一个国家都有一条且仅有一条通信渠道，且这个渠道有一个距离，这样就形成了一个有向完全图。 世界末日的预兆已经来了，世界上很多东西都在遭到不明原因的破坏，包括这些通信渠道。现在为了联合制造出诺亚方舟，需要统计所有国家对（a到b和b到a是不同的）之间通信最短距离之和。即需要求出表示i国家与j国家之间的最小距离。可是每隔一段时间就有一些渠道会被破坏，现在DQ星球的首领急需要你来解决这个问题。

• 输入描述 Input Description
  对于每组数据，第一行是一个n，表示有n个国家，接下来有n行，每有n个整数。第i行第j列的数字表示国家i到国家j的通信渠道距离（距离不大于10000）。接下来是一个数字m，表示在可以预知的未来中会有m次破坏会施加到通信渠道中，每次破坏只能破坏一条渠道，一条渠道可以被破坏多次， 但是第一次破坏这条渠道就无法再发送信息。接下来有m行，每行两个整数a、b，表示国家a到国家b的通信渠道遭到破坏。

• 输出描述 Output Description
  对于每组数据，输出m行，第i行表示第i次破坏后对应的答案是多少。如果存在两个国家无法相互到达，输出INF。

• 样例输入 Sample Input
  3
  0 1 1
  1 0 1
  1 1 0
  4
  1 2
  1 2
  2 3
  2 1

• 样例输出 Sample Output
  7
  7
  8
  INF

• 数据范围及提示 Data Size & Hint
  $40\%的数据中1<n\le50,1<m\le50;$
  $100\%的数据中1<n\le200,1<m\le200;$

• 题解
  本题和并查集的分离有点像了，都是离线倒序处理。用一个栈存储答案，先把所有该删的边都删掉，然后floyd出最短距离，压栈，用掉了$O(n^3)$。然后按破坏顺序的倒序处理，每处理一次就把这条边被破坏的次数减一。若该边被破坏次数减到了0，就在图中加上这条边。每处理一次就以这条边为中间边更新所有点对的距离，用时$O(n^2)$，共处理m次。这个算法总时间复杂度为$O((n+m)n^2)$，2s足够了。

• Code

#include <cstdio>
#include <stack>
#include <algorithm>
using namespace std;
const int can = 0, oo = 1000000000;
int n, m, map[205][205], f[205][205], des[205][205];
struct Point
{
    int x, y;
    Point(int x = 0, int y = 0) :x(x), y(y) {}
}pnt[205];
int top;
stack <int> ans;
void init()
{
    int a, b;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            scanf("%d", &map[i][j]);
            f[i][j] = map[i][j];
        }
    }
    scanf("%d", &m);
    for(int i = 1; i <= m; ++i)
    {
        scanf("%d%d", &a, &b);
        f[a][b] = oo;
        ++des[a][b];
        pnt[++top] = Point(a, b);
    }
}
int getans()
{
    int tmp = 0;
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            if(i != j && f[i][j] == oo)
            {
                return oo;
            }
            else
            {
                tmp += f[i][j];
            }
        }
    }
    return tmp;
}
void work()
{
    for(int k = 1; k <= n; ++k)
    {
        for(int i = 1; i <= n; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
            }
        }
    }
    for(int i = 1; i <= m; ++i)
    {
        ans.push(getans());
        --des[pnt[top].x][pnt[top].y];
        if(des[pnt[top].x][pnt[top].y] == can)
        {
            f[pnt[top].x][pnt[top].y] = min(f[pnt[top].x][pnt[top].y], map[pnt[top].x][pnt[top].y]);
        }
        for(int j = 1; j <= n; ++j)
        {
            for(int k = 1; k <= n; ++k)
            {
                f[j][k] = min(f[j][k], f[j][pnt[top].x] + f[pnt[top].x][pnt[top].y] + f[pnt[top].y][k]);
            }
        }
        --top;
    }
    while(!ans.empty())
    {
        if(ans.top() == oo)
        {
            puts("INF");
        }
        else
        {
            printf("%d\n", ans.top());
        }
        ans.pop();
    }
}
int main()
{
    init();
    work();
    return 0;
}