Skip to content

Commit bc2c3d0

Browse files
samarthswami1016samarthswami1016
authored
Update README.md
1 parent 48f3a19 commit bc2c3d0

File tree

1 file changed

+320
-4
lines changed
  • solution/3400-3499/3470.Permutations IV

1 file changed

+320
-4
lines changed

‎solution/3400-3499/3470.Permutations IV/README.md‎

Lines changed: 320 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -111,25 +111,341 @@ tags:
111111
#### Python3
112112

113113
```python
114-
114+
from typing import List
115+
from math import factorial
116+
import heapq
117+
118+
class Solution:
119+
def permute(self, xxy: int, yyz: int) -> List[int]:
120+
121+
kasu = {}
122+
nnss = []
123+
majs = []
124+
ajwi = heapq.heappush
125+
laoq = []
126+
127+
zzp = [i for i in range(1, xxy + 1) if i % 2 == 1]
128+
zzq = [i for i in range(1, xxy + 1) if i % 2 == 0]
129+
130+
ppp = []
131+
nxr = None
132+
133+
for pps in range(xxy):
134+
if pps == 0:
135+
cnd = sorted(zzp + zzq)
136+
else:
137+
cnd = zzp if nxr == 1 else zzq
138+
139+
fff = False
140+
for cndt in cnd:
141+
if cndt % 2 == 1:
142+
nxt = 0
143+
noo = len(zzp) - 1
144+
nee = len(zzq)
145+
else:
146+
nxt = 1
147+
noo = len(zzp)
148+
nee = len(zzq) - 1
149+
150+
llq = noo + nee
151+
if llq == 0:
152+
cnt = 1
153+
else:
154+
if nxt == 1:
155+
if noo != (llq + 1) // 2 or nee != llq // 2:
156+
cnt = 0
157+
else:
158+
cnt = factorial(noo) * factorial(nee)
159+
else:
160+
if nee != (llq + 1) // 2 or noo != llq // 2:
161+
cnt = 0
162+
else:
163+
cnt = factorial(noo) * factorial(nee)
164+
165+
ajwi(nnss, cnt)
166+
ajwi(majs, llq)
167+
168+
if cnt >= yyz:
169+
ppp.append(cndt)
170+
if cndt % 2 == 1:
171+
zzp.remove(cndt)
172+
nxr = 0
173+
else:
174+
zzq.remove(cndt)
175+
nxr = 1
176+
fff = True
177+
break
178+
else:
179+
yyz -= cnt
180+
181+
ajwi(laoq, len(ppp))
182+
183+
if not fff:
184+
return []
185+
return ppp
115186
```
116187

117188
#### Java
118189

