XYZZY

XYZZY

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

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
  
  
  
  
 
  
  
  
  

   
   http://acm.hdu.edu.cn/showproblem.php?pid=1317
  
  
  
  
 
  
  
  
  

   
   这道题刚接触时没有什么思路，上网搜了一下资料，决定用改良的spfa和floyd算法，由于图论的知识比较生疏了，所以这几天一直看图论的相关数据结构和算法，复习了dijkstra和bellman-ford算法，和最小生成树prim算法，最后开始写，先用了floyd算法验证了起点到终点的连通性，接着用spfa算法搜索最短路径，由于spfa是不能检测出负权环的，这题中即不能检测出“充能环”，我就使用了一个数组来标记每个房间入队的次数，由bellman—ford算法可知如果房间不在负权环中，房间的入队次数不会大于n-1次，所以如果某个房间入队次数大于等于n次，即存在负权环了，再利用之前的可连通性数组检测连通性，如果该充能环与终点连通，即为可达。由于需要检测出所有负权环，所以在某个顶点入队2*n次之后才跳出循环，返回false。注：spfa是改进的bellman——ford，且综合了宽度优先算法的优点的一个求单源最短路径的算法。
  
  
  
  

   
    
  
  
  
  

   
   
#include <iostream>
#include <queue>
using namespace std;

bool way[101][101],reachable[101][101];
int romener[101],energy[101],queuetime[101],n,flag;
queue<int> searchg;

bool spfa(){
	int rom;
	searchg.push(1);
	queuetime[1]=1;
	while(!searchg.empty()){
		rom=searchg.front();
		searchg.pop();
		for(int i=1;i<=n;++i){
			if (way[rom][i]==true&&(energy[rom]+romener[i])>energy[i]){
					energy[i]=energy[rom]+romener[i];
					if(i==n)
						return true;
					++queuetime[i];
					if(queuetime[i]==n&&reachable[i][n]==true)
						return true;
					if(queuetime[i]==2*n)
						return false;
                    searchg.push(i);
			}
		}
	}
	return false;
}

int main(){
	int w,j;
	while(cin>>n&&n!=-1){
		while(!searchg.empty())
			searchg.pop();
		memset(reachable,false,sizeof(reachable));
		memset(way,false,sizeof(way));
		memset(queuetime,0,sizeof(queuetime));
		memset(energy,0,sizeof(energy));
		energy[1]=100;
		for (int i=1;i<=n;++i){
			cin>>romener[i]>>j;
			reachable[i][i]=true;
			for (int k=1;k<=j;++k){
				cin>>w;
				way[i][w]=true;
				reachable[i][w]=true;
			}
		}
		for (int k=1;k<=n;++k)
			for (int i=1;i<=n;++i)
				for (int j=1;j<=n;++j)
					if (reachable[i][k]==true&&reachable[k][j]==true)
						reachable[i][j]=true;
		if (reachable[1][n]==false){
			cout<<"hopeless"<<endl;
			continue;
		}
		flag=spfa();
		if(flag)
			cout<<"winnable"<<endl;
		else
			cout<<"hopeless"<<endl;
	}
	return 0;
}