最短路Dijkstra+Floyd

目录

Dijkstra

Dijkstra模板

eg:

Floyd

Floyd模板

eg1:

eg2:删点游戏

笔记:


Dijkstra

最短路Dijkstra+Floyd_第1张图片

n

最短路Dijkstra+Floyd_第2张图片

Dijkstra模板

#include
using namespace std;
const int N = 1e7;
struct Node {
    int y, v;
    Node(int _y, int _v) { y = _y, v = _v; }
};
vectoredge[N + 1];
int n, m, dist[N + 1];
bool b[N + 1];
int Dijkstra(int s, int t) {
    memset(b, 0, sizeof(b));
    memset(dist, 127, sizeof(dist));
    dist[s] = 0;
    while (1) {
        int x = -1;
        for (int i = 1; i <= n; i++) {
            if (!b[i] && dist[i] < 1 << 30)
                if (x == -1 || dist[i] < dist[x])
                    x = i;
        }if (x == t || x == -1)break;//找不到点加入集合C 结束
        b[x] = 1;
        for (auto i : edge[x])
            dist[i.y] = min(dist[i.y], dist[x] + i.v);
    }return dist[t];
}
#include
using namespace std;
const int N = 1e7;
struct Node {
    int y, v;
    Node(int _y, int _v) { y = _y, v = _v; }
};
set>q;
vectoredge[N + 1];
int n, m, dist[N + 1];

int Dijkstra(int s, int t) {
    memset(dist, 127, sizeof(dist));
    dist[s] = 0; q.clear();
    for (int i = 1; i <= n; i++)
        q.insert(make_pair(dist[i], i));
    while (!q.empty()) {
        int x = q.begin()->second;
        q.erase(q.begin());
        if (x == t || dist[x] > 1 << 30)break;//找不到点加入集合C 结束
        for (auto i : edge[x]) {//松弛操作更新
            if (dist[x] + i.v < dist[i.y]) {
                q.erase(make_pair(dist[i.y], i.y));
                dist[i.y] = dist[x] + i.v;
                q.insert(make_pair(dist[i.y], i.y));
            }
        }//dist[i.y] = min(dist[i.y], dist[x] + i.v);
    }return dist[t];
}

eg:

给你一张简单有向图,边权都为非负整数。以及一些询问,询问两个点之间的距离。

图用以下形式给出:

第一行输入三个整数 n,m,k,表示图的顶点数、边数和询问次数,顶点编号从 1到 。

接下来 m 行,每行三个整数 x,y,z,表示 x 到 y 有一条有向边,边权为 z。

接下来 k 行,每行两个整数 x,y,询问从 x到 y 的最短路长度,如果无法到达,输出 −1。

输入格式

第一行三个整数 n,m,k,表示图的顶点数、边数和询问次数。

接下来 m 行,每行有三个整数,代表一条边。

接下来 k 行,每行有两个整数,代表一次询问。

输出格式

输出共 k 行,每行一个数表示一次询问的答案。

样例输入

3 3 2
1 2 3
2 3 2
3 2 1
1 3
3 1

样例输出

5
-1

数据规模

对于所有数据,保证 2 ≤ n ≤ 5000, 0 ≤ m ≤ 10000, 1≤ k ≤5, 1 ≤ x,y ≤ n,x≠y,1 ≤ z ≤ 10000

