HDU 1317：XYZZY

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  rooms. One of the rooms is the start and one of the rooms is the finish. Each room has an energy value between - and +. One-way doorways interconnect pairs of rooms. 

The player begins in the start room with  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  (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 . A line containing - 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

-
-  

-
-  

-
-  

-
-  

-

Sample Output

hopeless
hopeless
winnable
winnable

题目

　　题目大意：一个最多有100个节点的图，你需要从1走到n（注意哦，有向边）。初始有100个能量，到达一个点会使你的能量值变化，如果能在能量为正的情况下到达点n则输出“NOIP有希望了dalao%%%”，否则输出“NOIP翻车了好开心”。（233333~）

　　芒果君：之前我们做的都是最短路，现在要做最长路，改个符号就行了。这道题对于我的难点是——如何判环。在不断更新最长路时负环可以忽略，但遇到正环应该怎样处理？我看到有一种Floyd+SPFA的方法比较好理解，其实很像广搜。这道题数据比较小，那我们就先做一遍Floyd,在SPFA中记录一个点被放进队列的次数，如果这个次数很不科学（cnt==n），那么就说明它在正环里。But，存在正环不能说明到不了终点，相反，如果它与终点连通，一定能到达（如果你觉得正环到终点可能能量会耗尽，那么请你讲正环看成无敌聚能环233333再好好想想），所以我们要在之前处理连通性。

 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #include<cstdlib>
 #include<vector>
 using namespace std;
 vector<int>e[];
 queue<int>Q;
 int oc[],vis[],dis[],map[][],n,w[];
 int read()
 {
     int x=,f=;
     char ch=getchar();
     while(ch<''||ch>''){
         if(ch=='-') f=-;
         ch=getchar();
     }
     while(ch>=''&&ch<=''){
         x=x*+ch-'';
         ch=getchar();
     }
     return x*f;
 }
 void floyd()
 {
     for(int k=;k<=n;++k)
         for(int i=;i<=n;++i)
             for(int j=;j<=n;++j)
                 map[i][j]=map[i][j]||(map[i][k]&&map[k][j]);
 }
 bool spfa()
 {
     memset(dis,-/,sizeof(dis));
     memset(vis,,sizeof(vis));
     memset(oc,,sizeof(oc));
     dis[]=;
     Q.push();
     vis[]=;
     oc[]=;
     while(!Q.empty()){
         int x=Q.front();
         Q.pop();
         vis[x]=;
         if(oc[x]>=n) {
             if(map[x][n]) return true;
             else continue;
         }
         for(int i=;i<e[x].size();++i){
             int v=e[x][i];
             if(dis[v]<dis[x]+w[v]&&dis[x]+w[v]>){
                 dis[v]=dis[x]+w[v];
                 if(v==n) return true;
                 if(!vis[v]){
                     oc[v]++;
                     vis[v]=;
                     Q.push(v);
                 }
             }
         }
     }
     return false;
 }
 int main()
 {
     int cnt,t;
     while(){
         scanf("%d",&n);
         if(n==-) break;
         memset(map,,sizeof(map));
         for(int i=;i<=n;++i){
             e[i].clear();
             w[i]=read();cnt=read();
             while(cnt--){
                 t=read();
                 e[i].push_back(t);
                 map[i][t]=;
             }
         }
         floyd();
         if(spfa()) printf("winnable\n");
         else printf("hopeless\n");
     }
     return ;
 }