搜索（1）BFS基础

已于 2022-11-09 00:00:46 修改
阅读量152 收藏 2
点赞数
分类专栏： 摆烂日记from acwing 文章标签： 算法 深度优先
于 2022-10-25 22:13:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64197656/article/details/127514883
版权

一、floodfill

（1）

 bfs，dfs均可。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;


typedef pair<int,int> PII;
const int N =1010;
int dx[8]={0,-1,-1,-1,0,1,1,1},dy[8]={-1,-1,0,1,1,1,0,-1};


char g[N][N];
int n,m;
bool st[N][N];
int ans;



void bfs()
{
    queue<PII> q;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        {
            if(!st[i][j]&&g[i][j]=='W')
            {
                ans++;
                q.push({i,j});
                while(q.size())
                {
                    auto t=q.front();
                    q.pop();
                    for(int i=0;i<8;i++)
                    {
                        int x=t.first+dx[i],y=t.second+dy[i];
                        if(x>=0&&x<n&&y>=0&&y<m&&g[x][y]=='W')
                            if(!st[x][y]) st[x][y]=true,q.push({x,y});
                    }

                }
            }
            else continue;
        }

}


int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>g[i];

    bfs();
    cout<<ans;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4194842/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

（2）

 位运算来考虑墙。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

typedef pair<int,int> PII;
const int N =55;

int n,m;
int g[N][N];
bool st[N][N];
int cnt;

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


int bfs(int sx,int sy)
{
    queue<PII> q;
    int area=0;
    q.push({sx,sy});
    st[sx][sy]=true;

    while(q.size())
    {
        area++;
        auto t=q.front();
        q.pop();

        for(int i=0;i<4;i++)
        {
            int a=t.first+dx[i],b=t.second+dy[i];
            if(a<0||b<0||a>=n||b>=m) continue;
            if(st[a][b]) continue;
            if(g[t.first][t.second]>>i&1) continue;//这个方向门不开(要和dx dy配合)
            q.push({a,b});
            st[a][b]=true;
        }

    }
    return area;
}


int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
            cin>>g[i][j];

    int area=0;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        {
            if(!st[i][j])
            {
                area=max(area,bfs(i,j));
                cnt++;
            }
        }
    cout<<cnt<<endl;
    cout<<area<<endl;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4200345/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

（3）

 每个点bfs一遍，bfs时如果碰到height一样的就加入队列，如果碰到height不一样的则判断正在搜索的是山峰还是山谷。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define x first
#define y second
using namespace std;

typedef pair<int,int> PII;
const int N = 1010;
int n;
int h[N][N];
bool st[N][N];


void bfs(int i,int j,bool &hash,bool &hasl)
{
    queue<PII> q;
    q.push({i,j});
    st[i][j]=true;

    while(q.size())
    {
        auto t=q.front();
        q.pop();

        for(int i=t.x-1;i<=t.x+1;i++)
            for(int j=t.y-1;j<=t.y+1;j++)
            {
                if(i==t.x&&j==t.y) continue;
                if(i<0||j<0||i>=n||j>=n) continue;
                if(h[i][j]!=h[t.x][t.y])
                {
                    if(h[i][j]>h[t.x][t.y])  hash=true;
                    else hasl=true;
                }
                else if(!st[i][j])
                {
                    st[i][j]=true;
                    q.push({i,j});
                }
            }
    }
}



int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>h[i][j];

    int peak=0,valley=0;

    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
        {
            if(!st[i][j])
            {
                bool hash=false,hasl=false;
                bfs(i,j,hash,hasl);
                if(!hash) peak++;
                if(!hasl) valley++;
            }
        }

    cout<<peak<<" "<<valley;

}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4200594/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、最短路模型

（1）

 边权为1，bfs可找最短路。用pre数组存储某个点的前驱，则可获得最短路线

为方便，反向搜索最短路，然后可从0,0开始直接输出前驱，即为正向最短路

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define x first
#define y second
using namespace std;

