UVA10917 A Walk Through the Forest

微微发亮的传送门

思路比较简单，就是先求出来所有点到家的最短路，这个非常好求了，把家当做起点，dijkstra还是spfa都可以搞定，假设用d数组来保存最短路，然后对于某一个点A，如果存在一个点B，使得d[A] > d[B]，就可以从A走到B，也就是说可以建立一条从A到B的有向边，这样的话，我们就能得到一个新图，只需要求从每一个点到终点有多少种方法即可，动态规划完全可以求出来。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int INF = 0x7fffffff;
const int maxn = 1000 + 10;
struct Edge{
	int from, to, dist;
};
struct HeapNode{
	int d, u;
	bool operator < (const HeapNode& rhs) const {
		return d > rhs.d;
	}
};
struct Dijkstra{
	int n, m;
	vector<Edge> edges;
	vector<int> G[maxn];
	bool done[maxn];
	int d[maxn], p[maxn];
	void init(int n){
		this -> n = n;
		for (int i = 0; i < n; i++)
			G[i].clear();
		edges.clear();
	}
	void AddEdge(int from, int to , int dist){
		edges.push_back((Edge){from, to, dist});
		m = edges.size();
		G[from].push_back(m - 1);
	}
	void dijkstra(int s){
		priority_queue<HeapNode> que;
		for (int i = 0; i < n; i++)
			d[i] = INF;
		d[s] = 0;
		memset(done, 0, sizeof(done));
		que.push((HeapNode){0, s});
		while(!que.empty()){
			HeapNode x = que.top(); que.pop();
			int u = x.u;
			if (done[u]) continue;
			done[u] = 1;
			for (int i = 0; i < G[u].size(); i++){
				Edge& e = edges[G[u][i]];
				if (d[e.to] > d[u] + e.dist){
					d[e.to] = d[u] + e.dist;
					p[e.to] = G[u][i];
					que.push((HeapNode){d[e.to], e.to});
				}
			}
		}
	}
};
Dijkstra solver;
int n, m, d[maxn];
int dp(int u){
	if (u == 1) return 1;
	int& ans = d[u];
	if (ans >= 0) return ans;
	ans = 0;
	for (int i = 0; i < solver.G[u].size(); i++){
		int v = solver.edges[solver.G[u][i]].to;
		if (solver.d[v] < solver.d[u]) ans += dp(v);
	}
	return ans;
}
int main(){
//	freopen("in.txt", "r", stdin);
	while(~scanf("%d", &n)){
		if (!n) break;
		scanf("%d", &m);
		solver.init(n);
		for (int i = 0; i < m; i++){
			int a, b, c;
			scanf("%d%d%d", &a, &b, &c);
			a -= 1; b -= 1;
			solver.AddEdge(a, b, c);
			solver.AddEdge(b, a, c);
		}
		solver.dijkstra(1);
		memset(d, -1, sizeof(d));
		printf("%d\n", dp(0));
	}
	return 0;
}