深搜广搜

最新推荐文章于 2024-03-19 22:58:15 发布
最新推荐文章于 2024-03-19 22:58:15 发布
阅读量326 收藏
点赞数 1
分类专栏： 暑期集训--算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuancijian/article/details/76589185
版权

我的心愿是世界和平！

深搜

有一个大小为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

yuancijian
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深搜与广搜
nodeee的博客
02-23 355
深搜 深搜是一种一条路走到黑，碰壁就倒退的算法。运用递归思想，如果到了不符合条件的节点就撤回一步，然后再选择另一条路走下去。如果这个节点的所有路径都走完了，再撤回一步。 //最简单的模板 int x[4]={0,1,0,-1}; int y[4]={1,0,-1,0};//上下左右四个方向走。也可以八个方向，这里我就不写了。 void dfs(int fx,int fy){//fx，fy是现在的...
深搜广搜概念
weixin_44091157的博客
05-31 315
广度优先搜索(BFS) 目的是系统地展开并检查图中的所有节点，它不考虑结果的可能位置，彻底地遍历整张图，直到找到结果为止。类似树的按层遍历，其过程为：首先访问初始点Vi，并将其标记为已访问过，接着访问Vi的所有未被访问过可到达的邻接点Vi1、Vi2……Vit，并均标记为已访问过，然后再按照Vi1、Vi2……Vit的次序，访问每一个顶点的所有未被访问过的邻接点，并均标记为已访问过，依此类推，直到图中...
搜索入门及深搜广搜演示
05-30
"搜索入门及深搜广搜演示" 搜索算法是一种常用的解决问题的方法，当我们面临着无法通过建立数学模型解决的问题时，搜索算法能够帮助我们找到解决方案。搜索算法可以分为两大类：深搜和广搜。深搜是一种基于回溯思想...
基于深搜和广搜实现北京市地铁线路搜索引擎
01-20
import requests import re import numpy as np import json import networkx as nx import matplotlib import matplotlib.pyplot as plt matplotlib.rcParams['font.sans-serif'] = ['SimHei'] ...
邻接表实现图的广搜和深搜(java模板）
04-14
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系。邻接表是图的一种常见存储方式，尤其适用于稀疏图（边的数量远小于顶点数量的平方）。本篇将详细介绍如何使用Java实现基于邻接表的图的广度...
图的实现及深搜和广搜
05-17
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系或连接。在这个主题中，我们将深入探讨如何使用链式存储结构实现图，并详细解释深度优先搜索（DFS）和广度优先搜索（BFS）这两种图遍历算法。...
图的数据结构深搜/广搜
06-03
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系或连接。在这个C++实现的项目中，我们关注的是图的深度优先搜索（DFS）和广度优先搜索（BFS）。这两种算法广泛应用于各种问题，如路径查找、...
深搜 vs 广搜
最新发布
学IT的细胞膜的博客
03-19 233
深搜 vs 广搜
搜索（深搜&广搜）
zjh_2017的博客
03-11 427
我记得在遥远的2017年，我会敲的搜索也只有暴力枚举了。那个时候的我深搜刚会一丢丢，所以也只配切切水题，然而经常死循环RE那是肯定的。如今的我因为在多次比赛中都死于搜索，那就必须得认真磕一下了。 其实是这样的：我眼里认为的暴力就真的只是暴力，暴力无非就两种：枚举打表和模拟。然而在这么多次比赛后，我总能听到那些dalao在那边说，这道题么暴力可以拿多少多少分。我听了一脸懵逼。我怎么就一分都拿不到。...
六、深搜广搜
konghhhhh的博客
06-18 308
搜索，所谓的万能算法，搜出答案。搜索算法是利用计算机的高性能来有目的的穷举一个问题的部分或者所有的可能情况，从而求出问题的解。但是实际上，用搜索做题几乎是经常TLE的，这也并不是搜索不对，而是在搜的过程要加上一些剪枝，来精简优化。        搜索有两方法，深搜和广搜。        1、深搜 深搜过程用到了回溯思想，通俗讲深搜就是每当有多个选择时找到一条路，沿这条路一直向前走的同时，给自
浅谈深搜广搜
qq_52332769的博客
05-06 2107
深搜广搜深度优先搜索 Depth First Search(DFS)简介：基本思想：回溯法：深搜优缺点优点缺点分析算法的实际实现流程：算法举例例一： 深度优先搜索 Depth First Search(DFS) 简介： 深度优先搜索所遵循的搜索策略是尽可能“深”地搜索树。 基本思想： 为了求得问题的解，会将每一结点所有可能路径都走一遍，先选择某一种可能情况向前（子结点）探索，在探索过程中，一旦发现原来的选择不符合要求，就回溯至父亲结点(可认为是上一结点)重新选择另一结点，继续向前探索，如此反复进行，直
搜索——深搜+广搜
feiwatellily的博客
02-01 5907
搜索 蕴含递归的思想，通过不停的试探去寻求解 常用方法有：暴力的搜索、深搜（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 927
DFS和BFS广度优先搜索深度优先搜索 一般用G=(V,E)来表示图。经常用邻接矩阵或者邻接表来描述一副图。图的遍历算法，根据访问节点的顺序，可分为广度优先搜索（BFS）和深度优先搜索（DFS）。 广度优先搜索 访问顺序是：A -> C -> D -> F -> B -> G -> E /* * 广度优先搜索（类似于树的层次遍历） */ void Matr...
广搜与深搜
雪雪
05-28 917
一、深搜 属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次； 深度优先遍历图的思想是，从图中某顶点v出发： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出...
深搜(dfs)和广搜(bfs)
R0Y0R的博客
12-11 1744
深搜(dfs)和广搜(bfs) 广搜可以用来解决最小路径问题和连通性问题 深搜可以解决连通性问题 实现方式 深搜用函数递归实现 广搜用队列实现 问题 输入地图判断连通性和最小路径，每次只能走上下左右，S为起点，T为终点，#为障碍物，.可以走，如以下地图： S… ###… … .###. …T. 深搜代码如下 #include <iostream> using namespace std; int n, m, sx, sy; char mmap[105][105]; int dir[4
广搜和深搜
08-22 1779
广搜（BFS）： 1找到的是第一条到达的最短路径                           2用队列实现 深搜（DFS）： 1可以把所有路径都找到。。。。                           2,可以用栈。。。。回溯概念。。
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...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值