HDU1317

XYZZY

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

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

题意解析

（看翻译吧！看翻译吧！）
本题的话，注意的有两点，一是判断能否到达终点，一是判断有没有正环。
判断终点的话用Floyd就行了。
判断正环的代码如下

bool SPFA(int s,int d[])
{
    queue<int> Q;//建立队列
    Q.push(s);//起点入队 
    d[s]=100;//初始值 
    while(!Q.empty())//队列中没有数则停止循环 
    {
        int u=Q.front();//访问每一个可以到达的点
        Q.pop();//出队 
        num[u]++;//该点的访问次数加1，也就是走过该点的次数
        if(num[u]>=n) return reach[u][n-1];
        /*当该点的访问次数大于或等于n时，表明有了正循环，因为一共有n个点，
        除去该点之外，还有n-1个点，也就是说可以通过n-1各店到达该点，当该点
        被访问了n或n次以上时，则表明有一个点到达该点的路径被访问了两次，形
        成了循环。
        返回reach[u][n-1]是判断从u能否到达终点。再解释清一些，如果能够到达该
        点则说明起点与这个正循环是联通的，相当于是判断能否从起点到终点*/
        for(int v=0;v<n;v++)
        {
            if(map[u][v]==true && d[u]+E[v]>d[v] && d[u]+E[v]>0)
            /*判断该路径是否通畅，并且走到v点后，v点的能量是不是增加的，能量
            是不是正的，能量为负数则说明能量耗尽死亡。*/
            {
                d[v]=d[u]+E[v];//更新能量
                Q.push(v);//入队 
            }
        }
    }
    return d[n-1]>0;
    //若没有正循环，则直接判断能否再能量耗尽之前能否到达终点。
}

完整代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstdlib>
using namespace std;
const int MAXV=110;
const int inf=-0x3f3f3f3f;
int n,m,E[MAXV],d[MAXV],num[MAXV];
bool reach[MAXV][MAXV],map[MAXV][MAXV];
 
void init()//初始化 
{
    memset(reach,false,sizeof(reach));
    memset(map,false,sizeof(map));
    fill(d,d+MAXV,inf);//和memset一样，将fill数组初始化为inf 
    memset(num,0,sizeof(num));
}
 
void Floyd()//判断能否到达终点 
{
    for(int k=0;k<n;k++)
    {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<n;j++)
            {
                reach[i][j]=reach[i][j] || (reach[i][k] && reach[k][j]);
            }
        }
    }
}
 
bool SPFA(int s,int d[])
{
    queue<int> Q;
    Q.push(s);//起点入队 
    d[s]=100;//初始值 
    while(!Q.empty())//队列中没有数则停止循环 
    {
        int u=Q.front();
        Q.pop();//出队 
        num[u]++;
        if(num[u]>=n) return reach[u][n-1];
        for(int v=0;v<n;v++)
        {
            if(map[u][v]==true && d[u]+E[v]>d[v] && d[u]+E[v]>0)
            {
                d[v]=d[u]+E[v];
                Q.push(v);//入队 
            }
        }
    }
    return d[n-1]>0;
}
 
int main()
{
    int v;
    while(scanf("%d",&n),n+1)
    {
        init();
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&E[i],&m);
            for(int j=0;j<m;j++)
            {
                scanf("%d",&v);
                v--;
                map[i][v]=true;
                reach[i][v]=true;
            }
        }
        Floyd();//判断能不能够到终点 
        if(!reach[0][n-1]) printf("hopeless\n");
        else
        {
            if(SPFA(0,d)) printf("winnable\n");
            else printf("hopeless\n");
        }
    }
    return 0;
}