算法专题学习之搜索

理想-

已于 2022-03-26 19:31:36 修改

阅读量538

点赞数

分类专栏：算法学习文章标签：算法深度优先广度优先

于 2022-02-08 19:00:53 首次发布

本文链接：https://blog.csdn.net/weixin_51624761/article/details/122827665

版权

算法学习专栏收录该内容

33 篇文章 5 订阅

订阅专栏

DFS之连通性模型

迷宫

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。

同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。

如果起点或者终点有一个不能通行(为#)，则看成无法办到。

注意：A、B不一定是两个不同的点。

输入格式
第1行是测试数据的组数 k ，后面跟着 k 组输入。

每组测试数据的第1行是一个正整数 n ，表示迷宫的规模是 n∗n 的。

接下来是一个 n∗n 的矩阵，矩阵中的元素为.或者#。

再接下来一行是 4 个整数 ha,la,hb,lb ，描述 A 处在第 ha 行, 第 la 列， B 处在第 hb 行, 第 lb 列。

注意到 ha,la,hb,lb 全部是从 0 开始计数的。

输出格式
k行，每行输出对应一个输入。

能办到则输出“YES”，否则输出“NO”。

数据范围
1≤n≤100

输入样例：

2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0

输出样例:

YES
NO

题目分析
本题目的是判断从起点能否到达终点，故只要有一条道路能到达重点即可，故不需要回溯（恢复现场），这与求路径总数，全排列不同，这两种都是要取得所有的结果，因此需要回溯。
题解

package ACwing.搜索;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 15:58
 */
public class _1112 {
    static int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
    static final int N = 110;
    static char[][] maze = new char[N][N];
    static boolean[][] vis = new boolean[N][N];
    static int sx, sy, ex, ey;
    static int n;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();
        for (int i = 0; i < k; i++) {
            n = scanner.nextInt();
            vis = new boolean[N][N];
            for (int j = 0; j < n; j++) {
                String str = scanner.next();
                scanner.nextLine();
                maze[j] = str.toCharArray();
            }
            sx = scanner.nextInt();
            sy = scanner.nextInt();
            ex = scanner.nextInt();
            ey = scanner.nextInt();
            if (dfs(sx, sy)) System.out.println("YES");
            else System.out.println("NO");
        }
    }

    static boolean dfs(int x, int y) {
        if (maze[x][y] == '#') return false;
        if (x == ex && y == ey) return true;
        vis[x][y] = true;
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i], b = y + dy[i];
            if (in(a, b) && !vis[a][b]) {
                if (dfs(a, b)) return true;//找到出口就返回
            }
        }
        return false;
    }

    static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < n;
    }
}

迷宫

题目描述

给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

输入格式
第一行N、M和T，N为行，M为列，T为障碍总数。第二行起点坐标SX,SY，终点坐标FX,FY。接下来T行，每行为障碍点的坐标。

输出格式
给定起点坐标和终点坐标，问每个方格最多经过1次，从起点坐标到终点坐标的方案总数。

输入输出样例
**输入 **

2 2 1
1 1 2 2
1 2

输出

说明/提示
【数据规模】
1≤N,M≤5

题目分析
本题目的是求路径总数要取得所有的结果，在搜索过程中需要不断回溯。

题解

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 13:30
 */
public class Main {
    static int[][] maze = new int[10][10];
    static int[][] der = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    static boolean[][] vis = new boolean[10][10];
    static int ans;
    static int n;
    static int m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t, sx, sy, fx, fy;
        n = scanner.nextInt();
        m = scanner.nextInt();
        t = scanner.nextInt();
        sx = scanner.nextInt();
        sy = scanner.nextInt();
        fx = scanner.nextInt();
        fy = scanner.nextInt();
        maze[sx][sy] = 1;//开始为1
        maze[fx][fy] = 3;//结束为3
        for (int i = 1; i <= t; i++) {
            int tx, ty;
            tx = scanner.nextInt();
            ty = scanner.nextInt();
            maze[tx][ty] = 2;//障碍为2
        }
        vis[sx][sy] = true;//起点标记走过
        dfs(sx, sy);
        System.out.println(ans);
    }

    public static void dfs(int x, int y) {
        if (maze[x][y] == 3) {
            ans++;
            return;
        }
        else {
            int tx, ty;
            for (int i = 0; i < 4; i++) {
                tx = x + der[i][0];
                ty = y + der[i][1];
                if(in(tx, ty) && !vis[tx][ty] && maze[x][y] != 2) {
                    vis[tx][ty] = true;//标记走过
                    dfs(tx,ty);
                    vis[tx][ty] = false;//回溯
                }
            }
        }
        
    }

    public static boolean in(int x, int y) {
        return x >= 1 && x <= n && y >= 1 && y <= m;
    }
}

FloodFill

1097池塘

题目描述
农夫约翰有一片 N∗M 的矩形土地。

最近，由于降雨的原因，部分土地被水淹没了。

现在用一个字符矩阵来表示他的土地。

每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。

