leetcode
leetcode 2551 ~ 2600
衣橱整理

衣橱整理

难度:

标签:

题目描述

English description is not available for the problem. Please switch to Chinese.

代码结果

运行时间: 76 ms, 内存: 15.5 MB


/*
 * Problem: Given an m x n grid representing a wardrobe, we need to count the number of cells that a cleaner can organize. The cleaner starts at grid[0][0] and can only move right or down. A cell can be organized only if the sum of the digits of the row index and the column index is less than or equal to cnt.
 *
 * Solution Approach using Java Stream API:
 * 1. Use a helper function to calculate the sum of the digits of a number.
 * 2. Use nested IntStream to iterate over each cell.
 * 3. Filter out cells that cannot be organized.
 * 4. Count the remaining cells.
 */

import java.util.stream.IntStream;

public class SolutionStream {
    public int digitSum(int x) {
        int sum = 0;
        while (x > 0) {
            sum += x % 10;
            x /= 10;
        }
        return sum;
    }

    public long organizeCells(int m, int n, int cnt) {
        return IntStream.range(0, m)
                .boxed()
                .flatMap(i -> IntStream.range(0, n)
                        .filter(j -> digitSum(i) + digitSum(j) <= cnt)
                        .boxed())
                .count();
    }

    public static void main(String[] args) {
        SolutionStream sol = new SolutionStream();
        System.out.println(sol.organizeCells(4, 7, 5)); // Output: 18
    }
}

解释

方法:

本题解采用深度优先搜索(DFS)的方法。从矩阵的左上角开始,递归地向右和向下进行搜索,同时跟踪已访问的节点以避免重复计算。搜索过程中,首先判断当前位置是否有效(即坐标在矩阵内,且各数位之和不超过给定的阈值k,且未被访问过),如果有效,则递归地探索当前位置的右侧和下方位置。每访问一个有效格子,就计算当前格子和其递归得到的格子数之和,最终返回总的可访问格子数。

时间复杂度:

O(m*n)

空间复杂度:

O(m*n)

代码细节讲解

🦆
为什么选择深度优先搜索(DFS)而不是广度优先搜索(BFS)来解决这个问题?
在解决路径搜索问题时,深度优先搜索(DFS)和广度优先搜索(BFS)各有优势。对于本题,DFS的优势在于实现简单,易于递归调用。DFS可以直接利用递归堆栈跟踪路径,而BFS则需要显式使用队列来存储未探索的节点。此外,DFS在遇到无效节点时可以立即回溯,这有助于减少不必要的计算和空间占用。虽然BFS也可以工作,但在这种情况下,DFS的空间和时间效率稍优,特别是在矩阵较大且阈值k较小导致可访问区域较小的情况下。
🦆
在实际实现中DFS如何确保不会因为递归过深而导致栈溢出?
为了防止递归过深导致栈溢出,通常需要对递归的深度进行控制。在本题中,递归的最大深度受到矩阵的大小和阈值k的限制。由于每次递归都需要满足数位和的条件,这通常限制了递归的深度。例如,当矩阵的尺寸很大但k非常小时,许多路径都会因为数位和过大而被剪枝,从而减少递归深度。此外,递归中还加入了检查是否已访问的逻辑,进一步减少不必要的递归调用。如果实际应用中仍担心栈溢出,可以考虑使用迭代的DFS实现,利用显式栈来模拟递归。
🦆
在计算数位之和的函数中,是否有更高效的方法,尤其是对于大矩阵中的较大数值?
在计算数位之和时,当前实现通过转换数字为字符串然后再进行迭代求和是有效的,但存在一定的性能开销。一个更高效的方法是直接使用数学计算:通过对数字连续使用除法和取模操作来提取每一位。例如,可以定义一个辅助函数,使用循环来提取每一位并累加。这种方法避免了字符串操作的开销,对于大数字或大矩阵更为高效。

相关问题