深搜广搜

最新推荐文章于 2025-03-27 20:05:36 发布
原创 最新推荐文章于 2025-03-27 20:05:36 发布 · 369 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文解析了多个经典的算法问题，包括深搜、广搜等方法的应用，如计算园中水洼数量、电路连接的最大和、摆放棋子方案数等问题，并提供了详细的代码实现。

我的心愿是世界和平！

深搜

有一个大小为N×M的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里共有多少水洼？

#include <stdio.h>
char map[110][110];
int ap[110][110];
int m,n;
void dfs(int i,int j)
{
    if(map[i][j]=='W')
    {
        ap[i][j]=1;//将已经搜索过的小水洼做标记.
        if(i-1>=0&&j-1>=0&&ap[i-1][j-1]==0)//不超出边界且未被搜索过.
            dfs(i-1,j-1);
        if(i-1>=0&&ap[i-1][j]==0)
            dfs(i-1,j);
        if(i-1>=0&&j+1<n&&ap[i-1][j+1]==0)
            dfs(i-1,j+1);
        if(j-1>=0&&ap[i][j-1]==0)
            dfs(i,j-1);
        if(j+1<n&&ap[i][j+1]==0)
            dfs(i,j+1);
        if(i+1<m&&j-1>=0&&ap[i+1][j-1]==0)
            dfs(i+1,j-1);
        if(i+1<m&&ap[i+1][j]==0)
            dfs(i+1,j);
        if(i+1<m&&j+1<n&&ap[i+1][j+1]==0)
            dfs(i+1,j+1);
    }
}
int main()
{
    int i,j,sum;
    while(~scanf("%d%d",&m,&n))
    {
        for(i=0;i<m;i++)
        {
            getchar();
            for(j=0;j<n;j++)
            {
                scanf("%c",&map[i][j]);
                ap[i][j]=0;
            }
        }
        sum=0;
        for(i=0;i<m;i++)
        {
            for(j=0;j<n;j++)
            {
                if(ap[i][j]==0&&map[i][j]=='W')
                {
                    sum++;
                    dfs(i,j);
                }
            }
        }
        printf("%d\n",sum);
    }
}

将所有的电路连接且其和最大。

#include<stdio.h>
int m,map[25][25],dis[25],sum,j;
#define max 0x3f3f3f3f
void dfs(int i,int shu)
{
    dis[i]=1;//取出点.
    int change=shu;
    for(j=1;j<=m;j++)
    {
        if(dis[j]==0)//该点和i不在一个集合里.
            change+=map[i][j];//加上它们的权值.
        else//和i在一个集合里
            change-=map[i][j];//减去它们的权值.
    }
    if(sum<change)
        sum=change;
    for(++i;i<=m;i++)//遍历剩下的点.
    {
        if(change>shu)
        {
            dfs(i,change);
            dis[i]=0;
        }
    }
}
int main()
{
    int i;
    while(~scanf("%d",&m))
    {
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=m;j++)
            {
                scanf("%d",&map[i][j]);
            }
            dis[i]=0;
        }
        sum=-max;
        dfs(1,0);
        printf("%d\n",sum);
    }
}

题目来源 ：http://acm.sdibt.edu.cn:8080/vjudge/contest/view.action?cid=1813#problem/B

在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放k个棋子的所有可行的摆放方案C。

#include<stdio.h>
#include<string.h>
int map[9][9];
int dis[9];
int di[9];
int m,n,num;
void dfs(int i,int j,int k)
{
    if(k==0){
        num++;}
    dis[i]=di[j]=1;
    int p=i,q=j;
    for(;i<m;i++)
    {
        if(p==i)
            j=q;
        else
            j=0;
        for(;j<m;j++)
        {
            if(dis[i]==0&&di[j]==0&&map[i][j]==1)
            {
                dfs(i,j,(k-1));
                dis[i]=0;
                di[j]=0;
            }
        }
    }
}
int main()
{
    char c;
    int i,j,k;
    while(scanf("%d%d",&m,&n))
    {
        if(m==-1&&n==-1)
            break;
        for(i=0;i<m;i++)
        {
            getchar();
            for(j=0;j<m;j++)
            {
                scanf("%c",&c);
                if(c=='#')
                    map[i][j]=1;
                else
                    map[i][j]=0;
            }
        }
        num=0;
        if(n==0)
        {
            printf("0\n");
            continue;
        }
        for(i=0;i<m;i++)
        {
            for(j=0;j<m;j++)
            {
                for(k=0;k<m;k++)
                    dis[k]=di[k]=0;
                if(map[i][j]==1)
                {
                    k=n;
                    dfs(i,j,k-1);
                }
            }
        }
        printf("%d\n",num);
    }
    return 0;
}

