PAT A1030 Travel Plan（Dijkstra+DFS）

题意：N个城市（0~N-1），M条道路（无向边），并给出M条道路的距离属性和花费属性。现给定起点S和终点D，求从起点到终点的最短路径、最短距离及花费。若有多条最短路径，选择花费最小的那条。

输出：最短路径 总距离 总花费

分析：第一标尺：结点到源点S的最短路径长度 第二标尺：结点到源点S的花费之和

1.先用Dijkstra算法，依次将d[i]最小的结点加入到顶点集合V。由于可能有多条最短路径，顶点I的前驱结点可能不止一个，故用vector<int>pre[N]，记录每个顶点的前驱顶点集合。

注意，在最短路径d[i]更新的时候，要将pre[i]清空，若知识找到另一条长度相同的最短路径，直接在pre[i]之后追加结点即可。

2.找到pre数组后，用DFS进行遍历。由于记录的是前驱结点，故从终点D开始遍历，遍历达到递归边界（i==S，即到达源点）时，累加当前tmppath中的所有边权或点权，和bestValue进行比较。

注：由于tmppath中结点从前到后的存储的是从D到S，故要反向遍历tmppath，

且若是点权：for (int j = tmppath.size() - 1; j >= 0; j--)

                      累加每个编号为tmppath[j]的点权。

    若是边权：for (int j = tmppath.size() - 1; j > 0; j--)

                   int id = tmppath[j];

                   int nextid = tmppath[j - 1];

                  累加每条（id,nextid）的边权。

递归返回时，总要进行tmppath.pop_back()操作。

3.图的存储由邻接表实现，注意Adj[i][k]中的k和dj[i][k].v的区别。

#include<iostream>
#include<stdlib.h>
#include<vector>
#include<algorithm>
#pragma warning(disable:4996)
using namespace std;
const int maxn = 510;
const int INF = 100000;

struct Node {
	int v;
	int distance;
	int cost;  //每条边的费用
};
vector<Node> Adj[maxn];
bool mark[maxn];
int d[maxn];   //当前最短路径长度
int sum[maxn]; //源点到顶点i的最少花费
vector<int>pre[maxn]; //记录每个顶点的所有前驱结点集合

vector<int> bestpath;
vector<int> tmppath;
int bestValue=INF;
int bestdistance;

void Dijkstra(int s,int N)
{
	fill(d, d + maxn, INF);
	memset(mark, 0, sizeof(mark));
	d[s] = 0;
	for (int i = 0; i < N; i++)
	{
		int u = -1, min = INF;
		for (int v = 0; v < N; v++)
		{
			if (!mark[v] && d[v] < min)
			{
				u = v;
				min = d[v];
			}
		}
		if (u == -1) return;
		//cout << u << ":";
		mark[u] = true;
		for (int j = 0; j < Adj[u].size(); j++)
		{
			int id = Adj[u][j].v;
			if (!mark[id] && d[u] + Adj[u][j].distance < d[id])
			{
				d[id] = d[u] + Adj[u][j].distance;
				pre[id].clear();
				pre[id].push_back(u);
				//cout << "hhhh:" << id;
			}
			else if (!mark[id] && d[u] + Adj[u][j].distance == d[id])
			{
				pre[id].push_back(u);
				//cout << "llll:" << id;
			}
		}
		//cout << endl;
	}
}

void DFS(int i,int S,int D)
{
	if (i == S)
	{
		cout << "reach S!" << endl;
		tmppath.push_back(S);
		int tmpValue = 0;
		for (int j = tmppath.size() - 1; j > 0; j--) //反向遍历tmppath，即从S到D
		{
			int id = tmppath[j];
			int nextid = tmppath[j - 1]; //下一个结点编号
			for (int k = 0; k < Adj[id].size(); k++)  //id是顶点编号，无法从邻接表直接获取其对应的权值
				if (nextid == Adj[id][k].v)           //先遍历id的每个邻接顶点，找到nexid对应的点，读其权值.
					tmpValue += Adj[id][k].cost;
		}
		cout << "tmpValue:" << tmpValue << " bestValue:" << bestValue << endl;
		if (tmpValue < bestValue)
		{
			cout << "updata bestValue!" << endl;
			bestpath = tmppath;
			bestValue = tmpValue;
			bestdistance = d[D];  //通过该方式获取最短路径值
		}
		tmppath.pop_back();   //!!!易错点 回退要清除该点。
		return;
	}
	else {
		tmppath.push_back(i);
		for (int j = 0; j < pre[i].size(); j++)
		{
			cout << "pre[i][j]" << pre[i][j] << endl;
			DFS(pre[i][j], S,D);
		}
		tmppath.pop_back();
	}
}

int main()
{
	int N, M,S, D;
	while (scanf("%d%d%d%d", &N, &M, &S, &D) != EOF)
	{
		int c1, c2, d, c;
		for (int i = 0; i < M; i++)
		{
			scanf("%d%d%d%d", &c1, &c2, &d, &c);
			Node n1, n2;
			n1.v = c2;
			n1.distance = d;
			n1.cost = c;
			Adj[c1].push_back(n1);
			n2.v = c1;
			n2.distance = d;
			n2.cost = c;
			Adj[c2].push_back(n1);
		}
		/*for (int i = 0; i < N; i++)
			cout << Adj[i].size() << endl;*/
		Dijkstra(S, N);

		for (int i = 0; i < N; i++)    //用于打印每个结点的前驱结点集合
		{
			cout << "pre" << i << ":";
			for (int j = 0; j < pre[i].size(); j++)
				cout << pre[i][j] << " ";
			cout << endl;
		}
		bestValue = INF;
		DFS(D, S,D);
		for (int i = bestpath.size() - 1; i >= 0; i--)
			printf("%d ", bestpath[i]);
		printf("%d ", bestValue);
		printf("%d\n", bestdistance);
	}
	system("pause");
	return 0;
}

/*
Input:
4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

Output:
0 2 3 3 40
*/