Floyd算法及其扩展应用

Floyd最短路应用：

多源多汇最短路
求传递闭包
找最小环（总和最小的环）
恰好经过 k k k 条边的最短路

1125. 牛的旅行

农民John的农场里有很多牧区，有的路径连接一些特定的牧区。

一片所有连通的牧区称为一个牧场。

但是就目前而言，你能看到至少有两个牧区不连通。

现在，John想在农场里添加一条路径（注意，恰好一条）。

一个牧场的直径就是牧场中最远的两个牧区的距离（本题中所提到的所有距离指的都是最短的距离）。

考虑如下的两个牧场，每一个牧区都有自己的坐标：

图 1 是有 5 个牧区的牧场，牧区用"*"表示，路径用直线表示。

图 1 所示的牧场的直径大约是 12.07106, 最远的两个牧区是 A 和 E，它们之间的最短路径是 A-B-E。

图 2 是另一个牧场。

这两个牧场都在John的农场上。

John将会在两个牧场中各选一个牧区，然后用一条路径连起来，使得连通后这个新的更大的牧场有最小的直径。

注意，如果两条路径中途相交，我们不认为它们是连通的。

只有两条路径在同一个牧区相交，我们才认为它们是连通的。

现在请你编程找出一条连接两个不同牧场的路径，使得连上这条路径后，所有牧场（生成的新牧场和原有牧场）中直径最大的牧场的直径尽可能小。

输出这个直径最小可能值。

输入格式

第 1 行：一个整数 N, 表示牧区数；

第 2 到 N+1 行：每行两个整数 X,Y，表示 N 个牧区的坐标。每个牧区的坐标都是不一样的。

第 N+2 行到第 2*N+1 行：每行包括 N 个数字 ( 0或1 ) 表示一个对称邻接矩阵。

例如，题目描述中的两个牧场的矩阵描述如下：

  A B C D E F G H 
A 0 1 0 0 0 0 0 0 
B 1 0 1 1 1 0 0 0 
C 0 1 0 0 1 0 0 0 
D 0 1 0 0 1 0 0 0 
E 0 1 1 1 0 0 0 0 
F 0 0 0 0 0 0 1 0 
G 0 0 0 0 0 1 0 1 
H 0 0 0 0 0 0 1 0

输入数据中至少包括两个不连通的牧区。

输出格式

只有一行，包括一个实数，表示所求答案。

数字保留六位小数。

数据范围

1 ≤ N ≤ 150 1≤N≤150 1≤N≤150,
0 ≤ X , Y ≤ 105 0≤X,Y≤105 0≤X,Y≤105

输入样例：

输出样例：

22.071068

思路：

用 Floyd算法求出任意两点之间的最短距离
求 m a x d [ i ] maxd[i] maxd[i]，表和 i i i 联通的且距离 i i i 最远的点的距离
情况 1 1 1：所有 m a x d [ i ] maxd[i] maxd[i] 的最大值

情况 2 2 2：枚举在哪两个点之间连边。 i ， j i，j i，j 需要满足 d [ i , j ] = I N F d[i, j]=INF d[i,j]=INF。 m a x d [ i ] + d i s t [ i , j ] + m a x d [ j ] maxd[i] + dist[i, j] + maxd[j] maxd[i]+dist[i,j]+maxd[j]

c++ 复制代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
typedef pair<int,int> PII;
const int N = 160;
const double INF = 1e20;
int n;
char g[N][N];
double dist[N][N], maxd[N]; // max[i]表示以结点i为起点的最长路径
PII p[N];

double dis(PII p, PII q){
    double dx = p.first - q.first, dy = p.second - q.second;
    return sqrt(dx * dx + dy * dy);
}

void Floyd(){
    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}

