力扣2025——分割数组的最多方案数

2025. 分割数组的最多方案数

难度困难

给你一个下标从 0 开始且长度为 n 的整数数组 nums 。分割 数组 nums 的方案数定义为符合以下两个条件的 pivot 数目：

• 1 <= pivot < n
• nums[0] + nums[1] + ... + nums[pivot - 1] == nums[pivot] + nums[pivot + 1] + ... + nums[n - 1]

同时给你一个整数 k 。你可以将 nums 中 一个 元素变为 k 或 不改变 数组。

请你返回在 至多 改变一个元素的前提下，最多 有多少种方法 分割 nums 使得上述两个条件都满足。

 

示例 1：

输入：nums = [2,-1,2], k = 3
输出：1
解释：一个最优的方案是将 nums[0] 改为 k 。数组变为 [3,-1,2] 。
有一种方法分割数组：
- pivot = 2 ，我们有分割 [3,-1 | 2]：3 + -1 == 2 。

示例 2：

输入：nums = [0,0,0], k = 1
输出：2
解释：一个最优的方案是不改动数组。
有两种方法分割数组：
- pivot = 1 ，我们有分割 [0 | 0,0]：0 == 0 + 0 。
- pivot = 2 ，我们有分割 [0,0 | 0]: 0 + 0 == 0 。

示例 3：

输入：nums = [22,4,-25,-20,-15,15,-16,7,19,-10,0,-13,-14], k = -33
输出：4
解释：一个最优的方案是将 nums[2] 改为 k 。数组变为 [22,4,-33,-20,-15,15,-16,7,19,-10,0,-13,-14] 。
有四种方法分割数组。

 

提示：

题解
可以创建一个前缀数组prefix和后缀数组suffix，分别表示前缀和、后缀和。
然后创建两个map left和right ,right[k]表示当前遍历元素右边后缀-前缀等于k的个数，left[k]则表示左边
当遍历到第i个元素的时候，可以将right[suffix[i+]-prefix[i]]--,left[suffix[i+1]-prefix]++;
然后遍历给定序列的每一个元素，此时我们可以计算一个差值diff=k-nums[i]，这个差值影响了前缀和后缀。
此时计算出了差值，我们就可以更新ans了

代码

点击查看代码

class Solution {
public:
    int waysToPartition(vector<int>& nums, int k) {
        // key表示相差后缀减去前缀的值
        //value表示满足这个值的所有pivot信息
        
        map<long long int,vector<int>> m; 
        long long int prefix[100000+10],suffix[100000+10];
        prefix[0] = nums[0];
        for(int i = 1 ;i < nums.size(); i++){
            prefix[i] = prefix[i-1] + nums[i];
        }
        suffix[nums.size() - 1] = nums[nums.size() - 1];
        for(int i = nums.size() - 2; i >= 0; i--){
            suffix[i] = suffix[i+1] + nums[i];
        } 

        
        map<long long int,int> right,left;
        for(int i = 0;i<nums.size()-1;i++){
            long long int cnt = suffix[i+1] - prefix[i];
            if(right.count(cnt)==0) {
                right[cnt] = 1;
            }
            else right[cnt]++;
        }
        //cout<<nums.size()<<endl;
        int ans = 0;
        if(right.count(0)>0) ans = max(ans,right[0]);
        for(int i = 0;i < nums.size();i++){
            long long int diff = k - nums[i];
            int now = right[diff] + left[-diff];
            right[suffix[i+1] - prefix[i]]--;
            left[suffix[i+1] - prefix[i]]++;
            ans = max(ans,now);
        }
        return ans;          
    }
};