总和最多为 K 的元素的最大和最小计数

这道题目是一个关于子集和的问题，可以使用动态规划来解决。

题目描述

给定一个包含 n 个正整数的数组 nums 和一个正整数 k ，找出该数组中【总和最多】恰好为 k 的连续子数组的个数。

数组 s 的【总和】定义为所有 s_i 的和。

样例

示例1：

输入：nums = [1,1,1], k = 2

输出: 2

解释: 此题有两个子集和为 2 的连续子数组。它们为 [1,1] 和 [1,1]。

示例2：

输入：nums = [1,2,3,4,5], k = 10

输出: 1

解释: 此题只有一个子集和为 10 的连续子数组。它为 [1,2,3,4]。

解题思路

我们可以使用动态规划来解决这道题目。

令 dp[i][j] 代表以 i 结尾，总和最多为 j 的连续子数组的个数。通过枚举结尾位置，求出所有可能。

我们可以得到状态转移方程式为：

dp[i][j] = dp[i - 1][j] + (j - nums[i]) 的次数

我们按照数组序列从左到右计算，对于每一个位置 i，可以枚举一遍它之前所有位置的和，如果满足要求则更新答案。

对于最终的答案，在得到的位置的 dp 数组中，长度最长的子集是最优的，因为其包含的数目最多。

对于求解最大值或者最小值的问题，可以使用贪心算法。

复杂度分析

该算法的时间复杂度为 $O(N ^ 2)$，空间复杂度为 $O(N)$。

代码实现

class Solution:
    def maxSubArrayLen(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        n = len(nums)
        dp = [0] * n
        ans = 0
        for i in range(n):
            for j in range(k, nums[i] - 1, -1):
                dp[j - nums[i]] += dp[j]
                if nums[i] == j:
                    dp[j - nums[i]] += 1
                ans = max(ans, dp[j - nums[i]])
        return ans

class Solution {
public:
    int maxSubArrayLen(vector<int>& nums, int k) {
        int n = nums.size();
        unordered_map<int, int> mp;
        mp[0] = -1;
        int ans = 0, sum = 0;
        for(int i = 0; i < n; i ++) {
            sum += nums[i];
            if(mp.count(sum - k))
                ans = max(ans, i - mp[sum - k]);
            if(!mp.count(sum))
                mp[sum] = i;
        }
        return ans;
    }
};

总结

通过这道题目，我们可以看到动态规划和贪心算法的结合使用，使得我们可以计算出数组中总和最多为 k 的连续子数组的个数。在应对此种类似的问题时，需要我们发掘更深的数据特征，而且需要思考问题的解法，并结合特定的数据结构优化算法，以取得更加出色的解决效果。