typedef pair<int,int> PII;
const int N =1010,M=N*N;

int n;
int g[N][N];
PII pre[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};

void bfs(int sx,int sy)
{
    queue<PII> q;
    q.push({sx,sy});
    memset(pre,-1,sizeof pre);
    pre[sx][sy]={0,0};

    while(q.size())
    {
        auto t=q.front();
        q.pop();

        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0||b<0||a>=n||b>=n) continue;
            if(g[a][b]) continue;
            if(pre[a][b].x!=-1) continue;//被搜过

            q.push({a,b});
            pre[a][b]=t;
        }
    }

}


int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            cin>>g[i][j];

    bfs(n-1,n-1);
    PII end(0,0);//构造函数

    while(true)
    {
        cout<<end.x<<" "<<end.y<<endl;
        if(end.x==n-1&&end.y==n-1) break;
        end=pre[end.x][end.y];
    }
    return 0;
}


作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4202184/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

（2）

 直接bfs搜，，计算一下跳跃之后坐标的数组即可

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define x first
#define y second
using namespace std;

typedef pair<int,int> PII;

const int N =155;

int n,m;
char g[N][N];
int dist[N][N];

int bfs()
{
    int dx[] = {-2, -1, 1, 2, 2, 1, -1, -2};
    int dy[] = {1, 2, 2, 1, -1, -2, -2, -1};

    int sx,sy;
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            if(g[i][j]=='K') sx=i,sy=j;

    queue<PII> q;
    q.push({sx,sy});
    memset(dist,-1,sizeof dist);
    dist[sx][sy]=0;

    while(q.size())
    {
        auto t=q.front();
        q.pop();

        for(int i=0;i<8;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0||b<0||a>=n||b>=m) continue;
            if(g[a][b]=='*') continue;
            if(dist[a][b]!=-1) continue;
            if(g[a][b]=='H') return dist[t.x][t.y]+1;

            dist[a][b]=dist[t.x][t.y]+1;
            q.push({a,b});
        }
    }
}


int main()
{
    cin>>m>>n;
    for(int i=0;i<n;i++) cin>>g[i];

    cout<<bfs()<<endl;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4202245/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

（3）

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N =100010;
int n,k;
int d[N];

int bfs()
{
    memset(d,-1,sizeof d);
    d[n]=0;
    queue<int> q;
    q.push(n);
    while(q.size())
    {
        int t=q.front();
        q.pop();
        
        if(t==k)   return d[t];
        
        
        int x=t+1;
        if(x<=100000&&d[x]==-1)    
        {
            d[x]=d[t]+1;
            q.push(x);
        }
        x=t-1;
        if(x>0&&d[x]==-1)   
        {
            d[x]=d[t]+1;
            q.push(x);
        }
        x=2*t;
        if(x<=100000&&x>0&&d[x]==-1)   
        {
            d[x]=d[t]+1;
            q.push(x);
        }
    }
}

int main()
{
    cin>>n>>k;
    if(n>k)//玄学优化
    {
        printf("%d",n-k);
        return 0;
    }
    else cout<<bfs()<<endl;
}

三、多源bfs

广度优先遍历的正确性：满足两段性和单调性

即1.在访问完所有的第i层节点后，才会开始搜索第i+1层节点。2.任意时刻，队列中至多有两个层次的结点。若其中一部分节点属于第i层，则另一部分节点属于第i+1层，并且所有第i层节点排在第i+1层节点之前。也就是说广度优先队列中的元素满足单调性和两段性。

本题思路： 求出每个0点到距离自己最近的1点的曼哈顿距离。

可以反向思考用每个1点作为虚拟原点，更新周围的0点的距离。

每个1点的距离显然是0。拓展每个节点时，把新元素加入队尾，可以使得队列中永远只有dist为x，与x+1的元素，并且dist为x的元素一定在dist为x+1的元素前面。即满足单调性和两段性。因此做法是正确的。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define x first
#define y second
using namespace std;

typedef pair<int,int> PII;
const int N =1010;

char g[N][N];
int n,m;
int dist[N][N];

void bfs()
{
    queue<PII> q;
    int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
    memset(dist,-1,sizeof dist);

    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++)
        {
            if(g[i][j]=='1')
            {
                q.push({i,j});
                dist[i][j]=0;
            }
        }


    while(q.size())
    {
        auto t=q.front();
        q.pop();

        for(int i=0;i<4;i++)
        {
            int a=t.x+dx[i],b=t.y+dy[i];
            if(a<0||b<0||a>=n||b>=m) continue;
            if(dist[a][b]!=-1) continue;

            dist[a][b]=dist[t.x][t.y]+1;
            q.push({a,b});//注意这个放在队尾的性质   
        }
    }


}