现在，约翰想知道他的土地中形成了多少片池塘。

每组相连的积水单元格集合可以看作是一片池塘。

每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。

请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。

输入格式
第一行包含两个整数 N 和 M 。

接下来 N 行，每行包含 M 个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。

输出格式
输出一个整数，表示池塘数目。

数据范围
1≤N,M≤1000
输入样例：

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

输出样例：

题目分析
这是一个求连通块的问题，调用一次dfs算一个连通块，并将’W’换为’.’,计算调用了几次dfs，即有几个池塘。这种方法也可以判断一个图是否连通。

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 17:40
 */
public class Main {
    static final int N = 1005;
    static char[][] pool = new char[N][N];
    static int n, m;
    static int[] dx = {1, 0, -1, 0, 1, -1, 1, -1}, dy = {0, 1, 0, -1, 1, -1, -1, 1};//上 右 下 左 右下 左上 左下 右上
    static int ans;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            String str = scanner.next();//Java里无法直接输入字符
            pool[i] = str.toCharArray();
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (pool[i][j] == 'W') {
                    dfs(i, j);//出现积水开始搜索
                    ans++;//一次搜索说明有一个池塘
                }
            }
        }
        System.out.println(ans);
    }

    static void dfs(int x, int y) {
        pool[x][y] = '.';//走过的地方变为陆地
        for (int i = 0; i < 8; i++) {
            int xx = x + dx[i];
            int yy = y + dy[i];
            if (in(xx, yy) && pool[xx][yy] == 'W') {
                dfs(xx, yy);
            }
        }
    }

    static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}

剪枝优化

小猫爬山

翰翰和达达饲养了 N 只小猫，这天，小猫们要去爬山。

经历了千辛万苦，小猫们终于爬上了山顶，但是疲倦的它们再也不想徒步走下山了（呜咕>_<）。

翰翰和达达只好花钱让它们坐索道下山。

索道上的缆车最大承重量为 W，而 N 只小猫的重量分别是 C1、C2……CN。

当然，每辆缆车上的小猫的重量之和不能超过 W。

每租用一辆缆车，翰翰和达达就要付 1 美元，所以他们想知道，最少需要付多少美元才能把这 N 只小猫都运送下山？

输入格式
第 1 行：包含两个用空格隔开的整数，N 和 W。
第 2…N+1 行：每行一个整数，其中第 i+1 行的整数表示第 i 只小猫的重量 Ci。

输出格式
输出一个整数，表示最少需要多少美元，也就是最少需要多少辆缆车。

数据范围
1≤N≤18,
1≤Ci≤W≤108
输入样例：

输出样例：

题目分析
搜索过程其实是按照一种树的形状进行搜索的，剪枝顾名思义就是减去剪去树的枝干，从而提高运算效率。将猫放进车里有两种情况，一种是放到已有的车里，一种是新开一辆车，因此dfs里有两个参数，表示第几只小猫和第几辆车。
剪枝优化可以优化几个地方，当小车个数大于答案时，返回；所有的小猫都放进车里时，更新答案并返回；另外要先考虑小猫决策小的情况，小猫体重越大，所能选择的车就越少，因此要对数组进行从大到小的排序。

题解


#include<iostream>
#include<algorithm>
using namespace std;
const int N = 20;
int n, m;
int c[N], w[N];
int ans = N;
void dfs(int u, int k)
{
    if(k >= ans)return;
    if(u == n)
    {
        ans = k;
        return;
    }
    for(int i = 1; i <= k; i++)
    {
        if(w[i] + c[u] <= m)//不超重
        {
            w[i] += c[u];//放入第u只小猫
            dfs(u + 1, k);
            w[i] -= c[u];//回溯
        }
    }
    w[k + 1] += c[u];//将第u只小猫放入第k+1个车中
    dfs(u + 1, k + 1);
    w[k + 1] -= c[u];//回溯
}
int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i++)
    {
        cin >> c[i];
    }
    sort(c, c + n,greater<int>());//从大到小排序
    dfs(0, 0);
    cout << ans;
    return 0;
}

数的划分

题目描述
将整数 n分成 k 份，且每份不能为空，任意两个方案不相同（不考虑顺序）。

例如：n=7，k=3，下面三种分法被认为是相同的。

1,1,5;
1,5,1;
5,1,1.

问有多少种不同的分法。

输入格式
n,k （6<n≤200，2≤k≤6）

输出格式
1 个整数，即不同的分法。

输入输出样例

输入

7 3

输出

题目分析

这是一道标准的DFS题目，思路简单清晰，要求算出指定的一个数可以按照指定的份数分成几份。本题要求只要两个划分所包含的数字集合相同，即可看作一个分法。判断一个划分是否为按照要求的分法有两个要求。第一，划分出的数的个数等于k。第二，每个划分出的数集的和等于n。满足这两个条件即可看作一个分法，同时也是递归调用空操作返回的一个判定条件。

