diff --git a/solution/3400-3499/3470.Permutations IV/README.md b/solution/3400-3499/3470.Permutations IV/README.md index 81b40ed8af1ec..7b7ec7de99442 100644 --- a/solution/3400-3499/3470.Permutations IV/README.md +++ b/solution/3400-3499/3470.Permutations IV/README.md @@ -114,24 +114,348 @@ tags: ```python +from typing import List +from math import factorial +import heapq + +class Solution: + def permute(self, xxy: int, yyz: int) -> List[int]: + + kasu = {} + nnss = [] + majs = [] + ajwi = heapq.heappush + laoq = [] + + zzp = [i for i in range(1, xxy + 1) if i % 2 == 1] + zzq = [i for i in range(1, xxy + 1) if i % 2 == 0] + + ppp = [] + nxr = None + + for pps in range(xxy): + if pps == 0: + cnd = sorted(zzp + zzq) + else: + cnd = zzp if nxr == 1 else zzq + + fff = False + for cndt in cnd: + if cndt % 2 == 1: + nxt = 0 + noo = len(zzp) - 1 + nee = len(zzq) + else: + nxt = 1 + noo = len(zzp) + nee = len(zzq) - 1 + + llq = noo + nee + if llq == 0: + cnt = 1 + else: + if nxt == 1: + if noo != (llq + 1) // 2 or nee != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + else: + if nee != (llq + 1) // 2 or noo != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + + ajwi(nnss, cnt) + ajwi(majs, llq) + + if cnt >= yyz: + ppp.append(cndt) + if cndt % 2 == 1: + zzp.remove(cndt) + nxr = 0 + else: + zzq.remove(cndt) + nxr = 1 + fff = True + break + else: + yyz -= cnt + + ajwi(laoq, len(ppp)) + + if not fff: + return [] + return ppp + ``` #### Java ```java +import java.util.*; + +class DPHelper { + static final long ok = 10000000000000000L; + long[][][] dp = new long[101][101][2]; + boolean[][][] vis = new boolean[101][101][2]; + + long compute(int o, int e, int p) { + if (o == 0 && e == 0) return 1; + if (vis[o][e][p]) return dp[o][e][p]; + + long r = 0; + if (p == 1) { + if (o == 0) r = 0; + else r = o * compute(o - 1, e, 0); + } else { + if (e == 0) r = 0; + else r = e * compute(o, e - 1, 1); + } + + if (r > ok) r = ok; + vis[o][e][p] = true; + dp[o][e][p] = r; + return r; + } +} + +class SortHelper { + void sortList(ArrayList list) { + Collections.sort(list); + } +} + +class PermutationHelper { + List buildPermutation(int p, ArrayList O, ArrayList E, long k, DPHelper d) { + List ans = new ArrayList<>(); + if (O.size() + E.size() == 0) return ans; + int i = 0; + + if (p == 1) { + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } + } else { + while (i < E.size()) { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = E.get(i); + E.remove(i); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + } + return ans; + } + + List alternateFormation(ArrayList O, ArrayList E, long k, DPHelper d, int n, SortHelper s) { + List ans = new ArrayList<>(); + int tot = O.size() + E.size(); + if (tot % 2 == 1) { + int i = 0; + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + i++; + } + } else { + ArrayList U = new ArrayList<>(); + U.addAll(O); + U.addAll(E); + s.sortList(U); + int i = 0; + while (i < U.size()) { + int x = U.get(i); + if (O.contains(x)) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int idx = O.indexOf(x); + O.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } else { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + } else { + int idx = E.indexOf(x); + E.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + i++; + } + } + return ans; + } +} + +class Solution { + public int[] permute(int n, long k) { + int o = (n + 1) / 2, e = n / 2; + ArrayList O = new ArrayList<>(), E = new ArrayList<>(); + + for (int i = 1; i <= n; i++) { + if (i % 2 == 1) O.add(i); + else E.add(i); + } + + SortHelper s = new SortHelper(); + s.sortList(O); + s.sortList(E); + + DPHelper d = new DPHelper(); + PermutationHelper ph = new PermutationHelper(); + + long tot = 0; + if (n % 2 == 1) tot = d.compute(O.size() - 1, E.size(), 0) * O.size(); + else tot = d.compute(O.size() - 1, E.size(), 0) * O.size() + d.compute(O.size(), E.size() - 1, 1) * E.size(); + + if (k > tot) return new int[0]; + + List res = ph.alternateFormation(O, E, k, d, n, s); + int[] ans = new int[res.size()]; + for (int i = 0; i < res.size(); i++) ans[i] = res.get(i); + + return ans; + } +} + ``` #### C++ ```cpp +class Solution { + long long f[105]; +public: + vector permute(int n, long long k) { + int i,j; + for(i=f[0]=1;i<=n;i++)if(f[i-1]>=k)f[i]=k; + else f[i]=f[i-1]*(i+1>>1); + if(!(n&1))f[n]*=2; + if(f[n] ans(n),a[2]; + for(i=0;i= k { + f[i] = k + } else { + f[i] = f[i-1] * int64((i+1)>>1) + } + } + if n%2 == 0 { + f[n] *= 2 + } + if f[n] < k { + return []int{} + } + k-- + ans := make([]int, n) + a := [2][]int{} + for i := 0; i < n; i++ { + a[i&1] = append(a[i&1], i) + } + + if n%2 == 1 { + ans[0] = int(k/f[n-1]) * 2 + k -= int64(ans[0]/2) * f[n-1] + } else { + ans[0] = int(k / f[n-1]) + k -= int64(ans[0]) * f[n-1] + } + + index := sort.SearchInts(a[ans[0]&1], ans[0]) + a[ans[0]&1] = append(a[ans[0]&1][:index], a[ans[0]&1][index+1:]...) + + for i := 1; i < n; i++ { + if n%2 == 1 { + ans[i] = a[i&1][k/f[n-i-1]] + } else { + ans[i] = a[(ans[0]^i)&1][k/f[n-i-1]] + } + k %= f[n-i-1] + + index = sort.SearchInts(a[ans[i]&1], ans[i]) + a[ans[i]&1] = append(a[ans[i]&1][:index], a[ans[i]&1][index+1:]...) + } + + for i := 0; i < n; i++ { + ans[i]++ + } + return ans +} + ``` diff --git a/solution/3400-3499/3470.Permutations IV/README_EN.md b/solution/3400-3499/3470.Permutations IV/README_EN.md index 611ba7acccf97..dbfc4bc2e0861 100644 --- a/solution/3400-3499/3470.Permutations IV/README_EN.md +++ b/solution/3400-3499/3470.Permutations IV/README_EN.md @@ -111,24 +111,348 @@ tags: ```python +from typing import List +from math import factorial +import heapq + +class Solution: + def permute(self, xxy: int, yyz: int) -> List[int]: + + kasu = {} + nnss = [] + majs = [] + ajwi = heapq.heappush + laoq = [] + + zzp = [i for i in range(1, xxy + 1) if i % 2 == 1] + zzq = [i for i in range(1, xxy + 1) if i % 2 == 0] + + ppp = [] + nxr = None + + for pps in range(xxy): + if pps == 0: + cnd = sorted(zzp + zzq) + else: + cnd = zzp if nxr == 1 else zzq + + fff = False + for cndt in cnd: + if cndt % 2 == 1: + nxt = 0 + noo = len(zzp) - 1 + nee = len(zzq) + else: + nxt = 1 + noo = len(zzp) + nee = len(zzq) - 1 + + llq = noo + nee + if llq == 0: + cnt = 1 + else: + if nxt == 1: + if noo != (llq + 1) // 2 or nee != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + else: + if nee != (llq + 1) // 2 or noo != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + + ajwi(nnss, cnt) + ajwi(majs, llq) + + if cnt >= yyz: + ppp.append(cndt) + if cndt % 2 == 1: + zzp.remove(cndt) + nxr = 0 + else: + zzq.remove(cndt) + nxr = 1 + fff = True + break + else: + yyz -= cnt + + ajwi(laoq, len(ppp)) + + if not fff: + return [] + return ppp + ``` #### Java ```java +import java.util.*; + +class DPHelper { + static final long ok = 10000000000000000L; + long[][][] dp = new long[101][101][2]; + boolean[][][] vis = new boolean[101][101][2]; + + long compute(int o, int e, int p) { + if (o == 0 && e == 0) return 1; + if (vis[o][e][p]) return dp[o][e][p]; + + long r = 0; + if (p == 1) { + if (o == 0) r = 0; + else r = o * compute(o - 1, e, 0); + } else { + if (e == 0) r = 0; + else r = e * compute(o, e - 1, 1); + } + + if (r > ok) r = ok; + vis[o][e][p] = true; + dp[o][e][p] = r; + return r; + } +} + +class SortHelper { + void sortList(ArrayList list) { + Collections.sort(list); + } +} + +class PermutationHelper { + List buildPermutation(int p, ArrayList O, ArrayList E, long k, DPHelper d) { + List ans = new ArrayList<>(); + if (O.size() + E.size() == 0) return ans; + int i = 0; + + if (p == 1) { + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } + } else { + while (i < E.size()) { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = E.get(i); + E.remove(i); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + } + return ans; + } + + List alternateFormation(ArrayList O, ArrayList E, long k, DPHelper d, int n, SortHelper s) { + List ans = new ArrayList<>(); + int tot = O.size() + E.size(); + if (tot % 2 == 1) { + int i = 0; + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + i++; + } + } else { + ArrayList U = new ArrayList<>(); + U.addAll(O); + U.addAll(E); + s.sortList(U); + int i = 0; + while (i < U.size()) { + int x = U.get(i); + if (O.contains(x)) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int idx = O.indexOf(x); + O.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } else { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + } else { + int idx = E.indexOf(x); + E.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + i++; + } + } + return ans; + } +} + +class Solution { + public int[] permute(int n, long k) { + int o = (n + 1) / 2, e = n / 2; + ArrayList O = new ArrayList<>(), E = new ArrayList<>(); + + for (int i = 1; i <= n; i++) { + if (i % 2 == 1) O.add(i); + else E.add(i); + } + + SortHelper s = new SortHelper(); + s.sortList(O); + s.sortList(E); + + DPHelper d = new DPHelper(); + PermutationHelper ph = new PermutationHelper(); + + long tot = 0; + if (n % 2 == 1) tot = d.compute(O.size() - 1, E.size(), 0) * O.size(); + else tot = d.compute(O.size() - 1, E.size(), 0) * O.size() + d.compute(O.size(), E.size() - 1, 1) * E.size(); + + if (k > tot) return new int[0]; + + List res = ph.alternateFormation(O, E, k, d, n, s); + int[] ans = new int[res.size()]; + for (int i = 0; i < res.size(); i++) ans[i] = res.get(i); + + return ans; + } +} + ``` #### C++ ```cpp +class Solution { + long long f[105]; +public: + vector permute(int n, long long k) { + int i,j; + for(i=f[0]=1;i<=n;i++)if(f[i-1]>=k)f[i]=k; + else f[i]=f[i-1]*(i+1>>1); + if(!(n&1))f[n]*=2; + if(f[n] ans(n),a[2]; + for(i=0;i= k { + f[i] = k + } else { + f[i] = f[i-1] * int64((i+1)>>1) + } + } + if n%2 == 0 { + f[n] *= 2 + } + if f[n] < k { + return []int{} + } + k-- + ans := make([]int, n) + a := [2][]int{} + for i := 0; i < n; i++ { + a[i&1] = append(a[i&1], i) + } + + if n%2 == 1 { + ans[0] = int(k/f[n-1]) * 2 + k -= int64(ans[0]/2) * f[n-1] + } else { + ans[0] = int(k / f[n-1]) + k -= int64(ans[0]) * f[n-1] + } + + index := sort.SearchInts(a[ans[0]&1], ans[0]) + a[ans[0]&1] = append(a[ans[0]&1][:index], a[ans[0]&1][index+1:]...) + + for i := 1; i < n; i++ { + if n%2 == 1 { + ans[i] = a[i&1][k/f[n-i-1]] + } else { + ans[i] = a[(ans[0]^i)&1][k/f[n-i-1]] + } + k %= f[n-i-1] + + index = sort.SearchInts(a[ans[i]&1], ans[i]) + a[ans[i]&1] = append(a[ans[i]&1][:index], a[ans[i]&1][index+1:]...) + } + + for i := 0; i < n; i++ { + ans[i]++ + } + return ans +} + ``` diff --git a/solution/3400-3499/3470.Permutations IV/solution.cpp b/solution/3400-3499/3470.Permutations IV/solution.cpp new file mode 100644 index 0000000000000..d4141209a683e --- /dev/null +++ b/solution/3400-3499/3470.Permutations IV/solution.cpp @@ -0,0 +1,40 @@ +class Solution { + long long f[105]; +public: + vector permute(int n, long long k) { + int i,j; + for(i=f[0]=1;i<=n;i++)if(f[i-1]>=k)f[i]=k; + else f[i]=f[i-1]*(i+1>>1); + if(!(n&1))f[n]*=2; + if(f[n] ans(n),a[2]; + for(i=0;i= k { + f[i] = k + } else { + f[i] = f[i-1] * int64((i+1)>>1) + } + } + if n%2 == 0 { + f[n] *= 2 + } + if f[n] < k { + return []int{} + } + k-- + ans := make([]int, n) + a := [2][]int{} + for i := 0; i < n; i++ { + a[i&1] = append(a[i&1], i) + } + + if n%2 == 1 { + ans[0] = int(k/f[n-1]) * 2 + k -= int64(ans[0]/2) * f[n-1] + } else { + ans[0] = int(k / f[n-1]) + k -= int64(ans[0]) * f[n-1] + } + + index := sort.SearchInts(a[ans[0]&1], ans[0]) + a[ans[0]&1] = append(a[ans[0]&1][:index], a[ans[0]&1][index+1:]...) + + for i := 1; i < n; i++ { + if n%2 == 1 { + ans[i] = a[i&1][k/f[n-i-1]] + } else { + ans[i] = a[(ans[0]^i)&1][k/f[n-i-1]] + } + k %= f[n-i-1] + + index = sort.SearchInts(a[ans[i]&1], ans[i]) + a[ans[i]&1] = append(a[ans[i]&1][:index], a[ans[i]&1][index+1:]...) + } + + for i := 0; i < n; i++ { + ans[i]++ + } + return ans +} \ No newline at end of file diff --git a/solution/3400-3499/3470.Permutations IV/solution.java b/solution/3400-3499/3470.Permutations IV/solution.java new file mode 100644 index 0000000000000..5bb48f9c0010d --- /dev/null +++ b/solution/3400-3499/3470.Permutations IV/solution.java @@ -0,0 +1,157 @@ +import java.util.*; + +class DPHelper { + static final long ok = 10000000000000000L; + long[][][] dp = new long[101][101][2]; + boolean[][][] vis = new boolean[101][101][2]; + + long compute(int o, int e, int p) { + if (o == 0 && e == 0) return 1; + if (vis[o][e][p]) return dp[o][e][p]; + + long r = 0; + if (p == 1) { + if (o == 0) r = 0; + else r = o * compute(o - 1, e, 0); + } else { + if (e == 0) r = 0; + else r = e * compute(o, e - 1, 1); + } + + if (r > ok) r = ok; + vis[o][e][p] = true; + dp[o][e][p] = r; + return r; + } +} + +class SortHelper { + void sortList(ArrayList list) { + Collections.sort(list); + } +} + +class PermutationHelper { + List buildPermutation(int p, ArrayList O, ArrayList E, long k, DPHelper d) { + List ans = new ArrayList<>(); + if (O.size() + E.size() == 0) return ans; + int i = 0; + + if (p == 1) { + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } + } else { + while (i < E.size()) { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + i++; + } else { + int x = E.get(i); + E.remove(i); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + } + return ans; + } + + List alternateFormation(ArrayList O, ArrayList E, long k, DPHelper d, int n, SortHelper s) { + List ans = new ArrayList<>(); + int tot = O.size() + E.size(); + if (tot % 2 == 1) { + int i = 0; + while (i < O.size()) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int x = O.get(i); + O.remove(i); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + i++; + } + } else { + ArrayList U = new ArrayList<>(); + U.addAll(O); + U.addAll(E); + s.sortList(U); + int i = 0; + while (i < U.size()) { + int x = U.get(i); + if (O.contains(x)) { + long cnt = d.compute(O.size() - 1, E.size(), 0); + if (k > cnt) { + k -= cnt; + } else { + int idx = O.indexOf(x); + O.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(0, O, E, k, d)); + return ans; + } + } else { + long cnt = d.compute(O.size(), E.size() - 1, 1); + if (k > cnt) { + k -= cnt; + } else { + int idx = E.indexOf(x); + E.remove(idx); + ans.add(x); + ans.addAll(buildPermutation(1, O, E, k, d)); + return ans; + } + } + i++; + } + } + return ans; + } +} + +class Solution { + public int[] permute(int n, long k) { + int o = (n + 1) / 2, e = n / 2; + ArrayList O = new ArrayList<>(), E = new ArrayList<>(); + + for (int i = 1; i <= n; i++) { + if (i % 2 == 1) O.add(i); + else E.add(i); + } + + SortHelper s = new SortHelper(); + s.sortList(O); + s.sortList(E); + + DPHelper d = new DPHelper(); + PermutationHelper ph = new PermutationHelper(); + + long tot = 0; + if (n % 2 == 1) tot = d.compute(O.size() - 1, E.size(), 0) * O.size(); + else tot = d.compute(O.size() - 1, E.size(), 0) * O.size() + d.compute(O.size(), E.size() - 1, 1) * E.size(); + + if (k > tot) return new int[0]; + + List res = ph.alternateFormation(O, E, k, d, n, s); + int[] ans = new int[res.size()]; + for (int i = 0; i < res.size(); i++) ans[i] = res.get(i); + + return ans; + } +} \ No newline at end of file diff --git a/solution/3400-3499/3470.Permutations IV/solution.py b/solution/3400-3499/3470.Permutations IV/solution.py new file mode 100644 index 0000000000000..d1f02ccafb6d6 --- /dev/null +++ b/solution/3400-3499/3470.Permutations IV/solution.py @@ -0,0 +1,72 @@ +from typing import List +from math import factorial +import heapq + +class Solution: + def permute(self, xxy: int, yyz: int) -> List[int]: + + kasu = {} + nnss = [] + majs = [] + ajwi = heapq.heappush + laoq = [] + + zzp = [i for i in range(1, xxy + 1) if i % 2 == 1] + zzq = [i for i in range(1, xxy + 1) if i % 2 == 0] + + ppp = [] + nxr = None + + for pps in range(xxy): + if pps == 0: + cnd = sorted(zzp + zzq) + else: + cnd = zzp if nxr == 1 else zzq + + fff = False + for cndt in cnd: + if cndt % 2 == 1: + nxt = 0 + noo = len(zzp) - 1 + nee = len(zzq) + else: + nxt = 1 + noo = len(zzp) + nee = len(zzq) - 1 + + llq = noo + nee + if llq == 0: + cnt = 1 + else: + if nxt == 1: + if noo != (llq + 1) // 2 or nee != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + else: + if nee != (llq + 1) // 2 or noo != llq // 2: + cnt = 0 + else: + cnt = factorial(noo) * factorial(nee) + + ajwi(nnss, cnt) + ajwi(majs, llq) + + if cnt >= yyz: + ppp.append(cndt) + if cndt % 2 == 1: + zzp.remove(cndt) + nxr = 0 + else: + zzq.remove(cndt) + nxr = 1 + fff = True + break + else: + yyz -= cnt + + ajwi(laoq, len(ppp)) + + if not fff: + return [] + return ppp \ No newline at end of file diff --git a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README.md b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README.md index 305837bdbe0bf..1e775efb1e18d 100644 --- a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README.md +++ b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README.md @@ -91,18 +91,185 @@ tags: ```python + +from sortedcontainers import SortedList as SL +fmin = lambda a, b: a if a < b else b +class Solution: + def minOperations(self, nums: List[int], l: int, k: int) -> int: + n = len(nums) + lt, gt = SL(), SL() + ls, gs = 0, 0 + def add(x): + nonlocal ls, gs + if not lt or x <= lt[-1]: + lt.add(x) + ls += x + else: + gt.add(x) + gs += x + def remove(x): + nonlocal ls, gs + if x <= lt[-1]: + lt.remove(x) + ls -= x + else: + gt.remove(x) + gs -= x + def adjust(): + nonlocal ls, gs + if len(lt) - len(gt) > 1: + x = lt.pop(-1) + ls -= x + gt.add(x) + gs += x + elif len(gt) - len(lt) > 0: + x = gt.pop(0) + gs -= x + lt.add(x) + ls += x + def getmed(): + return lt[-1] + cost = [0] * (n-l+1) + for i, x in enumerate(nums): + add(x) + adjust() + if i >= l: + remove(nums[i-l]) + adjust() + if i >= l-1: + med = getmed() + cur = gs - med*(len(gt)) + med*len(lt) - ls + cost[i-l+1] = cur + # print(cost) + dp = [[inf] * (k+1) for _ in range(n+1)] + dp[0][0] = 0 + for i in range(1, n+1): + for j in range(k+1): + dp[i][j] = dp[i-1][j] + if i-l >= 0 and k > 0: + dp[i][j] = fmin(dp[i][j], dp[i-l][j-1] + cost[i-l]) + + return dp[n][k] + + ``` #### Java ```java + +class Solution { + + public long minOperations(int[] nums, int x, int k) { + TreeSet set1 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]), set2 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]); + long sum[] = new long[nums.length - x + 1], left = 0, right = 0; + for (int i = 0; i < nums.length; i++) { + set2.add(i); + left += nums[set2.first()]; + right += nums[i] - nums[set2.first()]; + set1.add(set2.pollFirst()); + if (set1.size() > set2.size()) { + left -= nums[set1.last()]; + right += nums[set1.last()]; + set2.add(set1.pollLast()); + } + if (i >= x - 1) { + sum[i - x + 1] = nums[set2.first()] * (set1.size() - set2.size()) - left + right; + left -= set1.remove(i - x + 1) ? nums[i - x + 1] : 0; + right -= set2.remove(i - x + 1) ? nums[i - x + 1] : 0; + } + } + long[][] dp = new long[sum.length + x][k + 1]; + for (int i = 0; i < sum.length + x; i++) { + for (int j = 1; j <= k; j++) { + dp[i][j] = 1000000000000000000L; + } + } + for (int i = 0; i < sum.length; i++) { + for (int j = 1; j <= k; j++) { + dp[i + x][j] = Math.min(dp[i + x - 1][j], sum[i] + dp[i][j - 1]); + } + } + return dp[sum.length + x - 1][k]; + } +} + + ``` #### C++ ```cpp + +class Solution +{ +public: +#define ll long long + ll f[100003][23]; + long long minOperations(vector &a, int x, int k) + { + int n = a.size(); + for (int j = 0; j <= n; ++j) + for (int i = 0; i <= k; ++i) + f[j][i] = 1e18; + f[0][0] = 0; + multiset A, B; + ll as = 0, bs = 0; + for (int i = 0; i < n; ++i) + { + if (B.empty()) + as += a[i], A.insert(a[i]); + else if (A.empty()) + bs += a[i], B.insert(a[i]); + else if (a[i] <= *A.rbegin()) + as += a[i], A.insert(a[i]); + else + bs += a[i], B.insert(a[i]); + if (i - x >= 0) + { + if (A.find(a[i - x]) != A.end()) + { + as -= a[i - x], A.erase(A.find(a[i - x])); + } + else + { + bs -= a[i - x], B.erase(B.find(a[i - x])); + } + } + int sa = A.size(), sb = B.size(); + while (sa - sb >= 2) + { + int o = *A.rbegin(); + as -= o, bs += o; + B.insert(*A.rbegin()), A.erase(prev(A.end())); + --sa, ++sb; + } + while (sa < sb) + { + int o = *B.begin(); + bs -= o, as += o; + A.insert(*B.begin()), B.erase(B.begin()); + ++sa, --sb; + } + // 3 2 + // 3 3 + for (int j = 0; j <= k; ++j) + f[i + 1][j] = f[i][j]; + if (i >= x - 1) + { + ll Z = *A.rbegin(); + ll cost = Z * A.size() - as + bs - Z * B.size(); + for (int j = 1; j <= k; ++j) + f[i + 1][j] = min(f[i + 1][j], f[i - x + 1][j - 1] + cost); + } + } + return f[n][k]; + } +}; + + ``` #### Go diff --git a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README_EN.md b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README_EN.md index 182675e675e99..544b5e0b09689 100644 --- a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README_EN.md +++ b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/README_EN.md @@ -86,18 +86,185 @@ tags: ```python + +from sortedcontainers import SortedList as SL +fmin = lambda a, b: a if a < b else b +class Solution: + def minOperations(self, nums: List[int], l: int, k: int) -> int: + n = len(nums) + lt, gt = SL(), SL() + ls, gs = 0, 0 + def add(x): + nonlocal ls, gs + if not lt or x <= lt[-1]: + lt.add(x) + ls += x + else: + gt.add(x) + gs += x + def remove(x): + nonlocal ls, gs + if x <= lt[-1]: + lt.remove(x) + ls -= x + else: + gt.remove(x) + gs -= x + def adjust(): + nonlocal ls, gs + if len(lt) - len(gt) > 1: + x = lt.pop(-1) + ls -= x + gt.add(x) + gs += x + elif len(gt) - len(lt) > 0: + x = gt.pop(0) + gs -= x + lt.add(x) + ls += x + def getmed(): + return lt[-1] + cost = [0] * (n-l+1) + for i, x in enumerate(nums): + add(x) + adjust() + if i >= l: + remove(nums[i-l]) + adjust() + if i >= l-1: + med = getmed() + cur = gs - med*(len(gt)) + med*len(lt) - ls + cost[i-l+1] = cur + # print(cost) + dp = [[inf] * (k+1) for _ in range(n+1)] + dp[0][0] = 0 + for i in range(1, n+1): + for j in range(k+1): + dp[i][j] = dp[i-1][j] + if i-l >= 0 and k > 0: + dp[i][j] = fmin(dp[i][j], dp[i-l][j-1] + cost[i-l]) + + return dp[n][k] + + ``` #### Java ```java + + class Solution { + + public long minOperations(int[] nums, int x, int k) { + TreeSet set1 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]), set2 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]); + long sum[] = new long[nums.length - x + 1], left = 0, right = 0; + for (int i = 0; i < nums.length; i++) { + set2.add(i); + left += nums[set2.first()]; + right += nums[i] - nums[set2.first()]; + set1.add(set2.pollFirst()); + if (set1.size() > set2.size()) { + left -= nums[set1.last()]; + right += nums[set1.last()]; + set2.add(set1.pollLast()); + } + if (i >= x - 1) { + sum[i - x + 1] = nums[set2.first()] * (set1.size() - set2.size()) - left + right; + left -= set1.remove(i - x + 1) ? nums[i - x + 1] : 0; + right -= set2.remove(i - x + 1) ? nums[i - x + 1] : 0; + } + } + long[][] dp = new long[sum.length + x][k + 1]; + for (int i = 0; i < sum.length + x; i++) { + for (int j = 1; j <= k; j++) { + dp[i][j] = 1000000000000000000L; + } + } + for (int i = 0; i < sum.length; i++) { + for (int j = 1; j <= k; j++) { + dp[i + x][j] = Math.min(dp[i + x - 1][j], sum[i] + dp[i][j - 1]); + } + } + return dp[sum.length + x - 1][k]; + } +} + + ``` #### C++ ```cpp + + class Solution +{ +public: +#define ll long long + ll f[100003][23]; + long long minOperations(vector &a, int x, int k) + { + int n = a.size(); + for (int j = 0; j <= n; ++j) + for (int i = 0; i <= k; ++i) + f[j][i] = 1e18; + f[0][0] = 0; + multiset A, B; + ll as = 0, bs = 0; + for (int i = 0; i < n; ++i) + { + if (B.empty()) + as += a[i], A.insert(a[i]); + else if (A.empty()) + bs += a[i], B.insert(a[i]); + else if (a[i] <= *A.rbegin()) + as += a[i], A.insert(a[i]); + else + bs += a[i], B.insert(a[i]); + if (i - x >= 0) + { + if (A.find(a[i - x]) != A.end()) + { + as -= a[i - x], A.erase(A.find(a[i - x])); + } + else + { + bs -= a[i - x], B.erase(B.find(a[i - x])); + } + } + int sa = A.size(), sb = B.size(); + while (sa - sb >= 2) + { + int o = *A.rbegin(); + as -= o, bs += o; + B.insert(*A.rbegin()), A.erase(prev(A.end())); + --sa, ++sb; + } + while (sa < sb) + { + int o = *B.begin(); + bs -= o, as += o; + A.insert(*B.begin()), B.erase(B.begin()); + ++sa, --sb; + } + // 3 2 + // 3 3 + for (int j = 0; j <= k; ++j) + f[i + 1][j] = f[i][j]; + if (i >= x - 1) + { + ll Z = *A.rbegin(); + ll cost = Z * A.size() - as + bs - Z * B.size(); + for (int j = 1; j <= k; ++j) + f[i + 1][j] = min(f[i + 1][j], f[i - x + 1][j - 1] + cost); + } + } + return f[n][k]; + } +}; + + ``` #### Go diff --git a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.cpp b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.cpp new file mode 100644 index 0000000000000..683d7d50dc22b --- /dev/null +++ b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.cpp @@ -0,0 +1,59 @@ +class Solution { +public: +#define ll long long + ll f[100003][23]; + long long minOperations(vector& a, int x, int k) { + int n=a.size(); + for(int j=0; j<=n; ++j) + for(int i=0; i<=k; ++i) + f[j][i]=1e18; + f[0][0]=0; + multiset A,B; + ll as=0,bs=0; + for(int i=0; i=0) + { + if(A.find(a[i-x])!=A.end()) + { + as-=a[i-x],A.erase(A.find(a[i-x])); + } + else + { + bs-=a[i-x],B.erase(B.find(a[i-x])); + } + } + int sa=A.size(),sb=B.size(); + while(sa-sb>=2) + { + int o=*A.rbegin(); + as-=o,bs+=o; + B.insert(*A.rbegin()),A.erase(prev(A.end())); + --sa,++sb; + } + while(sa=x-1) + { + ll Z=*A.rbegin(); + ll cost=Z*A.size()-as+bs-Z*B.size(); + for(int j=1; j<=k; ++j) + f[i+1][j]=min(f[i+1][j],f[i-x+1][j-1]+cost); + } + } + return f[n][k]; + } +}; \ No newline at end of file diff --git a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.java b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.java new file mode 100644 index 0000000000000..8fdc4db56f2cb --- /dev/null +++ b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.java @@ -0,0 +1,35 @@ +class Solution { + + public long minOperations(int[] nums, int x, int k) { + TreeSet set1 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]), set2 = new TreeSet<>((o, p) -> nums[o] == nums[p] ? o - p : nums[o] - nums[p]); + long sum[] = new long[nums.length - x + 1], left = 0, right = 0; + for (int i = 0; i < nums.length; i++) { + set2.add(i); + left += nums[set2.first()]; + right += nums[i] - nums[set2.first()]; + set1.add(set2.pollFirst()); + if (set1.size() > set2.size()) { + left -= nums[set1.last()]; + right += nums[set1.last()]; + set2.add(set1.pollLast()); + } + if (i >= x - 1) { + sum[i - x + 1] = nums[set2.first()] * (set1.size() - set2.size()) - left + right; + left -= set1.remove(i - x + 1) ? nums[i - x + 1] : 0; + right -= set2.remove(i - x + 1) ? nums[i - x + 1] : 0; + } + } + long[][] dp = new long[sum.length + x][k + 1]; + for (int i = 0; i < sum.length + x; i++) { + for (int j = 1; j <= k; j++) { + dp[i][j] = 1000000000000000000L; + } + } + for (int i = 0; i < sum.length; i++) { + for (int j = 1; j <= k; j++) { + dp[i + x][j] = Math.min(dp[i + x - 1][j], sum[i] + dp[i][j - 1]); + } + } + return dp[sum.length + x - 1][k]; + } +} \ No newline at end of file diff --git a/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.py b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.py new file mode 100644 index 0000000000000..491924f6ea47c --- /dev/null +++ b/solution/3500-3599/3505.Minimum Operations to Make Elements Within K Subarrays Equal/solution.py @@ -0,0 +1,58 @@ +from sortedcontainers import SortedList as SL +fmin = lambda a, b: a if a < b else b +class Solution: + def minOperations(self, nums: List[int], l: int, k: int) -> int: + n = len(nums) + lt, gt = SL(), SL() + ls, gs = 0, 0 + def add(x): + nonlocal ls, gs + if not lt or x <= lt[-1]: + lt.add(x) + ls += x + else: + gt.add(x) + gs += x + def remove(x): + nonlocal ls, gs + if x <= lt[-1]: + lt.remove(x) + ls -= x + else: + gt.remove(x) + gs -= x + def adjust(): + nonlocal ls, gs + if len(lt) - len(gt) > 1: + x = lt.pop(-1) + ls -= x + gt.add(x) + gs += x + elif len(gt) - len(lt) > 0: + x = gt.pop(0) + gs -= x + lt.add(x) + ls += x + def getmed(): + return lt[-1] + cost = [0] * (n-l+1) + for i, x in enumerate(nums): + add(x) + adjust() + if i >= l: + remove(nums[i-l]) + adjust() + if i >= l-1: + med = getmed() + cur = gs - med*(len(gt)) + med*len(lt) - ls + cost[i-l+1] = cur + # print(cost) + dp = [[inf] * (k+1) for _ in range(n+1)] + dp[0][0] = 0 + for i in range(1, n+1): + for j in range(k+1): + dp[i][j] = dp[i-1][j] + if i-l >= 0 and k > 0: + dp[i][j] = fmin(dp[i][j], dp[i-l][j-1] + cost[i-l]) + + return dp[n][k] \ No newline at end of file