最短路：HDU1688 & HDU3191

 

Sightseeing

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 1620    Accepted Submission(s): 702

 

Problem Description

Tour operator Your Personal Holiday organises guided bus trips across the Benelux. Every day the bus moves from one city S to another city F. On this way, the tourists in the bus can see the sights alongside the route travelled. Moreover, the bus makes a number of stops (zero or more) at some beautiful cities, where the tourists get out to see the local sights.

Different groups of tourists may have different preferences for the sights they want to see, and thus for the route to be taken from S to F. Therefore, Your Personal Holiday wants to offer its clients a choice from many different routes. As hotels have been booked in advance, the starting city S and the final city F, though, are fixed. Two routes from S to F are considered different if there is at least one road from a city A to a city B which is part of one route, but not of the other route.

There is a restriction on the routes that the tourists may choose from. To leave enough time for the sightseeing at the stops (and to avoid using too much fuel), the bus has to take a short route from S to F. It has to be either a route with minimal distance, or a route which is one distance unit longer than the minimal distance. Indeed, by allowing routes that are one distance unit longer, the tourists may have more choice than by restricting them to exactly the minimal routes. This enhances the impression of a personal holiday.



For example, for the above road map, there are two minimal routes from S = 1 to F = 5: 1 → 2 → 5 and 1 → 3 → 5, both of length 6. There is one route that is one distance unit longer: 1 → 3 → 4 → 5, of length 7.

Now, given a (partial) road map of the Benelux and two cities S and F, tour operator Your Personal Holiday likes to know how many different routes it can offer to its clients, under the above restriction on the route length.
 

 

 

Input

The first line of the input file contains a single number: the number of test cases to follow. Each test case has the following format:

One line with two integers N and M, separated by a single space, with 2 ≤ N ≤ 1,000 and 1 ≤ M ≤ 10, 000: the number of cities and the number of roads in the road map.

M lines, each with three integers A, B and L, separated by single spaces, with 1 ≤ A, B ≤ N, A ≠ B and 1 ≤ L ≤ 1,000, describing a road from city A to city B with length L.

The roads are unidirectional. Hence, if there is a road from A to B, then there is not necessarily also a road from B to A. There may be different roads from a city A to a city B.

One line with two integers S and F, separated by a single space, with 1 ≤ S, F ≤ N and S ≠ F: the starting city and the final city of the route.

There will be at least one route from S to F.
 

 

 

Output

For every test case in the input file, the output should contain a single number, on a single line: the number of routes of minimal length or one distance unit longer. Test cases are such, that this number is at most 10^9 = 1,000,000,000.
 

 

 

Sample Input

2 5 8 1 2 3 1 3 2 1 4 5 2 3 1 2 5 3 3 4 2 3 5 4 4 5 3 1 5 5 6 2 3 1 3 2 1 3 1 10 4 5 2 5 2 7 5 2 7 4 1

 

 

Sample Output

3 2

 

菜是原罪，第一次写这种类型的题目QAQ。用dijkstra求最短路的同时求次短路，同时用cnt数组记录最短路及次短路的条数。需要注意的是可能从 u 到 v 有多条路，所以在这里只能用vector来存边，以及在dijkstra中最外层循环是2*n次而非n次。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define N 1005
int dis[N][2]; 
int cnt[N][2];
bool vis[N][2];
int n, m;
struct Edge{
	int v;
	int c;
	Edge(int _v = 0, int _c = 0): v(_v), c(_c) {};
};
vector<Edge> w[N];
void addedge(int u, int v, int c)
{
	w[u].push_back(Edge(v, c));
}
void dijkstra(int s, int e)
{
	memset(dis, INF, sizeof(dis));
	memset(vis, false, sizeof(vis));
	dis[s][0] = 0;
	cnt[s][0] = 1;
	for(int i = 1; i <= 2 * n; i++)
	{
		int minn = INF;
		int k = -1;
		int flag;
		for(int j = 1; j <= n; j++)
		{
			if(minn > dis[j][0] && !vis[j][0])
			{
				minn = dis[j][0];
				k = j;
				flag = 0;
			}
			else if(minn > dis[j][1] && !vis[j][1])
			{
				minn = dis[j][1];
				k = j;
				flag = 1;
			}
		}
		if(k == -1) break;
		vis[k][flag] = true;
		for(int j = 0; j < w[k].size(); j++)
		{
			int v = w[k][j].v;
			if(dis[v][0] > minn + w[k][j].c)
			{
				dis[v][1] = dis[v][0];
				cnt[v][1] = cnt[v][0];
				dis[v][0] = minn + w[k][j].c;
				cnt[v][0] = cnt[k][flag];
			}
			else if(dis[v][0] == minn + w[k][j].c)
			{
				cnt[v][0] += cnt[k][flag];
			}
			else if(dis[v][1] == minn + w[k][j].c)
			{
				cnt[v][1] += cnt[k][flag];
			}
			else if(dis[v][1] > minn + w[k][j].c)
			{
				dis[v][1] = minn + w[k][j].c;
				cnt[v][1] = cnt[k][flag];
			}
		}
	}
	if(dis[e][0] + 1 == dis[e][1]) printf("%d\n", cnt[e][0] + cnt[e][1]);
	else printf("%d\n", cnt[e][0]);
}
int main()
{
	int T;
	scanf("%d", &T);
	while(T--)
	{
		scanf("%d%d", &n, &m);
		for(int i = 1; i <= n; i++) w[i].clear();
		for(int i = 0; i < m; i++)
		{
			int u, v, c;
			scanf("%d%d%d", &u, &v, &c);
			addedge(u, v, c);
		}
		int s, e;
		scanf("%d%d", &s, &e);
		dijkstra(s, e);
	}
	return 0;
}

 

 

