2026-06-06：统计主导元素下标数。用go语言，给定一个整数数组 nums，长度为 n。我们称某个位置 i（通常只考虑 i ＜ n-1）上的元素为“主导元

2026-06-06：统计主导元素下标数。用go语言，给定一个整数数组 nums，长度为 n。我们称某个位置 i（通常只考虑 i < n-1）上的元素为“主导元素”，如果它严格大于数组中从 i+1 到 n-1 这一段所有元素的平均值。

你的目标是统计数组中满足上述条件的位置数量，并输出该数量（最右端下标 n-1 对应的元素不参与判断）。

1 <= nums.length <= 100。

1 <= nums[i] <= 100​​​​​​​。

输入： nums = [5,4,3]。

输出： 2。

解释：

在下标 i = 0 处，值 5 是主导元素，因为 5 > average(4, 3) = 3.5。

在下标 i = 1 处，值 4 是主导元素，相对于子数组 [3]。

下标 i = 2 不是主导元素，因为它右侧没有元素。因此答案是 2。

题目来自力扣3833。

1. 代码逻辑逐步执行

初始：

• n = 3
• ans = 0
• sufSum = 0（用来累加后缀和，即 i+1 到末尾的和）

循环 i = n-2 = 1 向下到 0：

第一轮 i = 1：

• 先做 sufSum += nums[i+1]
  • sufSum = 0 + nums[2] = 0 + 3 = 3
• 后缀长度 len = n-1-i = 3-1-1 = 1
• 检查 nums[1] * len > sufSum？
  • 4 * 1 = 4，4 > 3 成立 → ans++ → ans = 1

第二轮 i = 0：

• 先做 sufSum += nums[i+1]
  • sufSum = 3 + nums[1] = 3 + 4 = 7
• 后缀长度 len = n-1-i = 3-1-0 = 2
• 检查 nums[0] * len > sufSum？
  • 5 * 2 = 10，10 > 7 成立 → ans++ → ans = 2

循环结束，返回 ans = 2。

---

2. 算法核心要点

• 从右往左遍历，用一个变量 sufSum 累加当前 i 右边的所有元素和。
• 每次循环开头先加上 nums[i+1]（对 i 来说就是它右侧紧邻的元素，但 sufSum 实际是 i 右边全部的和）。
• 这样只需要 O(1) 的额外变量，不用每次重新计算后缀和。
• 比较时用乘法避免浮点数运算。

---

3. 时间复杂度

• 循环 n-1 次（从 n-2 到 0），每次循环 O(1) 操作。
• 总时间复杂度 O(n)。

---

4. 空间复杂度

• 除了输入数组，只用了 n, ans, sufSum 几个变量。
• 总额外空间复杂度 O(1)。

Go完整代码如下：

package main

import (
	"fmt"
)

func dominantIndices(nums []int) (ans int) {
	n := len(nums)
	sufSum := 0
	for i := n - 2; i >= 0; i-- {
		sufSum += nums[i+1]
		if nums[i]*(n-1-i) > sufSum {
			ans++
		}
	}
	return
}

func main() {
	nums := []int{5, 4, 3}
	result := dominantIndices(nums)
	fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

def dominant_indices(nums):
    n = len(nums)
    ans = 0
    suf_sum = 0
    for i in range(n - 2, -1, -1):
        suf_sum += nums[i + 1]
        if nums[i] * (n - 1 - i) > suf_sum:
            ans += 1
    return ans

if __name__ == "__main__":
    nums = [5, 4, 3]
    result = dominant_indices(nums)
    print(result)

C++完整代码如下：

#include <iostream>
#include <vector>

using namespace std;

int dominantIndices(vector<int>& nums) {
    int n = nums.size();
    int ans = 0;
    int sufSum = 0;

    for (int i = n - 2; i >= 0; i--) {
        sufSum += nums[i + 1];
        if (nums[i] * (n - 1 - i) > sufSum) {
            ans++;
        }
    }

    return ans;
}

int main() {
    vector<int> nums = {5, 4, 3};
    int result = dominantIndices(nums);
    cout << result << endl;

    return 0;
}