CDOJ 1147 秋实大哥带我飞 最短路径条数 dijkstra就可搞

啊，就是说给你一个图，让你求从1到n的最短路径条数，模1e9+7

图的边权可能为0或者正数，边和点都可以重复走

最短路径条数为无穷则输出-1

啊，那个边权全为正的情况好说，边和点也不可能重复走

就是如果边权为0的话，它可以沿着这个边无限次数的来回走，然后就是无穷了

嗯，看题解什么队列搞阿，网上搜了都是DFS，，后来感觉dijkstra就可以搞阿，，看到网上果然有一个这么搞的，代码太丑就没看了，自己YY了一下就来写了

dijkstra时，我们是先更新离它最近的点，然后逐个点逐个点的搞，相当于只要是我们这次遍历到的点，它的最短路就已经求出来了，但是它也会往别的点上去更新，所以我们就可以记录它的最短路径数，并在它更新时，扩散出去

首先，假如起点是s，ways[s]=1，自己到自己肯定只有一条路嘛，这样也方便后面更新

然后，就是，每当我们dist[v] > dist[u] + edge[i].w这个不等式成立时，我们就说明找到了到v的一条更短的路，所以ways[v]=ways[u]

然后，我们在更新时不仅要判大于，还有判等于，dist[v] == dist[u] + edge[i].w时，ways[v]+=ways[u]，到v的路径多了那么多条

然后，就没了，但是这道题有边权为0的情况，怎么办呢，就在两个更新处判一下，边权为0时直接记为-1，后面更新时也都判一下就行，然后相加时注意取模

就没了，没想到1A，蛤蛤

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <fstream>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
#define mod 1000000009
#define maxn 2005
#define maxm 4010
struct Edge
{
	int next, to, w;
	Edge() :next(0), to(0), w(0) { }
}edge[maxm];
int head[maxn], cnt = 0;
void add(int u, int v, int w)
{
	edge[cnt].w = w;
	edge[cnt].to = v;
	edge[cnt].next = head[u];
	head[u] = cnt++;
}
struct HeapNode
{
	int dis, u;
	bool operator <(const HeapNode& rhs)const
	{
		return (dis>rhs.dis) || (dis == rhs.dis&&u > rhs.u);
	}
	HeapNode()
	{
		dis = 0; u = 0;
	}
	HeapNode(int dis, int u)
	{
		this->dis = dis; this->u = u;
	}
};
int dist[maxn], ways[maxn];
bool done[maxn];
void dijkstra(int s)
{
	priority_queue<HeapNode> Q;
	memset(dist, 0x3f, sizeof(int)*maxn);
	memset(done, 0, sizeof(done));
	memset(ways, 0, sizeof(int)*maxn);
	dist[s] = 0;
	ways[s] = 1;
	Q.push(HeapNode(0, s));
	while (!Q.empty())
	{
		HeapNode x = Q.top(); Q.pop();
		int u = x.u;
		if (done[u])
			continue;
		done[u] = true;
		for (int i = head[u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].to;
			if (dist[v] > dist[u] + edge[i].w)
			{
				dist[v] = dist[u] + edge[i].w;
				if (edge[i].w == 0)
					ways[v] = -1;
				else
					ways[v] = ways[u];
				Q.push(HeapNode(dist[v], v));
			}
			else if (dist[v] == dist[u] + edge[i].w)
			{
				if (edge[i].w == 0)
					ways[v] = -1;
				else
				{
					if (ways[u] == -1 || ways[v] == -1)
						ways[v] = -1;
					else
						ways[v] = (ways[u] + ways[v]) % mod;
				}
			}
		}
	}
}
int main()
{
	//freopen("input.txt","r",stdin);
	//freopen("output.txt","w",stdout);
	//ios::sync_with_stdio(false);
	//cin.tie(0); cout.tie(0);
	//ifstream in;
	//in.open("input.txt", ios::in);
	memset(head, -1, sizeof(int)*maxn);
	cnt = 0;
	int n, m;
	scanf("%d%d", &n, &m);
	int s, e, c;
	for (int i = 0; i < m; ++i)
	{
		scanf("%d%d%d", &s, &e, &c);
		--s; --e;
		add(s, e, c);
		add(e, s, c);
	}
	dijkstra(0);
	printf("%d\n", ways[n - 1]);
	//system("pause");
	//while (1);
	return 0;
}