【算法专题】K倍区间问题

最新推荐文章于 2024-01-08 13:49:39 发布
最新推荐文章于 2024-01-08 13:49:39 发布
阅读量1.1k 收藏 8
点赞数 2
分类专栏： 算法专题 文章标签： 前缀和 哈希表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/118567154
版权

K倍区间问题

1. 概述

  • 一般会让求解满足条件的区间的个数，或者满足条件的区间的位置，或者满足条件的最长区间长度。

  • 需要满足的条件可能是：

    • （1）区间和是K的倍数；

    • （2）区间和等于K；

    • （3）序列是一个01序列，区间中0的个数等于1的个数。

2. 例题

AcWing 1230. K倍区间

问题描述

在这里插入图片描述

分析

  • 求出原数组的前缀和数组s，如果一个区间[j...i]中的数据是k的倍数，则有(s[i] - s[j - 1]) % k == 0。

  • 因此当我们考虑s[i]时，我们找到s[0...i-1]中有多少数和s[i]模k同余，将结果加到答案中即可。

代码

  • C++
#include <iostream>

using namespace std;

typedef long long LL;
const int N = 100010;

int n, k;
LL s[N];
int cnt[N];

int main() {
    
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    
    LL res = 0;
    cnt[0]++;
    for (int i = 1; i <= n; i++) {
        res += cnt[s[i] % k];
        cnt[s[i] % k]++;
    }
    
    printf("%lld\n", res);
    
    return 0;
}

扩展：输出所有满足条件的区间

#include <iostream>
#include <unordered_map>
#include <set>
#include <vector>

using namespace std;

typedef long long LL;
const int N = 100010;

int n, k;
LL s[N];
unordered_map<int, set<int>> pos;  // s[i]%k的值，位置

int main() {
    
    scanf("%d%d", &n, &k);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &s[i]);
        s[i] += s[i - 1];
    }
    
    // 输出所有倍数是k的区间的起始位置，数组下标从1开始
    pos[0] = {0};
    for (int i = 1; i <= n; i++) {
        if (pos.count(s[i] % k)) {
            for (auto p : pos[s[i] % k])
                cout << p + 1 << ' ' << i << endl;
        }
        pos[s[i] % k].insert(i);
    }
    
    return 0;
}

Leetcode 0523 连续的子数组和

题目描述：Leetcode 0523 连续的子数组和

在这里插入图片描述

分析

  • 本题的考点：前缀和、哈希表。

  • 首先求出原数组的前缀和数组s，对于某个s[i]，我们希望判断 sum[i] - sum[i-2], sum[i] - sum[i-3], ... , sum[i] - sum[0] 是否存在k的倍数即可。相当于判断sum[i]和sum[k]是否同余即可(0<= k <=i-2)，可以使用哈希表。

代码

  • C++
class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];

        unordered_set<int> hash;  // 存储余数
        for (int i = 2; i <= n; i++) {
            hash.insert(s[i - 2] % k);
            if (hash.count(s[i] % k)) return true;
        }
        return false;
    }
};

class Solution {
public:
    bool checkSubarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];

        unordered_set<int> hash;  // 存储余数
        hash.insert(0);
        for (int i = 2; i <= n; i++) {
            if (hash.count(s[i] % k)) return true;
            hash.insert(s[i - 1] % k);
        }
        return false;
    }
};
  • Java
class Solution {
    public boolean checkSubarraySum(int[] nums, int k) {
        int n = nums.length;
        int[] s = new int[n + 1];
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
        HashSet<Integer> hash = new HashSet<>();
        for (int i = 2; i <= n; i++) {
            hash.add(s[i - 2] % k);
            if (hash.contains(s[i] % k)) return true;
        }
        return false;
    }
}
  • Python
