【算法思想·数组】二分搜索实战应用

已于 2024-08-25 21:47:59 修改
阅读量1k 收藏 30
点赞数 12
文章标签： 算法 数据结构 python java
于 2024-08-20 01:55:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Captain823Jack/article/details/141338341
版权

本文参考labuladong算法小抄[二分搜索运用技巧]

1、原始的二分搜索代码

二分搜索的原型就是在「有序数组」中搜索一个元素target，返回该元素对应的索引。

如果该元素不存在，那可以返回一个什么特殊值，这种细节问题只要微调算法实现就可实现。

还有一个重要的问题，如果「有序数组」中存在多个target元素，那么这些元素肯定挨在一起，这里就涉及到算法应该返回最左侧的那个target元素的索引还是最右侧的那个target元素的索引，也就是所谓的「搜索左侧边界」和「搜索右侧边界」，这个也可以通过微调算法的代码来实现。

在具体的算法问题中，常用到的是「搜索左侧边界」和「搜索右侧边界」这两种场景，很少有让你单独「搜索一个元素」。

因为算法题一般都让你求最值，比如让你求吃香蕉的「最小速度」，让你求轮船的「最低运载能力」，求最值的过程，必然是搜索一个边界的过程，所以后面我们就详细分析一下这两种搜索边界的二分算法代码。

求最值的过程，必然是搜索一个边界的过程，所以后面我们就详细分析一下这两种搜索边界的二分算法代码。

「搜索左侧边界」的二分搜索算法的具体代码实现如下：

// 搜索左侧边界
int left_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            // 当找到 target 时，收缩右侧边界
            right = mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    return left;
}

假设输入的数组nums = [1,2,3,3,3,5,7]，想搜索的元素target = 3，那么算法就会返回索引 2。

如果画一个图，就是这样：

图片

「搜索右侧边界」的二分搜索算法的具体代码实现如下：

// 搜索右侧边界
int right_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            // 当找到 target 时，收缩左侧边界
            left = mid + 1;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else if (nums[mid] > target) {
            right = mid;
        }
    }
    return left - 1;
}

输入同上，那么算法就会返回索引 4，如果画一个图，就是这样：

图片

2、二分搜索问题的泛化

什么问题可以运用二分搜索算法技巧？

首先，你要从题目中抽象出一个自变量x，一个关于x的函数f(x)，以及一个目标值target。

同时，x, f(x), target还要满足以下条件：

1、f(x)必须是在x上的单调函数（单调增单调减都可以）。

2、题目是让你计算满足约束条件f(x) == target时的x的值。

上述规则听起来有点抽象，来举个具体的例子：

给你一个升序排列的有序数组nums以及一个目标元素target，请你计算target在数组中的索引位置，如果有多个目标元素，返回最小的索引。

这就是「搜索左侧边界」这个基本题型，解法代码之前都写了，但这里面x, f(x), target分别是什么呢？

我们可以把数组中元素的索引认为是自变量x，函数关系f(x)就可以这样设定：

// 函数 f(x) 是关于自变量 x 的单调递增函数
// 入参 nums 是不会改变的，所以可以忽略，不算自变量
int f(int x, int[] nums) {
    return nums[x];
}

其实这个函数f就是在访问数组nums，因为题目给我们的数组nums是升序排列的，所以函数f(x)就是在x上单调递增的函数。

最后，题目让我们求什么来着？是不是让我们计算元素target的最左侧索引？

是不是就相当于在问我们「满足f(x) == target的x的最小值是多少」？

画个图，如下：

图片

如果遇到一个算法问题，能够把它抽象成这幅图，就可以对它运用二分搜索算法。

算法代码如下：

// 函数 f 是关于自变量 x 的单调递增函数
int f(int x, int[] nums) {
    return nums[x];
}

int left_bound(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int left = 0, right = nums.length;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (f(mid, nums) == target) {
            // 当找到 target 时，收缩右侧边界
            right = mid;
        } else if (f(mid, nums) < target) {
            left = mid + 1;
        } else if (f(mid, nums) > target) {
            right = mid;
        }
    }
    return left;
}

这段代码把之前的代码微调了一下，把直接访问nums[mid]套了一层函数f，其实就是多此一举，但是，这样能抽象出二分搜索思想在具体算法问题中的框架。

3、运用二分搜索的套路框架

【二分搜索实战思考框架】

// 函数 f 是关于自变量 x 的单调函数
int f(int x) {
    // ...
}

