PKU 1511 SPFA ( 静态邻接表)

/*

	题意：给出一个图，求源点到其他各个点之和  加上   其他各个点到源点之和的最小值



	思路：SPFA, 建两个表，顺序不说，

	      逆序的情况：在初始化的时候在反向保存另一相同表

		              即：    1 ---> 2   13

					  反向后：2 ---> 1   13

					  要求各点到源点的距离和，即求源点到各点的距离和

					  所以，处理好后，只要求两次源点到各点距离和相加即可

	

	精髓：静态邻接表 !!!!

	      头一次接触这个东西，代码几乎是看着别人的写出来的，自己也有少许优化

		  很给力的东西，尤其是 逆向实现链表的传递，收获不小

*/











#include <iostream>

using namespace std;

const int MAX = 1000001;

const int inf = INT_MAX;//!!!!!!!!!!1!!!!!!!!!!

int N,m,n;



typedef struct vol

{

	int w,//当前位置

		v,//价值 value

		next;//下一结点的位置

} Voll;

Voll peo[MAX],rev[MAX];



int start1[MAX], start2[MAX];

int queue[MAX];  //优化序列

int path[MAX];   // path[i] 从1即到i当前最短路



__int64 SPFA( Voll peor[], int startt[])

{



	int i,start=0,end=1,temp;

	temp = 1;

	for(i=0;i<n+1;i++)

	{

		path[i] = inf;

	}

	

	path[temp] = 0;

	queue[0] = temp;



	while(start<end)

	{

		temp = queue[start];

		start++;



		for(i=startt[temp]; i!=-1; i=peor[i].next)

		{

			if(peor[i].v + path[temp] < path[peor[i].w])

			{

				path[peor[i].w] = peor[i].v + path[temp];

				queue[end++] = peor[i].w;

			}

		}

	}

	//

	__int64 sum=0;

	for(i=1;i<=n;i++)

	{

		sum+=path[i];

	}

	return sum;

}



void init()

{

	scanf("%d %d", &n, &m);

	int i,x,y,v;



	fill(start1, start1 + n+1, -1);//应该是 n+1!!!!!   - -!

	fill(start2, start2 + n+1, -1);

	

	for(i=0;i<m;i++)

	{

		scanf("%d %d %d",&x,&y,&v);



		peo[i].w = y;

		peo[i].v = v;

		peo[i].next = start1[x];   //保存邻接表串的始端位置，逆向实现相当给力!!!

		start1[x] = i;			   

		

		///reverse反向

		rev[i].w = x;

		rev[i].v = v;

		rev[i].next = start2[y];

		start2[y] = i;

	}

}



int main()

{

	scanf("%d", &N);

	while(N--)

	{

		init();	

		printf("%I64d\n", SPFA(peo, start1) + SPFA(rev, start2));

	}

	return 0;

}