class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        n = len(nums)
        s = [0 for _ in range(n + 1)]
        for i in range(1, n + 1):
            s[i] = s[i - 1] + nums[i - 1]
        hash = set()
        for i in range(2, n + 1):
            hash.add(s[i - 2] % k)
            if s[i] % k in hash:
                return True
        return False

时空复杂度分析

  • 时间复杂度： O ( n ) O(n) O(n)，n为数组长度。

  • 空间复杂度： O ( n ) O(n) O(n)。

Leetcode 0525 连续数组

题目描述：Leetcode 0525 连续数组

在这里插入图片描述

分析

  • 本题的考点：前缀和、哈希表。

  • 本题类似于Leetcode 0523 连续的子数组和。

  • 我们使用s[i]表示num[0...i-1]中1的个数减去0的个数，对于某个 i，寻找 sum[i] - sum[i-1], sum[i] - sum[i-2], ... , sum[i] - sum[0]中值为0的最小下标，更新结果。可以使用哈希表。

  • 实际上，数组s并不需要开出来，用一个变量记录当前的前缀和即可。

代码

  • C++
class Solution {
public:
    int findMaxLength(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int, int> hash;  // (1的个数减去0的个数，最小下标)
        hash[0] = 0;
        int res = 0;
        for (int i = 1, one = 0, zero = 0; i <= n; i++) {
            int x = nums[i - 1];
            if (x == 0) zero++;
            else one++;
            int s = one - zero;
            if (hash.count(s)) res = max(res, i - hash[s]);
            else hash[s] = i;
        }
        return res;
    }
};
  • Java
class Solution {
    public int findMaxLength(int[] nums) {
        int n = nums.length;
        HashMap<Integer, Integer> hash = new HashMap<>();  // (sum[i], sum[i]出现的最小下标i)
        hash.put(0, 0);  // sum[0] = 0
        int res = 0;
        for (int i = 1, one = 0, zero = 0; i <= n; i++) {
            int num = nums[i - 1];
            if (num == 0) zero++;
            else one++;
            int s = one - zero;  // s[i]
            if (hash.containsKey(s)) res = Math.max(res, i - hash.get(s));
            else hash.put(s, i);
        }
        return res;
    }
}
  • Python
class Solution:
    def findMaxLength(self, nums: List[int]) -> int:
        n = len(nums)
        hash = {}
        hash[0] = 0
        res = 0; zero = 0; one = 0
        for i in range(1, n + 1):
            x = nums[i - 1]
            if x == 0:
                zero += 1
            else:
                one += 1
            s = one - zero
            if s in hash:
                res = max(res, i - hash[s])
            else:
                hash[s] = i
        return res

时空复杂度分析

  • 时间复杂度： O ( n ) O(n) O(n)，n为数组长度。

  • 空间复杂度： O ( n ) O(n) O(n)。

Leetcode 0560 和为K的子数组

题目描述：Leetcode 0560 和为K的子数组

在这里插入图片描述

分析

  • 本题的考点：前缀和、哈希表。

  • 我们使用数组s表示nums的前缀和，当我们考虑s[i]时，我们希望找到存在多少个j，使得s[i]-s[j-1]=k，其中1<=j<=i，相当于让我们找到存在多少个s[i]-k，因此可以使用哈希表记录前面数据出现的次数即可。

  • 本题有两个扩展方向，可以扩展成多维，例如二维，对应Leetcode 1074 元素和为目标值的子矩阵数量。还可以在树上扩展，对应Leetcode 0437 路径总和 III。

代码

  • C++
class Solution {
public:
    int subarraySum(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
        unordered_map<int, int> hash;  // (数据，出现次数)
        int res = 0;
        for (int i = 0; i <= n; i++) {
            res += hash[s[i] - k];
            hash[s[i]]++;
        }
        return res;
    }
};
  • Java
