diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/README.md b/solution/3100-3199/3139.Minimum Cost to Equalize Array/README.md index 4a1856f7904b8..1f95e9097a5eb 100644 --- a/solution/3100-3199/3139.Minimum Cost to Equalize Array/README.md +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/README.md @@ -121,24 +121,163 @@ tags: ```python +class Solution: + MOD = 10 ** 9 + 7 + + def solve(self, k): + sumDifferences = k * len(self.nums) - self.sumNums + + ones = max(2 * (k - self.minNums) - sumDifferences, 0) + if (sumDifferences - ones) & 1 != 0: + ones += 1 + + return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2 + + def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int: + cost2 = min(2 * cost1, cost2) + + self.nums = nums + self.minNums = min(nums) + self.sumNums = sum(nums) + self.cost1 = cost1 + self.cost2 = cost2 + + m = max(nums) + + sameParity = range(m, 10 ** 18, 2) + diffParity = range(m + 1, 10 ** 18, 2) + i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i)) + j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j)) + + return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD + ``` #### Java ```java +class Solution { + public int minCostToEqualizeArray(int[] A, int c1, int c2) { + int ma = A[0], mi = A[0], n = A.length, mod = 1000000007; + long total = 0; + for (int a: A) { + mi = Math.min(mi, a); + ma = Math.max(ma, a); + total += a; + } + total = 1l * ma * n - total; + + if (c1 * 2 <= c2 || n <= 2) { + return (int) ((total * c1) % mod); + } + + long op1 = Math.max(0L, (ma - mi) * 2L - total); + long op2 = total - op1; + long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += op1 / (n - 2) * n; + op1 %= n - 2; + op2 = total - op1; + res = Math.min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = Math.min(res, total % 2 * c1 + total / 2 * c2); + } + return (int) (res % mod); + } +} + ``` #### C++ ```cpp +class Solution { +public: + int minCostToEqualizeArray(vector& A, int c1, int c2) { + int ma = *max_element(A.begin(), A.end()); + int mi = *min_element(A.begin(), A.end()); + int n = A.size(), mod = 1000000007; + long long su = accumulate(A.begin(), A.end(), 0LL); + long long total = 1LL * ma * n - su; + + if (c1 * 2 <= c2 || n <= 2) { + return (total * c1) % mod; + } + + long long op1 = max(0LL, (ma - mi) * 2 - total); + long long op2 = total - op1; + long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += op1 / (n - 2) * n; + op1 %= n - 2; + op2 = total - op1; + res = min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = min(res, total % 2 * c1 + total / 2 * c2); + } + + return res % mod; + } +}; + + ``` #### Go ```go +func minCostToEqualizeArray(nums []int, cost1 int, cost2 int) int { + mx, mod := 0, int(1e9)+7 + for _, v := range nums { + if v > mx { + mx = v + } + } + mv, cnt := 0, 0 + for _, v := range nums { + d := mx - v + if cnt += d; d > mv { + mv = d + } + } + ans := find(mv, cnt, cost1, cost2) + if len(nums) <= 2 { + return ans % mod + } + for (mv<<1) > cnt { + mv, cnt = mv + 1, cnt + len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + } + mv, cnt = mv + 1, cnt + len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + return ans % mod +} + +func find(mv, cnt, c1, c2 int) int { + switch { + case c1<<1 <= c2: + return cnt * c1 + case mv<<1 <= cnt: + return (cnt>>1)*c2 + (cnt&1)*c1 + } + return (cnt-mv)*c2 + (mv<<1-cnt)*c1 +} + +func min(x, y int) int { + if x < y { + return x + } + return y +} + + ``` diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/README_EN.md b/solution/3100-3199/3139.Minimum Cost to Equalize Array/README_EN.md index 6ba8643735da5..7025d886565ad 100644 --- a/solution/3100-3199/3139.Minimum Cost to Equalize Array/README_EN.md +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/README_EN.md @@ -119,24 +119,163 @@ tags: ```python +class Solution: + MOD = 10 ** 9 + 7 + + def solve(self, k): + sumDifferences = k * len(self.nums) - self.sumNums + + ones = max(2 * (k - self.minNums) - sumDifferences, 0) + if (sumDifferences - ones) & 1 != 0: + ones += 1 + + return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2 + + def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int: + cost2 = min(2 * cost1, cost2) + + self.nums = nums + self.minNums = min(nums) + self.sumNums = sum(nums) + self.cost1 = cost1 + self.cost2 = cost2 + + m = max(nums) + + sameParity = range(m, 10 ** 18, 2) + diffParity = range(m + 1, 10 ** 18, 2) + i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i)) + j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j)) + + return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD + ``` #### Java ```java +class Solution { + public int minCostToEqualizeArray(int[] A, int c1, int c2) { + int ma = A[0], mi = A[0], n = A.length, mod = 1000000007; + long total = 0; + for (int a: A) { + mi = Math.min(mi, a); + ma = Math.max(ma, a); + total += a; + } + total = 1l * ma * n - total; + + if (c1 * 2 <= c2 || n <= 2) { + return (int) ((total * c1) % mod); + } + + long op1 = Math.max(0L, (ma - mi) * 2L - total); + long op2 = total - op1; + long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += op1 / (n - 2) * n; + op1 %= n - 2; + op2 = total - op1; + res = Math.min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = Math.min(res, total % 2 * c1 + total / 2 * c2); + } + return (int) (res % mod); + } +} + ``` #### C++ ```cpp +class Solution { +public: + int minCostToEqualizeArray(vector& A, int c1, int c2) { + int ma = *max_element(A.begin(), A.end()); + int mi = *min_element(A.begin(), A.end()); + int n = A.size(), mod = 1000000007; + long long su = accumulate(A.begin(), A.end(), 0LL); + long long total = 1LL * ma * n - su; + + if (c1 * 2 <= c2 || n <= 2) { + return (total * c1) % mod; + } + + long long op1 = max(0LL, (ma - mi) * 2 - total); + long long op2 = total - op1; + long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += op1 / (n - 2) * n; + op1 %= n - 2; + op2 = total - op1; + res = min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = min(res, total % 2 * c1 + total / 2 * c2); + } + + return res % mod; + } +}; + + ``` #### Go ```go +func minCostToEqualizeArray(nums []int, cost1 int, cost2 int) int { + mx, mod := 0, int(1e9)+7 + for _, v := range nums { + if v > mx { + mx = v + } + } + mv, cnt := 0, 0 + for _, v := range nums { + d := mx - v + if cnt += d; d > mv { + mv = d + } + } + ans := find(mv, cnt, cost1, cost2) + if len(nums) <= 2 { + return ans % mod + } + for (mv<<1) > cnt { + mv, cnt = mv + 1, cnt + len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + } + mv, cnt = mv + 1, cnt + len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + return ans % mod +} + +func find(mv, cnt, c1, c2 int) int { + switch { + case c1<<1 <= c2: + return cnt * c1 + case mv<<1 <= cnt: + return (cnt>>1)*c2 + (cnt&1)*c1 + } + return (cnt-mv)*c2 + (mv<<1-cnt)*c1 +} + +func min(x, y int) int { + if x < y { + return x + } + return y +} + + ``` diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.cpp b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.cpp new file mode 100644 index 0000000000000..df0b469f74f20 --- /dev/null +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.cpp @@ -0,0 +1,30 @@ +class Solution { +public: + int minCostToEqualizeArray(std::vector &A, int c1, int c2) { + int ma = *std::max_element(A.begin(), A.end()); + int mi = *std::min_element(A.begin(), A.end()); + int n = A.size(), mod = 1000000007; + long long su = std::accumulate(A.begin(), A.end(), 0LL); + long long total = 1LL * ma * n - su; + + if (c1 * 2 <= c2 || n <= 2) { + return (total * c1) % mod; + } + + long long op1 = std::max(0LL, (ma - mi) * 2 - total); + long long op2 = total - op1; + long long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += op1 / (n - 2) * n; + op1 %= n - 2; + op2 = total - op1; + res = std::min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = std::min(res, total % 2 * c1 + total / 2 * c2); + } + + return res % mod; + } +}; diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.go b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.go new file mode 100644 index 0000000000000..6dae5e358f746 --- /dev/null +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.go @@ -0,0 +1,43 @@ +func minCostToEqualizeArray(nums []int, cost1 int, cost2 int) int { + mx, mod := 0, int(1e9)+7 + for _, v := range nums { + if v > mx { + mx = v + } + } + mv, cnt := 0, 0 + for _, v := range nums { + d := mx - v + if cnt += d; d > mv { + mv = d + } + } + ans := find(mv, cnt, cost1, cost2) + if len(nums) <= 2 { + return ans % mod + } + for (mv << 1) > cnt { + mv, cnt = mv+1, cnt+len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + } + mv, cnt = mv+1, cnt+len(nums) + ans = min(ans, find(mv, cnt, cost1, cost2)) + return ans % mod +} + +func find(mv, cnt, c1, c2 int) int { + switch { + case c1<<1 <= c2: + return cnt * c1 + case mv<<1 <= cnt: + return (cnt>>1)*c2 + (cnt&1)*c1 + } + return (cnt-mv)*c2 + (mv<<1-cnt)*c1 +} + +func min(x, y int) int { + if x < y { + return x + } + return y +} diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.java b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.java new file mode 100644 index 0000000000000..e8bd78bcf65ae --- /dev/null +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.java @@ -0,0 +1,32 @@ +class Solution { + public int minCostToEqualizeArray(int[] A, int c1, int c2) { + int ma = A[0], mi = A[0], n = A.length, mod = 1000000007; + long total = 0; + for (int a : A) { + mi = Math.min(mi, a); + ma = Math.max(ma, a); + total += a; + } + total = 1L * ma * n - total; + + if (c1 * 2 <= c2 || n <= 2) { + return (int) ((total * c1) % mod); + } + + long op1 = Math.max(0L, (ma - mi) * 2L - total); + long op2 = total - op1; + long res = (op1 + op2 % 2) * c1 + op2 / 2 * c2; + + total += (op1 / (n - 2)) * n; + op1 %= (n - 2); + op2 = total - op1; + res = Math.min(res, (op1 + op2 % 2) * c1 + op2 / 2 * c2); + + for (int i = 0; i < 2; i++) { + total += n; + res = Math.min(res, (total % 2) * c1 + (total / 2) * c2); + } + + return (int) (res % mod); + } +} diff --git a/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.py b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.py new file mode 100644 index 0000000000000..835fa193d4f9f --- /dev/null +++ b/solution/3100-3199/3139.Minimum Cost to Equalize Array/Solution.py @@ -0,0 +1,21 @@ +class Solution: + MOD = 10**9 + 7 + def solve(self, k): + sumDifferences = k * len(self.nums) - self.sumNums + ones = max(2 * (k - self.minNums) - sumDifferences, 0) + if (sumDifferences - ones) & 1 != 0: + ones += 1 + return ones * self.cost1 + ((sumDifferences - ones) // 2) * self.cost2 + def minCostToEqualizeArray(self, nums: List[int], cost1: int, cost2: int) -> int: + cost2 = min(2 * cost1, cost2) + self.nums = nums + self.minNums = min(nums) + self.sumNums = sum(nums) + self.cost1 = cost1 + self.cost2 = cost2 + m = max(nums) + sameParity = range(m, 10**18, 2) + diffParity = range(m + 1, 10**18, 2) + i = bisect_left(sameParity, 0, key=lambda i: self.solve(i + 2) - self.solve(i)) + j = bisect_left(diffParity, 0, key=lambda j: self.solve(j + 2) - self.solve(j)) + return min(self.solve(sameParity[i]), self.solve(diffParity[j])) % Solution.MOD