广搜

Catch the cow.
POJ3278

#include <stdio.h>
#include <iostream>
#include <queue>
using namespace std;
int s[160010];
int main()
{
    int a,b,k,sum;
    while(~scanf("%d%d",&a,&b))
    {
        if(a==b)
        {
            printf("0\n");
            continue;
        }
        for(k=0;k<=160000;k++)
            s[k]=0;
        queue<int>p;
        p.push(a);
        while(!p.empty())
        {
            if(p.front()-1==b||p.front()+1==b||2*p.front()==b)
            {
                s[b]=s[p.front()]+1;
                break;
            }
            if(1+p.front()<=100000&&s[1+p.front()]==0)//注意条件的先后,先保证1+p.front()在数组范围内，再判断数组,避免RE.
            {
                p.push(1+p.front());
                s[1+p.front()]=s[p.front()]+1;
            }
            if(p.front()-1>=0&&s[p.front()-1]==0)
            {
                p.push(p.front()-1);
                s[p.front()-1]=s[p.front()]+1;
            }
            if(2*p.front()<=160000&&s[2*p.front()]==0)
            {
                p.push(2*p.front());
                s[2*p.front()]=s[p.front()]+1;
            }
            p.pop();
        }
        printf("%d\n",s[b]);
    }
    return 0;
}

判断Y和M到同一个@的最短路径。如果定下@，每次找Y和M到@的路径，会超时。我们可以记录下@的位置，先找到Y和M到每个可行点的路径，最后循环@点，相加位置点即可。注意：@点，Y点，M点均为可行点。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <queue>
using namespace std;
char map[210][210];
int s[210][210];//记录Y到每个可行点的最短距离.
int ss[210][210];//记录M到每个可行点的最短距离.
struct edge
{
    int x;
    int y;
} ed;
struct point
{
    int x;
    int y;
} po[40010];//记录@点的位置.
int main()
{
    int num,m,n,i,j,k,Yx,Yy,Mx,My,px,py,sum;
    while(~scanf("%d%d",&m,&n))
    {
        num=-1;
        for(i=0; i<m; i++)
        {
            getchar();
            for(j=0; j<n; j++)
            {
                scanf("%c",&map[i][j]);
                if(map[i][j]=='Y')
                {
                    Yx=i;
                    Yy=j;
                    map[i][j]='.';
                }
                if(map[i][j]=='M')
                {
                    Mx=i;
                    My=j;
                    map[i][j]='.';
                }
                if(map[i][j]=='@')
                {
                    po[++num].x=i;
                    po[num].y=j;
                    map[i][j]='.';
                }
            }
        }
        for(i=0; i<m; i++)
            for(j=0; j<n; j++)
            {
                s[i][j]=0;
                ss[i][j]=0;
            }
        queue<edge>p;
        ed.x=Yx;
        ed.y=Yy;
        p.push(ed);
        while(!p.empty())//Y到每个可行点的最短距离.
        {
            px=p.front().x;
            py=p.front().y;
            p.pop();
            if(px-1>=0&&s[px-1][py]==0&&map[px-1][py]=='.')
            {
                ed.x=px-1;
                ed.y=py;
                p.push(ed);
                s[px-1][py]=s[px][py]+1;
            }
            if(py-1>=0&&s[px][py-1]==0&&map[px][py-1]=='.')
            {
                ed.x=px;
                ed.y=py-1;
                p.push(ed);
                s[px][py-1]=s[px][py]+1;
            }
            if(py+1<n&&s[px][py+1]==0&&map[px][py+1]=='.')
            {
                ed.x=px;
                ed.y=py+1;
                p.push(ed);
                s[px][py+1]=s[px][py]+1;
            }
            if(px+1<m&&s[px+1][py]==0&&map[px+1][py]=='.')
            {
                ed.x=px+1;
                ed.y=py;
                p.push(ed);
                s[px+1][py]=s[px][py]+1;
            }
        }
        queue<edge>q;
        ed.x=Mx;
        ed.y=My;
        q.push(ed);
        while(!q.empty())//M到每个可行点的最短距离.
        {
            px=q.front().x;
            py=q.front().y;
            q.pop();
            if(px-1>=0&&ss[px-1][py]==0&&map[px-1][py]=='.')
            {
                ed.x=px-1;
                ed.y=py;
                q.push(ed);
                ss[px-1][py]=ss[px][py]+1;
            }
            if(py-1>=0&&ss[px][py-1]==0&&map[px][py-1]=='.')
            {
                ed.x=px;
                ed.y=py-1;
                q.push(ed);
                ss[px][py-1]=ss[px][py]+1;
            }
            if(py+1<n&&ss[px][py+1]==0&&map[px][py+1]=='.')
            {
                ed.x=px;
                ed.y=py+1;
                q.push(ed);
                ss[px][py+1]=ss[px][py]+1;
            }
            if(px+1<m&&ss[px+1][py]==0&&map[px+1][py]=='.')
            {
                ed.x=px+1;
                ed.y=py;
                q.push(ed);
                ss[px+1][py]=ss[px][py]+1;
            }
        }
        int mi=0x3f3f3f3f;
        for(k=0; k<=num; k++)//循环@点.
        {
            if(s[po[k].x][po[k].y]!=0&&ss[po[k].x][po[k].y]!=0)
            {
                sum=s[po[k].x][po[k].y]+ss[po[k].x][po[k].y];
                if(sum<mi)
                    mi=sum;
            }
        }
        printf("%d\n",mi*11);
    }
    return 0;
}