class Solution {
    public int subarraySum(int[] nums, int k) {
        int n = nums.length;
        int[] s = new int[n + 1];
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
        HashMap<Integer, Integer> hash = new HashMap<>();
        int res = 0;
        for (int i = 1; i <= n; i++) {
            hash.put(s[i - 1], hash.getOrDefault(s[i - 1], 0) + 1);
            res += hash.getOrDefault(s[i] - k, 0);
        }
        return res;
    }
}
  • Python
class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        n = len(nums)
        s = [0 for _ in range(n + 1)]
        for i in range(1, n + 1):
            s[i] = s[i - 1] + nums[i - 1]
        hash = {}
        hash[0] = 1
        res = 0
        for i in range(1, n + 1):
            if s[i] - k in hash:
                res += hash[s[i] - k]
            if s[i] in hash:
                hash[s[i]] += 1
            else:
                hash[s[i]] = 1
        return res

时空复杂度分析

  • 时间复杂度： O ( n ) O(n) O(n)，n为数组长度。

  • 空间复杂度： O ( n ) O(n) O(n)。

Leetcode 0930 和相同的二元子数组

题目描述：Leetcode 0930 和相同的二元子数组

在这里插入图片描述

分析

代码

  • C++
class Solution {
public:
    int numSubarraysWithSum(vector<int>& nums, int goal) {
        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];

        int res = 0;
        unordered_map<int, int> cnt;
        for (int i = 1; i <= n; i++) {
            cnt[s[i - 1]]++;
            res += cnt[s[i] - goal];
        }
        return res;
    }
};
  • Java
class Solution {
    public int numSubarraysWithSum(int[] nums, int goal) {
        int n = nums.length;
        int[] s = new int[n + 1];
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];

        int res = 0;
        HashMap<Integer, Integer> cnt = new HashMap<>();
        for (int i = 0; i <= n; i++) {
            res += cnt.getOrDefault(s[i] - goal, 0);
            cnt.put(s[i], cnt.getOrDefault(s[i], 0) + 1);
        }
        return res;
    }
}
  • Python
class Solution:
    def numSubarraysWithSum(self, nums: List[int], goal: int) -> int:
        n = len(nums)
        s = [0 for _ in range(n + 1)]
        for i in range(1, n + 1):
            s[i] = s[i - 1] + nums[i - 1]
        
        res = 0
        cnt = {}
        for i in range(1, n + 1):
            if s[i - 1] not in cnt:
                cnt[s[i - 1]] = 0
            cnt[s[i - 1]] += 1
            if s[i] - goal in cnt:
                res += cnt[s[i] - goal]
        return res

时空复杂度分析

  • 时间复杂度： O ( n ) O(n) O(n)，n为数组长度。

  • 空间复杂度： O ( n ) O(n) O(n)。

Leetcode 1074 元素和为目标值的子矩阵数量

题目描述：Leetcode 1074 元素和为目标值的子矩阵数量

在这里插入图片描述

分析

  • 本题的考点：前缀和、哈希表。

  • 我们枚举子矩阵的上下边界，并计算出该边界内每列的元素和，则原问题转换成了如下一维问题：给定一个整数数组和一个整数target，计算该数组中子数组和等于 target 的子数组个数。对应Leetcode 0560 和为K的子数组问题。

代码

  • C++
class Solution {
public:
    // Leetcode 0560 和为K的子数组
    int subarraySum(vector<int> &nums, int target) {
        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
        unordered_map<int, int> hash;
        hash[0] = 1;
        int res = 0;
        for (int i = 1; i <= n; i++) {
            res += hash[s[i] - target];
            hash[s[i]]++;
        }
        return res;
    }

    int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {
        int n = matrix.size(), m = matrix[0].size();
        int res = 0;
        for (int i = 0; i < n; i++) {  // 枚举上边界
            vector<int> nums(m);
            for (int j = i; j < n; j++) {  // 枚举下边界
                for (int k = 0; k < m; k++)
                    nums[k] += matrix[j][k];
                res += subarraySum(nums, target);
            }
        }
        return res;
    }
};
  • Java
