Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit f0ec4ac

Browse files
feat: add solutions to lc problem: No.2967 (#2113)
No.2967.Minimum Cost to Make Array Equalindromic
1 parent 3e04854 commit f0ec4ac

File tree

7 files changed

+585
-6
lines changed

7 files changed

+585
-6
lines changed

‎solution/2900-2999/2967.Minimum Cost to Make Array Equalindromic/README.md‎

Lines changed: 199 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -64,34 +64,230 @@
6464

6565
<!-- 这里可写通用的实现逻辑 -->
6666

67+
**方法一:预处理 + 排序 + 二分查找**
68+
69+
题目中回文数的范围是 $[1, 10^9],ドル回文数由于对称性,我们可以在 $[1, 10^5]$ 的范围内枚举,然后将其翻转后拼接,得到所有的回文数,注意,如果是奇数长度的回文数,我们在翻转前要去掉最后一位。预处理得到的回文数数组记为 $ps$。我们对数组 $ps$ 进行排序。
70+
71+
接下来,我们对数组 $nums$ 进行排序,然后取 $nums$ 的中位数 $x,ドル我们只需要通过二分查找,在回文数组 $ps$ 中,找到一个与 $x$ 最接近的数,然后计算 $nums$ 变成这个数的代价,即可得到答案。
72+
73+
时间复杂度 $O(n \times \log n),ドル空间复杂度 $O(M)$。其中 $n$ 是数组 $nums$ 的长度,而 $M$ 是回文数组 $ps$ 的长度。
74+
6775
<!-- tabs:start -->
6876

6977
### **Python3**
7078

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

7381
```python
74-
82+
ps = []
83+
for i in range(1, 10**5 + 1):
84+
s = str(i)
85+
t1 = s[::-1]
86+
t2 = s[:-1][::-1]
87+
ps.append(int(s + t1))
88+
ps.append(int(s + t2))
89+
ps.sort()
90+
91+
92+
class Solution:
93+
def minimumCost(self, nums: List[int]) -> int:
94+
def f(x: int) -> int:
95+
return sum(abs(v - x) for v in nums)
96+
97+
nums.sort()
98+
i = bisect_left(ps, nums[len(nums) // 2])
99+
return min(f(ps[j]) for j in range(i - 1, i + 2) if 0 <= j < len(ps))
75100
```
76101

77102
### **Java**
78103

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

81106
```java
82-
107+
public class Solution {
108+
private static long[] ps;
109+
private int[] nums;
110+
111+
static {
112+
ps = new long[2 * (int) 1e5];
113+
for (int i = 1; i <= 1e5; i++) {
114+
String s = Integer.toString(i);
115+
String t1 = new StringBuilder(s).reverse().toString();
116+
String t2 = new StringBuilder(s.substring(0, s.length() - 1)).reverse().toString();
117+
ps[2 * i - 2] = Long.parseLong(s + t1);
118+
ps[2 * i - 1] = Long.parseLong(s + t2);
119+
}
120+
Arrays.sort(ps);
121+
}
122+
123+
public long minimumCost(int[] nums) {
124+
this.nums = nums;
125+
Arrays.sort(nums);
126+
int i = Arrays.binarySearch(ps, nums[nums.length / 2]);
127+
i = i < 0 ? -i - 1 : i;
128+
long ans = 1L << 60;
129+
for (int j = i - 1; j <= i + 1; j++) {
130+
if (0 <= j && j < ps.length) {
131+
ans = Math.min(ans, f(ps[j]));
132+
}
133+
}
134+
return ans;
135+
}
136+
137+
private long f(long x) {
138+
long ans = 0;
139+
for (int v : nums) {
140+
ans += Math.abs(v - x);
141+
}
142+
return ans;
143+
}
144+
}
83145
```
84146

85147
### **C++**
86148

87149
```cpp
88-
150+
using ll = long long;
151+
152+
ll ps[2 * 100000];
153+
154+
int init = [] {
155+
for (int i = 1; i <= 100000; i++) {
156+
string s = to_string(i);
157+
string t1 = s;
158+
reverse(t1.begin(), t1.end());
159+
string t2 = s.substr(0, s.length() - 1);
160+
reverse(t2.begin(), t2.end());
161+
ps[2 * i - 2] = stoll(s + t1);
162+
ps[2 * i - 1] = stoll(s + t2);
163+
}
164+
sort(ps, ps + 2 * 100000);
165+
return 0;
166+
}();
167+
168+
class Solution {
169+
public:
170+
long long minimumCost(vector<int>& nums) {
171+
sort(nums.begin(), nums.end());
172+
int i = lower_bound(ps, ps + 2 * 100000, nums[nums.size() / 2]) - ps;
173+
auto f = [&](ll x) {
174+
ll ans = 0;
175+
for (int& v : nums) {
176+
ans += abs(v - x);
177+
}
178+
return ans;
179+
};
180+
ll ans = LLONG_MAX;
181+
for (int j = i - 1; j <= i + 1; j++) {
182+
if (0 <= j && j < 2 * 100000) {
183+
ans = min(ans, f(ps[j]));
184+
}
185+
}
186+
return ans;
187+
}
188+
};
89189
```
90190
91191
### **Go**
92192
93193
```go
194+
var ps [2 * 100000]int64
195+
196+
func init() {
197+
for i := 1; i <= 100000; i++ {
198+
s := strconv.Itoa(i)
199+
t1 := reverseString(s)
200+
t2 := reverseString(s[:len(s)-1])
201+
ps[2*i-2], _ = strconv.ParseInt(s+t1, 10, 64)
202+
ps[2*i-1], _ = strconv.ParseInt(s+t2, 10, 64)
203+
}
204+
sort.Slice(ps[:], func(i, j int) bool {
205+
return ps[i] < ps[j]
206+
})
207+
}
208+
209+
func reverseString(s string) string {
210+
cs := []rune(s)
211+
for i, j := 0, len(cs)-1; i < j; i, j = i+1, j-1 {
212+
cs[i], cs[j] = cs[j], cs[i]
213+
}
214+
return string(cs)
215+
}
216+
217+
func minimumCost(nums []int) int64 {
218+
sort.Ints(nums)
219+
i := sort.Search(len(ps), func(i int) bool {
220+
return ps[i] >= int64(nums[len(nums)/2])
221+
})
222+
223+
f := func(x int64) int64 {
224+
var ans int64
225+
for _, v := range nums {
226+
ans += int64(abs(int(x - int64(v))))
227+
}
228+
return ans
229+
}
230+
231+
ans := int64(math.MaxInt64)
232+
for j := i - 1; j <= i+1; j++ {
233+
if 0 <= j && j < len(ps) {
234+
ans = min(ans, f(ps[j]))
235+
}
236+
}
237+
return ans
238+
}
239+
240+
func abs(x int) int {
241+
if x < 0 {
242+
return -x
243+
}
244+
return x
245+
}
246+
```
94247

248+
### **TypeScript**
249+
250+
```ts
251+
const ps = Array(2e5).fill(0);
252+
253+
const init = (() => {
254+
for (let i = 1; i <= 1e5; ++i) {
255+
const s: string = i.toString();
256+
const t1: string = s.split('').reverse().join('');
257+
const t2: string = s.slice(0, -1).split('').reverse().join('');
258+
ps[2 * i - 2] = parseInt(s + t1, 10);
259+
ps[2 * i - 1] = parseInt(s + t2, 10);
260+
}
261+
ps.sort((a, b) => a - b);
262+
})();
263+
264+
function minimumCost(nums: number[]): number {
265+
const search = (x: number): number => {
266+
let [l, r] = [0, ps.length];
267+
while (l < r) {
268+
const mid = (l + r) >> 1;
269+
if (ps[mid] >= x) {
270+
r = mid;
271+
} else {
272+
l = mid + 1;
273+
}
274+
}
275+
return l;
276+
};
277+
const f = (x: number): number => {
278+
return nums.reduce((acc, v) => acc + Math.abs(v - x), 0);
279+
};
280+
281+
nums.sort((a, b) => a - b);
282+
const i: number = search(nums[nums.length >> 1]);
283+
let ans: number = Number.MAX_SAFE_INTEGER;
284+
for (let j = i - 1; j <= i + 1; j++) {
285+
if (j >= 0 && j < ps.length) {
286+
ans = Math.min(ans, f(ps[j]));
287+
}
288+
}
289+
return ans;
290+
}
95291
```
96292

97293
### **...**

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /