[POJ3613]Cow Relays && Floyd倍增

本文详细介绍了如何通过阅读论文《矩阵乘法-俞华程》来理解和实现矩阵乘法和Floyd倍增算法,并提供了一个实际的C++代码示例。文章着重于解决在实现过程中遇到的常见问题,如离散化处理和单位矩阵的正确建立,以确保算法的正确性和效率。

怎么说呢 如果有看论文(矩阵乘法-俞华程) 这道题还是相当异常非常的简 (除了本人自己玩自己忘记离散化 直接函数爆栈调N久甚至求助吴老师之外) 

唯一需要注意的就是单位矩阵的建立是对角线为0 其他全部为正无穷 

Floyd倍增的原因论文上有说 其实我也没怎么看

废话就说到这里 上代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<iostream>
using namespace std;
#define MAXN 100
#define MAXM 100
#define INF 0x3f3f3f3f
typedef int LL;
struct Matrix{  
    int n, m;  
    LL A[MAXN+10][MAXN+10];  
}E, Z, A;
int Map[MAXN+10][MAXN+10];
int n, m, ST, ED, K, Fish;
int ID[MAXN*10+10], idcnt;
int N;
void Get_E()
{
	memset(E.A, 0x3f, sizeof(E.A));
	for(int i = 0; i < MAXN; i++) 
        E.A[i][i] = 0;
}
void New_mul(Matrix AA, Matrix BB, Matrix &Ans)
{
	Matrix D;
    memset(Ans.A, 0x3f, sizeof(D.A));
    Ans.n = D.n = AA.n;
    Ans.m = D.m = BB.m;
	for(int k = 0; k < MAXN; k++)  
        for(int i = 0; i < MAXN; i++)  
            for(int j = 0; j < MAXN; j++)  
                if(Ans.A[i][j] > AA.A[i][k] + BB.A[k][j])  
                    Ans.A[i][j] = AA.A[i][k] + BB.A[k][j];
}
void pow_mod(Matrix A, int k, Matrix &Ans)
{
    Matrix ans = E, t = A, tmp;
    Ans.n = ans.n = A.n;
    Ans.m = ans.m = A.m;
    while(k)
    {
        if(k & 1)
		{
			New_mul(ans, t, tmp);
			ans = tmp;
		}
        New_mul(t, t, tmp);
		t = tmp;
        k >>= 1;
    }
    memcpy(Ans.A, ans.A, sizeof(ans.A));
}
Matrix Ans;
int main()
{
	ios::sync_with_stdio(false);
	Get_E();
	memset(Map, 0x3f, sizeof(Map));
	cin >> n >> m >> ST >> ED;
	ST--; ED--;
	memset(ID, -1, sizeof(ID));
	for(int i = 0; i < m; i++)
	{
		int u, v, d;
		cin >> d >> u >> v;
		u--;
		v--;
		if(~ID[u] == 0) ID[u] = idcnt++;
		if(~ID[v] == 0) ID[v] = idcnt++;
		Map[ID[u]][ID[v]] = Map[ID[v]][ID[u]] = d;
	}
	E.n = E.m = Z.n = Z.m = A.n = A.m = MAXN;
	memcpy(A.A, Map, sizeof(Map));
	pow_mod(A, n, Ans);
	cout << Ans.A[ID[ST]][ID[ED]] << '\n';
}


### 解题思路 POJ 3613 Cow Relays 问题要求计算在给定的图中,从起点到终点恰好经过 $k$ 条边的最短路径。常规的暴力解法,即每次走一步更新最短路径,时间复杂度为 $O(k * n^3)$,效率较低。可利用二进制思想和矩阵快速幂的方法,将时间复杂度优化到 $O(logK * n^3)$ [^2]。 具体思路如下: 1. **图的表示**:使用邻接矩阵来表示图,矩阵中的元素 `mat[i][j]` 表示从节点 `i` 到节点 `j` 的最短距离,初始值设为无穷大 `INF`。 2. **矩阵乘法的定义**:普通矩阵乘法是对应元素相乘再相加,而这里定义的矩阵乘法是对应元素相加再取最小值。即 `C.mat[i][j] = min(C.mat[i][j], A.mat[i][k] + B.mat[k][j])`,表示从节点 `i` 经过节点 `k` 到节点 `j` 的最短距离。 3. **矩阵快速幂**:通过不断地将矩阵自乘,利用二进制的思想,快速计算出经过 $k$ 条边的最短路径矩阵。 4. **节点编号映射**:由于节点编号可能不连续,使用一个数组 `f` 来将原始节点编号映射到连续的编号,方便矩阵操作。 ### 代码实现 以下是实现该算法的 C++ 代码: ```cpp #include <stdio.h> #include <string.h> #include <algorithm> #include <iostream> using namespace std; #define INF ((1<<30)-1) int n; struct matrix { int mat[201][201]; matrix() { for(int i = 0; i < 201; i++) for(int j = 0; j < 201; j++) mat[i][j] = INF; } }; int f[2001]; matrix mul(matrix A, matrix B) { matrix C; int i, j, k; for(i = 1; i <= n; i++) { for(j = 1; j <= n; j++) { for(k = 1; k <= n; k++) { C.mat[i][j] = min(C.mat[i][j], A.mat[i][k] + B.mat[k][j]); } } } return C; } matrix powmul(matrix A, int k) { matrix B; for(int i = 1; i <= n; i++) B.mat[i][i] = 0; while(k) { if(k & 1) B = mul(B, A); A = mul(A, A); k >>= 1; } return B; } int main() { matrix A; int k, t, s, e, a, b, c; scanf("%d%d%d%d", &k, &t, &s, &e); int num = 1; while(t--) { scanf("%d%d%d", &c, &a, &b); if(f[a] == 0) f[a] = num++; if(f[b] == 0) f[b] = num++; A.mat[f[a]][f[b]] = A.mat[f[b]][f[a]] = c; } n = num - 1; A = powmul(A, k); cout << A.mat[f[s]][f[e]] << endl; return 0; } ``` ### 代码解释 1. **结构体 `matrix`**:定义了一个矩阵结构体,用于存储图的邻接矩阵,构造函数将矩阵元素初始化为无穷大。 2. **函数 `mul`**:实现了自定义的矩阵乘法,计算两个矩阵相乘的结果。 3. **函数 `powmul`**:实现了矩阵快速幂,通过不断地将矩阵自乘,快速计算出经过 $k$ 条边的最短路径矩阵。 4. **主函数 `main`**:读取输入数据,将节点编号映射到连续的编号,初始化邻接矩阵,调用 `powmul` 函数计算经过 $k$ 条边的最短路径矩阵,最后输出从起点到终点的最短距离。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值