使网格图至少有一条有效路径的最小代价（队列/双端队列）

题目：https://leetcode-cn.com/problems/minimum-cost-to-make-at-least-one-valid-path-in-a-grid/
更简洁的做法是用双端队列，当时没相到

class Solution {
public:
    /*
    *队列：把同层次的优先遍历
    */
    struct node{
        int val;
        int x,y;
        node(){}
        node(int _val,int _x,int _y):val(_val),x(_x),y(_y){}
    };
    int m,n;
    bool check(int x,int y ){
        return (x>=0&&x<m&&y>=0&&y<n);
    }
    bool vis[101][101];
    vector<node> ve;
    int dx[5]={0,0,0,1,-1};
    int dy[5]={0,1,-1,0,0};
    int minCost(vector<vector<int>>& grid) {
        m = grid.size();
        n = grid[0].size();
        queue<node> q;
        node cur;
        memset(vis,0,sizeof(vis));
        vis[0][0] = 1;
        q.push(node(0,0,0));
        while(!q.empty()) {
            int val = q.front().val;
            ve.clear();
            while(!q.empty() && q.front().val == val) {
                cur = q.front();q.pop();
                if(cur.x == m-1 && cur.y == n-1) return val;
                
                ve.push_back(cur);
                int x = cur.x+dx[grid[cur.x][cur.y]];
                int y = cur.y+dy[grid[cur.x][cur.y]];
                if(!check(x,y)||vis[x][y]) continue;
                vis[x][y] = 1;
                q.push(node(val,x,y));
            }
            
            int sz = ve.size();
            for(int i = 0;i < sz;i++){
                cur = ve[i];
                for(int k = 1;k <= 4;k++) {
                    if(k == grid[cur.x][cur.y]) continue;
                    int x = cur.x+dx[k];
                    int y = cur.y+dy[k];
                    if(!check(x,y)||vis[x][y]) continue;
                    vis[x][y] = 1;
                    q.push(node(val+1,x,y));
                }
            }
        }
        return -1;//
    }
};