P1002 过河卒：图论动态规划入门-CFANZ编程社区

1 介绍

本专题介绍使用floyd算法求解的题目。

使用floyd算法，可以求解如下问题：

最短路。
传递闭包。
找图中的距离总和最小的环路。
求恰好经过k条边的最短路。

floyd算法的原理讲解：基于动态规划。

状态表示d[k,i,j]：(1)集合：所有从i出发，最终走到j，且中间只经过结点编号不超过k的所有路径。(2)属性：路径长度的最小值。

状态计算：(1)所有不含结点k的路径，即d[k-1,i,j]。(2)所有包含结点k的路径，即d[k-1,i,k] + d[k-1,k,j]。

状态转移为：d[k,i,j] = min(d[k-1,i,j], d[k-1,i,k] + d[k-1,k,j])

考虑优化掉第一维状态之后，有，

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]);
		}
	}
}

2 训练

题目1：1125牛的旅行

C++代码如下，

#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) {
                maxd[i] = max(maxd[i], d[i][j]);
            }
        }
        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) {
                r2 = min(r2, maxd[i] + maxd[j] + get_dist(q[i], q[j]));
            }
        }
    }
    
    printf("%.6lf\n", max(r1, r2));
    
    return 0;
}

题目2：343排序

C++代码如下，

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

using namespace std;

const int N = 30;
bool st[N];
int dist[N][N];
int n, m;

void floyd() {
    for (int k = 0; k < n; ++k) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (dist[i][k] == 1 && dist[k][j] == 1) {
                    dist[i][j] = 1;
                }
            }
        }
    }
    
    return;
}

int get_type() {
    for (int i = 0; i < n; ++i) {
        if (dist[i][i] == 1) {
            return 2; //有冲突
        }
    }
    
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j) {
                if (dist[i][j] == 0 && dist[j][i] == 0) {
                    return 0; //无解
                }
            }
        }
    }
    
    return 1; //有解
}

char get_min() {
    int t = -1; //没有走到i的结点
    for (int i = 0; i < n; ++i) {
        if (st[i]) continue;
        //i是不是我们要输出的答案
        
        bool flag = true;
        for (int j = 0; j < n; ++j) {
            if (i != j) {
                if (st[j] == false && dist[j][i] == 1) {
                    flag = false;
                    break;
                }
            }
        }
        
        if (flag) {
            t = i;
            st[t] = true;
            return 'A' + t;
        }
    }
    return '#';
}

int main() {
    while (cin >> n >> m) {
        if (n == 0 && m == 0) break;
        
        memset(dist, 0, sizeof dist);
        
        int type = 0;
        int iter = -1;
        
        for (int i = 0; i < m; ++i) {
            string t;
            cin >> t;
            int a = t[0] - 'A', b = t[2] - 'A';
            
            
            if (type == 0) {
                dist[a][b] = 1;
                floyd();
                
                type = get_type();
                
                if (type != 0) {
                    iter = i + 1;
                }                
            }
        }
        
        //输出答案
        if (type == 0) {
            printf("Sorted sequence cannot be determined.\n");
        } else if (type == 2) {
            printf("Inconsistency found after %d relations.\n", iter);
        } else if (type == 1) {
            printf("Sorted sequence determined after %d relations: ", iter);
            memset(st, 0, sizeof st);
            for (int i = 0; i < n; ++i) {
                cout << get_min();
            }
            cout << "." << endl;
        }
    }
    return 0;
}

题目3：344观光之旅

C++代码如下，

#include <iostream>
#include <cstring>
#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;
}

题目4：345牛站

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);
    return;
}

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);
        mul(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;
}

P1002 过河卒：图论动态规划入门

目录

1 介绍

2 训练