Codeforces 295B——Flody算法求最短路径

B. Greg and Graph

time limit per test

3 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Greg has a weighed directed graph, consisting of n vertices. In this graph any pair of distinct vertices has an edge between them in both directions. Greg loves playing with the graph and now he has invented a new game:

• The game consists of n steps.
• On the i-th step Greg removes vertex number xi from the graph. As Greg removes a vertex, he also removes all the edges that go in and out of this vertex.
• Before executing each step, Greg wants to know the sum of lengths of the shortest paths between all pairs of the remaining vertices. The shortest path can go through any remaining vertex. In other words, if we assume that d(i, v, u) is the shortest path between vertices v and u in the graph that formed before deleting vertex xi, then Greg wants to know the value of the following sum: .

Help Greg, print the value of the required sum before each step.

Input

The first line contains integer n (1 ≤ n ≤ 500) — the number of vertices in the graph.

Next n lines contain n integers each — the graph adjacency matrix: the j-th number in the i-th line aij (1 ≤ aij ≤ 105, aii = 0) represents the weight of the edge that goes from vertex i to vertex j.

The next line contains n distinct integers: x1, x2, ..., xn (1 ≤ xi ≤ n) — the vertices that Greg deletes.

Output

Print n integers — the i-th number equals the required sum before the i-th step.

Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams of the %I64dspecifier.

Sample test(s)

input

1
0
1

output

0 

input

2
0 5
4 0
1 2

output

9 0 

input

4
0 3 1 1
6 0 400 1
2 4 0 1
1 1 1 0
4 1 2 3

output

17 23 404 0 

题目大意：

在n个顶点的图中，每次求得各个顶点之间的最短路径，然后再删去其中一个点，删除这个点的同时，与该点相邻的边也删除，再求得各个顶点之间的最短路径，直到所有的顶点都被删除。最后依次将删除点前所求的最短路径输出。

解题思路：

对于删除顺序，我们可以反过来做，这样就相当于每次添加一个点到图中，然后询问当前图的所有点间的最短路径之和。对于每次添加操作，就相当于用当前添加的点v，去更新整个图的最短路，也就是dist[s][t] = min(dist[s][t], dist[s][v]+dist[v][t]);。具体解释在代码中给出。

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
#define maxn 510

//考虑数据范围应用LONG LONG型
long long dist[maxn][maxn];
long long seq[maxn];
long long ans[maxn];

void update ( int v , int n ) //将顶点v放入到图中，更新各顶点相互之间的最短路径 
{                             //Floyd算法
    for ( int i = 1 ; i <= n ; i ++ )
        for ( int j = 1 ; j <= n ; j ++ )
            dist[i][j] = min ( dist[i][j] , dist[i][v] + dist[v][j] );
}

long long Sum ( int ths , int n ) //假设这时候图中只有seq[ths---n]的顶点，那么把seq[n]---seq[ths]的顶点间相互的最短路径相加即为所求
{                                 //因为顶点u到自己的距离为0，所以不会影响Sum的结果
    long long sum = 0;
    for ( int i = n ; i >= ths ; i -- )
        for ( int j = n ; j >= ths ; j --)
        {
            int u = seq[i];
            int v = seq[j];
            sum += dist[u][v];
        }
    return sum;                   
}

int main()
{
    long long n;
    while ( scanf ( "%I64d" , &n ) != EOF )
    {
        for ( int i = 1 ; i <= n ; i ++ )
            for ( int j = 1 ; j <= n ; j ++ )
                scanf ( "%I64d" , &dist[i][j] );
        for ( int i = 1 ; i <= n ; i ++ )
            scanf ( "%I64d" ,  &seq[i] );
        for ( int i = n ; i >= 1 ; i -- )//从序列的最后一个开始，当做将这些顶点顺序插入
        {
            int v = seq[i];              //获得顶点编号
            update ( v , n );            //Floyd算法，更新各点最短路径
            ans[i] = Sum ( i , n );      
        }
        for ( int i  = 1 ; i <= n ; i ++ )
            printf ( "%I64d " , ans[i] );
        printf ( "\n" );
    }
    return 0;
}

技巧总结：

正难则反，要有逆向思维，将顺序倒转过来，不正好就是Floyd算法的思想吗？最后记得考虑数据的范围，500*（10^5 )将会超过int类型的表示范围。