码迷,mamicode.com
首页 > 其他好文 > 详细

hdu 1625 Numbering Paths 最短路的变形,使用Floyd 外加判环

时间:2015-02-17 17:43:31      阅读:196      评论:0      收藏:0      [点我收藏+]

标签:floyd   hdu1625   numbering paths   acm   

Numbering Paths

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 158    Accepted Submission(s): 47


Problem Description
Problems that process input and generate a simple ``yes‘‘ or ``no‘‘ answer are called decision problems. One class of decision problems, the NP-complete problems, are not amenable to general efficient solutions. Other problems may be simple as decision problems, but enumerating all possible ``yes‘‘ answers may be very difficult (or at least time-consuming).

This problem involves determining the number of routes available to an emergency vehicle operating in a city of one-way streets.

Given the intersections connected by one-way streets in a city, you are to write a program that determines the number of different routes between each intersection. A route is a sequence of one-way streets connecting two intersections.

Intersections are identified by non-negative integers. A one-way street is specified by a pair of intersections. For example, j k indicates that there is a one-way street from intersection j to intersection k. Note that two-way streets can be modeled by specifying two one-way streets: j k and k j .

Consider a city of four intersections connected by the following one-way streets:

0 1
0 2
1 2
2 3

There is one route from intersection 0 to 1, two routes from 0 to 2 (the routes are 0-1-2 and 0-2 ), two routes from 0 to 3, one route from 1 to 2, one route from 1 to 3, one route from 2 to 3, and no other routes.
It is possible for an infinite number of different routes to exist. For example if the intersections above are augmented by the street , there is still only one route from 0 to 1, but there are infinitely many different routes from 0 to 2. This is because the street from 2 to 3 and back to 2 can be repeated yielding a different sequence of streets and hence a different route. Thus the route 0-2-3-2-3-2 is a different route than 0-2-3-2 .
 

Input
The input is a sequence of city specifications. Each specification begins with the number of one-way streets in the city followed by that many one-way streets given as pairs of intersections. Each pair j k represents a one-way street from intersection j to intersection k. In all cities, intersections are numbered sequentially from 0 to the ``largest‘‘ intersection. All integers in the input are separated by whitespace. The input is terminated by end-of-file.

There will never be a one-way street from an intersection to itself. No city will have more than 30 intersections.
 

Output
For each city specification, a square matrix of the number of different routes from intersection j to intersection k is printed. If the matrix is denoted M, then M[j][k] is the number of different routes from intersection j to intersection k. The matrix M should be printed in row-major order, one row per line. Each matrix should be preceded by the string ``matrix for city k‘‘ (with k appropriately instantiated, beginning with 0).

If there are an infinite number of different paths between two intersections a -1 should be printed. DO NOT worry about justifying and aligning the output of each matrix. All entries in a row should be separated by whitespace.
 

Sample Input
7 0 1 0 2 0 4 2 4 2 3 3 1 4 3 5 0 2 0 1 1 5 2 5 2 1 9 0 1 0 2 0 3 0 4 1 4 2 1 2 0 3 0 3 1
 

Sample Output
matrix for city 0 0 4 1 3 2 0 0 0 0 0 0 2 0 2 1 0 1 0 0 0 0 1 0 1 0 matrix for city 1 0 2 1 0 0 3 0 0 0 0 0 1 0 1 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 matrix for city 2 -1 -1 -1 -1 -1 0 0 0 0 1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0
 

不得不说,这题的输出格式就尼玛傻逼。PE了4,5次,每一行的第一个数就要空格。艹,最讨厌这样的题了,怪不得做的人少!

这题主要就是判环,如果mat[k][k]!=0,则K这点存在一个环,根据floyd的动态规划的含义,,mat[i][j]如果经过一个这样的k点的话,那mat[i][j]也是一个环,


直接代码:

#include <stdio.h>
#include <string.h>
#define MAX 1010
#define INF 500000000
int mat[MAX][MAX] ;
void floyd(int n)
{
	for(int k = 0 ; k <= n ; ++k)
	{
		for(int i = 0 ; i <= n ; ++i)
		{
			if(mat[i][k] == 0)
				continue ;
			for(int j = 0 ; j <= n ; ++j)
			{
				if(mat[k][j] != 0)	//判环。 
				{
					if(mat[k][k] != 0 || mat[k][j] == -1 || mat[i][k] == -1)
					{
						mat[i][j] = -1 ;
					}
					else
					{
						mat[i][j] += mat[i][k]*mat[k][j] ;
					}
				}
				
			}
		}
	}
	for(int i = 0 ; i <= n ; ++i)
	{
		if(mat[i][i] > 0)
		{
			mat[i][i] = -1; 
		}
	}
}

int main()
{
	int n ,t=0;
	while(scanf("%d",&n) != EOF )
	{
		int max = -INF ;
		memset(mat,0,sizeof(mat)) ;
		for(int i = 0 ; i < n ; ++i)
		{
			int x , y ;
			scanf("%d%d",&x,&y) ;
			mat[x][y] = 1 ;
			if(x>max||y>max)
			{
				max = x>y?x:y ;
			}
		}
		floyd(max) ;
		printf("matrix for city %d\n",t++);
		for(int i = 0; i <= max ; ++i)
		{
			for(int j = 0 ; j <= max ; ++j)
			{
				printf(" %d",mat[i][j]) ;
			}
			printf("\n") ;
		}
	}
	return 0 ;
}


hdu 1625 Numbering Paths 最短路的变形,使用Floyd 外加判环

标签:floyd   hdu1625   numbering paths   acm   

原文地址:http://blog.csdn.net/lionel_d/article/details/43866641

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!