hdu1625 Numbering Paths (floyd判环)

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 207    Accepted Submission(s): 63

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

 

题意：给你n条边，让你求出一个点到另一个点能走的路线的条数，如果能走的路线中有环，那么就输出-1.

思路：因为数据很小，只有30，所以可以用floyd先算出每两个点之间的路线条数，方法为f[i][j]+=gra[i][k]*gra[k][j].然后循环每一个点，判断f[i][i]是不是为0，如果不为0，那么说明i这个点在环上，之后只要看任意两点j能不能经过i后到达k，如果能，那么f[j][k]就是-1.

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<string>
#include<algorithm>
using namespace std;
typedef unsigned long long ll;
#define inf 99999999
#define pi acos(-1.0)
#define maxn 505
#define maxnode 100
int gra[40][40];

int main()
{
    int n,m,i,j,c,d,k;
    int cas=0;
    while(scanf("%d",&m)!=EOF)
    {
        n=0;
        memset(gra,0,sizeof(gra));
        for(i=1;i<=m;i++){
            scanf("%d%d",&c,&d);
            gra[c][d]=1;
            n=max(n,c);
            n=max(n,d);
        }
        for(k=0;k<=n;k++){
            for(i=0;i<=n;i++){
                for(j=0;j<=n;j++){
                    gra[i][j]+=gra[i][k]*gra[k][j];
                }
            }
        }
        for(i=0;i<=n;i++){
            if(gra[i][i]){
                gra[i][i]=-1;
                for(j=0;j<=n;j++){
                    for(k=0;k<=n;k++){
                        if(gra[j][i] && gra[i][k]){
                            gra[j][k]=-1;
                        }
                    }
                }
            }
        }
        printf("matrix for city %d\n",cas++);
        for(i=0;i<=n;i++){
            for(j=0;j<=n;j++){
                printf(" %d",gra[i][j]);
            }
            printf("\n");
        }
    }
}