闯关游戏

小明在玩一个很好玩的游戏，这个游戏一共有至多 100 个地图，其中地图 1 是起点，房间n 是终点。
有的地图是补给站，可以加ki 点体力，而有的地图里存在怪物，需要消耗 ki 点体力，地图与地图之
间存在一些单向通道链接。  小明从 1 号地图出发，有 100 点初始体力。每进入一个地图的时候，需要扣除或者增加相应的体力
值。这个过程持续到走到终点，或者体力值归零就会 Game Over。不过，他可以经过同个地图任
意次，且每次都需要接受该地图的体力值。  输入格式: 第 1 行一个整数 n (n≤100)。第 2 ~ n+1 行，每行第一个整数表示该地图体力值变化。
接下来是从该房间能到达的房间名单，第一个整数表示房间数，后面是能到达的房间编号。  输出格式: 若玩家能到达终点，输出Yes，否则输出No。
 样例输入
 5加粗样式
 0 1 2
 -60 1 3
 -60 1 4
 20 1 5
 0 0
 样例输出
 No

这道题是典型的最长路径问题，可以用SPFA来做。（最长问题只需要将判断改为dis[u]+eid[i].w>dis[eid[i].to]即可，然后将dis数组全部初始化为一个很小的值。）

这道题的独特点就在于如何处理正圈，因为只要有正圈（不包含顶点）的存在就会产生无限循环所以需要特殊处理，在将某个点压入队列之前需要判断这个点的入队次数是否大于总顶点数，如果是的则说明含有正圈所以将改点的dis值改为无穷，并不再允许该点入队。这样就确保不会一直循环下去*

代码如下

#include <iostream>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;

const int MAX_M=10000;
const int MAX_N=1000;
const int inf=0x3f3f3f3f;
int dis[MAX_N];
int inq[MAX_N];//记录顶点是否在队列当中
int head[MAX_N];
int value[MAX_N];
int number_entrance[MAX_N];//记录每个顶点入队几次
int n;
vector <int> arr;//记录包含正圈的顶点，确保他们不再入队


struct edge{
    int w;
    int to;
    int next;
}eid[MAX_M];

int ans=0;
void insert(int u,int v,int w){
    eid[ans].w=w;
    eid[ans].to=v;
    eid[ans].next=head[u];
    head[u]=ans++;
}
void add(int u,int v,int w){
    insert(u,v,w);
    insert(v,u,w);
}

void prin(int n){
    for (int i = 0; i <n ; ++i) {
        cout<<dis[i]<<" ";
    }
    cout<<endl;
}
void spfa(int a){
    queue<int> q;
    memset(dis,-inf, sizeof(dis));
    memset(inq,0, sizeof(inq));
    memset(number_entrance,0, sizeof(number_entrance));

    dis[a]=value[a]+100;
    inq[a]=1;
    number_entrance[a]++;
    q.push(a);
    while(!q.empty()){
        int x=q.front();
        q.pop();
        inq[x]=0;
        for(int i=head[x];i!=-1;i=eid[i].next){
            if(x==n-1)//注意最后一个顶点不能再往回走了
                break;
            int y=eid[i].to;
            if(dis[x]+eid[i].w>dis[y]){
                dis[y]=dis[x]+eid[i].w;

                bool flag=0;
                for (int j = 0; j <arr.size() ; ++j) {
                    if(y==arr[j]) {
                        flag = 1;
                        break;
                    }
                }
                if(flag==1)
                    continue;

                if(inq[y]==0){
                    q.push(y);
                    inq[y]=1;
                    number_entrance[y]++;
                    if(number_entrance[y]>n) {
                        dis[y]=inf;
                        eid[i].w=inf;
                        inq[y]=0;
                        arr.push_back(y);
                    }
                }
            }
        }
    }
}

int main() {

    memset(head,-1, sizeof(head));

    cin>>n;
    vector<int> str[n];
    for (int i = 0; i <n ; ++i) {
        int x;
        cin>>x;
        value[i]=x;
        int m;
        cin>>m;
        for(int j=0;j<m;j++){
            int p;
            cin>>p;
            str[i].push_back(--p);
        }
    }
    for(int i=0;i<n;i++){
        for(int j=0;j<str[i].size();++j){
            insert(i,str[i][j],value[str[i][j]]);
            insert(str[i][j],i,value[i]);//注意！这里不能直接用add因为两个方向的权值是不相同的。
        }
    }

    spfa(0);
    if(dis[n-1]>0)
        cout<<"YES"<<endl;
    else
        cout<<"NO"<<endl;

    for(int i=0;i<n;i++){
        cout<<dis[i]<<" ";
    }

    return 0;
}

寒门很苦，更苦的是不读书
寒门很难，更难的是总想偷懒
寒门很累，更累的是一辈子都陷入狭隘和愚昧