Skip to content

Commit b2d0ecf

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2499
No.2499.Minimum Total Cost to Make Arrays Unequal
1 parent 78408a6 commit b2d0ecf

File tree

10 files changed

+366
-17
lines changed

10 files changed

+366
-17
lines changed

‎solution/2400-2499/2499.Minimum Total Cost to Make Arrays Unequal/README.md

+126-4
Original file line numberDiff line numberDiff line change
@@ -66,34 +66,156 @@
6666

6767
<!-- 这里可写通用的实现逻辑 -->
6868

69+
**方法一：贪心**
70+
71+
我们先同时遍历数组 `nums1` 和 `nums2`，统计相同位置上的值相同的个数 `same`，这些位置上的值必须交换，因此，将这些位置下标累加到答案中。另外，用数组或哈希表 `cnt` 统计这些相同值的出现次数。
72+
73+
如果所有相同值的出现次数均不超过 `same` 的一半，那么意味着，我们可以在其内部，通过两两交换，使得对应位置上的值不同，而这些交换，已经在上面累加下标时计入了答案中了，无需额外的代价。否则，如果某个值的出现次数超过 `same` 的一半，那么对于这个值就是多出的个数，我们需要在数组的其他位置上找到合适的，进行交换。这里我们可以直接遍历一遍数组得出。
74+
75+
如果最终还有剩余位置未能交换，说明无法达成目标，返回 $-1$ 即可，否则返回答案。
76+
77+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 `nums1` 或 `nums2` 的长度。
78+
6979
<!-- tabs:start -->
7080

7181
### **Python3**
7282

7383
<!-- 这里可写当前语言的特殊实现逻辑 -->
7484

7585
```python
76-
86+
class Solution:
87+
def minimumTotalCost(self, nums1: List[int], nums2: List[int]) -> int:
88+
ans = same = 0
89+
cnt = Counter()
90+
for i, (a, b) in enumerate(zip(nums1, nums2)):
91+
if a == b:
92+
same += 1
93+
ans += i
94+
cnt[a] += 1
95+
96+
m = lead = 0
97+
for k, v in cnt.items():
98+
if v * 2 > same:
99+
m = v * 2 - same
100+
lead = k
101+
break
102+
for i, (a, b) in enumerate(zip(nums1, nums2)):
103+
if m and a != b and a != lead and b != lead:
104+
ans += i
105+
m -= 1
106+
return -1 if m else ans
77107
```
78108

79109
### **Java**
80110

81111
<!-- 这里可写当前语言的特殊实现逻辑 -->
82112

83113
```java
84-
114+
class Solution {
115+
public long minimumTotalCost(int[] nums1, int[] nums2) {
116+
long ans = 0;
117+
int same = 0;
118+
int n = nums1.length;
119+
int[] cnt = new int[n + 1];
120+
for (int i = 0; i < n; ++i) {
121+
if (nums1[i] == nums2[i]) {
122+
ans += i;
123+
++same;
124+
++cnt[nums1[i]];
125+
}
126+
}
127+
int m = 0, lead = 0;
128+
for (int i = 0; i < cnt.length; ++i) {
129+
int t = cnt[i] * 2 - same;
130+
if (t > 0) {
131+
m = t;
132+
lead = i;
133+
break;
134+
}
135+
}
136+
for (int i = 0; i < n; ++i) {
137+
if (m > 0 && nums1[i] != nums2[i] && nums1[i] != lead && nums2[i] != lead) {
138+
ans += i;
139+
--m;
140+
}
141+
}
142+
return m > 0 ? -1 : ans;
143+
}
144+
}
85145
```
86146

87147
### **C++**
88148

