c++ 解决区间最大数和矩阵最大面积

给定一个实数序列,设计一个最有效的算法,找到一个总和数最大的区间等于某个事先给定的数字。

我们可以使用前缀和和哈希表来设计一个高效的算法。这个算法的时间复杂度是 O(n),空间复杂度也是 O(n)。

cpp 复制代码
#include <vector>
#include <unordered_map>
#include <iostream>

std::pair<int, int> findMaxLengthSubarrayWithSum(const std::vector<double>& arr, double targetSum) {
    std::unordered_map<double, int> sumIndex; // 用于存储前缀和及其索引
    double currentSum = 0; // 当前的前缀和
    int maxLength = 0; // 最长子数组的长度
    int endIndex = -1; // 最长子数组的结束索引

    sumIndex[0] = -1; // 初始化前缀和为0的索引为-1

    for (int i = 0; i < arr.size(); ++i) {
        currentSum += arr[i]; // 计算当前前缀和

        double complement = currentSum - targetSum; // 计算需要寻找的互补和

        if (sumIndex.find(complement) != sumIndex.end()) { // 如果找到了互补和
            int length = i - sumIndex[complement]; // 计算子数组长度
            if (length > maxLength) { // 如果这个子数组更长
                maxLength = length; // 更新最大长度
                endIndex = i; // 更新结束索引
            }
        }

        if (sumIndex.find(currentSum) == sumIndex.end()) { // 如果这个前缀和之前没出现过
            sumIndex[currentSum] = i; // 记录这个前缀和的索引
        }
    }

    if (endIndex != -1) { // 如果找到了符合条件的子数组
        return {endIndex - maxLength + 1, endIndex}; // 返回起始和结束索引
    } else {
        return {-1, -1}; // 如果没找到,返回{-1, -1}
    }
}

int main() {
    std::vector<double> arr = {1.0, 4.0, 20.0, 3.0, 10.0, 5.0}; // 示例数组
    double targetSum = 33.0; // 目标和

    auto result = findMaxLengthSubarrayWithSum(arr, targetSum); // 调用函数查找子数组

    if (result.first != -1) { // 如果找到了符合条件的子数组
        std::cout << "找到了和为 " << targetSum << " 的最长子数组,索引范围: [" 
                  << result.first << ", " << result.second << "]" << std::endl;
    } else { // 如果没有找到符合条件的子数组
        std::cout << "没有找到和为 " << targetSum << " 的子数组" << std::endl;
    }

    return 0;
}

这个算法的工作原理如下:

  1. 我们使用一个哈希表 sumIndex 来存储每个前缀和及其对应的索引。
  2. 我们遍历数组,不断累加当前的和 currentSum
  3. 对于每个位置,我们计算 complement = currentSum - targetSum。如果这个 complement 存在于我们的哈希表中,那么说明我们找到了一个和为 targetSum 的子数组。
  4. 我们记录找到的最长的子数组。
  5. 如果当前的 currentSum 还没有在哈希表中,我们就将它加入哈希表。

这个算法的优点是:

  • 时间复杂度为 O(n),因为我们只需要遍历一次数组。
  • 空间复杂度为 O(n),用于存储哈希表。
  • 它可以处理包含正数、负数和零的数组。
  • 它可以找到最长的符合条件的子数组。

这个算法比简单的滑动窗口方法更有效,因为它可以处理包含负数的情况,并且可以在一次遍历中找到最长的符合条件的子数组。

第二个问题,在一个二维矩阵中,寻找一个矩阵的区域,使其中的数字之和达到最大值,著名的"最大子矩阵和"问题。我们可以使用Kadane算法的二维扩展来解决这个问题。以下是C++实现,并附有中文注释:

cpp 复制代码
#include <vector>
#include <climits>
#include <iostream>

struct SubMatrix {
    int top, left, bottom, right, sum;
};

