面试题目：(8)合法分割的最小坐标

题目

• 如果元素 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 <= 105
  • 1 <= nums[i] <= 109
  • nums 有且只有一个支配元素。

代码

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>

int main()
{
    char nums[256] = "";
    fgets(nums,sizeof(nums),stdin);
    nums[strcspn(nums,"\n")] = '\0';
    int count = 1;
    for (int i = 0; i < strlen(nums); i++)
    {
        if (nums[i] == ',' )
            count++;
    }
    int nums_int[count];
    int end = 0;
    int index = 0;
    for (int i = 0; i < strlen(nums); i++)
    {
        if (nums[i] <= '9' && nums[i] >= '0')
        {
            end = end * 10 + nums[i] - '0';
        }
        else if (nums[i] == ',' || nums[i] == ']')
        {
            nums_int[index++] = end;
            end = 0;
        }
    }
    
    for (int i = 0; i < count; i++)
    {
        int left[110] =  {0},right[110] =  {0};
        for (int j = 0; j <= i; j++)
        {
            left[nums_int[j]]++;
        }
        for (int j = i+1; j < count; j++)
        {
            if (j == count)
                break;       
            right[nums_int[j]]++;
        }
        int max_left = 0,max_right = 0,left_index = 0,right_index = 0;
        for (int k = 0; k < 110; k++)
        {
            if (left[k] > max_left)
            {
                max_left = left[k];
                left_index = k;
            }
            if (right[k] > max_right)
            {
                max_right = right[k];
                right_index = k;
            }
        }
        if (left_index == right_index && max_left * 2 > (i + 1) && max_right * 2 > (count - i - 1)) 
        {
            printf("%d\n", i);
            return 0;
        }
    }
    printf("-1\n");
    return 0;
}

分析

• 接收字符串
• 遍历算出有多少个数字
• 遍历拿出每个数字到数组
• 从第一个元素数组开始分割为左右两个数组，遍历下去
  • 遍历统计左右两个数组里面各个数出现的次数
  • 遍历获取到出现最多次数的数字
  • 判断是否是合法分割的最小下标
    • 是就输出
    • 不是就继续遍历
  • 遍历完没有就输出-1

改进

获取到出现最多次数的数字我上面分成了两步，其实可以用算法来进行快速筛选，可以使用 Boyer-Moore 投票算法找到支配元素

    int dominant = nums_int[0], freq = 0;

    for (int i = 0; i < count; i++)
    {
        if (nums_int[i] == dominant)
        {
            freq++;
        }
        else
        {
            freq--;
            if (freq == 0)
            {
                dominant = nums_int[i];
                freq = 1;
            }
        }
    }

• 初始化 dominant 为数组的第一个元素，freq 计数器为 0
• 遍历数组
  • 如果当前元素等于 dominant，则增加计数器 freq
  • 如果当前元素不等于 dominant，则减少计数器 freq
  • 如果 freq 变为 0，说明之前的候选者被抵消，重置 dominant 为当前元素并将计数器为 1
• 经过这一遍历，dominant 将是数组中的支配元素