class Solution {
    public int numSubmatrixSumTarget(int[][] matrix, int target) {
        int n = matrix.length, m = matrix[0].length;
        int res = 0;
        for (int i = 0; i < n; i++) {  // 枚举上边界
            int[] nums = new int[m];
            for (int j = i; j < n; j++) {  // 枚举下边界
                for (int k = 0; k < m; k++)
                    nums[k] += matrix[j][k];
                res += subarraySum(nums, target);
            }
        }
        return res;
    }

    private int subarraySum(int[] nums, int target) {
        int n = nums.length;
        HashMap<Integer, Integer> hash = new HashMap<>();
        hash.put(0, 1);
        int s = 0, res = 0;  // s: 前缀和
        for (int i = 1; i <= n; i++) {
            s += nums[i - 1];
            res += hash.getOrDefault(s - target, 0);
            hash.put(s, hash.getOrDefault(s, 0) + 1);
        }
        return res;
    }
}
  • Python
class Solution:
    def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
        n = len(matrix); m = len(matrix[0])
        res = 0
        for i in range(n):
            nums = [0 for _ in range(m)]
            for j in range(i, n):
                for k in range(m):
                    nums[k] += matrix[j][k]
                res += self.subarraySum(nums, target)
        return res
    
    def subarraySum(self, nums: List[int], k: int) -> int:
        n = len(nums)
        s = [0 for _ in range(n + 1)]
        for i in range(1, n + 1):
            s[i] = s[i - 1] + nums[i - 1]
        hash = {}
        hash[0] = 1
        res = 0
        for i in range(1, n + 1):
            if s[i] - k in hash:
                res += hash[s[i] - k]
            if s[i] in hash:
                hash[s[i]] += 1
            else:
                hash[s[i]] = 1
        return res

时空复杂度分析

  • 时间复杂度： O ( n 2 × m ) O(n^2 \times m) O(n2×m)，n、m为行数、列数。
  • 空间复杂度： O ( m ) O(m) O(m)。

Leetcode 0437 路径总和 III

题目描述：Leetcode 0437 路径总和 III

在这里插入图片描述

分析

  • 本题的考点：前缀和、哈希表、递归。

  • 本题存在两种解法，这里都将讲解一下：

方法1

  • 考虑本题的一个简化形式，如果给我们一个一维数组，让我们求子数组等于某值的区间个数，可以使用前缀和，具体可以参考Leetcode 0560 和为K的子数组。

  • 本题也可以使用前缀和，在递归遍历的过程中，使用cur表示当前路径的前缀和，当我们考虑当前节点时，我们需要找到当前路径前面存在多少个节点的前缀和t，使得cur-t=sum，相当于让我们找到存在多少个cur-sum，因此可以使用哈希表记录前面数据出现的次数即可。

  • 使用C++实现这种方法。因为每个节点只会被遍历一遍，因此时间复杂度是O(n)的，n是树中节点数目。

  • 另外值得一提的是，LC560除了这种扩展方式，还可以扩展成多维，例如二维，对应Leetcode 1074 元素和为目标值的子矩阵数量。

方法2

  • 还存在一种直接使用递归的做法，pathSum(root, sum)表示的含义是：在以root为根结点的二叉树中，寻找和为sum的路径，返回这样的路径个数。我们可以拆分成两部分考虑：（1）包含root且和为sum的路径条数；（2）不包含root且和为sum的路径条数（递归遍历root的左右孩子）。

  • 使用Java实现这种方式。时间复杂度是 O ( n 2 ) O(n ^ 2) O(n2)的，n是树中节点数目。

代码

  • C++
class Solution {
public:
    unordered_map<int, int> cnt;  // (前缀和，出现的次数)
    int res = 0;

    int pathSum(TreeNode* root, int sum) {
        cnt[0]++;
        dfs(root, sum, 0);
        return res;
    }