如果当一个数以及划分的数量都很大时，采用DFS会有很高的时间复杂度，递归调用次数太多也会有栈溢出的风险，在这里我们要使用剪枝。DFS执行期间会产生一棵搜索树，减去一些不重要的枝干从而提高计算效率这种策略，我们称之为剪枝。我们可以一开始就按递增顺序存，这样可以避免计算相同的分法。同时，若sum + i * (k - num) <= n，这样可以减少不必要的计算。

题解

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/9 15:06
 */
public class Main {
        static int ans;
        static int n ,k;
        public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                n = scanner.nextInt();
                k = scanner.nextInt();
                dfs(1,0,0);
                System.out.println(ans);
        }
        public static void dfs(int start, int sum, int num){
                if(num == k) {
                        if(sum == n)ans++;
                        return ;
                }
                for(int i = start; sum + i * (k - num) <= n; i++) {
                        dfs(i , sum + i, num + 1);
                }
        }
}

马的遍历

题目描述

有一个 n×m 的棋盘，在某个点 (x, y)上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式
输入只有一行四个整数，分别为 n, m, x, y。

输出格式
一个 n×m 的矩阵，代表马到达某个点最少要走几步（左对齐，宽 5格，不能到达则输出 -1）。

输入输出样例

输入

3 3 1 1

输出

0    3    2    
3    -1   1    
2    1    4

说明/提示

数据规模与约定

对于全部的测试点，保证 1 ≤ x ≤ n ≤ 400，1 ≤ y ≤ m ≤ 400。

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/3/25 15:01
 */
public class Main {
    static final int N = 405;
    static int[][] dir = {{-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}};
    static int n, m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        bfs(x, y);
    }

    public static void bfs(int x, int y) {
        int[][] dist = new int[N][N];
        for (int i = 1; i < N; i++) {
            Arrays.fill(dist[i], -1);
        }
        Queue<Point> q = new LinkedList<>();
        q.add(new Point(x, y));
        dist[x][y] = 0;
        while (!q.isEmpty()) {
            Point poll = q.poll();
            for (int i = 0; i < 8; i++) {
                int dx = poll.x + dir[i][0];
                int dy = poll.y + dir[i][1];
                if (dx >= 1 && dx <= n && dy >= 1 && dy <= m && dist[dx][dy] == -1) {
                    dist[dx][dy] = dist[poll.x][poll.y] + 1;
                    q.add(new Point(dx, dy));
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                System.out.printf("%-5d", dist[i][j]);
            }
            System.out.println();
        }
    }

    static class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

}

01迷宫

题目描述

有一个仅由数字0与1组成的n × n格迷宫。若你位于一格00上，那么你可以移动到相邻4格中的某一格1上，同样若你位于一格1上，那么你可以移动到相邻4格中的某一格0上。

你的任务是：对于给定的迷宫，询问从某一格开始能移动到多少个格子（包含自身）。

输入格式

第11行为两个正整数n,m。

下面n行，每行n个字符，字符只可能是0或者1，字符之间没有空格。

接下来m行，每行2个用空格分隔的正整数i，j，对应了迷宫中第i行第j列的一个格子，询问从这一格开始能移动到多少格。

输出格式

m行，对于每个询问输出相应答案。

输入输出样例

输入

输出

4
4

说明/提示

所有格子互相可达。

对于20%的数据，n≤10；

对于40%的数据，n≤50；

对于50%的数据，m≤5；

对于60%的数据，n≤100,m≤100；

对于100%的数据，n≤1000,m≤100000。

#include <iostream>
using namespace std;
const int N = 1005;
char maze[N][N];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int book[N][N];
struct point
{
    int x, y;
} q[1000005];
int n, m, sx, sy;
void bfs(int x, int y)
{
    int ans = 1, head = 0, tail = 0;
    q[tail].x = x;
    q[tail].y = y;
    book[x][y] = 1;
    tail++;
    while (head < tail)
    {
        for (int i = 0; i < 4; i++)
        {
            int tx = q[head].x + dx[i];
            int ty = q[head].y + dy[i];
            if (!(tx <= n && tx >= 1 && ty <= n && ty >= 1)) continue;
            if (book[tx][ty] == 0 && maze[q[head].x][q[head].y] != maze[tx][ty])
            {
                book[tx][ty] = 1;
                q[tail].x = tx;
                q[tail].y = ty;
                ans++;
                tail++;
            }
        }
        head++;
    }
    for (int i = 0; i < tail; i++)
    {
        book[q[i].x][q[i].y] = ans;
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= n; ++j)
            cin >> maze[i][j];
    }
    for (int i = 0; i < m; ++i)
    {
        cin >> sx >> sy;
        if (book[sx][sy] != 0) cout << book[sx][sy] << endl;
        else
        {
            bfs(sx, sy);
            cout << book[sx][sy] << endl;
        }
    }
    return 0;
}

理想-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
算法专题学习之搜索

DFS之连通性模型迷宫一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。注意：A、B不一定是两个不同的点。输入格式第1行是测试数据的组数 k ，后面跟着 k
复制链接

扫一扫