题目链接：http://poj.org/problem?id=1511

题目大意：

给你一个N个点的图，求1点到其他每个点最短路权值之和sum1，然后再求反向最短路（其他所有点到1点最短距离）之和sum2。输出sum1+sum2

解题思路：

别人说的题意，正好最短路也忘了，就用SPFA写了一下。结果SPFA忘了。。。问了别人，算是懂了。

所谓的SPFA，就是bellman-ford的优化，因为bellman-ford是循环更新每条边n-1次（循环次数固定），但是效率很低，因为不可能每条边都需要更新这么多次吧。所以，出现了SPFA。SPFA的改进之处在于，我加入队列的元素都是已经松弛过，最短距离减小的点，我每次取出对头，更新所以经过这个节点的其他点，如果其他节点的最短距离通过这个队头的点能变小，就松弛。不能就遍历其他点。这样，更新的次数大大减少。

之前我的SPFA是用邻接矩阵实现的，效率之挫就不多说了，因为没有充分利用邻接表的优势，因为邻接矩阵我必须逐个遍历，才能知道两点之间是否存在边，而邻接表存储的就是两点之间相连的边。

这样，SPFA+邻接表的组合就变得更加强大。。。。

总结就是：

最短路题目，最好都使用邻接表+SPFA。这样，差不多就能解决了。（除非特别出数据专门卡SPFA！~~还没遇到~~~~）

代码如下：

#include<iostream>
#include<cstdio>
#include<climits>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;

#define CLR(arr, what) memset(arr, what, sizeof(arr))
const int N = 1000010;
const long long MAX = 10000000000000005; //数据太大。10亿*100W

int Head[N], Next[N], Key[N], Num[N], num;
long long dis[N];
bool visit[N];
int nodenum, edgenum;

struct Edge //结构体存图，方便反向建边
{
	int u, v;
	int weight;
}edge[N];

void add(int u, int v, int cost) //u,v之间加入权值为cost的边
{
	Key[num] = cost;
	Next[num] = Head[u];
	Num[num] = v;
	Head[u] = num++;
}

void init()
{
	num = 0;
	CLR(Head, -1);
	for(int i = 1; i <= nodenum; ++i)
		dis[i] = MAX;
}

long long SPFA(int start)
{
	long long total = 0;
	int temp;
	queue<int> q;
	while(!q.empty())
		q.pop();
	CLR(visit, false);

	dis[start] = 0;
	visit[start] = true;

	q.push(start);
	while(!q.empty())
	{
		temp = q.front();
		q.pop();
		visit[temp] = false;
		for(int i = Head[temp]; i != -1; i = Next[i]) //邻接表实现
		{
			if(dis[Num[i]] > dis[temp] + Key[i])
			{
				dis[Num[i]] = dis[temp] + Key[i];
				if(!visit[Num[i]])
				{
					q.push(Num[i]);
					visit[Num[i]] = true;
				}
			}
		}
	}
	for(int i = 1; i <= nodenum; ++i)
		total += dis[i];
	return total;
}

int main()
{
	int ncase;
	int top;
	long long answer;
	scanf("%d", &ncase);
	while(ncase--)
	{
		top = answer = 0;
		scanf("%d%d", &nodenum, &edgenum);
		init();
		for(int i = 0; i < edgenum; ++i)
		{
			scanf("%d %d %d", &edge[top].u, &edge[top].v, &edge[top].weight);
			add(edge[top].u, edge[top].v, edge[top].weight);
			top++;
		}
		answer += SPFA(1);
		init();
		for(int i = 0; i < top; ++i) //反向图
			add(edge[i].v, edge[i].u, edge[i].weight);
		answer += SPFA(1);
		printf("%lld\n", answer);
	}
	return 0;
}