2025.9.2日志-CSDN博客

本文链接：https://blog.csdn.net/2403_87366795/article/details/151123523

洛谷P3956 棋盘(dfs/bfs)

题意:

一张大小 $m * m$ 的棋盘，每个格子有无色、黄色、红色三种可能，所站的格子上必须有颜色，走到下一个格子花费 $1$ 个金币，当且仅当当前格子颜色与上一个格子的颜色不同，颜色相同不花费金币，可以耗费 $2$ 金币使用魔法使得下一个无色的格子暂时变成任意颜色，走过这个格子后，该格子变回无色。问从棋盘的左上角走到右下角花费的最少金币数。

初始思路：

考虑用二元组 $(x, y)$ 表示当前搜索到的格子，附带参数 $cos t$ 表示当前已用金币数，参数 $f l a g$ 表示上一个格子是否使用魔法。我用 $BFS$ 搜索，写完后连样例都没过，不过这种思路没有问题。我的代码问题是没有对走到当前格的最小花费与当前的花费比较，导致了当前格的正确最小花费被错误地更新。只需开一个 $cs t$ 数组记录每个格子的最小花费。

DFS思路：

看的洛谷题解：

思路转换：

上面的思路是对一个格子的上下左右四个方向进行搜索，这样不好处理对格子施加魔法的情况。
考虑施加魔法的本质就是允许走到曼哈顿距离是 $2$ 且有颜色的下一个格子中。这样暂且不考虑不同颜色格子带来的花费，总会花费 $2$ 的金币数。总代价为：走到相同或不同格子里的花费 $+ 2$ 。

搜索方案：

对周围十二个方向搜索：

需走一个格子： $(x - 1, y), (x, y - 1), (x + 1, y), (x, y + 1)$
需走两个格子： $(x - 1, y - 1), (x - 2, y), (x - 1, y + 1), (x, y + 2), (x + 1, y + 1), (x + 2, y), (x + 1, y - 1), (x, y - 2)$
在这样的情况下，可能存在 $(x, y) \to (x + 2, y)$ ，但本身 $(x + 1, y)$ 是有颜色的情况。走 $2$ 步会多算代价，但是结合了走 $1$ 步的方法，最终这两步会由走 $1$ 步的方法生成最小答案。

剪枝：

当前已用金币数若大于等于当前格的金币数，就没必要向下搜了，直接 $re t u r n$ 。

答案统计:

当当前格子是 $(m, m)$ 时，用 $an s$ 更新答案，但有一种情况要单独考虑：
如果 $(m, m)$ 无色，会导致无法统计，因为搜索会跳过没有颜色的格子。所以在跳到格子 $(m - 1, m)$ 或者 $(m, m - 1)$ 时，判断 $(m, m)$ 的颜色是否存在，如果不存在的话，则答案对 $q + 2$ 取 $min$ 。

代码：

#include<bits/stdc++.h>
using namespace std;

const int N=110;
const int MAX=0x3f3f3f3f;

int col[N][N],cst[N][N];
bool vis[N][N];
int dx[]={0,-1,0,1,-1,-1,1,1,0,-2,0,2};
int dy[]={-1,0,1,0,-1,1,1,-1,-2,0,2,0};
int cost[]={0,0,0,0,2,2,2,2,2,2,2,2};

int main()
{
    int n,m;
    cin>>m>>n;

    for(int i=1,x,y,c;i<=n;i++) 
    {
        cin>>x>>y>>c;
        col[x][y]=c+1;
    }
    int ans=MAX;
    memset(cst,0x3f,sizeof cst);
    // cout<<cst[0];
    auto dfs=[&](auto& self,int x,int y,int ct)->void
    {
        if(cst[x][y]<=ct) return;
        cst[x][y]=ct;
        if(x==m&&y==m) {ans=min(ans,ct);return;}
        if(x+y==2*m-1&&col[x][y]==0) {ans=min(ans,ct+2);return;}
        vis[x][y]=true;
        for(int i=0;i<12;i++)
        {
            int nx=x+dx[i];
            int ny=y+dy[i];
            if(nx>=1&&nx<=m&&ny>=1&&ny<=m&&!vis[nx][ny]&&col[nx][ny]!=0)
            {
                int tmp=cost[i];
                tmp+=(col[x][y]==col[nx][ny]? 0:1);
                self(self,nx,ny,ct+tmp);
            }
        }
        vis[x][y]=false;
    };
    dfs(dfs,1,1,0);
    if(ans==MAX) cout<<-1;
    else 
    cout<<ans;
    return 0;
}

BFS思路:

对于每个格子，上下左右扩展，每个格子除了记录坐标 $(x, y)$ ,还有上一个格子是否使用了魔法，用 $f l a g$ 标记；当前格子的使用的金币数；当前格子的颜色。
格子的颜色记录是为了方便动态记录施加魔法导致的颜色变化。
写完后遇到的问题：
魔法会临时改变格子颜色（逻辑上），但 $b ug$ 代码只读取网格初始颜色 $co l$ ，未在状态中保存动态颜色。
例如：从有颜色格子 $A$ 移动到无颜色格子 $B$ （使用魔法，颜色继承 $A$ ）。当从 $B$ 移动到 $C$ 时：正确：应比较 $B$ 的魔法颜色（即 $A$ 的颜色）和 $C$ 的颜色。错误：比较的是 $B$ 的初始网格颜色 $(0)$ 和 $C$ 的颜色，导致花费计算错误。

改正：在 $n o d e$ 结构体中添加 $co l$ 字段，记录上一个格子的颜色。

分类讨论细节在代码中：

#include <bits/stdc++.h>
using namespace std;

struct node
{
    int x,y,cost,flag,col;
};

int dx[]={-1,0,1,0};
int dy[]={0,-1,0,1};

int main()
{
    int n,m;
    cin>>m>>n;
    
    vector<vector<int>> col(m+1,vector<int>(m+1));
    vector<vector<int>> cst(m+1,vector<int>(m+1,0x3f3f3f3f));
    queue<node> q;

    for(int i=1;i<=n;i++) 
    {
        int x,y,c;
        cin>>x>>y>>c;
        col[x][y]=c+1;
    }

    q.push({1,1,0,0,col[1][1]});
    cst[1][1]=0;
    while(!q.empty())
    {
        node now=q.front();
        q.pop();
        int x=now.x,y=now.y;
        int ct=now.cost;
        for(int i=0;i<4;i++)
        {
            int nx=x+dx[i],ny=y+dy[i];
            if(nx<1||nx>m||ny<1||ny>m||(now.flag&&col[nx][ny]==0))continue;
            node next={nx,ny,0,0,0};
            int sum=0;
            if(col[nx][ny]>0)
            {
                if(col[nx][ny]==now.col)
                    sum=0;
                else 
                    sum=1;
                next.flag=0;
                next.col=col[nx][ny];
            }
            else
            {
                sum=2;
                next.flag=1;
                // col[nx][ny]=col[x][y];//这样不行，不知道为啥。
                next.col=now.col;
            }
            next.cost=sum+ct;
            if(next.cost<cst[nx][ny])
            {
                cst[nx][ny]=next.cost;
                q.push(next);
            }
        }
    }
    if(cst[m][m]==0x3f3f3f3f) cout<<-1;
    else cout<<cst[m][m];
    return 0;
}