int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++) cin>>g[i];

    bfs();
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++) cout<<dist[i][j]<<" ";
        cout<<endl;
    }
    return 0;


}


作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4206207/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

四、最小步数模型

 分析：求路径—存前驱 状态抽象为字符串 为方便从标准态反向搜索 要求字典序最小—搜索方案按abc的顺序搜。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<unordered_map>
using namespace std;

char g[2][4];
unordered_map<string,int> dist;
unordered_map<string,pair<char,string>> pre;


void set(string state)//把字符串转化成数组魔板，，方便状态转移
{
    for(int i=0;i<4;i++) g[0][i]=state[i];
    for(int i=7,j=0;j<4;i--,j++) g[1][j]=state[i];
}

string get()
{
    string res;
    for (int i = 0; i < 4; i ++ ) res += g[0][i];
    for (int i = 3; i >= 0; i -- ) res += g[1][i];    
    return res;
}

string move0(string state)
{
    set(state);

    for(int i=0;i<4;i++) swap(g[0][i],g[1][i]);

    return get();

}

string move1(string state)
{
    set(state);

    int v0=g[0][3],v1=g[1][3];

    for(int i=3;i>0;i--)
        g[0][i]=g[0][i-1],g[1][i]=g[1][i-1];
    g[0][0]=v0,g[1][0]=v1;

    return get();
}

string move2(string state)
{
    set(state);
    int v = g[0][1];
    g[0][1] = g[1][1];
    g[1][1] = g[1][2];
    g[1][2] = g[0][2];
    g[0][2] = v;    


    return get();
}


int bfs(string start,string end)
{
    if(start==end) return 0;
    queue<string> q;

    q.push(start);
    dist[start]=0;

    while(q.size())
    {
        auto t=q.front();
        q.pop();

        string m[3];
        m[0]=move0(t);
        m[1] = move1(t);
        m[2] = move2(t);
        for(int i=0;i<3;i++)//按abc的顺序搜 就是字典序最小的方案
        {
            if(!dist.count(m[i]))
            {
                dist[m[i]]=dist[t]+1;
                pre[m[i]]={'A'+i,t};
                q.push(m[i]);
                if(m[i]==end) return dist[m[i]];
            }
        }
    }
    return -1;
}

