HDU 1317/POJ 1932 Floyd + Spfa 最长路

题意：一个有向图，一个人要从点1到点n，每条边的权值为-100~100。但这个人经过这条边时，他的生命值就会加上这条边的权值，初始生命值为100。若无论走哪条路都不能到达点n或者经过某一边的生命值小于等于0时，则表示行动失败。给出信息，判断这个人的行动能否成功。

思路：一开始的思路很奇怪(英语题经常会读不太懂题)......直接Floyd找最长路，判断能否到达且到达终点时的生命值是否大于0，然后迷之WA了两个小时。

后来把题多读了几遍才发现是中途生命值小于等于0也不行，而且没有考虑环的情况。

这道题主要要注意以下几点：

1.最长路的途中生命值小于等于0，失败。

2.存在正环：若经过正环后能到达终点，不能直接判断成功，还要看从起点进入正环的过程中，生命值是否小于等于0 。

若经过正环后不能到达终点，不能直接判断失败，还要看有没有其他正环，或从起点到终点不需要经过正环也能全程生命值大于0。

所以先Floyd判断点与点之间的导通关系，然后再用Spfa跑一个最长路，松弛条件是到达下一个节点后，当前生命值加上权边的生命值大于0且路更长。到达正环后，若正环与终点导通，直接返回1，否则要继续看队列的下一个元素，继续判断。

代码：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1000 + 10;
int G[maxn][maxn];
struct P{
    int v,w;
    int next;
}edge[maxn*10];
int head[maxn],vis[maxn],dis[maxn],out[maxn];
int n,tot = 0;

void init(void){
    tot = 0;
    memset(G,0,sizeof(G));
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    memset(out,0,sizeof(out));
}

void add(int u,int v,int w){
    edge[tot].v = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void input(void){
    for(int i=1 ;i<=n ;i++){
        int w,m;
        scanf("%d%d",&w,&m);
        while(m--){
            int v;
            scanf("%d",&v);
            G[i][v] = 1;
            add(i,v,w);
        }
    }
}

void Floyd(void){
    for(int k=1 ;k<=n ;k++){
        for(int i=1 ;i<=n ;i++){
            if(G[i][k]){
                for(int j=1 ;j<=n ;j++){
                    if(G[k][j]){
                        G[i][j] = 1;
                    }
                }
            }
        }
    }    
}

bool spfa(int st,int ed){
    queue<int> que;
    dis[st] = 100;
    que.push(st);
    
    while(que.size()){
        int u = que.front();
        que.pop();
        if(++out[u] > n){
            if(G[u][ed])    return 1;
            else            continue;
        }
        vis[u] = 0;
        for(int i=head[u] ;i!=-1 ;i = edge[i].next){
            int v = edge[i].v,w = edge[i].w;
            if(dis[u] + w > dis[v]){
                dis[v] = dis[u] + w;
                if(!vis[v]){
                    vis[v] = 1;
                    que.push(v);
                }
            }
        }    
    }
    if(dis[ed]>0)    return 1;
    return 0;
}

bool solve(void){
    if(!G[1][n])    return false;
    if(spfa(1,n))    return true;
    else            return false;
}

int main(){
    while(scanf("%d",&n) != EOF){
    	if(n == -1)	break;
        init();    
        input();
        Floyd();
        if(solve()){
            printf("winnable\n");
        }
        else{
            printf("hopeless\n");
        }
    }
    return 0;
}