int main(){
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d%d", &p[i].first, &p[i].second);
    for (int i = 0; i < n; i++) scanf("%s", g[i]);
    // 初始化距离
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if(i != j) {
                if(g[i][j] == '1') dist[i][j] = dis(p[i], p[j]);
                else dist[i][j] = INF;
            }
    Floyd();
    // 求出以每个起点开始的直径（即在连通块中的最长距离）
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if(dist[i][j] < INF){
                maxd[i] = max(maxd[i], dist[i][j]);
            }
    // 不加边的时候最长距离
    double res1 = 0;
    for (int i = 0; i < n; i++) res1 = max(res1, maxd[i]);
    // 添加一条边之后的最长距离（保证添加的这条边的两个顶点不连通）
    double res2 = INF;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++){
            if(dist[i][j] >= INF){
                res2 = min(res2, dis(p[i], p[j]) + maxd[i] + maxd[j]);
            }
        }
    printf("%.6lf", max(res1, res2));
    return 0;
}

**想一下输出结果为什么要取 r e s 1 res1 res1 和 r e s 2 res2 res2 之间的最大值？**因为答案的那一条路径有可能是连接前的某一个连通块的直径，但是这条直径也得是所有连通块中的最大路径值，也有可能是添加一条边之后组成的直径。取 r e s 1 res1 res1 和 r e s 2 res2 res2 之间最大值的原因在于，题目要求求解的是在给定条件下（可以选择不添加边或者添加一条边），图中的最长路径（或称直径）是多少。因此，我们需要比较这两种情况：一种是不添加边时的最长路径；另一种是通过添加一条边能够实现的最优（即尽可能短的）最长路径。最终的结果应该是这两者中的较大值，因为无论选择哪种策略，图中仍然存在的最长路径不能比这个值更长。

343. 排序

给定 n n n 个变量和 m m m 个不等式。其中 n n n 小于等于 26 26 26，变量分别用前 n n n 的大写英文字母表示。

不等式之间具有传递性，即若 A > B A>B A>B 且 B > C B>C B>C，则 A > C A>C A>C。

请从前往后遍历每对关系，每次遍历时判断：

如果能够确定全部关系且无矛盾，则结束循环，输出确定的次序；
如果发生矛盾，则结束循环，输出有矛盾；
如果循环结束时没有发生上述两种情况，则输出无定解。

输入格式

输入包含多组测试数据。

每组测试数据，第一行包含两个整数 n n n 和 m m m。

接下来 m m m 行，每行包含一个不等式，不等式全部为小于关系。

当输入一行 0 0 时，表示输入终止。

输出格式

每组数据输出一个占一行的结果。

结果可能为下列三种之一：

如果可以确定两两之间的关系，则输出 "Sorted sequence determined after t relations: yyy...y.",其中't'指迭代次数，'yyy...y'是指升序排列的所有变量。
如果有矛盾，则输出： "Inconsistency found after t relations."，其中't'指迭代次数。
如果没有矛盾，且不能确定两两之间的关系，则输出 "Sorted sequence cannot be determined."。

数据范围

2 ≤ n ≤ 26 2≤n≤26 2≤n≤26，变量只可能为大写字母 A ∼ Z A∼Z A∼Z。

输入样例1：

4 6
A<B
A<C
B<C
C<D
B<D
A<B
3 2
A<B
B<A
26 1
A<Z
0 0

输出样例1：

Sorted sequence determined after 4 relations: ABCD.
Inconsistency found after 2 relations.
Sorted sequence cannot be determined.

输入样例2：

6 6
A<F
B<D
C<E
F<D
D<E
E<F
0 0

输出样例2：

Inconsistency found after 6 relations.

输入样例3：

5 5
A<B
B<C
C<D
D<E
E<A
0 0

输出样例3：

Sorted sequence determined after 4 relations: ABCDE.

什么是传递闭包? 传递闭包是把所有能够间接到达的点连接起来，表示它们能够直接到达

Floyd算法可以在 O ( n 3 ) O(n^3) O(n3) 的时间复杂度下将 g ( i , j ) g(i, j) g(i,j) 变成它的传递闭包 d ( i , j ) d(i, j) d(i,j)，步骤：