SubMatrix findMaxSumSubMatrix(const std::vector<std::vector<int>>& matrix) {
    int rows = matrix.size();
    if (rows == 0) return {0, 0, 0, 0, 0};
    int cols = matrix[0].size();
    if (cols == 0) return {0, 0, 0, 0, 0};

    SubMatrix result = {0, 0, 0, 0, INT_MIN}; // 存储最终结果
    std::vector<int> temp(rows, 0); // 临时数组,用于存储列的和

    // 枚举所有可能的左右列边界
    for (int left = 0; left < cols; ++left) {
        std::fill(temp.begin(), temp.end(), 0); // 重置临时数组
        for (int right = left; right < cols; ++right) {
            // 将当前列加到临时数组中
            for (int i = 0; i < rows; ++i) {
                temp[i] += matrix[i][right];
            }

            // 在临时数组上应用一维Kadane算法
            int currentSum = 0;
            int maxSum = INT_MIN;
            int tempTop = 0, top = 0, bottom = 0;

            for (int i = 0; i < rows; ++i) {
                currentSum += temp[i];
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                    top = tempTop;
                    bottom = i;
                }
                if (currentSum < 0) {
                    currentSum = 0;
                    tempTop = i + 1;
                }
            }

            // 更新全局最大值
            if (maxSum > result.sum) {
                result = {top, left, bottom, right, maxSum};
            }
        }
    }

    return result;
}

int main() {
    std::vector<std::vector<int>> matrix = {
        {1, 2, -1, -4, -20},
        {-8, -3, 4, 2, 1},
        {3, 8, 10, 1, 3},
        {-4, -1, 1, 7, -6}
    };

    SubMatrix result = findMaxSumSubMatrix(matrix);

    std::cout << "最大子矩阵和为: " << result.sum << std::endl;
    std::cout << "子矩阵位置: (" << result.top << "," << result.left << ") 到 ("
              << result.bottom << "," << result.right << ")" << std::endl;

    return 0;
}

这个算法的工作原理如下:

  1. 我们枚举矩阵的所有可能的左右列边界。
  2. 对于每一对左右边界,我们计算这些列之间所有元素的和,存储在一个临时数组中。
  3. 在这个临时数组上,我们应用一维的Kadane算法来找到最大子数组和,这个子数组对应于我们要找的子矩阵的上下边界。
  4. 我们跟踪全局最大和及其对应的子矩阵位置。
  5. 最后返回具有最大和的子矩阵。

这个算法的时间复杂度是O(n^3),其中n是矩阵的边长(假设矩阵是方阵)。虽然这不是最优的解法,但它是较为直观且易于实现的方法。

对于更大的矩阵,存在更高效的算法,如使用二维线段树或者二维树状数组的方法,它们可以将时间复杂度降低到O(n^2 log n)或O(n^2)。但这些方法的实现会更加复杂。

相关推荐
此生只爱蛋13 分钟前
【手撕排序2】快速排序
c语言·c++·算法·排序算法
blammmp20 分钟前
Java:数据结构-枚举
java·开发语言·数据结构
何曾参静谧33 分钟前
「C/C++」C/C++ 指针篇 之 指针运算
c语言·开发语言·c++
暗黑起源喵38 分钟前
设计模式-工厂设计模式
java·开发语言·设计模式
WaaTong43 分钟前
Java反射
java·开发语言·反射
咕咕吖44 分钟前
对称二叉树(力扣101)
算法·leetcode·职场和发展
Troc_wangpeng44 分钟前
R language 关于二维平面直角坐标系的制作
开发语言·机器学习
努力的家伙是不讨厌的1 小时前
解析json导出csv或者直接入库
开发语言·python·json
Envyᥫᩣ1 小时前
C#语言:从入门到精通
开发语言·c#
九圣残炎1 小时前
【从零开始的LeetCode-算法】1456. 定长子串中元音的最大数目
java·算法·leetcode