算法：最小生成树（prime，kruskal，floyd）

最小生成树

Floyd算法O（n^3）- 动态规划

思路

• f[i, j, k]

  表示从

  i

  走到

  j

  的路径上除

  i

  和

  j

  点外只经过

  1

  到

  k

  的点的所有路径的最短距离。那么

  f[i, j, k] = min(f[i, j, k - 1], f[i, k, k - 1] + f[k, j, k - 1])

• 读入邻接矩阵，每次通过动态规划转换成从i到j的最短距离矩阵
• 在下面代码中，判断从a到b是否是无穷大距离时，需要进行

  if(t > INF/2)

  判断，而非是

  if(t == INF)

  判断，原因是INF是一个确定的值，并非真正的无穷大，会随着其他数值而受到影响，t大于某个与

  INF

  相同数量级的数即可。
• 注意邻接矩阵的初始化。

题目描述

给定一个n个点m条边的有向图，图中可能存在重边和自环，边权可能为负数。

再给定k个询问，每个询问包含两个整数x和y，表示查询从点x到点y的最短距离，如果路径不存在，则输出“impossible”。

数据保证图中不存在负权回路。

输入格式

第一行包含三个整数n，m，k

接下来m行，每行包含三个整数x，y，z，表示存在一条从点x到点y的有向边，边长为z。

接下来k行，每行包含两个整数x，y，表示询问点x到点y的最短距离。

输出格式

共k行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出“impossible”。

数据范围

1≤n≤200,

1≤k≤n2

1≤m≤20000,

图中涉及边长绝对值均不超过10000。

输入样例：

3 3 2

1 2 1

2 3 2

1 3 1

2 1

1 3

输出样例：

impossible

1

代码

#include <iostream>
#include <cstring>
using namespace std;
const int N = 210, INF = 1e9;
int d[N][N];

int main()
{
    int n, m, q;
    cin >> n >> m >> q;
    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 --)
    {
        int x, y, k;
        cin >> x >> y >> k;
        d[x][y] = min(d[x][y], k);
    }
    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]);
    while(q --)
    {
        int x, y;
        cin >> x >> y;
        if (d[x][y] > INF / 2) cout << "impossible" << endl;
        else cout << d[x][y] << endl;
    }
    return 0;
}
           

原题链接

Kruskal算法O（mlogm)

思路

• 将所有边按权重从小到大排序
• 枚举每条边a,b权重c

  • if a, b两点不连通

    将a, b边加入集合中

注意：枚举每条边的操作是并查集操作。

需要使用变量cnt来记录加进集合的边数，若

cnt < n - 1

表示不能遍历所有点

问题描述

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。

由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。

输入格式

第一行包含两个整数n和m。

接下来m行，每行包含三个整数u，v，w，表示点u和点v之间存在一条权值为w的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

数据范围

1≤n≤105,

1≤m≤2∗105,

图中涉及边的边权的绝对值均不超过1000。

输入样例：

4 5

1 2 1

1 3 2

1 4 3

2 3 2

3 4 4

输出样例：

6

代码

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1000010;

int n, m;
int p[N];
struct Edge
{
    int a, b, w;
    
    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[N];

int find(int x)
{
    if (x != p[x]) p[x] = find(p[x]);
    return p[x];
}


int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
        p[i] = i;
    for (int i = 0; i < m; ++i)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edges[i] = {a, b, w};
    }
    sort(edges, edges+m);
    int ans = 0, cnt = 0;
    for (int i = 0; i < m; ++i)
    {
        int a = find(edges[i].a);
        int b = find(edges[i].b);
        if (a != b){
            p[a] = b;
            ans += edges[i].w;
            cnt ++;
        }
    }
    if (cnt < n - 1) cout << "impossible";
    else cout << ans << endl;
    return 0;
}
           

原题链接

Prime算法O(n^2)

思路

dist[i]

距离设置为无穷大

s:当前已经在连通块中的所有点

for i 1…n

(1)t 找到集合外距离最近的点 总共O（n^2）次

(2)st 对该店进行标记

(3)用t更新其他点到集合的距离

dist[1] = 0

问题描述

给定一个n个点m条边的无向图，图中可能存在重边和自环，边权可能为负数。

求最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

给定一张边带权的无向图G=(V, E)，其中V表示图中点的集合，E表示图中边的集合，n=|V|，m=|E|。

由V中的全部n个顶点和E中n-1条边构成的无向连通子图被称为G的一棵生成树，其中边的权值之和最小的生成树被称为无向图G的最小生成树。

输入格式

第一行包含两个整数n和m。

接下来m行，每行包含三个整数u，v，w，表示点u和点v之间存在一条权值为w的边。

输出格式

共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出impossible。

数据范围

1≤n≤500,

1≤m≤105,

图中涉及边的边权的绝对值均不超过10000。

输入样例：

4 5

1 2 1

1 3 2

1 4 3

2 3 2

3 4 4

输出样例：

6

代码

#include <iostream>
#include <cstring>
using namespace std;

int n, m;
const int N = 510, INF = 0x3f3f3f3f;
int g[N][N];
int st[N];
int dist[N];

int prime()
{
    int ans = 0;
    memset (dist, 0x3f, sizeof dist);
    for (int i = 0; i < n; ++i)
    {
        int t = -1;
        for (int j = 1; j <= n; ++j)
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        if (i && dist[t] == INF) return INF;
        if (i) ans += dist[t];   
        st[t] = true;
        for (int j = 1; j <= n; ++j)
        {
            dist[j] = min(dist[j], g[t][j]);
        }
    }
    return ans;
}


int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    while (m -- )
    {
        int x, y, c;
        cin >> x >> y >> c;
        g[x][y] = g[y][x] = min(g[x][y], c);
    }
    int t = prime();
    if (t == INF) cout << "impossible" << endl;
    else cout << t << endl;
    return 0;
}
           

原题链接