#include
#include
#include
using namespace std;
struct Node {
	int y, v;
	Node(int _y, int _v) {
		y = _y, v = _v;
	}
};
vectoredge[5001];
int n, m, k, s, t, dist[5001];
bool b[5001];
void dijkstra(int s, int t) {
	memset(dist, 127, sizeof(dist));
	memset(b, false, sizeof(b));
	dist[s] = 0;
	while (1) {
		int x = -1;
		for (int i = 1; i <= n; i++) {//找V-S中最小距离的点 将其加入S 
			//cout << 'i' << i << endl;
			if (!b[i] && dist[i] < 1 << 30) {//遍历所有点找V-S中的且距离小于正无穷的点 
				if (x == -1 || dist[x] > dist[i])//最开始还没找到一个点或找的点距离小于已找到点x 
				{
					x = i;//更新点x,将x加入S
				   //cout<<'x'<

Floyd

最短路Dijkstra+Floyd_第3张图片

 空间复杂度O(n^3)->O(n^2)

最短路Dijkstra+Floyd_第4张图片

Floyd模板

#include
using namespace std;
const int N = 300;
int n, m, q, f[N+1][N+1];
void Floyd() {
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (f[i][k] < 1 << 30 && f[k][j] < 1 << 30)//判断两点之间是否有路径
                    f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
int main() {
    scanf("%d%d%d", &n, &m, &q);
    memset(f, 127, sizeof(f));//初始最大化 点到点距离无限大  
                              //确保任意点之间都有边时不需要 同理不需要f[i][i]=0;
    for (int i = 1; i <= n; i++) 
        f[i][i] = 0;//自己到自己距离为0
    int x, y, z;
    for (int i = 1; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        f[x][y] = z;//有向边距离初始化
    }
    Floyd();

    return 0;
}

eg1:

数据范围:

2 ≤ n ≤ 300, 0 ≤ m ≤ 20000, 1 ≤ k ≤ 100000, 1 ≤ x,y ≤ n,x≠y, 1 ≤ z ≤ 10000

#include
using namespace std;
const int N = 300;
int n, m, q, f[N+1][N+1];
void Floyd() {
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                if (f[i][k] < 1 << 30 && f[k][j] < 1 << 30)
                    f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
int main() {
    scanf("%d%d%d", &n, &m, &q);
    memset(f, 127, sizeof(f));//初始最大化 点到点距离无限大
    for (int i = 1; i <= n; i++) 
        f[i][i] = 0;//自己到自己距离为0
    int x, y, z;
    for (int i = 1; i <= m; i++) {
        scanf("%d%d%d", &x, &y, &z);
        f[x][y] = z;//有向边距离初始化
    }
    Floyd();
    int s, t;
    for (int i = 1; i <= q; i++) {
        scanf("%d%d", &s, &t);
        if (f[s][t] < 1 << 30)printf("%d\n", f[s][t]);
        else printf("-1\n");
    }
    return 0;
}

eg2:删点游戏

给你一张简单有向图,我们要把所有点依次删完。小蜗每次会删掉图中的一个点和所有与它相连的边,小蜗想知道每删去一个点之后图中所有点对的距离之和。

图用以下形式给出:

第一行输入一个数 n, 表示顶点数。

接下来 n 行,会输入一个 n∗n 的矩阵 A 表示这张图的邻接矩阵,矩阵第 i 行第 j列表示 i 号顶点到 j 号顶点有一条边权为 A[i][j] 的边。

接下来一行,输入 n 个数 xi,代表删除顶点的次序。

你需要求出删除了第 0 个点(一个点都没删除)到第 n−1 个点(图中还剩下一个点)时,图中所有点对的距离之和。

#include
using namespace std;
const int N = 300;
int n, f[N+1][N+1],c[N+1],a[N+1];//c[]记录删点顺序
bool b[N + 1];//记录点i是否加入图中

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
            scanf("%d", &f[i][j]);
    for (int i = 1; i <= n; i++)scanf("%d", &c[i]);
    memset(b, 0, sizeof(b));

    for (int l = n; l > 0; l--) {//倒序删除顺序 即加入顺序 Floyd
        int k = c[l];
        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]);
                //加入k点后 更新所有距离
                //i,j循环所有点,但f[i][j]只是初始值与已加入的k点更新的最小距离
                //且后续会根据 b[i] b[j]判断是否该点加入 加入才会计算到ans中去 
        b[k] = 1;
        int ans = 0;
        for (int i = 1; i <= n; i++)//记录加入点c[l]时最短距离和
            for (int j = 1; j <= n; j++)
                if (b[i] && b[j])ans += f[i][j];
        a[l] = ans;
    }
    for (int i = 1; i <= n; i++)printf("%d ", a[i]);
    return 0;
}

笔记:

1)Dijkstra与Floyd区别:

    Dijkstra:一点到其他点的最短距离O(n*(nm)log n)(优化版+所有点最短路版)

                   vector边表存储边信息edge[x].push_back( Node( y,v ) );

    Floyd:所有点之间的最短距离O(n^3)

                邻接矩阵存储边信息 f [x][y]=v;

都可记录中间过程点即路径

2)数组拷贝:memcpy(f[i], dist, sizeof(dist));

3)有向图考虑将所有边反向

4)题目要求依次删点时考虑依次加点

你可能感兴趣的:(图论,c++,算法)