ACWing 4481 -- 双端队列 & 贪心 & dp

题目描述

方格探索

思路

最简单的思路：$bfs$，遍历所有的点，只需要额外记录左右走的次数就可以了。

还有一种思路就是 $dp$ + 优化。
从最暴力的角度出发，我们需要在 $dp$ 中维护四个变量 $（x,y,cnta,cntb）$ ，$cnta$ 和 $cntb$ 分别表示想左右走走的次数。
这样做的时间复杂度是 O(N^4)。
第一次优化：对于 $cnta$ 和 $cntb$，我们只需要记录一个就行了，为什么呢？
假设我们的起点为 $(x,y)$，现在走到了某一个点 $(a,b)$。如果向右走的次数为 $cntb$，那么有：$y+cntb-cnta=b$。
即：$cnta=y-b+cntb$。
第二次优化：我们甚至一个 $cnt$ 都不需要记录。
在最开始的暴力和优化掉一个 $cnt$ 的状态表示中，我们状态的结果是这个点是否合法。
我们可以从另一种角度考虑：让状态表示的是走到这个点所需的向右走的最少次数。
然后再根据这个值判断是否合法即可。
这样我们就优化掉了两个 $cnt$，只剩下坐标 $x$ 和 $y$了。

注意无论是从简单的 $bfs$ 还是 $dp$ 的角度去考虑，都需要注意一个点：我们要人为的为我们走的路径规定一个顺序（除非你不判重）。
当然不判重是不可行的，因为图中可能存在环。
否则的话，一个点可能有多种方式走过去。假如存在一条路径是不合法的，存在一条路径是合法的。
如果我们先走不合法的路径，然后标记为走过了，并且表示为不合法。
这时候如果下一次合法的路径走到这个点的时候，就不会继续往下走（因为已经标记为走过了），因此我们就漏了一个点。
那么有没有什么办法解决这个问题呢？
贪心！我们可以贪心的上下走，尽量不左右走，这样当我们第一次走到某个点的时候，左右走的次数肯定是最少的，这时候如果都不合法，那么后面的点肯定也不合法了。
关于这里问题可以参考这个作者

代码1 dfs

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

const int N = 2010;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};

int n, m, cntx, cnty;
char g[N][N];
int ans;

typedef struct Node{
    Node(int _x, int _y, int _cnta, int _cntb) 
    : x(_x), y(_y), cnta(_cnta), cntb(_cntb) 
    {}
    int x;
    int y;
    int cnta;
    int cntb;
} node;

void bfs(int sx, int sy)
{
    deque<node> q;
    q.push_back({sx, sy, 0, 0});
    g[sx][sy] = '*';    // 在原数组上做修改来实现判重
    ans = 1;
    // cout << "(" << sx << ',' << sy << ")" << endl;
    
    while(q.size())
    {
        auto t = q.front();
        q.pop_front();
        for(int i = 0; i < 4; i ++ )
        {
            int adda = (i == 0), addb = (i == 2); // a表示向左，b表示向右
            int a = t.x + dx[i], b = t.y + dy[i];
            
            if(a < 0 || a >= n || b < 0 || b >= m || g[a][b] == '*')    continue;
            if(t.cnta + adda > cntx || t.cntb + addb > cnty)  continue;
            
            // 如果走的是上下，放到队列的前面
            // 如果走的是左右，放到队列的后面
            node newNode = {a, b, t.cnta + adda, t.cntb + addb}; 
            if(i == 1 || i == 3)    q.push_front(newNode);
            else    q.push_back(newNode);
            g[a][b] = '*';      // 去重
            ans ++ ;
        }
    }
}

int main()
{
    int sx, sy;
    cin >> n >> m >> sx >> sy >> cntx >> cnty;
    for(int i = 0; i < n; i ++ )    cin >> g[i];
    
    bfs(sx - 1, sy - 1);  // 题目给定下标从1开始，我们的从0开始
    cout << ans << endl;
    
    return 0;
}

代码3 dp

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>

#define x first
#define y second

using namespace std;

typedef pair<int, int> PII;

const int N = 2010;

int n, m, sx, sy, X, Y;
int dist[N][N];
char g[N][N];
bool st[N][N];

void bfs()
{
    memset(dist, 0x3f, sizeof dist);
    dist[sx][sy] = 0;
    deque<PII> q;
    q.push_back({sx, sy});

    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    while (q.size())
    {
        auto t = q.front();
        q.pop_front();
        if (st[t.x][t.y]) continue;
        st[t.x][t.y] = true;

        for (int i = 0; i < 4; i ++ )
        {
            int x = t.x + dx[i], y = t.y + dy[i];
            if (x < 0 || x >= n || y < 0 || y >= m || g[x][y] == '*') continue;
            int w = 0;
            if (i == 1) w = 1;
            if (dist[x][y] > dist[t.x][t.y] + w)
            {
                dist[x][y] = dist[t.x][t.y] + w;
                if (w) q.push_back({x, y});
                else q.push_front({x, y});
            }
        }
    }
}

int main()
{
    scanf("%d%d%d%d%d%d", &n, &m, &sx, &sy, &X, &Y);
    sx --, sy -- ;

    for (int i = 0; i < n; i ++ ) scanf("%s", g[i]);

    bfs();

    int res = 0;
    for (int i = 0; i < n; i ++ )
        for (int j = 0; j < m; j ++ )
        {
            int b = dist[i][j];
            if (b <= Y && b - (j - sy) <= X)
                res ++ ;
        }

    printf("%d\n", res);
    return 0;
}