How Many Paths Are There

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2067    Accepted Submission(s): 735

 

Problem Description

  oooccc1 is a Software Engineer who has to ride to the work place every Monday through Friday. For a long period, he went to office with the shortest path because he loves to sleep late…Time goes by, he find that he should have some changes as you could see, always riding with the same path is boring.
  One day, oooccc1 got an idea! Why could I take another path? Tired at all the tasks he got, he got no time to carry it out. As a best friend of his, you’re going to help him!
  Since oooccc1 is now getting up earlier, he is glad to take those paths, which are a little longer than the shortest one. To be precisely, you are going to find all the second shortest paths.
  You would be given a directed graph G, together with the start point S which stands for oooccc’1 his house and target point E presents his office. And there is no cycle in the graph. Your task is to tell him how long are these paths and how many there are.

 

 

Input

There are some cases. Proceed till the end of file.
The first line of each case is three integers N, M, S, E (3 <= N <= 50, 0 <= S , E <N)
N stands for the nodes in that graph, M stands for the number of edges, S stands for the start point, and E stands for the end point.
Then M lines follows to describe the edges: x y w. x stands for the start point, and y stands for another point, w stands for the length between x and y.
All the nodes are marked from 0 to N-1.

 

 

Output

For each case,please output the length and count for those second shortest paths in one line. Separate them with a single space.

 

 

Sample Input

3 3 0 2 0 2 5 0 1 4 1 2 2

 

 

Sample Output

6 1

跟上面那题一个套路

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define N 55
int dis[N][2]; 
int cnt[N][2];
bool vis[N][2];
int n, m;
struct Edge{
	int v;
	int c;
	Edge(int _v = 0, int _c = 0): v(_v), c(_c) {};
};
vector<Edge> w[N];
void addedge(int u, int v, int c)
{
	w[u].push_back(Edge(v, c));
}
void dijkstra(int s, int e)
{
	memset(dis, INF, sizeof(dis));
	memset(vis, false, sizeof(vis));
	dis[s][0] = 0;
	cnt[s][0] = 1;
	for(int i = 1; i <= 2 * n; i++)
	{
		int minn = INF;
		int k = -1;
		int flag;
		for(int j = 0; j < n; j++)
		{
			if(minn > dis[j][0] && !vis[j][0])
			{
				minn = dis[j][0];
				k = j;
				flag = 0;
			}
			else if(minn > dis[j][1] && !vis[j][1])
			{
				minn = dis[j][1];
				k = j;
				flag = 1;
			}
		}
		if(k == -1) break;
		vis[k][flag] = true;
		for(int j = 0; j < w[k].size(); j++)
		{
			int v = w[k][j].v;
			if(dis[v][0] > minn + w[k][j].c)
			{
				dis[v][1] = dis[v][0];
				cnt[v][1] = cnt[v][0];
				dis[v][0] = minn + w[k][j].c;
				cnt[v][0] = cnt[k][flag];
			}
			else if(dis[v][0] == minn + w[k][j].c)
			{
				cnt[v][0] += cnt[k][flag];
			}
			else if(dis[v][1] == minn + w[k][j].c)
			{
				cnt[v][1] += cnt[k][flag];
			}
			else if(dis[v][1] > minn + w[k][j].c)
			{
				dis[v][1] = minn + w[k][j].c;
				cnt[v][1] = cnt[k][flag];
			}
		}
	}
	printf("%d %d\n", dis[e][1], cnt[e][1]);
}
int main()
{
	int s, e;
	while(~scanf("%d%d%d%d", &n, &m, &s, &e))
	{
		for(int i = 0; i < n; i++) w[i].clear();
		for(int i = 0; i < m; i++)
		{
			int u, v, c;
			scanf("%d%d%d", &u, &v, &c);
			addedge(u, v, c);
		}
		dijkstra(s, e);
	}
	return 0;
}