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