int main()
{
    int x;
    string start,end;
    for(int i=0;i<8;i++)
    {
        cin>>x;
        end+=char(x+'0');
    }

    for(int i=1;i<=8;i++) start+=char(i+'0');

    int step=bfs(start,end);

    cout<<step<<endl;
    string res;
    while(end != start)
    {
        res+=pre[end].first;
        end=pre[end].second;
    }

    reverse(res.begin(),res.end());
    if(step>0) cout<<res<<endl;
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/4208297/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

BlessingSoftware1
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 算法基础篇：深度优先搜索（ DFS ）和广度优先搜索（ BFS ）
小蓝枣的博客
07-19 7360
深度优先搜索（ DFS ）和广度优先搜索（ BFS ）是两种常用的图遍历算法，用于在图中搜索目标节点或遍历图的所有节点。本篇博客将介绍 DFS 和 BFS 算法的基本概念，并通过实例代码演示它们的应用。
【leetcode/BFS】完全平方数（从目标节点反向搜索）
qq_43338695的博客
10-12 175
题目描述： 给定正整数n，找到若干个完全平方数（比如1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。 示例1: 输入: n = 12 输出: 3 解释: 12 = 4 + 4 + 4. 示例 2: 输入: n = 13 输出: 2 解释: 13 = 4 + 9. 解题思路： 这已经不是我们做过的第一题BFS了，显然如果是最朴素...
C++-queue：queue基本用法【q.push(x)、q.front()、q.back()、q.pop()、q.size()、q.empty()】
u013250861的博客
12-20 1万+
为了降低时间复杂度，将数组当作一个首尾相连的圆环，分别用两个标志front、rear代表队列的头部和尾部。删除元素时，队首标志往后移，添加元素时，若队尾没有空间，考虑数组的头部空间若还有，则在队头添加元素，防止数组内存空间的流失。出队操作：数组头部元素出队之后，头部之后的元素均需要往前移动一个位置，时间复杂度为O（n）设置一个标志变量flag，同时满足front=rear且flag=1时为满队列。入队操作：在数组的末尾添加元素，时间复杂度为O（1）链表头为队列头部，链表尾为队列尾部。空一个元素，保持为空。
push 函数介绍
poptar的博客
10-27 1万+
stack::push();//在栈顶增加元素 queue::push();//将x 接到队列的末端。 stack与queue常见方法介绍 1、stack stack 模板类的定义在<stack>头文件中。 stack 模板类需要两个模板参数，一个是元素类型，一个容器类型，但只有元素类型是必要的，在不指定容器类型时，默认的容器类型为deque。 定义stack 对象的示例代码如下： stack<int> s1; stack<string> s2..
C++-deque：deque基本用法【q.push_back(x)、q.push_front()、q.pop_back()、q.pop_front()、q.insert()、q.erase()】
最新发布
u013250861的博客
01-05 1218
【代码】C++-deque：deque基本用法【q.push_back(x)、q.push_front()、q.pop_back()、q.pop_front()、q.insert()、q.erase()】
BFS进阶技巧——多源BFS、最小步数模型、双端队列广搜、双向广搜
AKAPinkman的博客
01-31 1705
多源BFS 多源BFS时有从多个源点出发的bfs算法,只需要将多个源点都连一条边权为0的边到虚拟源点,那么问题就等价于从虚拟源点开始BFS。 一开始直接将所有源点加入BFS的队列即可. 矩阵距离 输入样例： 3 4 0001 0011 0110 输出样例： 3 2 1 0 2 1 0 0 1 0 0 1 思路 题意为搜索所有0点到一群1点的最短曼哈顿距离。 将所有为1的点直接加入bfs队列，向外搜索，由bfs性质到达的点一定离虚拟源点最短,而到虚拟源点的距离 == 到1点的距离,故最短。 代码 /*
leetcode-BFS-1:BFS-1
06-29
总结起来，LeetCode上的BFS题目是提升编程能力的重要练习，它涵盖了基础的算法思想和实际应用。通过理解和实践这些问题，你不仅可以掌握BFS，还可以深化对数据结构、图论以及问题解决策略的理解，这对任何IT专业人员...
广度有限搜索 bfs 基础 骑士的任务 课件
10-14
**广度优先搜索 (BFS) 基础与骑士任务** 广度优先搜索（BFS）是一种在图或树中寻找最短路径的搜索算法，它的主要特点是按照层次顺序进行搜索，即从起始节点开始，优先遍历离起始节点更近的节点，再遍历更远的节点。...
BFS 广度优先搜索算法 matlab
03-19
**正文** 广度优先搜索（Breadth-First Search，简称BFS）是一种在图或树数据结构中遍历或搜索节点的经典算法。...通过深入理解和实践，我们可以更好地掌握这种基础的搜索算法，并应用于各种复杂场景。
test_1_DFS_BFS.rar_bfs_bfs路径_dfs_寻路_自动寻路
09-20
在计算机科学领域，深度优先搜索（DFS，Depth-First Search）和广度优先搜索（BFS，Breadth-First Search）是两种基础且重要的图遍历算法，广泛应用于网络爬虫、游戏寻路、图论问题求解等多个场景。本项目"test_1_...
QPush怎么集成到其他环境中 java...
u010457275的专栏
10-17 251
QPush 台湾作者编写的，主要功能就是从外部推送消息iphone端，提供iphone端的app，遗憾的是并未提供其他平台，也没有公开接口      本文主要是讲怎么在java中调用他的推送接口，总结:java环境通过调用接口已达到发送消息到iphone 本身qpush推送消息是需要认证的，但是在认证过后可以直接拿到认证信息，这些认证信息并不会过期，可能后期作者会进行修改， 认证信息包括：s...
数据结构：队列queue 函数push() pop size empty front back
AMY100727的博客
09-04 2707
队列queue： 　　push()　　pop()　　size()　　empty()　　front()　　back() push() 队列中由于是先进先出，push即在队尾插入一个元素，如：可以输出：Hello World！ queue<string> q; q.push("Hello World!"); q.push("China"); cout&l...
Qt QPushButton详解
芒种、的博客
09-23 2384
一、QPushButton 1. QPushButton事件信号 void pressed(); //按钮按下 void released(); //按钮抬起 void clicked(bool checked = false); //按钮选中和松开 void toggled(bool checked);
Leetcode典型题解答和分析、归纳和汇总——T98（验证二叉搜索树）
weixin_44504987的博客
02-29 150
问题描述： 问题解析： 本题与102题解决的方法类似，只是我们改用队列的结构来进行求解。首先队列是一种先进先出的数据结构，而且对于数据的接入采用q.push()函数，而对于数据的输出我们采用q.pop()函数。每一次迭代过程，我们都需要把左右节点压入队列中，并且保证压入的数据不会出现比队列长度更长的情况。还要对于偶数行，进行tmp数据反转情况，然后再压入到数组集中。 /** * D...
push（）——深入理解
菜鸟少年的博客
12-07 1万+
数组和类数组 数组是一种特殊的对象，两者本质上没有太大的区别。 类数组是一种长得像数组的对象，数组上的方法他不全都有。
队列(queue)
编程之路
10-11 1720
# include <iostream> # include <queue> # include <list> # include <deque> using namespace std;/* 队列(queue): 先进先出 定义: queue<int,deque<int> > q; queue<int,list<int> > q;
Qt之QPushButton(属性 信号 快捷键)
yky的博客
08-02 2万+
PushButton顾名思义----按钮，也是Qt常用的控件之一，至于应用场景，就不必多说了，下面将从以下几个方面对QPushButton进行介绍: [1]常用属性介绍 [2]信号事件 [3]快捷键设置 针对QPushButton还会用到对其背景颜色、圆角边框、渐变显示效果、鼠标悬停与鼠标离开的不同显示效果、用图片代替QPushButton进行显示等美化相关的属性进行设置。这些全部用Qt ...
c++queue容器介绍
热门推荐
我的ACM
10-02 8万+
一.queue模版类的定义在头文件中。 queue与stack模版非常类似，queue模版也需要定义两个模版参数，一个是元素类型，一个是容器类型，元素类型是必要的，容器类型是可选的，默认为dqueue类型。 定义queue对象的示例代码如下： queueq1; queueq2; queue的基本操作有： 1.入队：如q.push(x):将x元素接到队列的末端； 2.出队：如q.pop
pushpush(双向队列/列表)
月殇
07-31 921
                                            pushpush                                                                 时间限制: 1 Sec  内存限制: 128 MB                                                         ...
双向BFS算法在搜索策略中的应用
状态空间是搜索算法的基础，它由状态、状态转移、以及状态之间的关系组成。状态是问题在某一时刻的描述，状态转移则描述了问题如何从一个状态变化到另一个。状态空间可以视为一个图，其中每个节点代表一个状态，边...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值