2026-06-30：容量最小的箱子。用go语言，给定一个整数数组 capacity 和一个整数 itemSize： - capacity[i] 表示第 i 个

2026-06-30：容量最小的箱子。用go语言，给定一个整数数组 capacity 和一个整数 itemSize：

• capacity[i] 表示第 i 个箱子的容量。

• 若某个箱子的容量满足 capacity[i] >= itemSize，则说明该箱子可以放下这个物品。 任务是：

找出所有能放下该物品的箱子中，容量最小的那个箱子对应的下标并返回。

补充规则：

• 如果存在多个箱子的容量都满足“最小容量”这一条件，则返回其中下标最小的那个。

• 如果所有箱子都无法放下该物品，则返回 -1。

1 <= capacity.length <= 100。

1 <= capacity[i] <= 100。

1 <= itemSize <= 100。

输入： capacity = [1,5,3,7], itemSize = 3。

输出： 2。

解释：

下标为 2 的箱子容量为 3，是可以存放该物品的容量最小的箱子，因此答案是 2。

题目来自力扣3861。

一、函数执行分步详细过程

步骤1：初始化两个标记变量

1. 变量 minC：用来记录符合条件箱子的最小容量，初始赋值为系统最大整数 math.MaxInt，保证后续任意合法箱子容量都会比它小，能完成首次替换。
2. 变量 ans：用来记录最终要返回的箱子下标，初始赋值 -1，对应题目“无可用箱子返回-1”的默认结果。

步骤2：从头遍历整个容量数组，逐个校验每个箱子

遍历规则：按数组下标从小到大依次读取每一个箱子的下标 i 和对应容量 c，保证出现多个相同最小容量时，只会保留最先遇到（下标更小）的下标，满足题目补充规则。 数组元素依次遍历流程：

第1轮循环：i=0，c=1

判断条件：c >= itemSize → 1 >= 3，结果不成立。 不进入内部逻辑，直接跳过，minC、ans 保持原值不变。

第2轮循环：i=1，c=5

判断条件：5 >= 3，条件成立；继续判断 c < minC → 5 < 最大整数，条件成立。

1. 更新最小容量：minC = 5
2. 更新结果下标：ans = 1 当前记录：可用最小容量5，对应下标1。

第3轮循环：i=2，c=3

判断条件：3 >= 3，条件成立；继续判断 c < minC → 3 < 5，条件成立。

1. 更新最小容量：minC = 3
2. 更新结果下标：ans = 2 当前记录：可用最小容量3，对应下标2。

第4轮循环：i=3，c=7

判断条件：7 >= 3，条件成立；继续判断 c < minC → 7 < 3，条件不成立。 不更新任何变量，minC 仍为3、ans 仍为2。

步骤3：遍历结束，返回结果变量

全部箱子遍历完毕，ans 存储的值为2，将2作为函数返回值输出。

补充边界场景逻辑说明

1. 多个箱子拥有相同最小可用容量： 因为遍历严格按下标从小到大执行，只有当当前箱子容量严格小于已记录最小容量时，才会更新下标；容量相等时不会触发更新，会保留更早、下标更小的下标，符合题目要求。 例：capacity=[4,3,3],itemSize=3，遍历到i=1时ans=1，i=2容量同为3不更新，最终返回1。
2. 无箱子能放下物品： 全程没有任何一次进入条件内部，ans 始终是初始值-1，最终返回-1。

二、复杂度分析

1. 时间复杂度

数组长度记为 n（capacity.length）。 算法会完整遍历数组中每一个元素，循环执行 n 次，每次循环内仅做两次数值比较、少量赋值操作，都是常数级 O(1) 运算，无嵌套循环。 总时间复杂度：O(n)

2. 额外空间复杂度

算法仅创建了两个独立整型变量 minC、ans，开辟的存储空间数量和输入数组长度 n 无关，是固定常数空间，没有新建数组、切片、哈希表等随输入规模变化的容器。 总额外空间复杂度：O(1)

Go完整代码如下：

package main

import (
	"fmt"
	"math"
)

func minimumIndex(capacity []int, itemSize int) int {
	minC := math.MaxInt
	ans := -1
	for i, c := range capacity {
		if c >= itemSize && c < minC {
			minC = c
			ans = i
		}
	}
	return ans
}

func main() {
	capacity := []int{1, 5, 3, 7}
	itemSize := 3
	result := minimumIndex(capacity, itemSize)
	fmt.Println(result)
}

Python完整代码如下：

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

import math

def minimum_index(capacity: list[int], item_size: int) -> int:
    min_c = math.inf
    ans = -1
    for i, c in enumerate(capacity):
        if c >= item_size and c < min_c:
            min_c = c
            ans = i
    return ans


def main() -> None:
    capacity = [1, 5, 3, 7]
    item_size = 3
    result = minimum_index(capacity, item_size)
    print(result)


if __name__ == "__main__":
    main()

C++完整代码如下：

#include <iostream>
#include <vector>
#include <climits>   // 提供 INT_MAX

int minimumIndex(const std::vector<int>& capacity, int itemSize) {
    int minC = INT_MAX;
    int ans = -1;
    for (int i = 0; i < capacity.size(); ++i) {
        int c = capacity[i];
        if (c >= itemSize && c < minC) {
            minC = c;
            ans = i;
        }
    }
    return ans;
}

int main() {
    std::vector<int> capacity = {1, 5, 3, 7};
    int itemSize = 3;
    int result = minimumIndex(capacity, itemSize);
    std::cout << result << std::endl;
    return 0;
}