牛客1005 迷宫2

题目描述
这是一个关于二维格子状迷宫的题目。迷宫的大小为N×M，左上角格子座标为(1,1)、右上角格子座标为(1,M)、左下角格子座标为(N,1)、右下角格子座标为(N,M)。每一格都用-1到109之间的整数表示，意义分别为：-1为墙壁，0为走道，而1到109之间的正整数代表特殊的走道。
蜥蜴最初位于迷宫的座标(1,1)的格子，每一步蜥蜴只能往上、下、左、右、左上、右上、左下、右下八个方向之一前进一格，并且，他也不能走出迷宫边界。蜥蜴的目的地是走到迷宫的右下角格子，也就是座标位置(N,M)。我们想要动一些手脚，使得蜥蜴没有办法从(1,1)出发并抵达(N,M)。我们学会了一个邪恶的法术，这个法术可以把特殊的走道变成墙壁，施法一次的代价为表示该特殊走道的正整数。
假设，我们可以在蜥蜴出发之前不限次数的使用这个邪恶的法术，所花的总代价即为每次施法代价的总和，蜥蜴出发之后就不能再使用这个法术了，请问让蜥蜴没办法达到终点所必须花费的最小总代价是多少呢？
注意，0所代表的走道是无法变为墙壁的。
输入描述:
输入的第一行有三个正整数Q,N,M。
代表接下来有Q组数据，这Q组数据都是N×M的迷宫。
接下来每组数据各N行，代表一个迷宫，每行各M个整数，第i行中的第j个整数代表迷宫座标(i,j)的格子。
输出描述:
每一组数据输出一行，如果无论如何蜥蜴都能到达终点，请在这一行中输出-1，否则请在这一行中输出一个代表答案的整数。
示例1
输入

3 3 3
0 2 2
3 2 3
2 2 0
0 1 2
-1 1 -1
2 1 0
0 1 2
0 0 0
2 1 0

输出

6
1
-1

备注:
1<=Q<=5103
1<=Q×N×M<=2.510^5
1<=N,M<=500
代表迷宫格子的数字为介于-1和$10^9$间的整数(包含-1和$10^9$)
每个迷宫中，代表座标(1,1)和(N,M)的格子的数字一定是0
思路：
本质上就是修建一条最短的路，将左上角与右下角分隔开来。
可以考虑从左侧及下侧，为源点，找到一条权值最小能走到上侧或右侧的路径。
我们将权值为0的点标记为st，即无法到达，因为这里是不可修建墙的点。
将权值为-1的点标记为0，即无须任何代价就可以建造一个墙。
接下来就是跑最短路就可以了。
注意：
初始化dist要在循环中进行，使用memset会超时！
代码：

#include<iostream>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
int g[1005][1005];
long long dist[1005][1005];
bool st[1005][1005];
int n,m;
struct Node
{
    int x,y;
    long long dis;
    friend bool operator<(const Node &a,const Node &b)
    {
        return a.dis>b.dis;
    }
};
int dx[]={0,0,1,-1},dy[]={1,-1,0,0};
long long dijkstra()
{
    priority_queue<Node>q;
    for(int i=2;i<n;i++)
    {
        int x=i;
        int y=1;
        if(st[x][y])
        {
            continue;
        }
        q.push({x,y,g[x][y]});
        dist[x][y]=g[x][y];
    }
    for(int j=2;j<m;j++)
    {
        int x=n;
        int y=j;
        if(st[x][y])
        {
            continue;
        }
        q.push({x,y,g[x][y]});
        dist[x][y]=g[x][y];
    }
    while(!q.empty())
    {
        Node t=q.top();
        q.pop();
        int x=t.x;
        int y=t.y;
        long long dis=t.dis;
        if(st[x][y])
        {
            continue;
        }
        if(x==1 || y==m)
        {
            return dis;
        }
        st[x][y]=true;
        for(int i=0;i<4;i++)
        {
            int a=x+dx[i];
            int b=y+dy[i];
            if(a<1 || a>n || b<1 || b>m)
            {
                continue;
            }
            if(dist[a][b]>dis+g[x][y])
            {
                dist[a][b]=dis+g[a][b];
                q.push({a,b,dis+g[a][b]});
            }
        }
    }
    return -1;
}
int main()
{
    int q;
    cin>>q>>n>>m;
    while(q--)
    {
        memset(st,false,sizeof st); 
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                cin>>g[i][j];
                dist[i][j]=1e18;
                if(g[i][j]==0)
                {
                    st[i][j]=true;
                }
                if(g[i][j]==-1)
                {
                    g[i][j]=0;
                }
            }
        }
        st[1][1]=true;
        st[n][m]=true;
        cout<<dijkstra()<<endl;
    }
}