// 主函数，在 f(x) == target 的约束下求 x 的最值
int solution(int[] nums, int target) {
    if (nums.length == 0) return -1;
    // 问自己：自变量 x 的最小值是多少？
    int left = ...;
    // 问自己：自变量 x 的最大值是多少？
    int right = ... + 1;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (f(mid) == target) {
            // 问自己：题目是求左边界还是右边界？
            // ...
        } else if (f(mid) < target) {
            // 问自己：怎么让 f(x) 大一点？
            // ...
        } else if (f(mid) > target) {
            // 问自己：怎么让 f(x) 小一点？
            // ...
        }
    }
    return left;
}

具体来说，想要用二分搜索算法解决问题，分为以下几步：

1、确定x, f(x), target分别是什么，并写出函数f的代码。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

3、根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

4、实战

875. 爱吃香蕉的珂珂

【算法思路】

按步骤思考即可：

1、确定x, f(x), target分别是什么，并写出函数f的代码。

自变量x是什么呢？回忆之前的函数图像，二分搜索的本质就是在搜索自变量。

所以，题目让求什么，就把什么设为自变量，珂珂吃香蕉的速度就是自变量x。

那么，在x上单调的函数关系f(x)是什么？

显然，吃香蕉的速度越快，吃完所有香蕉堆所需的时间就越少，速度和时间就是一个单调函数关系。

所以，f(x)函数就可以这样定义：

若吃香蕉的速度为x根/小时，则需要f(x)小时吃完所有香蕉。

代码实现如下：

// 定义：速度为 x 时，需要 f(x) 小时吃完所有香蕉
// f(x) 随着 x 的增加单调递减
int f(int[] piles, int x) {
    int hours = 0;
    for (int i = 0; i < piles.length; i++) {
        hours += piles[i] / x;
        if (piles[i] % x > 0) {
            hours++;
        }
    }
    return hours;
}

target就很明显了，吃香蕉的时间限制H自然就是target，是对f(x)返回值的最大约束。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

珂珂吃香蕉的速度最小是多少？多大是多少？

显然，最小速度应该是 1，最大速度是piles数组中元素的最大值，因为每小时最多吃一堆香蕉，胃口再大也白搭嘛。

这里可以有两种选择，要么你用一个 for 循环去遍历piles数组，计算最大值，要么你看题目给的约束，piles中的元素取值范围是多少，然后给right初始化一个取值范围之外的值。

我选择第二种，题目说了1 <= piles[i] <= 10^9，那么我就可以确定二分搜索的区间边界：

public int minEatingSpeed(int[] piles, int H) {
    int left = 1;
    // 注意，right 是开区间，所以再加一
    int right = 1000000000 + 1;

    // ...
}

3、根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

现在我们确定了自变量x是吃香蕉的速度，f(x)是单调递减的函数，target就是吃香蕉的时间限制H，题目要我们计算最小速度，也就是x要尽可能小：

这就是搜索左侧边界的二分搜索嘛，不过注意f(x)是单调递减的，不要闭眼睛套框架，需要结合上图进行思考，写出代码：

【Java】

public int minEatingSpeed(int[] piles, int H) {
    int left = 1;
    int right = 1000000000 + 1;

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (f(piles, mid) <= H) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return left;
}

// f(x) 随着 x 的增加单调递减
int f(int[] piles, int x) {
    // 见上文
}

【Python】

class Solution:
    def minEatingSpeed(self, piles: List[int], h: int) -> int:
        '''
        数据结构：现有数组
        思路：
            1、二分搜索递减函数的左侧边界
            2、f(x)即消耗时间，x是吃香蕉的速度，target是h
        '''
        def timeNeeded(piles: List, v: int) -> int:
            res = 0
            for pile in piles:
                res += math.ceil(pile / v)
            return res

        piles.sort()
        left, right = 1, piles[-1]

        while left <= right:
            mid = left + (right - left) // 2
            if timeNeeded(piles, mid) > h:
                left = mid + 1
            else:
                right = mid - 1

        return left

1011. 在 D 天内送达包裹的能力

传送带上的包裹必须在 days 天内从一个港口运送到另一个港口。

传送带上的第 i 个包裹的重量为 weights[i]。每一天，我们都会按给出重量（weights）的顺序往传送带上装载包裹。我们装载的重量不会超过船的最大运载重量。

返回能在 days 天内将传送带上的所有包裹送达的船的最低运载能力。

示例 1：

