算法专题学习之搜索

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

说明/提示
【数据规模】
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.

输出样例:

3

题目分析
这是一个求连通块的问题,调用一次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
输入样例:

5 1996
1
2
1994
12
29

输出样例:

2

题目分析
搜索过程其实是按照一种树的形状进行搜索的,剪枝顾名思义就是减去剪去树的枝干,从而提高运算效率。将猫放进车里有两种情况,一种是放到已有的车里,一种是新开一辆车,因此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

输出

4

题目分析

这是一道标准的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行,对于每个询问输出相应答案。

输入输出样例

输入

2 2
01
10
1 1
2 2

输出

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
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值