119190
```java
120-
191+
import java.util.*;
192+
193+
class DPHelper {
194+
static final long ok = 10000000000000000L;
195+
long[][][] dp = new long[101][101][2];
196+
boolean[][][] vis = new boolean[101][101][2];
197+
198+
long compute(int o, int e, int p) {
199+
if (o == 0 && e == 0) return 1;
200+
if (vis[o][e][p]) return dp[o][e][p];
201+
202+
long r = 0;
203+
if (p == 1) {
204+
if (o == 0) r = 0;
205+
else r = o * compute(o - 1, e, 0);
206+
} else {
207+
if (e == 0) r = 0;
208+
else r = e * compute(o, e - 1, 1);
209+
}
210+
211+
if (r > ok) r = ok;
212+
vis[o][e][p] = true;
213+
dp[o][e][p] = r;
214+
return r;
215+
}
216+
}
217+
218+
class SortHelper {
219+
void sortList(ArrayList<Integer> list) {
220+
Collections.sort(list);
221+
}
222+
}
223+
224+
class PermutationHelper {
225+
List<Integer> buildPermutation(int p, ArrayList<Integer> O, ArrayList<Integer> E, long k, DPHelper d) {
226+
List<Integer> ans = new ArrayList<>();
227+
if (O.size() + E.size() == 0) return ans;
228+
int i = 0;
229+
230+
if (p == 1) {
231+
while (i < O.size()) {
232+
long cnt = d.compute(O.size() - 1, E.size(), 0);
233+
if (k > cnt) {
234+
k -= cnt;
235+
i++;
236+
} else {
237+
int x = O.get(i);
238+
O.remove(i);
239+
ans.add(x);
240+
ans.addAll(buildPermutation(0, O, E, k, d));
241+
return ans;
242+
}
243+
}
244+
} else {
245+
while (i < E.size()) {
246+
long cnt = d.compute(O.size(), E.size() - 1, 1);
247+
if (k > cnt) {
248+
k -= cnt;
249+
i++;
250+
} else {
251+
int x = E.get(i);
252+
E.remove(i);
253+
ans.add(x);
254+
ans.addAll(buildPermutation(1, O, E, k, d));
255+
return ans;
256+
}
257+
}
258+
}
259+
return ans;
260+
}
261+
262+
List<Integer> alternateFormation(ArrayList<Integer> O, ArrayList<Integer> E, long k, DPHelper d, int n, SortHelper s) {
263+
List<Integer> ans = new ArrayList<>();
264+
int tot = O.size() + E.size();
265+
if (tot % 2 == 1) {
266+
int i = 0;
267+
while (i < O.size()) {
268+
long cnt = d.compute(O.size() - 1, E.size(), 0);
269+
if (k > cnt) {
270+
k -= cnt;
271+
} else {
272+
int x = O.get(i);
273+
O.remove(i);
274+
ans.add(x);
275+
ans.addAll(buildPermutation(0, O, E, k, d));
276+
return ans;
277+
}
278+
i++;
279+
}
280+
} else {
281+
ArrayList<Integer> U = new ArrayList<>();
282+
U.addAll(O);
283+
U.addAll(E);
284+
s.sortList(U);
285+
int i = 0;
286+
while (i < U.size()) {
287+
int x = U.get(i);
288+
if (O.contains(x)) {
289+
long cnt = d.compute(O.size() - 1, E.size(), 0);
290+
if (k > cnt) {
291+
k -= cnt;
292+
} else {
293+
int idx = O.indexOf(x);
294+
O.remove(idx);
295+
ans.add(x);
296+
ans.addAll(buildPermutation(0, O, E, k, d));
297+
return ans;
298+
}
299+
} else {
300+
long cnt = d.compute(O.size(), E.size() - 1, 1);
301+
if (k > cnt) {
302+
k -= cnt;
303+
} else {
304+
int idx = E.indexOf(x);
305+
E.remove(idx);
306+
ans.add(x);
307+
ans.addAll(buildPermutation(1, O, E, k, d));
308+
return ans;
309+
}
310+
}
311+
i++;
312+
}
313+
}
314+
return ans;
315+
}
316+
}
317+
318+
class Solution {
319+
public int[] permute(int n, long k) {
320+
int o = (n + 1) / 2, e = n / 2;
321+
ArrayList<Integer> O = new ArrayList<>(), E = new ArrayList<>();
322+
323+
for (int i = 1; i <= n; i++) {
324+
if (i % 2 == 1) O.add(i);
325+
else E.add(i);
326+
}
327+
328+
SortHelper s = new SortHelper();
329+
s.sortList(O);
330+
s.sortList(E);
331+
332+
DPHelper d = new DPHelper();
333+
PermutationHelper ph = new PermutationHelper();
334+
335+
long tot = 0;
336+
if (n % 2 == 1) tot = d.compute(O.size() - 1, E.size(), 0) * O.size();
337+
else tot = d.compute(O.size() - 1, E.size(), 0) * O.size() + d.compute(O.size(), E.size() - 1, 1) * E.size();
338+
339+
if (k > tot) return new int[0];
340+
341+
List<Integer> res = ph.alternateFormation(O, E, k, d, n, s);
342+
int[] ans = new int[res.size()];
343+
for (int i = 0; i < res.size(); i++) ans[i] = res.get(i);
344+
345+
return ans;
346+
}
347+
}
121348
```
122349