g ( i , j ) = 1 g(i,j) = 1 g(i,j)=1 表示 i − > j i->j i−>j 存在一条边， g ( i , j ) = 0 g(i,j) = 0 g(i,j)=0 表示 i − > j i->j i−>j 不存在边
初始化： d ( i , j ) = g ( i , j d(i,j) = g(i,j d(i,j)=g(i,j)

c++ 复制代码

for k
    for i
        for j
            if(d(i,k) && d(k, j))
                d(i,j) = 1

思路：

对每一次，先求出传递闭包 d ( i , j ) d(i,j) d(i,j)
矛盾：如果存在 d ( i , i ) = 1 d(i,i)=1 d(i,i)=1
唯一确定序列：说明任意两个字母都可以确定大小关系，因此对于任意的 i ! = j , d ( i , j ) i!=j,d(i,j) i!=j,d(i,j) 和 d ( j , i ) d(j,i) d(j,i) 必有一个是 1 1 1

**如果确定了序列，如果排序呢？**每次找到一个小于其他没有被标记的数，它就是最小数，把它输出后继续查找
否则序列不唯一

c++ 复制代码

#include<iostream>
#include<algorithm>
#include<string>
#include<cstring>
using namespace std;
const int N = 30;
int n, m, g[N][N], d[N][N];
bool st[N];

void Floyd(){
    memcpy(d, g, sizeof d);
    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                d[i][j] |= d[i][k] && d[k][j];
}

int check(){
    // 矛盾
    for (int i = 0; i < n; i++) if(d[i][i]) return 2;
    // 不能确定序列
    for (int i = 0; i < n; i++)
        for (int j = 0; j < i; j++)
            if(!d[i][j] && !d[j][i]) return 0;
    return 1; // 确定序列
}

char get_min(){
    for (int i = 0; i < n; i++){
        if(!st[i]){
            bool flag = true;
            for (int j = 0; j < n; j++){
                if(!st[j] && d[j][i]){
                    flag = false;
                    break;
                }
            }
            if(flag){
                st[i] = true;
                return i + 'A';
            }
        }
    }
}

int main(){
    while(cin >> n >> m, n || m){
        memset(g, 0, sizeof g);
        int type = 0, t; // type=0不能确定 type=2矛盾 type=1表示可以确定序列
        for (int i = 1; i <= m; i++){
            char str[5];
            cin >> str;
            int a = str[0] - 'A', b = str[2] - 'A';
            if(!type){
                g[a][b] = 1;
                Floyd();
                type = check();
                if(type) t = i;
            }
        }
        if(!type) cout << "Sorted sequence cannot be determined." << endl;
        else if(type == 1) {
            memset(st, false, sizeof st);
            cout << "Sorted sequence determined after " << t << " relations: ";
            for (int i = 1; i <= n; i++) cout << get_min();
            cout << "." << endl;
        }
        else if(type == 2) cout << "Inconsistency found after "<< t << " relations." << endl;
    }
    return 0;
}

在 Floyd 中 d [ i ] [ j ] d[i][j] d[i][j] |= d [ i ] [ k ] d[i][k] d[i][k] && d [ k ] [ j ] d[k][j] d[k][j] 而不是直接等于，因为原来如果 ( i , j ) (i,j) (i,j) 是连接的话仍然应该是连接的

344. 观光之旅

给定一张无向图，求图中一个至少包含 3 3 3 个点的环，环上的节点不重复，并且环上的边的长度之和最小。

该问题称为无向图的最小环问题。

你需要输出最小环的方案，若最小环不唯一，输出任意一个均可。

输入格式

第一行包含两个整数 N N N 和 M M M，表示无向图有 N N N 个点， M M M 条边。

接下来 M M M 行，每行包含三个整数 u ， v ， l u，v，l u，v，l 表示点 u u u 和点 v v v 之间有一条边，边长为 l l l。

输出格式

输出占一行，包含最小环的所有节点（按顺序输出），如果不存在则输出 No solution.。

数据范围

1 ≤ N ≤ 100 1≤N≤100 1≤N≤100,
1 ≤ M ≤ 10000 1≤M≤10000 1≤M≤10000,
1 ≤ l < 500 1≤l<500 1≤l<500

输入样例：

输出样例：

1 3 5 2

c++ 复制代码

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int n, m;
int d[N][N], g[N][N];
int pos[N][N];
int path[N], cnt;

void get_path(int i, int j)
{
    if (pos[i][j] == 0) return;

    int k = pos[i][j];
    get_path(i, k);
    path[cnt ++ ] = k;
    get_path(k, j);
}

int main()
{
    cin >> n >> m;

    memset(g, 0x3f, sizeof g);
    for (int i = 1; i <= n; i ++ ) g[i][i] = 0;

    while (m -- )
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = g[b][a] = min(g[a][b], c);
    }

    int res = INF;
    memcpy(d, g, sizeof d);
    for (int k = 1; k <= n; k ++ )
    {
        for (int i = 1; i < k; i ++ )
            for (int j = i + 1; j < k; j ++ )
                if ((long long)d[i][j] + g[j][k] + g[k][i] < res)
                {
                    res = d[i][j] + g[j][k] + g[k][i];
                    cnt = 0;
                    path[cnt ++ ] = k;
                    path[cnt ++ ] = i;
                    get_path(i, j);
                    path[cnt ++ ] = j;
                }

        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                if (d[i][j] > d[i][k] + d[k][j])
                {
                    d[i][j] = d[i][k] + d[k][j];
                    pos[i][j] = k;
                }
    }

    if (res == INF) puts("No solution.");
    else
    {
        for (int i = 0; i < cnt; i ++ ) cout << path[i] << ' ';
        cout << endl;
    }

    return 0;
}

345. 牛站

给定一张由 T T T 条边构成的无向图，点的编号为 1 ∼ 1000 1∼1000 1∼1000 之间的整数。

求从起点 S S S 到终点 E E E 恰好经过 N N N 条边（可以重复经过）的最短路。

注意: 数据保证一定有解。

输入格式

第 1 1 1 行：包含四个整数 N ， T ， S ， E N，T，S，E N，T，S，E。

第 2.. T + 1 2..T+1 2..T+1 行：每行包含三个整数，描述一条边的边长以及构成边的两个点的编号。

输出格式

输出一个整数，表示最短路的长度。

数据范围

2 ≤ T ≤ 100 2≤T≤100 2≤T≤100,
2 ≤ N ≤ 1 0 6 2≤N≤10^6 2≤N≤106

输入样例：

输出样例：

c++ 复制代码

#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
const int N = 210;
int k, n, m, S, E;
int g[N][N];
int res[N][N];

void mul(int c[][N], int a[][N], int b[][N]){
    static int temp[N][N];
    memset(temp, 0x3f, sizeof temp);
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                temp[i][j] = min(temp[i][j], a[i][k] + b[k][j]);
    memcpy(c, temp, sizeof temp);
}

void qmi(){
    memset(res, 0x3f, sizeof res);
    for (int i = 1; i <= n; i++) res[i][i] = 0;
    while(k){
        if(k & 1) mul(res, res, g); // res = res * g
        mul(g, g, g); // g = g * g
        k >>= 1;
    }
}

int main(){
    cin >> k >> m >> S >> E;
    memset(g, 0x3f, sizeof g);
    map<int,int> ids;
    if(!ids.count(S)) ids[S] = ++n;
    if(!ids.count(E)) ids[E] = ++n;
    S = ids[S], E = ids[E];
    while(m--){
        int a, b, c;
        cin >> c >> a >> b;
        if(!ids.count(a)) ids[a] = ++n;
        if(!ids.count(b)) ids[b] = ++n;
        a = ids[a], b = ids[b];
        g[a][b] = g[b][a] = min(g[a][b], c);
    }
    qmi();
    cout << res[S][E] << endl;
    return 0;
}