    // cur: 前缀和
    void dfs(TreeNode* root, int sum, int cur) {
        if (!root) return;
        cur += root->val;
        res += cnt[cur - sum];
        cnt[cur]++;
        dfs(root->left, sum, cur), dfs(root->right, sum, cur);
        cnt[cur]--;
    }
};
  • Java
class Solution {
    // 在以root为根结点的二叉树中，寻找和为sum的路径，返回这样的路径个数
    public int pathSum(TreeNode root, int sum) {

        if (root == null) return 0;

        int res = findPath(root, sum);  // 包含结点root其和为sum的个数
        res += pathSum(root.left, sum);  // 进入左子树，寻找和为sum的路径
        res += pathSum(root.right, sum);  // 进入右子树，寻找和为sum的路径

        return res;
    }

    // 在以node为根结点的二叉树中，寻找包含node的路径，和为sum, 返回这样的路径个数
    private int findPath(TreeNode node, int sum) {

        if (node == null) return 0;

        int res = 0;
        sum -= node.val;
        if (sum == 0) res += 1;

        res += findPath(node.left, sum);
        res += findPath(node.right, sum);

        return res;
    }
}

时空复杂度分析

  • 时间复杂度：C++： O ( n ) O(n) O(n)，n为树中节点数目。Java： O ( n 2 ) O(n^2) O(n2)。

  • 空间复杂度：和递归深度有关。

