POJ-1502 MPI Maelstrom (裸dijkstra算法)

题目大意：

大概就是说，有n个处理器，每两个处理器之间都有两个状态，一是可直接联通，而是不可直接联通。
然后求出从第一个处理器到另外各个点的时间最长的值是多少。
这道题的输入需要注意一下，题目输入的是一个邻接矩阵的下三角，所以需要自己特殊处理一下。但是问题并不大。

算法分析：

这道题就是纯粹的裸dijkstra模板，我之前写的那篇POJ-1602其实并不是dijkstra算法，当时我没有搞明白dijstra算法的
具体实现，是自己瞎j8乱写的（虽然最后也做出来了），这次我完全理解了dijkstra算法，所以特意写了一篇博客记录一下。
这次的运气比较好，一次就A掉了 (^_^)

代码

#include <stdio.h>
#include <string.h>

#include <iostream>
#include <algorithm>

#define MAXNUM 0x7fffffff

using namespace std;

int n;
long long edge[110][110];
long long maxn[110];
bool statu[110];

int dijkstra()
{
for (int i = 1; i <= n; i++) {
maxn[i] = MAXNUM;
statu[i] = false;
}
maxn[1] = 0;
for (int i = 1; i <= n; i++) {
int x = 1;
long long maxtmp = MAXNUM;
for (int j = 1; j <= n; j++) {
if (maxn[j] < maxtmp && !statu[j]) {
x = j;
maxtmp = maxn[j];
}
}
statu[x] = true;
for (int j = 1; j <= n; j++) {
if (maxn[j] > maxn[x] + edge[x][j] && edge[x][j] != -1 && edge[x][j]) {
maxn[j] = maxn[x] + edge[x][j];
}
}
}
long long minn = 0;
for (int i = 1; i <= n; i++) {
if (minn < maxn[i])
minn = maxn[i];
}

return minn;
}

int main()
{
char charNum[100];
long long numtmp;

while (scanf("%d", &n) != EOF) {

4000
edge[1][1] = 0;
for (int i = 2; i <= n; i++) {
edge[i][i] = 0;
for (int j = 1; j < i; j++) {
scanf("%s", &charNum);
if (charNum[0] == 'x')
numtmp = -1;
else
sscanf(charNum, "%lld", &numtmp);
edge[i][j] = numtmp;
edge[j][i] = numtmp;
}
}
//        for (int i = 1; i <= n; i++) {
//            for (int j = 1; j <= n; j++) {
//                printf("%lld\t", edge[i][j]);
//            }
//            printf("\n");
//        }
printf("%d\n", dijkstra());
}

return 0;
}