HDU 1317--XYZZY 【spfa判断正环求最长路径 && floyd求传递闭包】

XYZZY

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

Problem Description

It has recently been discovered how to run open-source software on the Y-Crate gaming device. A number of enterprising designers have developed Advent-style games for deployment on the Y-Crate. Your job is to test a number of these designs to see which are winnable.
Each game consists of a set of up to 100 rooms. One of the rooms is the start and one of the rooms is the finish. Each room has an energy value between -100 and +100. One-way doorways interconnect pairs of rooms.

The player begins in the start room with 100 energy points. She may pass through any doorway that connects the room she is in to another room, thus entering the other room. The energy value of this room is added to the player's energy. This process continues until she wins by entering the finish room or dies by running out of energy (or quits in frustration). During her adventure the player may enter the same room several times, receiving its energy each time.

 

Input

The input consists of several test cases. Each test case begins with n, the number of rooms. The rooms are numbered from 1 (the start room) to n (the finish room). Input for the n rooms follows. The input for each room consists of one or more lines containing:

the energy value for room i
the number of doorways leaving room i
a list of the rooms that are reachable by the doorways leaving room i
The start and finish rooms will always have enery level 0. A line containing -1 follows the last test case.

 

Output

In one line for each case, output "winnable" if it is possible for the player to win, otherwise output "hopeless".

 

Sample Input

  
  

   
   5
0 1 2
-60 1 3
-60 1 4
20 1 5
0 0
5
0 1 2
20 1 3
-60 1 4
-60 1 5
0 0
5
0 1 2
21 1 3
-60 1 4
-60 1 5
0 0
5
0 1 2
20 2 1 3
-60 1 4
-60 1 5
0 0
-1
  
  

 

Sample Output

  
  

   
   hopeless
hopeless
winnable
winnable
  
  

 

题意：

题目意思：有n个房间，每个房间都有一个能量值（可正可负）和对应的可以离开该房间的道路，离开这个房间需要在原有能量值的基础上加上该房间的能量值，当已有能量为0时游戏失败，问能否从房间1到达房间n。    起始有100个能量值。

思路：

转化为在SPFA求最长路，就不会出现负环。那么分两种情况。

（1）出现正环，显然退出条件是正环中的某个点 u 入队列次数 > n，此时退出时只需判断 1 -- u -- n 是否存在路径（1 可以通过这个正环连通n），连通这步可以用Floyd来求传递闭包。

（2）没有出现正环，用spfa求最长路径，在不存在正环的情况下到达n的最长路径大于0说明可以到达第n个房间。

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
#include <iostream>
#define maxn 1100
#define maxm 11000
#define INF 0x3f3f3f3f
using namespace std;

struct node{
	int u, v, w, next;
};

node edge[maxm];

int n, cnt;
int head[maxn];
int vis[maxn];
int dist[maxn];
int map[maxn][maxn];
int used[maxn];

void init(){
	cnt = 0;
	memset(head, -1, sizeof(head));
	memset(map, 0 , sizeof(map));
}

void add(int u, int v, int w){
	edge[cnt] = {u ,v, w, head[u]};
	head[u] = cnt++;
}

void getmap(){  
    int x, y, d, k;  
    for(x = 1; x <= n; x++)  {  
        scanf("%d%d", &d, &k);  
        while(k--)  
        {  
            scanf("%d", &y);  
            add(x, y, d);  
            map[x][y] = 1;  
        }  
    }  
}  

void floyd(){
	for(int k = 1; k <= n; ++k)
		for(int i = 1; i <= n; ++i)
			for(int j = 1;j <= n; ++j)
				map[i][j] = map[i][j] || (map[i][k] && map[k][j]);
}

int jud(int mid){
	if(map[1][mid] && map[mid][n])
		return 1;
	else
		return 0;
}

int SPFA(){
	for(int i = 1; i <= n; ++i){
		dist[i] = 0;
		vis[i] = 0;
		used[i] = 0;
	}
	dist[1] = 100;
	vis[1] = 1;
	used[1] = 1;
	queue<int>q;
	q.push(1);
	while(!q.empty()){
		int u = q.front();
		q.pop();
		if(used[u] > n){
			if(jud(u))
				return 1;
			else 
				continue;
		}
		vis[u] = 0;
		for(int i = head[u]; i != -1; i = edge[i].next){
			int v = edge[i].v;
			int w = edge[i].w;
			if(dist[v] < dist[u] + w){
				dist[v] = dist[u] + w;
				if(!vis[v]){
					vis[v] = 1;
					used[v]++;
					q.push(v);
				}
			}
		}
	}
	if(dist[n] > 0)
		return 1;
	else 
		return 0;
}

int main (){
	while(scanf("%d", &n) ,n !=-1){
		init();
		getmap();
		floyd();
		if(SPFA())
			printf("winnable\n");
		else 
			printf("hopeless\n");
	}
	return 0;
}