输入：weights = [1,2,3,4,5,6,7,8,9,10], days = 5
输出：15
解释：
船舶最低载重 15 就能够在 5 天内送达所有包裹，如下所示：
第 1 天：1, 2, 3, 4, 5
第 2 天：6, 7
第 3 天：8
第 4 天：9
第 5 天：10

请注意，货物必须按照给定的顺序装运，因此使用载重能力为 14 的船舶并将包装分成 (2, 3, 4, 5), (1, 6, 7), (8), (9), (10) 是不允许的。

示例 2：

输入：weights = [3,2,2,4,1,4], days = 3
输出：6
解释：
船舶最低载重 6 就能够在 3 天内送达所有包裹，如下所示：
第 1 天：3, 2
第 2 天：2, 4
第 3 天：1, 4

示例 3：

输入：weights = [1,2,3,1,1], days = 4
输出：3
解释：
第 1 天：1
第 2 天：2
第 3 天：3
第 4 天：1, 1

提示：

  • 1 <= days <= weights.length <= 5 * 104
  • 1 <= weights[i] <= 500

【算法思路】

1、确定x, f(x), target分别是什么，并写出函数f的代码。

题目问什么，什么就是自变量，也就是说船的运载能力就是自变量x。

运输天数和运载能力成反比，所以可以让f(x)计算x的运载能力下需要的运输天数，那么f(x)是单调递减的。

函数f(x)的实现如下：

// 定义：当运载能力为 x 时，需要 f(x) 天运完所有货物
// f(x) 随着 x 的增加单调递减
int f(int[] weights, int x) {
    int days = 0;
    for (int i = 0; i < weights.length; ) {
        // 尽可能多装货物
        int cap = x;
        while (i < weights.length) {
            if (cap < weights[i]) break;
            else cap -= weights[i];
            i++;
        }
        days++;
    }
    return days;
}

对于这道题，target显然就是运输天数D，我们要在f(x) == D的约束下，算出船的最小载重。

2、找到x的取值范围作为二分搜索的搜索区间，初始化left和right变量。

船的最小载重是多少？最大载重是多少？

显然，船的最小载重应该是weights数组中元素的最大值，因为每次至少得装一件货物走，不能说装不下嘛。

最大载重显然就是weights数组所有元素之和，也就是一次把所有货物都装走。

这样就确定了搜索区间[left, right)：

public int shipWithinDays(int[] weights, int days) {
    int left = 0;
    // 注意，right 是开区间，所以额外加一
    int right = 1;
    for (int w : weights) {
        left = Math.max(left, w);
        right += w;
    }

    // ...
}

3、需要根据题目的要求，确定应该使用搜索左侧还是搜索右侧的二分搜索算法，写出解法代码。

现在我们确定了自变量x是船的载重能力，f(x)是单调递减的函数，target就是运输总天数限制D，题目要我们计算船的最小载重，也就是x要尽可能小：

图片

【Java】

public int shipWithinDays(int[] weights, int days) {
    int left = 0;
    int right = 1;
    for (int w : weights) {
        left = Math.max(left, w);
        right += w;
    }

    while (left < right) {
        int mid = left + (right - left) / 2;
        if (f(weights, mid) <= days) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }

    return left;
}

int f(int[] weights, int x) {
    int days = 0;
    for (int i = 0; i < weights.length; ) {
        // 尽可能多装货物
        int cap = x;
        while (i < weights.length) {
            if (cap < weights[i]) break;
            else cap -= weights[i];
            i++;
        }
        days++;
    }
    return days;
}

【Python】

class Solution:
    def shipWithinDays(self, weights: List[int], days: int) -> int:
        '''
        数据结构：数组本身
        思路：
            1、二分搜索，对应的f(x)是所需天数,x是每天运载能力，target是days
            2、l = max(weights), r = sum(weights)
        '''
        def daysNeeded(weights: List, capability: int) -> int:
            days = 0
            i = 0
            size = len(weights)
            # 外层while遍历weights
            while i < size:
                cap = capability
                # 内层while旨在尽可能多装货物
                while i < size:
                    if cap < weights[i]:
                        break
                    else:
                        cap -= weights[i]
                    i += 1
                days += 1
            return days

        left = max(weights)
        right = sum(weights)

        while left <= right:
            mid = left + (right - left) // 2
            if daysNeeded(weights, mid) <= days:
                right = mid - 1
            elif daysNeeded(weights, mid) > days:
                left = mid + 1

        return left