89149
```cpp
90-
150+
class Solution {
151+
public:
152+
long long minimumTotalCost(vector<int>& nums1, vector<int>& nums2) {
153+
long long ans = 0;
154+
int same = 0;
155+
int n = nums1.size();
156+
int cnt[n + 1];
157+
memset(cnt, 0, sizeof cnt);
158+
for (int i = 0; i < n; ++i) {
159+
if (nums1[i] == nums2[i]) {
160+
ans += i;
161+
++same;
162+
++cnt[nums1[i]];
163+
}
164+
}
165+
int m = 0, lead = 0;
166+
for (int i = 0; i < n + 1; ++i) {
167+
int t = cnt[i] * 2 - same;
168+
if (t > 0) {
169+
m = t;
170+
lead = i;
171+
break;
172+
}
173+
}
174+
for (int i = 0; i < n; ++i) {
175+
if (m > 0 && nums1[i] != nums2[i] && nums1[i] != lead && nums2[i] != lead) {
176+
ans += i;
177+
--m;
178+
}
179+
}
180+
return m > 0 ? -1 : ans;
181+
}
182+
};
91183
```
92184
93185
### **Go**
94186
95187
```go
96-
188+
func minimumTotalCost(nums1 []int, nums2 []int) (ans int64) {
189+
same, n := 0, len(nums1)
190+
cnt := make([]int, n+1)
191+
for i, a := range nums1 {
192+
b := nums2[i]
193+
if a == b {
194+
same++
195+
ans += int64(i)
196+
cnt[a]++
197+
}
198+
}
199+
var m, lead int
200+
for i, v := range cnt {
201+
if t := v*2 - same; t > 0 {
202+
m = t
203+
lead = i
204+
break
205+
}
206+
}
207+
for i, a := range nums1 {
208+
b := nums2[i]
209+
if m > 0 && a != b && a != lead && b != lead {
210+
ans += int64(i)
211+
m--
212+
}
213+
}
214+
if m > 0 {
215+
return -1
216+
}
217+
return ans
218+
}
97219
```
98220

99221
### **...**

‎solution/2400-2499/2499.Minimum Total Cost to Make Arrays Unequal/README_EN.md

+116-4
Original file line numberDiff line numberDiff line change
@@ -65,25 +65,137 @@ Hence, we return -1.
6565
### **Python3**
6666

6767
```python
68-
68+
class Solution:
69+
def minimumTotalCost(self, nums1: List[int], nums2: List[int]) -> int:
70+
ans = same = 0
71+
cnt = Counter()
72+
for i, (a, b) in enumerate(zip(nums1, nums2)):
73+
if a == b:
74+
same += 1
75+
ans += i
76+
cnt[a] += 1
77+
78+
m = lead = 0
79+
for k, v in cnt.items():
80+
if v * 2 > same:
81+
m = v * 2 - same
82+
lead = k
83+
break
84+
for i, (a, b) in enumerate(zip(nums1, nums2)):
85+
if m and a != b and a != lead and b != lead:
86+
ans += i
87+
m -= 1
88+
return -1 if m else ans
6989
```
7090

7191
### **Java**
7292

7393
```java
74-
94+
class Solution {
95+
public long minimumTotalCost(int[] nums1, int[] nums2) {
96+
long ans = 0;
97+
int same = 0;
98+
int n = nums1.length;
99+
int[] cnt = new int[n + 1];
100+
for (int i = 0; i < n; ++i) {
101+
if (nums1[i] == nums2[i]) {
102+
ans += i;
103+
++same;
104+
++cnt[nums1[i]];
105+
}
106+
}
107+
int m = 0, lead = 0;
108+
for (int i = 0; i < cnt.length; ++i) {
109+
int t = cnt[i] * 2 - same;
110+
if (t > 0) {
111+
m = t;
112+
lead = i;
113+
break;
114+
}
115+
}
116+
for (int i = 0; i < n; ++i) {
117+
if (m > 0 && nums1[i] != nums2[i] && nums1[i] != lead && nums2[i] != lead) {
118+
ans += i;
119+
--m;
120+
}
121+
}
122+
return m > 0 ? -1 : ans;
123+
}
124+
}
75125
```
76126

77127
### **C++**
78128

