XYZZY(spfa求最长路)

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

XYZZY

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

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

 

 

Source

University of Waterloo Local Contest 2003.09.27

 

题意： 每个房间有一个能量值，初始100能量，问是否可以从1走到n

题解： 这个题是用spfa求最长路，并且判环很巧妙的写法

　　　 用一个数组存放点的权值，每次走进这个点的时候如果从起点到这个点的剩余能量加上这个点的能量大于0 的话就可以走出去，代码中给出详细的注释

说明：在求最长路的时候只能用spfa或者是Floyd不能用dijk（因为dijk使用贪心写的，所以会有问题）spfa在判环的时候很灵活，再建图的时候也很灵活，如果所给的是点权值而不是边权的时候可以用一个点的数组来存点权，帅气。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define N 110
#define INF 0x1fffffff
int node[N];
struct Edge{
    int to;
    int next;
}edge[N*N];
int dis[N];
int que[N*N];
bool inq[N];
int cnt[N];
int n;
int top;
int head[N];
int Enct;
void add(int from , int to)
{
    edge[Enct].to = to;
    edge[Enct].next = head[from];
    head[from] = Enct++;
}
void init()
{
    Enct = 0;
    memset(head,-1,sizeof(head));
}
void spfa()
{
    top = 0;
    for(int i =1 ;i <= n ;i++)
        inq[i] = false,cnt[i] = 0,dis[i]= -INF;//要定义成一个没有意义的数-INF 
    que[top++] = 1;
    dis[1] = 100;
    inq[1] = true;
    cnt[1]++;
    for(int i= 0 ; i < top ; i++)
    {
        int u = que[i];
        inq[u] = false;
        if(dis[u] + node[u] <= 0) continue;//没办法走出这个点所以不再用这个点去更新其他的点 
        for(int j = head[u] ; j!=-1 ;j = edge[j].next)
        {
            Edge e = edge[j];
            if(dis[e.to]<dis[u]+node[u])//如果下一个点的到起点的dis小于这个点到起点的dis加上这个点自己的权值的话 更新为最长录路 
            {
                dis[e.to] = dis[u] + node[u];
                if(inq[e.to]==false)
                {
                    // que[top++] = e.to;
                    // inq[e.to] = true;
                    cnt[e.to]++;
                    if(cnt[e.to]>n) continue;//这里在判定环的时候在这个点在第n次加入队列的时候证明有环，这时候仍把它加入队列，并用这个点权值更新为INF
                                            //并用这个点去更新这个环所在路径的值都为INF这样就可以解决有正环但却不一定与起点终点联通的问题了，因为这样处理后这个环只能更新其路径上的值 
                    else if(cnt[e.to]==n)
                        dis[e.to] = INF;//更新 
                    que[top++] = e.to;
                    inq[e.to] = 1;
                }
            }
        }
    }
}//spfa在用的时候一定要注意其编号是不是从1开始编号的 还是从0，注意 
int main()
{
    while(~scanf("%d",&n)&&n!=-1)
    {
        init();
        int a,cn,t;
        int tm = 0;
        for(t = 1 ; t <= n ;t++ )
        {
            scanf("%d%d",&a,&cn);
            node[t] = a;
            for(int i =0 ;i < cn;i++)
            {
                int to;
                scanf("%d",&to);
                add(t,to);
            }
        }
        spfa();
//        for(int i = 1; i <= n; i++) printf("%d ", dis[i]); puts("");
        if(dis[n]>0)puts("winnable");
        else puts("hopeless");
    }
    return 0;
}