410. 分割数组的最大值

【Python】

class Solution:
    '''
    数据结构：数组本身
    思路：【经典二分搜索】
        1、本题与运载货物那题本质一模一样
        2、k是运货所需天数，最大和即为运载能力capacity，nums即为待运输的货物
    '''
    def splitArray(self, nums: List[int], k: int) -> int:
        # 构造处理数组最大值并返回对应数组个数的函数
        # 函数横轴x代表分割后数组的最大和，纵轴f(x)代表可分割成几个子数组
        def getMax(nums: List, m: int) -> int:
            res = 0
            i = 0
            while i < len(nums):
                # 每次进循环即将最大容量m赋予cap
                cap = m
                # 尽可能多容纳数组里的元素
                while i < len(nums):
                    if cap < nums[i]:
                        break
                    else:
                        cap -= nums[i]
                    i += 1
                res += 1
            return res
        # left即所有元素各分一组，此时最大和自然是max(nums)
        # right即原数组即为子数组，此时最大和自然是sum(nums)
        left, right = max(nums), sum(nums)

        while left <= right:
            mid = left + (right - left) // 2
            if getMax(nums, mid) <= k:
                right = mid - 1
            else:
                left = mid + 1

        return left

【算法思路】

这个题目有点类似前文一道经典动态规划题目 高楼扔鸡蛋，题目比较绕，又是最大值又是最小值的。

简单说，给你输入一个数组nums和数字m，你要把nums分割成m个子数组。

肯定有不止一种分割方法，每种分割方法都会把nums分成m个子数组，这m个子数组中肯定有一个和最大的子数组对吧。

我们想要找一个分割方法，该方法分割出的最大子数组和是所有方法中最大子数组和最小的。

请你的算法返回这个分割方法对应的最大子数组和。

我滴妈呀，这个题目看了就觉得难的不行，完全没思路，这题怎么运用我们之前说套路，转化成二分搜索呢？

其实，这道题和上面讲的运输问题是一模一样的，不相信的话我给你改写一下题目：

你只有一艘货船，现在有若干货物，每个货物的重量是nums[i]，现在你需要在m天内将这些货物运走，请问你的货船的最小载重是多少？

这不就是刚才我们解决的力扣第 1011 题「在 D 天内送达包裹的能力」吗？

货船每天运走的货物就是nums的一个子数组；在m天内运完就是将nums划分成m个子数组；让货船的载重尽可能小，就是让所有子数组中最大的那个子数组元素之和尽可能小。

所以这道题的解法直接复制粘贴运输问题的解法代码即可。

