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