hdu-1317 XYZZY---Floyd判连通+bellman最短路

题目链接：

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

题目大意：

题意：有n个房间(n<=100)，每个房间有一个点权（第1号房间和第n号房间权值均为0），到达该房间时会自动获得该点权（可能为负权）。给出一些无向边。有一个人，初始有能量值100，初始位置是第1号房间，要走到第n号房间，且路途中不得使身上能量值小于或等于0。能到达第n个房间就算赢，问能否赢。

解题思路：

这里最坑的是第一号房间可能和最后一个房间连通不了。所以首先得判断连通性，再Bellman求最短路。

如果floyd判断房间1和房间n不连通，直接输出失败

如果在第n次还在松弛并且松弛的点可以到达终点n，说明存在正环且该正环能到达n，此时一定是成功的。

如果到达n的时候能量值为正数则成功，为0或者负数则失败

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 10000 + 10;
const int INF = 0x3f3f3f3f;
struct edge
{
    int u, v, w;
    edge(){}
    edge(int u, int v, int w):u(u), v(v), w(w){}
};
edge e[maxn];
bool Map[105][105];
int num[105], n, d[maxn], tot;
void addedge(int u, int v, int w)
{
    e[tot++] = edge(u, v, w);
}
void floyd()//判断连通性
{
    for(int k = 1; k <=n; k++)
    {
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                Map[i][j] |= (Map[i][k]&Map[k][j]);
            }
        }
    }
}
bool Bellman(int u)
{
    memset(d, -INF, sizeof(d));
    d[u] = 100;
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < tot; j++)
        {
            int u = e[j].u, v = e[j].v, w = e[j].w;
            if(d[u] + w > d[v] && d[u] > 0)//d[u]>0说明只有能量为正的点才可以对其相邻的边进行松弛
            {
                d[v] = d[u] + w;
                if(i == n - 1 && Map[v][n])
                //i==n-1说明第n次迭代还在松弛，说明存在正环
                //Map[v][n]=1说明松弛的点可以到达终点（这里改成Map[u][n]也是一样的，因为这两个的值是一样的，因为存在边<u, v>）
                //满足上面两个条件说明存在一个正环，且该环可以到达终点
                //可以一直在正环中运动使得能量值无穷大，最后就一定能到终点
                    return 1;
            }
        }
    }
    return d[n] > 0;
}
int main()
{
    while(cin >> n && n != -1)
    {
        int t, x;
        tot = 0;
        memset(Map, 0, sizeof(Map));
        for(int i = 1; i <= n; i++)
        {
            cin >> num[i];
            cin >> t;
            while(t--)
            {
                cin >> x;
                Map[i][x] = 1;
            }
        }
        for(int u = 1; u <= n; u++)
        {
            for(int v = 1; v <= n; v++)
            {
                if(Map[u][v])addedge(u, v, num[v]);
            }
        }
        floyd();
        if(!Map[1][n])cout<<"hopeless"<<endl;//1-n直接不连通
        else if(Bellman(1))cout<<"winnable"<<endl;
        else cout<<"hopeless"<<endl;
    }
    return 0;
}