MPI Maelstrom POJ - 1502

最新推荐文章于 2021-08-15 15:25:36 发布

原创最新推荐文章于 2021-08-15 15:25:36 发布 · 648 阅读

0 ·

CC 4.0 BY-SA版权

POJ 同时被 2 个专栏收录

113 篇文章

订阅专栏

图论

80 篇文章

订阅专栏

本文探讨了在具有不同性能的计算机网络中，如何优化消息传播时间。通过构建类似于二叉树的网络结构，利用Floyd算法和Dijkstra算法，找到了从指定节点发送消息到网络中所有节点的最短路径，进而确定了消息传播的最小时间成本。

一、内容

 实验室有很多台计算机，由于每个人计算机的性能不同，导致计算机之间发送信息的速度不同，所以花费时间不同。

消息从第一台电脑发送到第二台电脑后，这两台电脑能再向其他电脑发送消息，就是一种类似二叉树的结构。

当然并不是真正的二叉树——我们的计算机有一些特殊的特性，我们应该加以利用。

我们的计算机允许同时向连接到它的任意数量的其他计算机发送消息。

然而，消息不一定同时到达目的地——这涉及到计算机配置。

一般来说，我们需要考虑到拓扑结构中每个计算机的时间成本，并相应地计划将消息传播所需的总时间降到最低。

涂爷需要经常给其他人发消息，她想要知道如果她发出一个消息，至少要等多久全部的人才可以都收到通知。

Input
第一行输入一个n，表示有多少台计算机（涂爷当然是一号机啦~）。

    随后n-1行，以邻接矩阵的形式给出计算机（1~n）之间通讯需要的时间。

    由于两台计算机相互通信时间相等，且计算机自己和自己不需要通信，所以只给出了矩阵的下三角。

    ps：x表示由于部分计算机之间存在特殊的磁场并不能通信。

    ps2：该题所有数据范围0~100。

Output
输出一行表示涂爷需要等待的时间。.
Sample Input

Sample Output

二、思路

直接求出1号点到其他所有点的最短路径，由于问的是发送消息到其他所有点的时间，那么找出1号点到其他所有点的最短路径中的最大值即可。

三、代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 105, INF = 0x3f3f3f3f;
int n, g[N][N];
char w[20];
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
			}
		}
	}
}
int main() {
	scanf("%d", &n);
	memset(g, 0x3f, sizeof(g));
	for (int i = 1; i <= n; i++) g[i][i] = 0;
	for (int i = 2; i <= n; i++) {
		for (int j = 1; j <= i - 1; j++) {
			scanf("%s", w);
			if (w[0] == 'x') continue;
			int t = atoi(w); //将数组转化为整型 
			g[i][j] = g[j][i] = t;
		}
	}
	floyd();
	int ans = 0;
	for (int i = 2; i <= n; i++) {
		if (g[1][i] != INF) ans = max(ans, g[1][i]);
	}
	printf("%d\n", ans);
	return 0;
}

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#define max(a, b) (a > b ? a : b)
using namespace std;
const int N = 105, INF = 0x3f3f3f3f;
struct E {
	int v, w, next;
} e[N * N * 2];
struct Node {
	int v, d;
	Node(int v, int d):v(v), d(d){}
	bool operator < (const Node &w)const {
		return d > w.d;
	}
};
int n, len = 1, head[N], d[N];
bool vis[N];
char w[20];
void add(int u, int v, int w) {
	e[len].v = v;
	e[len].w = w;
	e[len].next = head[u];
	head[u] = len++;
}
void djkstra(int u) {
	memset(d, 0x3f, sizeof(d));
	priority_queue<Node> q;
	d[u] = 0;
	q.push(Node(u, 0));
	while (!q.empty()) {
		u = q.top().v;
		q.pop();
		if (vis[u]) continue;
		vis[u] = true;
		for (int j = head[u]; j; j = e[j].next) {
			int v = e[j].v;
			int w = e[j].w;
			if (!vis[v] && d[v] > d[u] + w) {
				d[v] = d[u] + w;
				q.push(Node(v, d[v]));
			}
		}
	}
}
int main() {
	scanf("%d", &n);
	for (int i = 2; i <= n; i++) {
		for (int j = 1; j <= i - 1; j++) {
			scanf("%s", w);
			if (w[0] == 'x') continue;
			int t = atoi(w);			
			add(i, j, t);
			add(j, i, t);
		}
	}
	djkstra(1);
	int ans = 0;
	for (int i = 2; i <= n; i++) ans = max(ans, d[i]);
	printf("%d", ans);
	return 0;
}