最短路POJ 3268

POJ 3268题目大意如下：

有N头牛分布在N个农场，现在有一头X农场的牛要举办party，那么其他农场的牛都会去参加。其中N最大为1000，农场和农场之间存在一些单向路径，路径的条数M最大为100000。如果每头牛都走最短路径（算上来回，也就是从它的农场到X农场，再从X农场回到自己农场），那么这些最短路径中最长的路径是多少？

这里涉及到的是任意两点间的最短路径，

1）一开始想到的是warshall算法，但是想想O(N^3)的复杂度，还是放弃最好。

2）如果考虑Bellman算法呢？它的复杂度是和边以及点数都有关的，从实现手法上看就是：O(E*V)的复杂度。但是对于计算单源最短路径的Bellman算法，如果计算多源那么就是O(E*V^2)的复杂度，所以Bellman也是不行。

3）之后再想Dijikstra算法（之前还没有理解清楚负圈的意思，一直不敢用（我去。。），后来想想，和圈是不一样的，如果是正圈的话，多次更新也不会出现道路不断变小的情况），如果对点考虑的话复杂度是V^2，但是考虑边就不是了，复杂度可以降到O(E*logV)的程度，如果计算任意两点的话，那么复杂度就是：O(V*E*logV)

虽然还是比较到，但是如果利用经典最短路算法，这里已经做到最优了。代码如下：Accept 4604K / 1079MS

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <vector>

using namespace std;
const int maxn = 1005;
const int INF = 1000000;
typedef pair<int, int> P;

struct edge {
	int to, cost;
	edge(){}
	edge(int to, int cost): to(to), cost(cost){}
};

int N, M, X;
int dis[maxn][maxn];
vector<edge> Grap[maxn];

void dijkstra(int s) {
	priority_queue<P, vector<P>, greater<P> > que;
	for (int i = 0; i <= N; i++) dis[s][i] = INF;
	dis[s][s] = 0;
	que.push(P(0, s));

	while (!que.empty()) {
		P p = que.top();
		que.pop();
		int v = p.second, len = Grap[v].size();
		//如果从队列中取出的路径长度大于当前的“最短路径”，那么这条路径可以被忽略
		if (dis[s][v] < p.first) continue;
		for (int i = 0; i < len; i++) {
			edge e = Grap[v][i];
			//将当前的最短路放入队列，以备下次更新使用
			if (dis[s][e.to] > dis[s][v] + e.cost) {
				dis[s][e.to] = dis[s][v] + e.cost;
				que.push(P(e.cost, e.to));
			}
		}
	}
}

void solve() {
	int ans = 0;
	for (int i = 1; i <= N; i++) dijkstra(i);
	for (int i = 1; i <= N; i++) {
		if (i == X) continue;
		int temp = dis[i][X] + dis[X][i];
		if (ans < temp) ans = temp; 
	}
	printf("%d\n", ans);
}

int main() {
	int x, y, t;
	scanf("%d %d %d", &N, &M, &X);
	for (int i = 0; i < M; i++) {
		scanf("%d %d %d", &x, &y, &t);
		Grap[x].push_back(edge(y, t));
	}
	solve();
	return 0;
}