你好世界wxx
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法竞赛专题解析--动态规划优化(1)四边形不等式1
08-04
【算法竞赛专题解析--动态规划优化(1)四边形不等式1】 动态规划（Dynamic Programming，简称DP）是一种解决复杂问题的有效方法，通过将问题分解为子问题，然后利用子问题的解来构建原问题的解。在《算法竞赛入门到...
图像处理的各种专题算法
08-23
图像处理是一个广泛的领域，涉及多种算法和技术，用于改善、分析或提取图像中的信息。本篇文章主要讨论了几个关键的图像处理...在实际工作中，根据任务需求选择合适的算法组合，能够有效地解决图像处理中的各种问题。
K倍区间 Acwing 1230
qq_62224565的博客
02-09 194
qwq
K倍区间
qq_45832461的博客
03-19 238
K倍区间 题目描述 核心思路 1.最简单的方法，采用暴力枚举，三层循环 for(int r = 1; r <= n; r++) for(int l = 1; l <= n; l++) { int sum = 0; for(int i = l; i <= r; i++) { ·········计算区间和 } 判断是否可整除k } 升级版1:优化最里面一层循
k倍区间（思维）
smilng的博客
03-21 4381
k倍区间 给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入 第一行包含两个整数N和K。(1 <= N, K <= 100000) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)...
k倍区间 蓝桥杯
m0_53203911的博客
04-12 575
给定一个长度为 N 的数列，A1,A2,…AN，如果其中一段连续的子序列 Ai,Ai+1,…Aj 之和是 K 的倍数，我们就称这个区间 [i,j] 是 K 倍区间。 你能求出数列中总共有多少个 K 倍区间吗？ 输入格式 第一行包含两个整数 N 和 K。 以下 N 行每行包含一个整数 Ai。 输出格式 输出一个整数，代表 K 倍区间的数目。 数据范围 1≤N,K≤100000, 1≤Ai≤100000 输入样例： 5 2 1 2 3 4 5 输出样例： 6 求区间[l,r]的和是k的倍数的个数。求区间和，我们
K倍区间(前缀和 + 组合数)
山中一扶苏的博客
03-06 981
题目链接 题目描述 输入描述 输出描述 输入样例 5 2 1 2 3 4 5 输出样例 6 题解 c++代码 #include <iostream> #include <cstring> #include <algorithm> #include <map> using namespace std; typedef long long ll; const int N = 1e5 + 10,INF = 1e9 + 7; typedef long long
上海交通大学ACM算法模板gai.docx
11-13
ST、度限制最小生成树、最优比率生成树（0/1分数规划）、最小花费置换、区间K大数、LCA（最近公共祖先）算法、单词前缀树、FFT（快速傅里叶变换）等。 这些算法和知识对于参加ACM竞赛或进行算法设计和优化至关重要...
上海交通大学ACM算法模板
06-03
ST、度限制最小生成树、最优比率生成树、最小花费置换、区间K大数、LCA（最近公共祖先）算法、单词前缀树、大数乘法（FFT）、二分图网络最大流最小割、混合图欧拉回路、无源汇上下界网络流、二分图最小点权覆盖、带...
k倍区间（蓝桥杯）
m0_73825335的博客
03-24 283
k倍区间（前缀和知识）
K倍区间-前缀和
最新发布
2302_79372568的博客
01-08 517
给定一个长度为 N 的数列A1,A2，…AN，如果其中一段连续的子序列 Ai,Ai+1,…Aj 之和是 K 的倍数，我们就称这个区间 [i,j] 是 K倍区间。你能求出数列中总共有多少个 K倍区间吗？
K倍区间类问题
qq_62092806的博客
07-21 233
K倍区间问题：简单来说就是，给定一个长度为N的数列,a1,a2,a3,…an,如果其中有一段子序列ai,ai+1,…aj(i
k倍区间
Become hunger become strong
03-19 1734
标题： k倍区间 给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i &lt;= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入 第一行包含两个整数N和K。(1 &lt;= N, K &lt;= 100000) 以下N行每行包含一个整数Ai。(1 &lt;= Ai &lt...
求连续子数组和等于给定目标值的区间--面试题
a546167160的博客
07-02 5094
题目 给定n个数和一个target，输出连续区间和为target的所有区间 写代码的时候遇到的问题 保存区间内元素和，区间变化加减操作即可，而不是每次对区间求和，这样时间复杂度就是O(n)了，否则是O(n^2)，因为还要遍历区间内部元素 如果初始化元素和为0，样例，arr = [4] ，target = 4，应该返回[0,0]，出错。因此，初始化为数组第一个元素 j循环向后加时，防止越界；当区间...
蓝桥杯-【K倍区间】【2017年省赛B组题解】-动态规划解法-【C++】
老陈聊架构
03-30 1424
K倍区间 给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i &lt;= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。 你能求出数列中总共有多少个K倍区间吗？ 输入 ----- 第一行包含两个整数N和K。(1 &lt;= N, K &lt;= 100000) 以下N行每行包含一个整数Ai。(1 &lt;=...
连续子数组的和为指定值的最大长度
Master-Fei的博客
10-16 1893
连续子数组的和为指定值的最大长度 例如： arr = {3,4,1,7,8}，和为15的最长子数组为{3,4,1,7} arr 3 4 1 7 8 sum 3 7 8 15 23 index 0 1 2 3 4 每次把（sum, i）存入一个map，当然sum不能被覆盖，每次遍历的时查找 sum-
求连续区间和为目标值的一种解题思路
hanzhen7541的博客
03-17 1178
今天在leetcode上面遇到了一道题，我觉得解题思路很好，在此记录下来： 题目是： 给定一个放有字符和数字的数组，找到最长的子数组，且包含的字符和数字的个数相同。 返回该子数组，若存在多个最长子数组，返回左端点最小的。若不存在这样的数组，返回一个空数组。 如： 输入: ["A","1","B","C","D","2","3","4","E","5","F","G","6","7","...
蓝桥杯算法训练：区间k大数查询详解及Java实现
蓝桥杯算法训练答案提供了一个名为"区间k大数查询"的问题，它考察的是排序和查找算法在特定情境下的应用。该题目针对的是编程竞赛中的经典问题，主要涉及数据结构和算法设计，特别是针对大规模数据集（n, m ≤ 1000...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值