Floyd

1基础模板

原理：dp思想

多源最短路，每个点到每个点的距离

模板+思路

 

#include <iostream>
using namespace std;

const int N = 210, M = 2e+10, INF = 1e9;

int n, m, k, x, y, z;
int d[N][N];

void floyd() {
    for(int k = 1; k <= n; k++)
        for(int i = 1; i <= n; i++)
            for(int j = 1; j <= n; j++)
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
//如果i<k<j时，这个式子可以判断要不要选择k这个点，第一重循环表示到k这个点要不要选k，
//可能选了k时i到j的距离会变小，或者变大，如果j==k时，就是判断要不要走到j这个点（肯定走，因为式子的判断就成为min(d[i][j],d[i][j]+0)，
//那有最短路不包含j点怎么办，很简单，只要在k==这个j时不选k即可）
}

int main() {
    cin >> n >> m >> k;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            if(i == j) d[i][j] = 0;
            else d[i][j] = INF;
    while(m--) {
        cin >> x >> y >> z;
        d[x][y] = min(d[x][y], z);
        //注意保存最小的边
    }
    floyd();
    while(k--) {
        cin >> x >> y;
        if(d[x][y] > INF/2) puts("impossible");
        //由于有负权边存在所以约大过INF/2也很合理
        else cout << d[x][y] << endl;
    }
    return 0;
}

那怎么从三维（i，j，k）转化成（i，j）两位

 这就表示了从i到j的最短距离了

能解决的问题

 

2.最短路

 

 思路；

对于这道题,经过分析,我们发现:
对于每一个点,在这个连通块中一定会有一个点与他联通且与他的距离最远.
再看一眼n的范围,果断使用Floyd算法.
先求出每一个点到其他点的距离,找出用Maxstep[i]代表与点i相距最远的点距离点i的距离（求该连通块在选i点作为半径一点时的直径长度）.
先记录一下最大的Maxstep[i],记为ans1.
再考虑加边(注意加边必须加在不连通的两个点之间):
我们枚举每一对不连通的点对,考虑在这两个点加边.
加完边后,我们注意到此时的直径应该是Maxstep[i]+dis(i,j)+Maxstep[j].
我们再找出此时最短的一条Maxstep[i]+dis(i,j)+Maxstep[j],记为ans2.
最终答案记为max(ans1,ans2).

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

#define x first
#define y second

using namespace std;

typedef pair<double, double> PDD;

const int N = 155;
const double INF = 1e20;

int n;
PDD q[N];
double d[N][N];
double maxd[N];
char g[N][N];

double get_dist(PDD a, PDD b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; i ++ ) cin >> q[i].x >> q[i].y;
    for (int i = 0; i < n; i ++ ) cin >> g[i];

    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            if (i == j) d[i][j] = 0;
            else if (g[i][j] == '1') d[i][j] = get_dist(q[i], q[j]);
            else d[i][j] = INF;//求出该连通块每相邻两点的距离

    for (int k = 0; k < n; k ++ )
        for (int i = 0; i < n; i ++ )
            for (int j = 0; j < n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);//求出该连通块任意两点间最短距离

    double r1 = 0;
    for (int i = 0; i < n; i ++ )
    {
        for (int j = 0; j < n; j ++ )
            if (d[i][j] < INF / 2)
                maxd[i] = max(maxd[i], d[i][j]);//求出该连通块中带i点的最长直径长度
        r1 = max(r1, maxd[i]);求出该连通块的最大直径
    }

    double r2 = INF;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < n; j ++ )
            if (d[i][j] > INF / 2)
                r2 = min(r2, maxd[i] + maxd[j] + get_dist(q[i], q[j]));//找到最小半径

    printf("%.6lf\n", max(r1, r2));//可能连完所有连通块后，其带i，j两点的直径还没有一个连通块中最长直径大，答案需要我们求出连通块的（最小）直径（直径是该连通块的两点间最大距离）

    return 0;
}

3.传递闭包问题

 

 

 

 

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

using namespace std;

const int N = 26;

int n, m;
bool g[N][N], d[N][N];
bool st[N];

void floyd() //通过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];//注意是|=，因为i，j连通后不能再变为0；
            //if(!d[i][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 'A' + i;
            }
       }
}

int main()
{
    while(cin >> n >> m, n || m)
    {
        memset(g, 0, sizeof g);
        int type = 0, t; // t 记录轮次  type记录判断出来与否的标志
        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) puts("Sorted sequence cannot be determined.");
        else if(type == 2) printf("Inconsistency found after %d relations.\n", t);
        else 
        {
            memset(st, 0, sizeof st);
            printf("Sorted sequence determined after %d relations: ", t);
            for(int i = 0; i < n; i ++) printf("%c", get_min());
            printf(".\n");
        }
    }
    return 0;
}