Captain823Jack
关注
  • 12
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二分搜索算法通解框架
东
05-02 517
文章介绍了二分搜索最常见的几个场景的使用：寻找一个数、寻找左侧边界以及寻找右侧边界。阅读本文只需读者了解二分搜索的使用限制和基本原理即可。
二分K-mean均值算法原理讲解和代码实战
梁先森的博客
04-26 1584
二分K-mean均值算法原理讲解和代码实战
【算法面试】二分查找：如何在有序数组中高效搜索目标值
小明的Java问道之路
06-24 3958
二分查找是一种高效的查找算法，其时间复杂度为O(log n)，非常适用于大规模有序数组的查找任务。通过本文展示的多种实现方法，你可以灵活选择适合自己场景的实现方式。此外，理解并掌握二分查找的基本原理和细节，将会对提升你的编码能力和解决问题的效率大有裨益。希望这些方法能够帮助你顺利解决问题，确保程序顺利运行。！！博主v：XiaoMing_Java嗨，大家好，我是小 明（小明java问道之路），
算法-算法思想：二分查找的魅力与智慧
master_chenchen的博客
07-06 780
二分查找，一种在有序数组中查找特定元素的高效算法，其核心思想是通过不断将搜索区间减半，逐步缩小目标范围，直至找到目标元素或确定目标不存在。与线性查找相比，二分查找的时间复杂度仅为O(log n)，极大地提升了查找效率。
【Java算法】二分查找 下
2302_79806056的博客
07-09 1344
段代码实现了一个查找山峰数组中峰值索引的算法。山峰数组是一个先递增后递减的数组，即存在一个索引 使得对于所有的 ，有 ，且对于所有的 ，有 。这个索引 就是峰值的索引。 算法使用了二分查找(Binary Search)的方法来寻找峰值索引。其核心思想是在数组中寻找拐点（即峰值），在该点左侧的值小于右侧的值，在右侧则相反。由于数组是先升后降的，这个拐点就是我们所要找的峰值。具体分析如下：初始化两个指针 和 ，分别指
滚雪球学Java(33)：数组算法大揭秘：应用案例实战分享
**My Coding Family**
09-21 123
🏆本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，助你一臂之力，带你早日登顶🚀，欢迎大家关注&&收藏！持续更新中，up！up！up！！
一个几乎全民都会的算法——二分查找
汉阳Hann's Home
04-05 3558
20年前央视2套有一档叫《幸运52》的综艺节目，其中一个环节叫《幸运超市》，每一期主持人都会给佳宾们出示几个商品，凡是佳宾猜中价格的，就能获赠这件商品。这档节目红极一时，被很多地方卫视节目复制抄袭。
【面试高频算法解析】算法练习1 二分查找
sinat_41883985的博客
01-03 1236
本专栏旨在通过分类学习算法，使您能够牢固掌握不同算法的理论要点。通过策略性地练习精选的经典题目，帮助您深度理解每种算法，避免出现刷了很多算法题，还是一知半解的状态。
【Java算法】二分查找 上
2302_79806056的博客
07-08 1045
二分查找适用于任何已排序的数据集合，如数组、列表等。它不适用于无序的数据结构，因为在这种情况下，算法无法保证每次都能将搜索空间减半。此外，二分查找也可以扩展用于查找特定条件下的元素，例如查找目标值的最左侧位置或最右侧位置，或者在没有精确匹配的情况下找到最近的元素。
算法面试通关40讲完整课件 35-36 二分查找
07-06
二分查找，也称为折半查找，是一种在有序数组中查找特定元素的搜索算法。它的基本思想是将数组分成两半，每次都比较中间元素与目标值，根据比较结果决定是在左半部分还是右半部分继续查找，直到找到目标元素或者搜索...
减治思想——二分查找详细总结
「 虚幻私塾」
04-23 853
🚀 优质资源分享 🚀 学习路线指引（点击解锁） 知识定位 人群定位 🧡 Python实战微信订餐小程序 🧡 进阶级 本课程是python flask+微信小程序的完美结合，从项目搭建到腾讯云部署上线，打造一个全栈订餐系统。 💛Python量化交易实战💛 入门级 手把手带你打造一个易扩展、更安全、效率更高的量化交易系统 减治思想——二分查找详细总结 二分查找应用于有序数组，可以在以O(log(n))O(log⁡(n))O(\log(n))时间复杂度进行查找。其思想在于利用数组的有序性直
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 635
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 124
所谓的递归其实就是函数自己调用自己的情况。
力扣（无重叠区间）
yyssas的博客
08-29 62
先按照左侧数字排序，然后对于i位置和i+1位置，如果i位置右侧数字大于i+1位置左侧数字，则说明这两个区间有重叠，则需要移除更可能和后面重叠的那一个，因为排序是按照左边从小到大排序的，所以左边一定是小的，此时要关注的就是右边，也就是选择i和i+1右侧更小的那个，即右侧大的那个删除。一直到右侧小于k的左侧停止，此时剩下的一定是不会重叠的那个。需要移除区间的最小数量，使剩余区间互不重叠。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 311
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
C语言刷题日记(附详解)(2)
ixiaotang_的博客
08-24 3416
你所厌恶的今天，是昨天死去之人奢望的明天。你所浪费的现在，是未来的你回不去的曾经。时间如此宝贵，作为学生，学习就是我们的职责，那么不要懈怠！让我们开始今天的学习吧！
字节跳动（社招）三面算法原题
最新发布
宫水三叶的刷题日记
08-29 442
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
【数据结构-二维前缀和】【含空间优化】力扣3070. 元素和小于等于 k 的子矩阵的数目
sjsjs11的博客
08-29 135
col_sum[j]在遍历行的时候，也会依次计算该列的元素和，要计算前缀和s，实际上就是目前该列的元素和逐列累加，当发现s大于k的时候，那么就停止该行接下来的前缀和，继续计算下一行第一列开始的前缀和，继续遍历行的某个位置的前缀和。这种方法就是传统的前缀和做法，在这道题中，如果group[i][j]小于k，则继续遍历，然后count增加，如果group[i][j]大于k，说明不需要继续遍历这一行接下来列的前缀和了，直接开始计算新一行每一列的前缀和。返回包含 grid 左上角元素、元素和小于或等于 k 的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值