poj3268

Dijkstra算法的变形。初步看确实直接想到用Floyd，提交后直接TLE，没有注意到时间只有2000ms。最后改进了一下Dijkstra算法，从Party定点x到各定点距离好求，而从各点到x的多源单点问题就需要一点小技巧了。把所有的边全部反向，求x到各顶点距离，这样结果就得到了各顶点到x的最短距离。用领接矩阵的话很好做，无需直接的把边反向操作，用存边矩阵E[i][x](表示定点 i 到定点 x)替换E[x][i]即可。

整体时间复杂度为O(v^2)，效果还不错，用最小堆的话应该还可以再降一点。空间消耗比较大。

代码如下：

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

const int INF = 0x3f3f3f3f;

int E[1000][1000], map[1000][1000];

void CreatMap(int n, int m){
	int e1, e2, weight;
	memset(E, 0, sizeof(E));
	for(int i=0;i<m;i++){
		scanf("%d%d%d", &e1, &e2, &weight);
		E[e1-1][e2-1] = weight;
	}
}

void Dijkstra(int n, int x){
	memset(map, INF, sizeof(map));
	int visited_1[n], visited_2[n];
	memset(visited_1, 0, sizeof(visited_1));
	memset(visited_2, 0, sizeof(visited_2));
	map[x][x] = 0;
	int min1, min2, k1, k2;
	for(int i=0;i<n;i++){
		k1 = -1, k2 = -1;
		//map第x行，为从x到各定点，即回去的路 
		for(int j=0;j<n;j++)
			if(visited_1[j] == 0)
				if(k1==-1 || min1 > map[x][j])
					k1 = j, min1 = map[x][j];
		visited_1[k1] = 1;
		for(int j=0;j<n;j++){
			if(E[k1][j] && map[x][j] > map[x][k1] + E[k1][j])
				map[x][j] = map[x][k1] + E[k1][j];
		}
		
		//map第x列，为各定点到x，即去party的路 
		for(int j=0;j<n;j++)
			if(visited_2[j] == 0)
				if(k2==-1 || min2 > map[j][x])
					k2 = j, min2 = map[j][x];
		visited_2[k2] = 1;
		for(int j=0;j<n;j++){
			if(E[j][k2] && map[j][x] > map[k2][x] + E[j][k2])	//注意倒置 
				map[j][x] = map[k2][x] + E[j][k2];
		}
	}
}

int FindMax(int n, int x){
	int min = 0;
	for(int i=0;i<n;i++){
		if(map[i][x] + map[x][i] > min)
			min = map[i][x] + map[x][i];
	}
	return min;
}

int main(){
	int n, m, x;
	scanf("%d%d%d", &n, &m, &x);
	CreatMap(n, m);
	Dijkstra(n, x-1);
	m = FindMax(n, x-1);
	printf("%d", m);
	
	return 0;
}