合法分割的最小下标

如果元素 x 在长度为 m 的整数数组 arr 中满足 freq(x) * 2 > m ,那么我们称 x 是 支配元素 。其中 freq(x) 是 x 在数组 arr 中出现的次数。注意,根据这个定义,数组 arr 最多 只会有 一个 支配元素。

给你一个下标从 0 开始长度为 n 的整数数组 nums ,数据保证它含有一个支配元素。

你需要在下标 i 处将 nums 分割成两个数组 nums[0, ..., i] 和 nums[i + 1, ..., n - 1] ,如果一个分割满足以下条件,我们称它是 合法 的:

0 <= i < n - 1
nums[0, ..., i] 和 nums[i + 1, ..., n - 1] 的支配元素相同。
这里, nums[i, ..., j] 表示 nums 的一个子数组,它开始于下标 i ,结束于下标 j ,两个端点都包含在子数组内。特别地,如果 j < i ,那么 nums[i, ..., j] 表示一个空数组。

请你返回一个 合法分割 的 最小 下标。如果合法分割不存在,返回 -1 。

示例 1:

输入:nums = [1,2,2,2]
输出:2
解释:我们将数组在下标 2 处分割,得到 [1,2,2] 和 [2] 。
数组 [1,2,2] 中,元素 2 是支配元素,因为它在数组中出现了 2 次,且 2 * 2 > 3 。
数组 [2] 中,元素 2 是支配元素,因为它在数组中出现了 1 次,且 1 * 2 > 1 。
两个数组 [1,2,2] 和 [2] 都有与 nums 一样的支配元素,所以这是一个合法分割。
下标 2 是合法分割中的最小下标。
示例 2:

输入:nums = [2,1,3,1,1,1,7,1,2,1]
输出:4
解释:我们将数组在下标 4 处分割,得到 [2,1,3,1,1] 和 [1,7,1,2,1] 。
数组 [2,1,3,1,1] 中,元素 1 是支配元素,因为它在数组中出现了 3 次,且 3 * 2 > 5 。
数组 [1,7,1,2,1] 中,元素 1 是支配元素,因为它在数组中出现了 3 次,且 3 * 2 > 5 。
两个数组 [2,1,3,1,1] 和 [1,7,1,2,1] 都有与 nums 一样的支配元素,所以这是一个合法分割。
下标 4 是所有合法分割中的最小下标。
示例 3:

输入:nums = [3,3,3,3,7,2,2]
输出:-1
解释:没有合法分割。

提示:

\(1 <= nums.length <= 10^5\)
\(1 <= nums[i] <= 10^9\)
nums 有且只有一个支配元素。

解题思路

支配元素的定义:出现次数*2 > nums.size()。
那么分割后要求两边子数组的支配元素相同,则分割后的两个子数组的支配元素必然是原数组的支配元素。
反证法:
假设两个子数组的长度为len1,len2,支配元素为a,那么有

\[freq_1(a) * 2 > len1 \]

\[freq_2(a) * 2 > len2 \]

也就是

\[freq(a) = freq_1(a) + freq_2(a) > len1 + len2 = len(arr) \]

也就是a是原数组的支配元素,由于a和x并不是同一个值,也就是数组中具有两个支配元素,矛盾。
故两个子数组中的支配元素和原数组相同。

得到上述结论就好办了:

  1. 统计支配元素以及支配元素的数目
  2. 遍历可以作为分割下标的[0,n-1),判断是否仍然是支配元素

code

class Solution {
public:
    
    //支配元素:出现次数 * 2 > nums.size()
    //数据nums保证存在一个支配元素
    //分割后还是同一个支配元素

    int minimumIndex(vector<int>& nums) {
        
        int govern = 0;
        int govern_nums = 0;
        
        unordered_map<int,int> cnt;
        for(auto item : nums)
            cnt[item] ++;
        
        for(auto item : cnt)
            if(item.second * 2 > nums.size())
            {
                govern = item.first;
                govern_nums = item.second;
            }
        
        
        //记录i以及i往前有多少个govern元素
        unordered_map<int,int> pos_cnt;
        int last = 0;
        for(int i = 0; i < nums.size();i ++)
        {
            if(nums[i] == govern)
            {
                pos_cnt[i] = last + 1;
                last = last + 1;
            }
        }
        
        //查找最小合法分割
        
        int pos = -1;
        for(int i = 0;i < nums.size() -1;i ++)
        {
            if(pos_cnt[i] * 2 > (i + 1) && (govern_nums - pos_cnt[i]) * 2 > (nums.size() - i - 1))
            {
                pos = i;
                break;
            }
        }
        
        return pos;
        
        
    }
};
posted on 2023-07-31 20:56  huangxk23  阅读(3)  评论(0编辑  收藏  举报