PKU 1932 XYZZY(Floyd+Bellman||Spfa+Floyd)

题目大意：原题链接

给你一张图，初始你在房间1，初始生命值为100，进入每个房间会加上那个房间的生命（可能为负），问是否能到达房间n。（要求进入每个房间后生命值都大于0）

解题思路：

解法一：Floyd+Bellman

1.Floyd先判断图是否连通,不连通则直接失败

2.Bellman Ford然后跑最长路,判断是否有正环或者有正通路

#include<cstdio>
#include<cstring>
using namespace std;
int n,val[],d[];
bool graph[][],link[][];
int main()
{
    int i,j,k,cnt,id;
    while(scanf("%d",&n),n!=-){
        memset(d,-,sizeof(d));
        memset(val,,sizeof(val));
        memset(link,false,sizeof(link));
        memset(graph,false,sizeof(graph));
        for(i=;i<=n;i++){
            scanf("%d%d",&val[i],&cnt);
            while(cnt--){
                scanf("%d",&id);
                graph[i][id]=true;
                link[i][id]=true;//用于判断任意两点间的连通性
            }
        }
        //Floyd判断连通性
        for(k=;k<=n;k++){
            for(i=;i<=n;i++){
                for(j=;j<=n;j++){
                    if(link[i][k]&&link[k][j])
                        link[i][j]=true;
                }
            }
        }
        if(!link[][n]){
            printf("hopeless\n");
            continue;
        }//必须加上这个
        link[n][n]=true;
        //Bellman-ford求最长路径
        d[]=;
        for(k=;k<=n;k++){//遍历每一个节点
            bool sign=true;
            for(i=;i<=n;i++){//遍历每一条边
                for(j=;j<=n;j++){//j,n必须是连通的,并且前一个点d[i]为正
                    if(graph[i][j]&&link[j][n]&&d[j]<d[i]+val[j]&&d[i]>){
                        d[j]=d[i]+val[j];
                        sign=false;
                    }
                }
            }//如果d[j]已经不能更新了,说明最长路已经查找完毕,即不存在正环,退出循环
            if(sign) break;
        }
        if(k>n||d[n]>) printf("winnable\n");//有正环或者有正通路
        else printf("hopeless\n");
    }
}

解法二：Spfa+Floyd

1.Spfa先判正环+跑最长路,以及判断是否存在正通路

2.若d[n]<=0,则Floyd然后根据存在正环以及是否连通起点和终点判断是否会成功到达n点

#include<cstdio>
#include<cstring>
#include<queue>
#define inf 0x3f3f3f3f
using namespace std;
int n,p,num[];//num[u]表示u入队次数
int val[],d[];
bool in[],link[][];
queue<int> que;
bool Spfa_floyd(int u)
{
    for(int i=;i<=n;i++){
        d[i]=-inf;
        in[i]=,num[i]=;
    }
    while(!que.empty()) que.pop();//que定义为全局变量就得清空队列
    que.push(u);
    in[u]=true;
    num[u]=,d[u]=;
    while(!que.empty()){
        u=que.front();
        que.pop();
        in[u]=false;
        if(num[u]>n){
            p=u;
            break;//Spfa某节点入队次数大于n则有正环
        }
        for(int v=;v<=n;v++){
            if(link[u][v]&&d[u]+val[v]>&&d[u]+val[v]>d[v]){
                d[v]=d[u]+val[v];//最长路
                if(!in[v]){
                    que.push(v);
                    in[v]=true;
                    num[v]++;
                }
            }
        }
    }
    if(d[n]>) return true;
    else{
        for(int k=;k<=n;k++)
            for(int i=;i<=n;i++)
                for(int j=;j<=n;j++)
                    if(link[i][k]&&link[k][j])
                        link[i][j]=true;
        if(num[p]>n&&link[][p]&&link[p][n])
            return true;//如果存在正环,并且连接起点和终点
        return false;
    }
}  

int main()
{
    while(scanf("%d",&n),n!=-){
        memset(link,,sizeof(link));
        memset(val,,sizeof(val));
        for(int i=;i<=n;i++){
            int cnt,id;
            scanf("%d%d",&val[i],&cnt);
            for(int j=;j<=cnt;j++){
                scanf("%d",&id);
                link[i][id]=true;
            }
        }
        if(Spfa_floyd()) puts("winnable");
        else puts("hopeless");
    }
}