HDU-1317-XYZZY（负权处理 弗洛伊德判断连通性）

D - 最短路(负权处理)
Time Limit:1000MS Memory Limit:32768KB 64bit IO Format:%I64d & %I64u
Submit

Status

Practice

HDU 1317
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

代码

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<math.h>
#include<string.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=100005;
int Map_Floyd[105][105];//弗洛伊德判断连通性
int u[maxn];
int v[maxn];
int w[maxn];
int first[maxn];
int nextn[maxn];//以上为邻接表数组
int dis[maxn];
int vis[maxn];//SPFA用到
int N;//矩阵尺寸
int M;//每行边的数量
int len;//边的数量
void init()//初始化邻接表并建图
{
    memset(Map_Floyd,0,sizeof(Map_Floyd));//初始化为未联通
    memset(first,-1,sizeof(first));
    memset(nextn,-1,sizeof(nextn));
    memset(u,0,sizeof(u));
    memset(v,0,sizeof(v));
    memset(w,0,sizeof(w));
    //以上初始化有点乱
    len=0;//初始化边的数量
    for(int i=1; i<=N; i++)
    {
        scanf("%d%d",&w[i],&M);
        for(int j=0; j<M; j++)
        {
            int x;
            scanf("%d",&x);
            u[len]=i;
            v[len]=x;//i到x的边的权值为w[i]
            nextn[len]=first[u[len]];
            first[u[len]]=len;
            len++;
            Map_Floyd[i][x]=1;//标记i到x为已联通
        }
    }
}
void Floyd()
{
    for(int k=1; k<=N; k++)
        for(int i=1; i<=N; i++)
            for(int j=1; j<=N; j++)
                if(!Map_Floyd[i][j])//邻接矩阵存储路径联通信息
                    Map_Floyd[i][j]=Map_Floyd[i][k]&&Map_Floyd[k][j];
}
bool Bellman(int len)//传入邻接表边的数量,各点到point的最短距离
{
    for(int i=0; i<=N; i++)
        dis[i]=-INF;//距离初始化为负无穷
    dis[1]=100;//出发点能量有一百点
    for(int k=0; k<N-1; k++) //贝尔曼算法
        for(int i=0; i<len; i++)
        {
            int now=u[i];
            int to=v[i];
            if(dis[to]<dis[now]+w[to]&&dis[now]+w[to]>0)
                dis[to]=dis[now]+w[to];
        }
    for(int i=0; i<len; i++)
    {
        int now=u[i];
        int to=v[i];
        if(dis[to]<dis[now]+w[to]&&dis[now]+w[to]>0&&Map_Floyd[to][N])
            return 1;
    }
    return dis[N]>0;
}
int main()
{
    while(~scanf("%d",&N)&&N>0)
    {
        init();
        Floyd();
        //下面的逻辑判断可能有问题
        if(!Map_Floyd[1][N])//未联通
        {
            printf("hopeless\n");
            continue;
        }
        if(Bellman(len))
            printf("winnable\n");
        else
            printf("hopeless\n");
    }
    return 0;
}