Haunted Graveyard ZOJ - 3391（SPFA）

从点（n，1）到点（1，m）的最短路径，可以转换地图成从（1，1）到（n，m）的最短路，因为有负权回路，所以要用spfa来判负环，

注意一下如果负环把终点包围在内的话， 如果用负环的话会输出无穷，但是有答案的，所以从终点出去的点不要，还有就是负环习惯用-1判断，但是可能会有负值，所以要用-inf

#include<map>
#include<set>
#include<ctime>
#include<cmath>
#include<stack>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define lowbit(x) (x & (-x))

typedef unsigned long long int ull;
typedef long long int ll;
const double pi = 4.0*atan(1.0);
const int inf = 0x3f3f3f3f;
const int maxn = ;
const int maxm = ;
const int mod = 1e9+;
using namespace std;

int n, m;
int T, tol;
struct Node {
    int u, v, w, next;
    bool operator < (Node a) const {
        return w > a.w;
    }
};
Node node[maxm];
int cnt[maxn];
int dis[maxn];
bool vis[maxn];
int head[maxn];
int maps[][];

void init() {
    tol = ;
    memset(cnt, , sizeof cnt);
    memset(vis, , sizeof vis);
    memset(dis, inf, sizeof dis);
    memset(maps, , sizeof maps);
    memset(head, -, sizeof head);
}

int getnum(int i, int j) {
    return (i-)*m + j;
}

void addnode(int u, int v, int w) {
    node[tol].u = u;
    node[tol].v = v;
    node[tol].w = w;
    node[tol].next = head[u];
    head[u] = tol++;
}

int spfa(int st, int ed) {
    int all = ed;
    queue<int> q;
    vis[st] = true;
    dis[st] = ;
    cnt[st]++;
    q.push(st);
    while(!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = false;
        if(u==ed)
            continue;
        for(int i=head[u]; ~i; i=node[i].next) {
            int v = node[i].v;
            int w = node[i].w;
            if(dis[v] > dis[u] + w) {
                dis[v] = dis[u] + w;
                if(!vis[v]) {
                    vis[v] = true;
                    cnt[v]++;
                    if(cnt[v] >= all)    return -inf;
                    q.push(v);
                }
            }
        }
    }
    return dis[ed];
}

int main() {
    while(scanf("%d%d",  &m, &n), n||m) {
        init();
        int q;
        scanf("%d", &q);
        int x, y;
        while(q--) {
            scanf("%d%d", &x, &y);
            x++, y++;
            maps[y][x] = ;
        }
        scanf("%d", &q);
        int x2, y2, t;
        while(q--) {
            scanf("%d%d%d%d%d", &x, &y, &x2, &y2, &t);
            x++, y++;
            x2++, y2++;
            maps[y][x] = ;

            addnode(getnum(y, x), getnum(y2, x2), t);
        }
//        for(int i=1; i<=n; i++)    for(int j=1; j<=m; j++)    printf("%d%c", maps[i][j], j==m ? '\n' : ' ');
        for(int i=; i<=n; i++) {
            for(int j=; j<=m; j++) {
                if(i == n && j == m)    continue;
                if(maps[i][j] == ) {
                    if(i- >=  && maps[i-][j] != )
                        addnode(getnum(i, j), getnum(i-, j), );
                    if(j- >=  && maps[i][j-] != )
                        addnode(getnum(i, j), getnum(i, j-), );
                    if(i+ <= n && maps[i+][j] != )
                        addnode(getnum(i, j), getnum(i+, j), );
                    if(j+ <= m && maps[i][j+] != )
                        addnode(getnum(i, j), getnum(i, j+), );
                }

            }
        }
        int ans = spfa(getnum(, ), getnum(n, m));
        if(ans == -inf)    printf("Never\n");
        else if(ans == inf)    printf("Impossible\n");
        else    printf("%d\n", ans);
    }
    return ;
}