123350
#### C++
124351

125352
```cpp
126-
353+
class Solution {
354+
long long f[105];
355+
public:
356+
vector<int> permute(int n, long long k) {
357+
int i,j;
358+
for(i=f[0]=1;i<=n;i++)if(f[i-1]>=k)f[i]=k;
359+
else f[i]=f[i-1]*(i+1>>1);
360+
if(!(n&1))f[n]*=2;
361+
if(f[n]<k)return {};
362+
k--;
363+
vector<int> ans(n),a[2];
364+
for(i=0;i<n;i++)a[i&1].push_back(i);
365+
if(n&1)
366+
{
367+
ans[0]=k/f[n-1]*2;
368+
k-=ans[0]/2*f[n-1];
369+
}
370+
else
371+
{
372+
ans[0]=k/f[n-1];
373+
k-=ans[0]*f[n-1];
374+
}
375+
a[ans[0]&1].erase(lower_bound(a[ans[0]&1].begin(),a[ans[0]&1].end(),ans[0]));
376+
for(i=1;i<n;i++)
377+
{
378+
if(n&1)
379+
{
380+
ans[i]=a[i&1][k/f[n-i-1]];
381+
}
382+
else
383+
{
384+
ans[i]=a[(ans[0]^i)&1][k/f[n-i-1]];
385+
}
386+
k%=f[n-i-1];
387+
a[ans[i]&1].erase(lower_bound(a[ans[i]&1].begin(),a[ans[i]&1].end(),ans[i]));
388+
}
389+
for(i=0;i<n;i++)ans[i]++;
390+
return ans;
391+
}
392+
};
127393
```
128394
129395
#### Go
130396
131397
```go
132-
398+
func permute(n int, k int64) []int {
399+
var f [105]int64
400+
f[0] = 1
401+
for i := 1; i <= n; i++ {
402+
if f[i-1] >= k {
403+
f[i] = k
404+
} else {
405+
f[i] = f[i-1] * int64((i+1)>>1)
406+
}
407+
}
408+
if n%2 == 0 {
409+
f[n] *= 2
410+
}
411+
if f[n] < k {
412+
return []int{}
413+
}
414+
k--
415+
ans := make([]int, n)
416+
a := [2][]int{}
417+
for i := 0; i < n; i++ {
418+
a[i&1] = append(a[i&1], i)
419+
}
420+
421+
if n%2 == 1 {
422+
ans[0] = int(k/f[n-1]) * 2
423+
k -= int64(ans[0]/2) * f[n-1]
424+
} else {
425+
ans[0] = int(k / f[n-1])
426+
k -= int64(ans[0]) * f[n-1]
427+
}
428+
429+
index := sort.SearchInts(a[ans[0]&1], ans[0])
430+
a[ans[0]&1] = append(a[ans[0]&1][:index], a[ans[0]&1][index+1:]...)
431+
432+
for i := 1; i < n; i++ {
433+
if n%2 == 1 {
434+
ans[i] = a[i&1][k/f[n-i-1]]
435+
} else {
436+
ans[i] = a[(ans[0]^i)&1][k/f[n-i-1]]
437+
}
438+
k %= f[n-i-1]
439+
440+
index = sort.SearchInts(a[ans[i]&1], ans[i])
441+
a[ans[i]&1] = append(a[ans[i]&1][:index], a[ans[i]&1][index+1:]...)
442+
}
443+
444+
for i := 0; i < n; i++ {
445+
ans[i]++
446+
}
447+
return ans
448+
}
133449
```
134450

135451
<!-- tabs:end -->

0 commit comments

Comments
 (0)