题目来源 ：http://acm.sdibt.edu.cn:8080/vjudge/contest/view.action?cid=1813#problem/H

深搜广搜2s总结
dc爱傲雪和技术
04-15 1177
回溯算法，其实就是dfs的过程，这里给出这一圈一圈的搜索过程是怎么做到的，是放在什么容器里，才能这样去遍历。其实，我们仅仅需要一个容器，能保存我们要遍历过的元素就可以，那么用队列，还是用栈，甚至用数组，都是可以的。用队列的话，就是保证每一圈都是一个方向去转，例如统一顺时针或者逆时针。因为队列是先进先出，加入元素和弹出元素的顺序是没有改变的。如果用栈的话，就是第一圈顺时针遍历，第二圈逆时针遍历，第三圈有顺时针遍历。因为栈是先进后出，加入元素和弹出元素的顺序改变了。但大家都习惯用队列了。
Leetcode刷题笔记（C++）——深搜广搜
CV小菜鸟的博客
08-02 538
Leetcode刷题笔记（C++）——深搜广搜 整理一下刷题过程中的思路，在这里进行一下总结与分享。 github地址：https://github.com/lvjian0706/Leetcode-solutions github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。 133. 克隆图 给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。 图中的每个节点都包含它的值 val（int） 和其邻居的列表
深搜和广搜
最新发布
2501_90729873的博客
03-27 788
是一种利用递归来实现的搜索算法，它尝试尽可能深地搜索树的分支。当节点v的所有边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个探寻过程亦将一直持续到所有节点都被发现为止。在C++中，常见的搜索算法包括顺序搜索、二分搜索、深度优先搜索（DFS）、广度优先搜索（BFS）等。是在连续的空间中进行搜索，每次将搜索区间减半，这种方法非常适合于有序的序列。首先对块进行搜索，确定目标所在的块，然后在该块内进行顺序搜索。广度优先搜索（BFS）
深搜与广搜
My_Fresh_Start的博客
12-06 5670
深度优先搜索与广度优先搜索 深度优先搜索的思想是尽可能深的搜索，算法艺术与信息学竞赛一书中提到:随机搜索就像是在慌乱之中找东西,因为你并不知道东西在哪,广度优先搜索则像是你的眼镜掉在地上之 深度优先搜索 (DFS) 深度优先搜索属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次；
搜索入门及深搜广搜演示
05-30
"搜索入门及深搜广搜演示" 搜索算法是一种常用的解决问题的方法，当我们面临着无法通过建立数学模型解决的问题时，搜索算法能够帮助我们找到解决方案。搜索算法可以分为两大类：深搜和广搜。深搜是一种基于回溯思想...
Java深搜和广搜
qq1922631820的博客
03-31 386
/ 表示点j已经被遍历过。// st[u] 表示点u已经被遍历过。(2) 宽度优先遍历 —— 模板题 AcWing 847. 图中点的层次。(1) 深度优先遍历 —— 模板题 AcWing 846. 树的重心。// 表示1号点已经被遍历过。
深搜广搜概念
weixin_44091157的博客
05-31 371
广度优先搜索(BFS) 目的是系统地展开并检查图中的所有节点，它不考虑结果的可能位置，彻底地遍历整张图，直到找到结果为止。类似树的按层遍历，其过程为：首先访问初始点Vi，并将其标记为已访问过，接着访问Vi的所有未被访问过可到达的邻接点Vi1、Vi2……Vit，并均标记为已访问过，然后再按照Vi1、Vi2……Vit的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依此类推，直到图中...
深搜 vs 广搜
学IT的细胞膜的博客
03-19 570
深搜 vs 广搜
搜索（深搜&广搜）
zjh_2017的博客
03-11 516
我记得在遥远的2017年，我会敲的搜索也只有暴力枚举了。那个时候的我深搜刚会一丢丢，所以也只配切切水题，然而经常死循环RE那是肯定的。如今的我因为在多次比赛中都死于搜索，那就必须得认真磕一下了。 其实是这样的：我眼里认为的暴力就真的只是暴力，暴力无非就两种：枚举打表和模拟。然而在这么多次比赛后，我总能听到那些dalao在那边说，这道题么暴力可以拿多少多少分。我听了一脸懵逼。我怎么就一分都拿不到。...
六、深搜广搜
konghhhhh的博客
06-18 416
搜索，所谓的万能算法，搜出答案。搜索算法是利用计算机的高性能来有目的的穷举一个问题的部分或者所有的可能情况，从而求出问题的解。但是实际上，用搜索做题几乎是经常TLE的，这也并不是搜索不对，而是在搜的过程要加上一些剪枝，来精简优化。        搜索有两方法，深搜和广搜。        1、深搜 深搜过程用到了回溯思想，通俗讲深搜就是每当有多个选择时找到一条路，沿这条路一直向前走的同时，给自
浅谈深搜广搜
qq_52332769的博客
05-06 2816
深搜广搜深度优先搜索 Depth First Search(DFS)简介：基本思想：回溯法：深搜优缺点优点缺点分析算法的实际实现流程：算法举例例一： 深度优先搜索 Depth First Search(DFS) 简介： 深度优先搜索所遵循的搜索策略是尽可能“深”地搜索树。 基本思想： 为了求得问题的解，会将每一结点所有可能路径都走一遍，先选择某一种可能情况向前（子结点）探索，在探索过程中，一旦发现原来的选择不符合要求，就回溯至父亲结点(可认为是上一结点)重新选择另一结点，继续向前探索，如此反复进行，直
搜索——深搜+广搜
feiwatellily的博客
02-01 6163
搜索 蕴含递归的思想，通过不停的试探去寻求解 常用方法有：暴力的搜索、深搜（DFS）、广搜（BFS） 引入 像是图的遍历一样，按照某个规则去访问图中的所有顶点，且每个顶点只被访问一次。 深度优先遍历（DFS） 就是要走就先走完一整条路，再返回去走别的可能的路。 举个栗子： 它的顶点访问次序就是以下几种： V1>V2>V4>V8>V5>V3>V6>V7 V1>V2>V5>V8>V4>V3>V6>V7 V1>V2>V
图的深搜(DFS)和广搜(BFS)
yiluo9918的博客
07-31 1127
DFS和BFS广度优先搜索深度优先搜索 一般用G=(V,E)来表示图。经常用邻接矩阵或者邻接表来描述一副图。图的遍历算法，根据访问节点的顺序，可分为广度优先搜索（BFS）和深度优先搜索（DFS）。 广度优先搜索 访问顺序是：A -> C -> D -> F -> B -> G -> E /* * 广度优先搜索（类似于树的层次遍历） */ void Matr...
广搜与深搜
雪雪
05-28 1150
一、深搜 属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次； 深度优先遍历图的思想是，从图中某顶点v出发： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出...
深搜(dfs)和广搜(bfs)
R0Y0R的博客
12-11 1894
深搜(dfs)和广搜(bfs) 广搜可以用来解决最小路径问题和连通性问题 深搜可以解决连通性问题 实现方式 深搜用函数递归实现 广搜用队列实现 问题 输入地图判断连通性和最小路径，每次只能走上下左右，S为起点，T为终点，#为障碍物，.可以走，如以下地图： S… ###… … .###. …T. 深搜代码如下 #include <iostream> using namespace std; int n, m, sx, sy; char mmap[105][105]; int dir[4
c++ 图 深搜 广搜
08-29
- *1* *2* *3* [【C++】数据结构之深搜+广搜 经典题型](https://blog.csdn.net/weixin_64967734/article/details/124994451)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值