同时运行 N 台电脑的最长时间

2141. 同时运行 N 台电脑的最长时间

你有 n 台电脑。给你整数 n 和一个下标从 0 开始的整数数组 batteries ，其中第 i 个电池可以让一台电脑运行 batteries[i] 分钟。你想使用这些电池让全部 n 台电脑同时运行。

一开始，你可以给每台电脑连接 至多一个电池 。然后在任意整数时刻，你都可以将一台电脑与它的电池断开连接，并连接另一个电池，你可以进行这个操作 任意次 。新连接的电池可以是一个全新的电池，也可以是别的电脑用过的电池。断开连接和连接新的电池不会花费任何时间。

注意，你不能给电池充电。

请你返回你可以让 n 台电脑同时运行的最长分钟数。

示例 1：

输入：n = 2, batteries = [3,3,3]
输出：4
解释：
一开始，将第一台电脑与电池 0 连接，第二台电脑与电池 1 连接。
2 分钟后，将第二台电脑与电池 1 断开连接，并连接电池 2 。注意，电池 0 还可以供电 1 分钟。
在第 3 分钟结尾，你需要将第一台电脑与电池 0 断开连接，然后连接电池 1 。
在第 4 分钟结尾，电池 1 也被耗尽，第一台电脑无法继续运行。
我们最多能同时让两台电脑同时运行 4 分钟，所以我们返回 4 。

示例 2：

输入：n = 2, batteries = [1,1,1,1]
输出：2
解释：
一开始，将第一台电脑与电池 0 连接，第二台电脑与电池 2 连接。
一分钟后，电池 0 和电池 2 同时耗尽，所以你需要将它们断开连接，并将电池 1 和第一台电脑连接，电池 3 和第二台电脑连接。
1 分钟后，电池 1 和电池 3 也耗尽了，所以两台电脑都无法继续运行。
我们最多能让两台电脑同时运行 2 分钟，所以我们返回 2 。

提示：

1 <= n <= batteries.length <= 10⁵
1 <= batteries[i] <= 10⁹

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

class Solution { public: long long maxRunTime(int n, vector<int>& batteries) { } };

python3 解法, 执行用时: 116 ms, 内存消耗: 29.4 MB, 提交时间: 2023-10-08 23:05:31

class Solution:
    # 排序 + 贪心
    def maxRunTime(self, n: int, batteries: List[int]) -> int:
        batteries.sort(reverse=True)
        s = sum(batteries)
        for b in batteries:
            if b <= s // n: return s // n
            s -= b
            n -= 1
            
    # 二分
    def maxRunTime2(self, n: int, batteries: List[int]) -> int:
        l, r = 0, sum(batteries) // n
        while l < r:
            x = (l + r + 1) // 2
            if n * x <= sum(min(b, x) for b in batteries):
                l = x
            else:
                r = x - 1
        return l

java 解法, 执行用时: 23 ms, 内存消耗: 55.1 MB, 提交时间: 2023-10-08 23:04:49

class Solution {
    // 二分
    public long maxRunTime(int n, int[] batteries) {
        var tot = 0L;
        for (var b : batteries) {
            tot += b;
        }
        long l = 0L, r = tot / n;
        while (l < r) {
            var x = (l + r + 1) / 2;
            var sum = 0L;
            for (var b : batteries) {
                sum += Math.min(b, x);
            }
            if (n * x <= sum) {
                l = x;
            } else {
                r = x - 1;
            }
        }
        return l;
    }
    
    // 排序 + 贪心
    public long maxRunTime2(int n, int[] batteries) {
        Arrays.sort(batteries);
        var sum = 0L;
        for (var b : batteries) {
            sum += b;
        }
        for (var i = batteries.length - 1; ; --i) {
            if (batteries[i] <= sum / n) {
                return sum / n;
            }
            sum -= batteries[i];
            --n;
        }
    }
}

cpp 解法, 执行用时: 172 ms, 内存消耗: 54.9 MB, 提交时间: 2023-10-08 23:04:08

class Solution {
public:
    // 排序 + 贪心
    long long maxRunTime(int n, vector<int> &batteries) {
        sort(batteries.begin(), batteries.end());
        long sum = accumulate(batteries.begin(), batteries.end(), 0L);
        for (int i = batteries.size() - 1;; --i) {
            if (batteries[i] <= sum / n) {
                return sum / n;
            }
            sum -= batteries[i];
            --n;
        }
    }
    
    // 二分
    long long maxRunTime2(int n, vector<int> &batteries) {
        long tot = accumulate(batteries.begin(), batteries.end(), 0L);
        long l = 0, r = tot / n;
        while (l < r) {
            long x = (l + r + 1) / 2, sum = 0;
            for (long b : batteries) {
                sum += min(b, x);
            }
            if (n * x <= sum) {
                l = x;
            } else {
                r = x - 1;
            }
        }
        return l;
    }
};

golang 解法, 执行用时: 128 ms, 内存消耗: 9.8 MB, 提交时间: 2023-10-08 23:03:17

// 二分
func maxRunTime(n int, batteries []int) int64 {
	tot := 0
	for _, b := range batteries {
		tot += b
	}
	return int64(sort.Search(tot/n, func(x int) bool {
		x++
		sum := 0
		for _, b := range batteries {
			sum += min(b, x)
		}
		return n*x > sum
	}))
}

func min(a, b int) int { if a > b { return b }; return a }

// 排序 + 贪心
func maxRunTime2(n int, batteries []int) int64 {
	sort.Ints(batteries)
	sum := 0
	for _, b := range batteries {
		sum += b
	}
	for i := len(batteries) - 1; ; i-- {
		if batteries[i] <= sum/n {
			return int64(sum / n)
		}
		sum -= batteries[i]
		n--
	}
}

上一题

下一题

详情