79129
```cpp
80-
130+
class Solution {
131+
public:
132+
long long minimumTotalCost(vector<int>& nums1, vector<int>& nums2) {
133+
long long ans = 0;
134+
int same = 0;
135+
int n = nums1.size();
136+
int cnt[n + 1];
137+
memset(cnt, 0, sizeof cnt);
138+
for (int i = 0; i < n; ++i) {
139+
if (nums1[i] == nums2[i]) {
140+
ans += i;
141+
++same;
142+
++cnt[nums1[i]];
143+
}
144+
}
145+
int m = 0, lead = 0;
146+
for (int i = 0; i < n + 1; ++i) {
147+
int t = cnt[i] * 2 - same;
148+
if (t > 0) {
149+
m = t;
150+
lead = i;
151+
break;
152+
}
153+
}
154+
for (int i = 0; i < n; ++i) {
155+
if (m > 0 && nums1[i] != nums2[i] && nums1[i] != lead && nums2[i] != lead) {
156+
ans += i;
157+
--m;
158+
}
159+
}
160+
return m > 0 ? -1 : ans;
161+
}
162+
};
81163
```
82164
83165
### **Go**
84166
85167
```go
86-
168+
func minimumTotalCost(nums1 []int, nums2 []int) (ans int64) {
169+
same, n := 0, len(nums1)
170+
cnt := make([]int, n+1)
171+
for i, a := range nums1 {
172+
b := nums2[i]
173+
if a == b {
174+
same++
175+
ans += int64(i)
176+
cnt[a]++
177+
}
178+
}
179+
var m, lead int
180+
for i, v := range cnt {
181+
if t := v*2 - same; t > 0 {
182+
m = t
183+
lead = i
184+
break
185+
}
186+
}
187+
for i, a := range nums1 {
188+
b := nums2[i]
189+
if m > 0 && a != b && a != lead && b != lead {
190+
ans += int64(i)
191+
m--
192+
}
193+
}
194+
if m > 0 {
195+
return -1
196+
}
197+
return ans
198+
}
87199
```
88200

89201
### **...**

‎solution/2400-2499/2499.Minimum Total Cost to Make Arrays Unequal/Solution.cpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
class Solution {
2+
public:
3+
long long minimumTotalCost(vector<int>& nums1, vector<int>& nums2) {
4+
long long ans = 0;
5+
int same = 0;
6+
int n = nums1.size();
7+
int cnt[n + 1];
8+
memset(cnt, 0, sizeof cnt);
9+
for (int i = 0; i < n; ++i) {
10+
if (nums1[i] == nums2[i]) {
11+
ans += i;
12+
++same;
13+
++cnt[nums1[i]];
14+
}
15+
}
16+
int m = 0, lead = 0;
17+
for (int i = 0; i < n + 1; ++i) {
18+
int t = cnt[i] * 2 - same;
19+
if (t > 0) {
20+
m = t;
21+
lead = i;
22+
break;
23+
}
24+
}
25+
for (int i = 0; i < n; ++i) {
26+
if (m > 0 && nums1[i] != nums2[i] && nums1[i] != lead && nums2[i] != lead) {
27+
ans += i;
28+
--m;
29+
}
30+
}
31+
return m > 0 ? -1 : ans;
32+
}
33+
};

‎solution/2400-2499/2499.Minimum Total Cost to Make Arrays Unequal/Solution.go

+31
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
func minimumTotalCost(nums1 []int, nums2 []int) (ans int64) {
2+
same, n := 0, len(nums1)
3+
cnt := make([]int, n+1)
4+
for i, a := range nums1 {
5+
b := nums2[i]
6+
if a == b {
7+
same++
8+
ans += int64(i)
9+
cnt[a]++
10+
}
11+
}
12+
var m, lead int
13+
for i, v := range cnt {
14+
if t := v*2 - same; t > 0 {
15+
m = t
16+
lead = i
17+
break
18+
}
19+
}
20+
for i, a := range nums1 {
21+
b := nums2[i]
22+
if m > 0 && a != b && a != lead && b != lead {
23+
ans += int64(i)
24+
m--
25+
}
26+
}
27+
if m > 0 {
28+
return -1
29+
}
30+
return ans
31+
}

0 commit comments

Comments
 (0)