【dfs】蓝桥杯-剪格子

本文介绍了一道编程题目,涉及将3x3的整数矩阵分割成两个数字和相等的部分,从左上角开始,寻找包含最小单元格数的分割方案。通过深度优先搜索(DFS)实现,给出了AC代码,并分享了思路和样例输入输出。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

问题描述

如下图所示,3 x 3 的格子中填写了一些整数。

+--*--+--+
|10* 1|52|
+--****--+
|20|30* 1|
*******--+
| 1| 2| 3|
+--+--+--+

我们沿着图中的星号线剪开,得到两个部分,每个部分的数字和都是60。

本题的要求就是请你编程判定:对给定的m x n 的格子中的整数,是否可以分割为两个部分,使得这两个区域的数字和相等。

如果存在多种解答,请输出包含左上角格子的那个区域包含的格子的最小数目。

如果无法分割,则输出 0。

输入格式

程序先读入两个整数 m n 用空格分割 (m,n<10)。

表示表格的宽度和高度。

接下来是n行,每行m个正整数,用空格分开。每个整数不大于10000。

输出格式

输出一个整数,表示在所有解中,包含左上角的分割区可能包含的最小的格子数目。

样例输入1

3 3
10 1 52
20 30 1
1 2 3

样例输出1

3

样例输入2

4 3
1 1 1 1
1 30 80 2
1 1 1 100

样例输出2

10

题意

RT,从左上角开始问是否有一种连续的分割方法把整个图划分为图内所有点权值之和相等的两个区域的方法,要求从左上角开始的连续区块数最小。

思路

dfs

AC代码

得分	100
CPU使用	0ms
内存使用	1.0MB

后台数据真的弱。。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <queue>
#include <bitset>
#include <stack>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
typedef long double ld;
#define mp make_pair
const int maxn = 106;
int a[maxn][maxn];
int vis[maxn][maxn];
int ans = 0x3f3f3f3f;
int SUM;
int n, m;
bool judge(int x, int y)
{
    if (vis[x][y] == 1 || x >= n || x < 0 || y >= m || y < 0)
        return false;
    return true;
}
void dfs(int temp, int x, int y, int sum)
{

    if (sum == SUM / 2 && temp < ans)
    {
        ans = temp;
        return;
    }
    else if (sum < SUM / 2)
    {
        //printf("%d %d %d\n", x, y, sum);
        vis[x][y] = 1;
        temp++;
        sum += a[x][y];
        if (judge(x + 1, y))
            dfs(temp, x + 1, y, sum);
        if (judge(x - 1, y))
            dfs(temp, x - 1, y, sum);
        if (judge(x, y + 1))
            dfs(temp, x, y + 1, sum);
        if (judge(x, y - 1))
            dfs(temp, x, y - 1, sum);
        temp--;
        vis[x][y] = 0;
        sum -= a[x][y];
    }
}
int main(void)
{

    scanf("%d%d", &m, &n);
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            scanf("%d", &a[i][j]);
            SUM += a[i][j];
        }
    }
    //cout << SUM << endl;
    dfs(0, 0, 0, 0);
    if (ans != 0x3f3f3f3f)
        printf("%d\n", ans);
    else
        puts("0");
    system("pause");
    return 0;
}

后记

创作于:2019-02-05
更新于:2021-10-14

### 关于蓝桥杯竞赛中的 Java DFS 解法 在蓝桥杯竞赛中,深度优先搜索(DFS)是一种常见的算法技术,用于解决许多复杂问题。以下是基于题目描述以及相关引用内容整理的一个典型 DFS 示例及其应用。 #### 1. **DFS 的基本概念** 深度优先搜索 (Depth First Search, DFS) 是一种遍历或搜索树或算法。该算法会尽可能深地探索每一个分支,在遇到无法继续前进的情况时回溯到上一层节点并尝试其他路径[^2]。 --- #### 2. **蓝桥杯 DFS 题目示例** 假设有一道典型的蓝桥杯题目如下: > 给定一个 n×m 的网格地,其中某些格子是障碍物 (&#39;#&#39;),其余为空白 (&#39;.&#39;)。从起点出发,求能够到达终点的最大步数。每次移动只能上下左右四个方向之一,并且不能穿过障碍物。 此问题可以通过 DFS 来实现。下面是一个完整的解决方案。 --- #### 3. **Java 实现代码** ```java import java.util.Scanner; public class BlueBridgeCupDFS { static int[][] directions = { {-1, 0}, {1, 0}, {0, -1}, {0, 1} }; // 上下左右 static boolean[][] visited; static char[][] grid; static int maxSteps = 0; // 记录最大步数 public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); // 行数 int m = sc.nextInt(); // 列数 grid = new char[n][]; visited = new boolean[n][m]; for (int i = 0; i < n; i++) { grid[i] = sc.next().toCharArray(); } dfs(0, 0, 0); // 假设从左上角 (0, 0) 开始 System.out.println(maxSteps); sc.close(); } private static void dfs(int row, int col, int steps) { if (row < 0 || row >= grid.length || col < 0 || col >= grid[row].length || grid[row][col] == &#39;#&#39; || visited[row][col]) { return; // 边界条件或者已经访问过 } visited[row][col] = true; // 标记当前点已访问 maxSteps = Math.max(maxSteps, steps + 1); // 更新最大步数 for (int[] dir : directions) { int newRow = row + dir[0]; int newCol = col + dir[1]; dfs(newRow, newCol, steps + 1); // 向四周扩展 } visited[row][col] = false; // 回溯,恢复状态 } } ``` 上述代码实现了通过 DFS 寻找从起点到任意可达位置的最大步数的功能。核心逻辑在于递归调用 `dfs` 方法来逐步深入探索可能的路径,并利用回溯机制确保每条路径都被充分考虑。 --- #### 4. **优化与注意事项** - **枝操作**:为了提高效率,可以在特定条件下提前终止不必要的递归过程。例如,当发现某条路径不可能优于已有最优解时即可停止进一步计算。 - **记忆化存储**:对于重复访问的状态,可以引入缓存机制减少冗余运算量。这通常适用于动态规划与 DFS 结合使用的场景[^3]。 - **边界处理**:务必仔细检查输入数据范围及特殊测试样例,比如全为障碍物的地等情况。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

两米长弦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值