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

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/code12hour/article/details/52081457

啊,就是说给你一个图,让你求从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;
}

展开阅读全文

没有更多推荐了,返回首页