Azt az egész sorozatot, ahol nincs két egyforma szomszédos elem, jó sorozatnak nevezzük.
Két jó N hosszúságú sorozatot kap: A=(A_1,A_2,\dots,A_N) és B=(B_1,B_2,\dots,B_N). Az A és B minden eleme 0 és M-1 között van, beleértve a határértékeket is.
A következő műveleteket tetszőleges számú alkalommal hajthatja végre, esetleg nullán:

- Válasszon egy i egész számot 1 és N között, beleértve a következőket:
- Állítsa be A_i \leftarrow (A_i + 1) \bmod M.
- Állítsa be A_i \leftarrow (A_i - 1) \bmod M. Itt (-1) \bmod M = M - 1.

Nem hajthat végre azonban olyan műveletet, amely miatt az A már nem jó sorozat.
Határozza meg, hogy lehetséges-e A egyenlő B-vel, és ha lehetséges, keresse meg az ehhez szükséges minimális műveletek számát.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Hozam

Ha a cél nem érhető el, nyomtassa ki a -1 értéket.
Ellenkező esetben nyomtassa ki a minimálisan szükséges műveletek számát egész számként.

Korlátok

- 2 \leq N \leq 2 \times 10^5
- 2 \leq M \leq 10^6
- 0\leq A_i,B_i< M(1\leq i\leq N)
- A_i\ne A_{i+1}(1\leq i\leq N-1)
- B_i\ne B_{i+1}(1\leq i\leq N-1)
- Minden bemeneti érték egész szám.

1. minta bemenet

3 9
2 0 1
4 8 1

1.minta kimenet

3

A célt három műveletben érheti el az alábbiak szerint:

- Állítsa be A_1 \leftarrow (A_1 + 1) \bmod M értéket. Most A = (3, 0, 1).
- Állítsa be A_2 \leftarrow (A_2 - 1) \bmod M. Most A = (3, 8, 1).
- Állítsa be A_1 \leftarrow (A_1 + 1) \bmod M értéket. Most A = (4, 8, 1).

A célt két vagy kevesebb műveletben lehetetlen elérni, így a válasz 3.
Például nem állíthatja be A_2 \leftarrow (A_2 + 1) \bmod M értéket az első műveletben, mert akkor A = (2, 1, 1) lenne, ami nem jó sorozat.

2. minta bemenet

3 9
1 8 2
1 8 2

2. minta kimenet

0

A és B kezdettől fogva egyenlő lehet.

3. minta bemenet

24 182
128 115 133 52 166 92 164 119 143 99 54 162 86 2 59 166 24 78 81 5 109 67 172 99
136 103 136 28 16 52 2 85 134 64 123 74 64 28 85 161 19 74 14 110 125 104 180 75

3.minta kimenet

811

Az olyan egész sorozatot, amelyben nincs két egyforma szomszédos elem, jó sorozatnak nevezzük.
Két jó N hosszúságú sorozatot kapunk: A=(A_1,A_2,\pontok,A_N) és B=(B_1,B_2,\pontok,B_N). A és B minden eleme 0 és M-1 között van.
A következő műveleteket tetszőleges számú alkalommal, akár nullával is elvégezheti A-n:

- Válasszon egy i egész számot 1 és N között (beleértve), és hajtsa végre a következők egyikét:
- Állítsa be: A_i \leftarrow (A_i + 1) \bmod M.
- Állítsa be: A_i \leftarrow (A_i - 1) \bmod M. Itt (-1) \bmod M = M - 1.

Azonban nem hajthat végre olyan műveletet, amely miatt A már nem jó sorozat.
Határozza meg, hogy lehetséges-e egyenlővé tenni A-t B-vel, és ha lehetséges, határozza meg az ehhez szükséges műveletek minimális számát!

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Kimenet

Ha a cél elérhetetlen, nyomtasson -1-et.
Ellenkező esetben a szükséges minimális számú műveletet egész számként írja ki.

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 2 \leq M \leq 10^6
- 0\leq A_i,B_i< M(1\leq i\leq N)
- A_i\ne A_{i+1}(1\leq i\leq N-1)
- B_i\ne B_{i+1}(1\leq i\leq N-1)
- Minden bemeneti érték egész szám.

1. minta bemenet

3 9
2 0 1
4 8 1

1. minta kimenet

3

A célt három művelettel érheti el az alábbiak szerint:

- Állítsa be: A_1 \leftarrow (A_1 + 1) \bmod M. Most A = (3, 0, 1).
- Állítsa be: A_2 \leftarrow (A_2 - 1) \bmod M. Most A = (3, 8, 1).
- Állítsa be: A_1 \leftarrow (A_1 + 1) \bmod M. Most A = (4, 8, 1).

Két vagy kevesebb művelettel lehetetlen elérni a célt, ezért a válasz 3.
Például nem állíthatja be az A_2 \leftarrow (A_2 + 1) \bmod M értéket az első műveletben, mert így A = (2, 1, 1) lenne, ami nem jó sorozat.

2. minta bemenet

3 9
1 8 2
1 8 2

2. minta kimenet

0

A és B kezdettől fogva egyenlő lehet.

Minta bemenet 3

24 182
128 115 133 52 166 92 164 119 143 99 54 162 86 2 59 166 24 78 81 5 109 67 172 99
136 103 136 28 16 52 2 85 134 64 123 74 64 28 85 161 19 74 14 110 125 104 180 75

3. minta kimenet

811

Egy egész számokból álló sorozat, ahol nincs két egymás melletti elem, amely azonos, jó sorozatnak nevezünk.
Két jó sorozat van megadva, amelynek a hossza N: A=(A_1,A_2,\dots,A_N) és B=(B_1,B_2,\dots,B_N). Az A és B minden eleme 0 és M-1 között van, beleértve.
A következő műveleteket tetszőleges alkalommal, esetleg nulla alkalommal végrehajthatja A-n:

- Válasszon ki egy egész számot i, ami 1 és N között van, beleértve, és hajtsa végre az alábbiak egyikét:
- Állítsa be A_i \leftarrow (A_i + 1) \bmod M.
- Állítsa be A_i \leftarrow (A_i - 1) \bmod M. Itt, (-1) \bmod M = M - 1.

Azonban nem hajthat végre olyan műveletet, ami miatt A már nem lenne jó sorozat.
Határozza meg, lehetséges-e, hogy A egyenlő legyen B-vel, és ha lehetséges, találja meg a szükséges minimális műveletek számát.

Bemenet

A bemenet a szabványos bemenetből a következő formátumban van megadva:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Kimenet

Ha a cél nem elérhető, nyomtasson -1.
Egyébként nyomtassa ki a szükséges minimális műveletek számát egész számként.

Korlátozások

- 2 \leq N \leq 2 \times 10^5
- 2 \leq M \leq 10^6
- 0\leq A_i,B_i< M(1\leq i\leq N)
- A_i\ne A_{i+1}(1\leq i\leq N-1)
- B_i\ne B_{i+1}(1\leq i\leq N-1)
- Az összes bemeneti érték egész szám.

Bemeneti minta 1

3 9
2 0 1
4 8 1

Kimeneti minta 1

3

A célt elérheti három művelettel a következőképpen:

- Állítsa be A_1 \leftarrow (A_1 + 1) \bmod M. Most A = (3, 0, 1).
- Állítsa be A_2 \leftarrow (A_2 - 1) \bmod M. Most A = (3, 8, 1).
- Állítsa be A_1 \leftarrow (A_1 + 1) \bmod M. Most A = (4, 8, 1).

Lehetetlen a célt kettő vagy kevesebb művelettel elérni, így a válasz 3.
Például nem állíthatja be A_2 \leftarrow (A_2 + 1) \bmod M az első műveletben, mert ez A = (2, 1, 1) lenne, ami nem jó sorozat.

Bemeneti minta 2

3 9
1 8 2
1 8 2

Kimeneti minta 2

0

A és B már az elején egyenlő lehetnek.

Bemeneti minta 3

24 182
128 115 133 52 166 92 164 119 143 99 54 162 86 2 59 166 24 78 81 5 109 67 172 99
136 103 136 28 16 52 2 85 134 64 123 74 64 28 85 161 19 74 14 110 125 104 180 75

Kimeneti minta 3

811


Kapsz N, M, K pozitív egész számokat, egy nem negatív C egész számot és egy A=(A_1, A_2, \ldots, A_N) N hosszúságú egész sorozatot.
Keresse meg a \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M C K
A_1 A_2 \ldots A_N

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 1 \le N \le 10^5
- 1 \le M \le 10^9
- 0 \le C < M
- 1 \le K \le 10^9
- 0 \le A_i < M
- Minden bemeneti érték egész szám.

1. minta bemenet

2 5 3 3
1 3

1. minta kimenet

4

k=0 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3, tehát \displaystyle \min_ {1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
k=1 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1, tehát \displaystyle \min_ {1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
k=2 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4, tehát \displaystyle \min_ {1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
Ezért a válasz 1+1+2=4. Ezért nyomtassa ki a 4-et.

2. minta bemenet

5 4 3 182
0 3 2 1 2

2. minta kimenet

0

Minta bemenet 3

5 718 651 193855
3 532 44 109 58

3. minta kimenet

29484897

Pozitív N, M, K egész számokat, egy C nemnegatív egész számot és egy N hosszúságú A=(A_1, A_2, \ldots, A_N) egész sorozatot kapunk.
Keresse meg a \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N M C K
A_1 A_2 \ldots A_N

Hozam

Nyomtassa ki a választ.

Korlátok

- 1 \le N \le 10^5
- 1 \le M \le 10^9
- 0 \le C < M
- 1 \le K \le 10^9
- 0 \le A_i < M
- Minden bemeneti érték egész szám.

1. minta bemenet

2 5 3 3
1 3

1.minta kimenet

4

A k=0 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3, tehát \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
A k=1 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1, tehát \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
A k=2 esetén \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 és \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4, tehát \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
Ezért a válasz 1 + 1 + 2 = 4. Ezért nyomtassa ki a 4-et.

2. minta bemenet

5 4 3 182
0 3 2 1 2

2. minta kimenet

0

3. minta bemenet

5 718 651 193855
3 532 44 109 58

3.minta kimenet

29484897


Van egy N hosszúságú S egész sorozat. Kezdetben az S minden eleme 0.
Két Q hosszúságú egész sorozatot is kap: P=(P_1,P_2,\dots,P_Q) és V=(V_1,V_2,\dots,V_Q).
A Snuke Q műveleteket szeretne végrehajtani az S sorozaton sorrendben. Az i-edik művelet a következő:

- Hajtsa végre az alábbi műveletek egyikét:
- Cserélje ki az S_1, S_2, \dots, S_{P_i} elemeket V_i-re. A művelet előtt azonban, ha van olyan elem a S_1, S_2, \dots S_{P_i} között, amely szigorúan nagyobb, mint V_i, Snuke sírni kezd.
- Cserélje ki az S_{P_i}, S_{P_i+1}, \dots, S_N elemeket V_i-re. A művelet előtt azonban, ha van olyan elem a S_{P_i}, S_{P_i+1}, \dots S_N között, amely szigorúan nagyobb, mint V_i, Snuke sírni kezd.

Keresse meg a Q-műveletek szekvenciáinak számát, ahol a Snuke minden műveletet sírás nélkül végre tud hajtani, modulo 998244353.
Két műveletsorozatot akkor és csak akkor különböztetünk meg, ha van 1 \leq i \leq Q úgy, hogy az i-edik művelet választása eltérő.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Hozam

Nyomtassa ki a választ egész számként.

Korlátok

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

8 3
1 8
8 1
2 1

1.minta kimenet

1

A Snuke sírás nélkül képes végrehajtani a három műveletet az alábbiak szerint:

- Cserélje ki S_1 8-ra.
- Cserélje ki S_8 1-re.
- Cserélje ki a S_2, S_3, \dots, S_8 helyére 1-et.

Egyetlen más műveletsor sem felel meg a feltételeknek, így a válasz 1. Például, ha az első műveletben 8-ra cseréli a S_1, S_2, \dots S_8, akkor a második műveletben sírni fog, függetlenül a választástól.

2. minta bemenet

8 3
8 1
1 8
1 2

2. minta kimenet

0

Nem számít, hogyan hajtja végre az első két műveletet, a harmadik műveletben sírni fog.

3. minta bemenet

241 82
190 3207371
229 3639088
61 4428925
84 17258698
34 42692503
207 59753183
180 67198566
78 99285033
60 102449991
234 122146510
111 126959145
141 152331579
78 159855439
11 169658471
22 189991287
37 204602946
73 209329065
72 215363269
152 236450854
175 237822921
22 261431608
144 252550201
54 268889550
238 276997357
69 313065279
226 330144323
6 335788783
126 345410019
220 348318997
166 365778763
142 382251905
200 406191336
234 392702679
83 409660987
183 410908761
142 445707116
205 470279207
230 486436406
156 494269002
113 495687706
200 500005738
162 505246499
201 548652987
86 449551554
62 459527873
32 574001635
230 601073337
175 610244315
174 613857555
181 637452273
158 637866397
148 648101378
172 646898076
144 682578257
239 703460335
192 713255331
28 727075136
196 730768166
111 751850547
90 762445737
204 762552166
72 773170159
240 803415865
32 798873367
195 814999380
72 842641864
125 851815348
116 858041919
200 869948671
195 873324903
5 877767414
105 877710280
150 877719360
9 884707717
230 880263190
88 967344715
49 977643789
167 979463984
70 981400941
114 991068035
94 991951735
141 995762200

3.minta kimenet

682155965

Ne felejtse el bevenni a számláló modulo 998244353.

Van egy N hosszúságú S egész sorozat. Kezdetben S minden eleme 0.
Két Q hosszúságú egész sorozatot is kapunk: P=(P_1,P_2,\pontok,P_Q) és V=(V_1,V_2,\pontok,V_Q).
Snuke sorrendben Q műveleteket akar végrehajtani az S sorozaton. Az i-edik művelet a következő:

- Hajtsa végre a következők egyikét:
- Cserélje ki az S_1, S_2, \dots, S_{P_i} elemeket V_i-re. Azonban a művelet előtt, ha az S_1, S_2, \dots, S_{P_i} között van olyan elem, amely szigorúan nagyobb, mint V_i, a Snuke sírni kezd.
- Cserélje ki az S_{P_i}, S_{P_i+1}, \dots, S_N elemeket V_i-re. Azonban a művelet előtt, ha az S_{P_i}, S_{P_i+1}, \dots, S_N között van olyan elem, amely szigorúan nagyobb, mint V_i, a Snuke sírni kezd.

Keresse meg a Q-műveletek azon sorozatainak számát, amelyekben Snuke sírás nélkül képes végrehajtani az összes műveletet, modulo 998244353.
Két műveletsort akkor és csak akkor különböztetünk meg, ha van 1 \leq i \leq Q, így az i-edik művelet választása eltérő.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Kimenet

Nyomtassa ki a választ egész számként.

Korlátozások

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- Minden bemeneti érték egész szám.

1. minta bemenet

8 3
1 8
8 1
2 1

1. minta kimenet

1

A Snuke sírás nélkül képes elvégezni a három műveletet az alábbiak szerint:

- Cserélje ki az S_1-et 8-ra.
- Cserélje ki az S_8-at 1-re.
- Cserélje ki az S_2, S_3, \dots, S_8 karaktereket 1-re.

Más műveletsorok nem felelnek meg a feltételeknek, így a válasz 1. Például, ha az első műveletben lecseréli S_1, S_2, \dots, S_8 8-ra, akkor a második műveletben a választástól függetlenül sírni fog.

2. minta bemenet

8 3
8 1
1 8
1 2

2. minta kimenet

0

Nem számít, hogyan végzi el az első két műveletet, a harmadik műveletben sírni fog.

Minta bemenet 3

241 82
190 3207371
229 3639088
61 4428925
84 17258698
34 42692503
207 59753183
180 67198566
78 99285033
60 102449991
234 122146510
111 126959145
141 152331579
78 159855439
11 169658471
22 189991287
37 204602946
73 209329065
72 215363269
152 236450854
175 237822921
22 261431608
144 252550201
54 268889550
238 276997357
69 313065279
226 330144323
6 335788783
126 345410019
220 348318997
166 365778763
142 382251905
200 406191336
234 392702679
83 409660987
183 410908761
142 445707116
205 470279207
230 486436406
156 494269002
113 495687706
200 500005738
162 505246499
201 548652987
86 449551554
62 459527873
32 574001635
230 601073337
175 610244315
174 613857555
181 637452273
158 637866397
148 648101378
172 646898076
144 682578257
239 703460335
192 713255331
28 727075136
196 730768166
111 751850547
90 762445737
204 762552166
72 773170159
240 803415865
32 798873367
195 814999380
72 842641864
125 851815348
116 858041919
200 869948671
195 873324903
5 877767414
105 877710280
150 877719360
9 884707717
230 880263190
88 967344715
49 977643789
167 979463984
70 981400941
114 991068035
94 991951735
141 995762200

3. minta kimenet

682155965

Ne felejtse el bevenni a modulo 998244353 számot.

Van egy N hosszúságú S egész sorozat. Kezdetben S minden eleme 0.
Adva van továbbá két Q hosszúságú egész számokból álló sorozat: P=(P_1,P_2,\dots,P_Q) és V=(V_1,V_2,\dots,V_Q).
Snuke Q műveleteket akar végrehajtani az S sorozaton sorrendben. Az i-edik művelet a következő:

- Hajtsa végre a következők egyikét:
- Cserélje ki az S_1, S_2, \dots, S_{P_i} elemek mindegyikét V_i-re. Azonban a művelet előtt, ha az S_1, S_2, \dots, S_{P_i} között van olyan elem, amely szigorúan nagyobb, mint V_i, a Snuke sírni kezd.
- Cserélje ki az S_{P_i}, S_{P_i+1}, \dots, S_N elemeket V_i-re. Azonban a művelet előtt, ha az S_{P_i}, S_{P_i+1}, \dots, S_N között van olyan elem, amely szigorúan nagyobb, mint V_i, a Snuke sírni kezd.

Keresse meg a Q-műveletek azon sorozatainak számát, amelyekben Snuke sírás nélkül képes végrehajtani az összes műveletet, modulo 998244353.
Két műveletsort akkor és csak akkor különböztetünk meg, ha van 1 \leq i \leq Q, így az i-edik művelet választása eltérő.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Kimenet

Nyomtassa ki a választ egész számként.

Korlátozások

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- Minden bemeneti érték egész szám.

Minta bemenet 1

8 3
1 8
8 1
2 1

Minta kimenet 1

1

A Snuke sírás nélkül képes elvégezni a három műveletet az alábbiak szerint:

- Cserélje ki az S_1-et 8-ra.
- Cserélje ki az S_8-at 1-re.
- Cserélje ki az S_2, S_3, \dots, S_8 karaktereket 1-re.

Más műveletsorok nem felelnek meg a feltételeknek, így a válasz 1. Például, ha az első műveletben lecseréli az S_1, S_2, \dots, S_8 értékeket 8-ra, akkor a második műveletben a választástól függetlenül sírni fog.

Minta bevitel 2

8 3
8 1
1 8
1 2

Minta kimenet 2

0

Nem számít, hogyan végzi el az első két műveletet, a harmadik műveletben sírni fog.

Minta bemenet 3

241 82
190 3207371
229 3639088
61 4428925
84 17258698
34 42692503
207 59753183
180 67198566
78 99285033
60 102449991
234 122146510
111 126959145
141 152331579
78 159855439
11 169658471
22 189991287
37 204602946
73 209329065
72 215363269
152 236450854
175 237822921
22 261431608
144 252550201
54 268889550
238 276997357
69 313065279
226 330144323
6 335788783
126 345410019
220 348318997
166 365778763
142 382251905
200 406191336
234 392702679
83 409660987
183 410908761
142 445707116
205 470279207
230 486436406
156 494269002
113 495687706
200 500005738
162 505246499
201 548652987
86 449551554
62 459527873
32 574001635
230 601073337
175 610244315
174 613857555
181 637452273
158 637866397
148 648101378
172 646898076
144 682578257
239 703460335
192 713255331
28 727075136
196 730768166
111 751850547
90 762445737
204 762552166
72 773170159
240 803415865
32 798873367
195 814999380
72 842641864
125 851815348
116 858041919
200 869948671
195 873324903
5 877767414
105 877710280
150 877719360
9 884707717
230 880263190
88 967344715
49 977643789
167 979463984
70 981400941
114 991068035
94 991951735
141 995762200

Minta kimenet 3

682155965

Ne felejtse el bevenni a modulo 998244353 számot.


Egy olyan egész szám sorozatot, amelynek hossza 1 és N közötti, beleértve a szélső értékeket, és minden eleme 1 és M közötti, jó sorozatnak nevezünk. A jó sorozat pontszámát az X pozitív osztóinak száma határozza meg, ahol X a sorozat elemeinek szorzata.
\displaystyle \sum_{k=1}^{N}M^k jó sorozat létezik. Keresse meg ezen sorozatok pontszámainak összegét 998244353-mas modulo szerint.

Bemenet

A bemenet a következő formátumban érkezik a szabványos bemenetről:
N M

Kimenet

Nyomtasd ki a választ egész számként.

Korlátozások

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- Az összes bemeneti érték egész szám.

Bemeneti minta 1

1 7

Kimeneti minta 1

16

Hét jó sorozat van: (1),(2),(3),(4),(5),(6),(7). A pontszámaik 1,2,2,3,2,4,2, így a válasz 1+2+2+3+2+4+2=16.

Bemeneti minta 2

3 11

Kimeneti minta 2

16095

Például, (8,11) és (1,8,2) jó sorozatok. Itt a pontszámok kiszámításának folyamata:

- Az elemek szorzata a (8,11) sorozatban 8 \times 11 = 88. A 88-nak nyolc pozitív osztója van: 1,2,4,8,11,22,44,88, így a (8,11) pontszáma 8.
- Az elemek szorzata az (1,8,2) sorozatban 1 \times 8 \times 2 = 16. A 16-nak öt pozitív osztója van: 1,2,4,8,16, így a (1,8,2) pontszáma 5.

Bemeneti minta 3

81131 14

Kimeneti minta 3

182955659

Ne felejtse el venni az eredményt a 998244353-as modulo szerint.

Jó sorozatnak nevezzük azokat az egész sorozatokat, amelynek hosszúsága 1 és N között van, és ahol minden elem 1 és M között van.
Egy jó sorozat pontszáma az X pozitív osztóinak száma, ahol X a sorozat elemeinek szorzata.
Vannak \displaystyle \sum_{k=1}^{N}M^k jó sorozatok. Keresse meg az összes modulo 998244353 sorozat pontszámának összegét.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M

Kimenet

Nyomtassa ki a választ egész számként.

Korlátozások

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- Minden bemeneti érték egész szám.

1. minta bemenet

1 7

1. minta kimenet

16

Hét jó sorozat létezik: (1), (2), (3), (4), (5), (6), (7). Pontszámuk rendre 1,2,2,3,2,4,2, így a válasz 1+2+2+3+2+4+2=16.

2. minta bemenet

3 11

2. minta kimenet

16095

Például (8,11) és (1,8,2) jó sorozatok. Íme a pontszámok kiszámításának folyamata:

- A (8,11) elemeinek szorzata 8 \x 11 = 88. A 88-nak nyolc pozitív osztója van: 1,2,4,8,11,22,44,88, tehát A (8,11) pontszáma 8.
- Az (1,8,2) elemeinek szorzata 1 \x 8 \x 2 = 16. A 16-nak öt pozitív osztója van: 1,2,4,8,16, tehát az (1,8,2) pontszáma 5.

Minta bemenet 3

81131 14

3. minta kimenet

182955659

Ne felejtse el beírni a modulo 998244353 eredményt.

Az 1 és N közötti hosszúságú egész sorozatot, ahol minden elem 1 és M között van, jó sorozatnak nevezzük.
Egy jó sorozat pontszámát úgy definiáljuk, mint X pozitív osztóinak számát, ahol X a sorozat elemeinek szorzata.
Vannak \displaystyle \sum_{k=1}^{N}M^k jó sorozatok. Keresse meg az összes modulo 998244353 szekvencia pontszámainak összegét.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N M

Hozam

Nyomtassa ki a választ egész számként.

Korlátok

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- Minden bemeneti érték egész szám.

1. minta bemenet

1 7

1. minta kimenet

16

Hét jó szekvencia van: (1),(2),(3),(4),(5),(6),(7). Pontszámuk rendre 1,2,2,3,2,4,2, tehát a válasz 1+2+2+3+2+4+2=16.

2. minta bemenet

3 11

2. minta  kimenet

16095

Például a (8,11) és az (1,8,2) jó sorozatok. Itt van a pontszámok kiszámításának folyamata:

- A (8,11) elemeinek szorzata 8 \times 11 = 88. A 88-nak nyolc pozitív osztója van: 1,2,4,8,11,22,44,88, tehát a (8,11) pontszáma 8.
- Az (1,8,2) elemeinek szorzata 1 \times 8 \times 2 = 16. A 16-nak öt pozitív osztója van: 1,2,4,8,16, tehát az (1,8,2) pontszáma 5.

3. minta bemenet

81131 14

3. minta kimenet

182955659

Ne felejtse el az eredményt modulo 998244353.


N hosszúságú egész sorozatokat kapunk: A=(A_1,A_2,\cdots,A_N) és B=(B_1,B_2,\cdots,B_N), valamint egy K egész számot.
A következő műveletet nulla vagy többször is végrehajthatja.

- Válasszon i és j egész számokat (1 \leq i,j \leq N).
Itt, |i-j| \leq K kell tartania.
Ezután módosítsa az A_i értékét A_j-re.

Határozza meg, hogy lehetséges-e azonossá tenni A-t B-vel.
Minden bemenethez T teszteset tartozik.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
T
case_1
case_2
\vdots
case_T

Minden teszteset a következő formátumban van megadva:
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Kimenet

Minden tesztesethez nyomtassa ki az Igen értéket, ha lehetséges, hogy A azonos legyen B-vel, máskülönben pedig a Nem értéket.

Korlátozások

- 1 \leq T \leq 125 000
- 1 \leq K < N \leq 250 000
- 1 \leq A_i,B_i \leq N
- Az N összege az összes tesztesetben minden bemenetben legfeljebb 250 000.
- Minden bemeneti érték egész szám.

Minta bemenet 1

4
3 1
1 1 2
1 2 2
5 4
2 4 5 1 3
2 1 3 2 2
13 1
3 1 3 3 5 3 3 4 2 2 2 5 1
5 3 3 3 4 2 2 2 2 5 5 1 3
20 14
10 6 6 19 13 16 15 15 2 10 2 16 9 12 2 6 13 5 5 9
5 9 6 2 10 19 16 15 13 12 10 2 9 6 5 16 19 12 15 13

Minta kimenet 1

Yes
Yes
No
Yes

Tekintsük az első tesztesetet.
Ha i=2-vel és j=3-mal operálunk, akkor A_2 értéke A_3=2-re változik, ami A=(1,2,2) lesz.

N hosszúságú egész sorozatokat kap: A=(A_1,A_2,\cdots,A_N) és B=(B_1,B_2,\cdots,B_N), valamint egy K egész számot.
A következő műveletet nulla vagy több alkalommal hajthatja végre.

- Válassza ki az i és j egész számokat (1 \leq i,j \leq N).
Itt |i-j| \leq K-nak tartania kell.
Ezután módosítsa a A_i értékét A_j-ra.

Határozzuk meg, hogy lehetséges-e A-t azonossá tenni B-vel.
Minden bemenethez T tesztesetek tartoznak.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
T
case_1
case_2
\vdots
case_T

Minden tesztesetet a következő formátumban kell megadni:
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Hozam

Minden tesztesethez nyomtassa ki az yes értéket, ha lehetséges, hogy A azonos legyen B-vel, és más módon a No értéket.

Korlátok

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- Az egyes bemenetek összes tesztesetének N összege legfeljebb 250000.
- Minden bemeneti érték egész szám.

1. minta bemenet

4
3 1
1 1 2
1 2 2
5 4
2 4 5 1 3
2 1 3 2 2
13 1
3 1 3 3 5 3 3 4 2 2 2 5 1
5 3 3 3 4 2 2 2 2 5 5 1 3
20 14
10 6 6 19 13 16 15 15 2 10 2 16 9 12 2 6 13 5 5 9
5 9 6 2 10 19 16 15 13 12 10 2 9 6 5 16 19 12 15 13

1.minta kimenet

Yes
Yes
No
Yes

Tekintsük az első tesztesetet.
Ha i=2-vel és j=3-mal dolgozunk, akkor a A_2 értéke A_3=2-re változik, így A=(1,2,2).

N hosszúságú egész sorozatokat kapunk: A=(A_1,A_2,\cdots,A_N) és B=(B_1,B_2,\cdots,B_N), valamint egy K egész számot.
A következő műveletet nulla vagy többször is végrehajthatja.

- Válasszon i és j egész számokat (1 \leq i,j \leq N).
Itt, |i-j| \leq K kell tartania.
Ezután módosítsa az A_i értékét A_j-re.

Határozza meg, hogy lehetséges-e azonossá tenni A-t B-vel.
Minden bemenethez T teszteset tartozik.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
T
eset_1
eset_2
\vdots
case_T

Minden teszteset a következő formátumban van megadva:
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Kimenet

Minden tesztesethez nyomtassa ki az Yes értéket, ha lehetséges, hogy A azonos legyen B-vel, máskülönben pedig a No értéket.

Korlátozások

- 1 \leq T \leq 125 000
- 1 \leq K < N \leq 250 000
- 1 \leq A_i,B_i \leq N
- Az N összege az összes tesztesetben minden bemenetben legfeljebb 250 000.
- Minden bemeneti érték egész szám.

1. minta bemenet

4
3 1
1 1 2
1 2 2
5 4
2 4 5 1 3
2 1 3 2 2
13 1
3 1 3 3 5 3 3 4 2 2 2 5 1
5 3 3 3 4 2 2 2 2 5 5 1 3
20 14
10 6 6 19 13 16 15 15 2 10 2 16 9 12 2 6 13 5 5 9
5 9 6 2 10 19 16 15 13 12 10 2 9 6 5 16 19 12 15 13

1. minta kimenet

Yes
Yes
No
Yes

Tekintsük az első tesztesetet.
Ha i=2-vel és j=3-mal operálunk, akkor A_2 értéke A_3=2-re változik, ami A=(1,2,2) lesz.


Keresse meg az (1,2,\cdots,N) P=(P_1,P_2,\cdots,P_N) permutációinak számát, modulo 998244353, amelyek teljesítik az összes alábbi M feltételt.

- Az i-edik feltétel: A P_{L_i},P_{L_i+1},\cdots,P_{R_i} maximuma nem P_{X_i}.
Itt L_i, R_i és X_i a bemenetben megadott egész számok.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- Minden bemeneti érték egész szám.

Minta bemenet 1

3 2
1 3 2
1 2 1

Minta kimenet 1

1

Csak egy permutáció, P=(1,2,3), felel meg a feltételeknek.

Minta bevitel 2

5 1
1 1 1

Minta kimenet 2

0

Minta bemenet 3

10 5
3 8 4
3 10 4
1 7 2
1 8 3
3 8 7

Minta kimenet 3

1598400

Minta bevitel 4

15 17
2 11 9
2 15 13
1 14 2
5 11 5
3 15 11
1 6 2
4 15 12
3 11 6
9 13 10
2 14 6
10 15 11
1 8 6
6 14 8
2 10 2
6 12 6
3 14 12
2 6 2

Minta kimenet 4

921467228

Keresse meg az (1,2,\cdots,N) P=(P_1,P_2,\cdots,P_N) permutációinak számát, modulo 998244353, amelyek teljesítik az összes alábbi M feltételt.

- Az i-edik feltétel: A P_{L_i},P_{L_i+1},\cdots,P_{R_i} maximuma nem P_{X_i}.
Itt L_i, R_i és X_i a bemenetben megadott egész számok.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

Kimenet

Nyomtassa ki a választ.

Korlátozások

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- Minden bemeneti érték egész szám.

1. minta bemenet

3 2
1 3 2
1 2 1

1. minta kimenet

1

Csak egy permutáció, P=(1,2,3), felel meg a feltételeknek.

2. minta bemenet

5 1
1 1 1

2. minta kimenet

0

Minta bemenet 3

10 5
3 8 4
3 10 4
1 7 2
1 8 3
3 8 7

3. minta kimenet

1598400

4. minta bemenet

15 17
2 11 9
2 15 13
1 14 2
5 11 5
3 15 11
1 6 2
4 15 12
3 11 6
9 13 10
2 14 6
10 15 11
1 8 6
6 14 8
2 10 2
6 12 6
3 14 12
2 6 2

4. minta kimenet

921467228

Keresse meg az (1,2,\cdots,N) P=(P_1,P_2,\cdots,P_N) permutációinak számát (modulo 998244353), amelyek megfelelnek az alábbi M feltételek mindegyikének.

- Az i-edik feltétel: A P_{L_i},P_{L_i+1},\cdots,P_{R_i} maximális értéke nem P_{X_i}.
Itt a L_i, R_i és X_i a bemenetben megadott egész számok.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

Hozam

Nyomtassa ki a választ.

Korlátok

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- Minden bemeneti érték egész szám.

1. minta bemenet

3 2
1 3 2
1 2 1

1. minta kimenet

1

Csak egy permutáció, P=(1,2,3) felel meg a feltételeknek.

2. minta bemenet

5 1
1 1 1

2. minta kimenet

0

3. minta bemenet

10 5
3 8 4
3 10 4
1 7 2
1 8 3
3 8 7

3. minta kimenet

1598400

4. minta bemenet

15 17
2 11 9
2 15 13
1 14 2
5 11 5
3 15 11
1 6 2
4 15 12
3 11 6
9 13 10
2 14 6
10 15 11
1 8 6
6 14 8
2 10 2
6 12 6
3 14 12
2 6 2

4. minta kimenet

921467228


Adott pozitív N és K egész számok.
Az NK hosszúságú egész sorozatot, ahol minden 1-től N-ig terjedő egész szám pontosan K-szor jelenik meg, jó egész sorozatnak nevezzük.
Legyen S a jó egész sorozatok száma.
Keresse meg a \operatorname{floor}((S+1)/2)-edik jó egész sorozatot a lexikográfiai sorrendben.
Itt a  \operatorname{floor}(x) az x-et meg nem haladó legnagyobb egész számot jelöli.
 Mi a lexikográfiai sorrend a sorozatok esetében?
Egy sorozat S = (S_1,S_2,\ldots,S_{|S|}) lexikográfiailag kisebb, mint egy sorozat T = (T_1,T_2,\ldots,T_{|T|}) ha bármelyik 1. vagy 2. alatta tartások.
Itt, |S| és |T| jelöljük az S és T hosszát.

-  |S| \lt |T| és (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
- Létezik 1 \leq i \leq \min\lbrace |S|, |T| \rbrace egész szám, amelyre mindkét alábbi feltétel teljesül:

- (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
- S_i (számszerűleg) kisebb, mint T_i.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N K

Kimenet

Nyomtassa ki a kívánt egész sorozatot, szóközökkel elválasztott elemekkel.

Korlátok

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Minden bemeneti érték egész szám.

1. minta bemenet

2 2

1. minta kimenet

1 2 2 1

Hat jó egész sorozat van:

- (1,1,2,2)
- (1,2,1,2)
- (1,2,2,1)
- (2,1,1,2)
- (2,1,2,1)
- (2,2,1,1)

Ezért a válasz a 3. sorozat lexikográfiai sorrendben (1,2,2,1).

2. minta bemenet

1 5

2. minta kimenet

1 1 1 1 1

3. minta bemenet

6 1

3. minta kimenet

3 6 5 4 2 1

4. minta bemenet

3 3

4. minta kimenet

2 2 2 1 3 3 3 1 1

Kapsz N és K pozitív egész számokat.
Egy NK hosszúságú egész sorozatot, ahol minden 1-től N-ig terjedő egész szám pontosan K-szer jelenik meg, jó egész sorozatnak nevezzük.
Legyen S a jó egész sorozatok száma.
Keresse meg a \operatorname{floor}((S+1)/2)-edik jó egész sorozatot lexikográfiai sorrendben.
Itt a \operatorname{floor}(x) a legnagyobb egész szám, amely nem haladja meg az x-et.
 Mi a szekvenciák lexikográfiai sorrendje?
Az S = (S_1,S_2,\ldots,S_{|S|}) sorozat lexikográfiailag kisebb, mint a T = (T_1,T_2,\ldots,T_{|T|}) sorozat, ha 1. vagy 2. tart.
Itt, |S| és |T| S és T hosszát jelentik.

- |S| \lt |T| és (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
- Létezik egy egész szám \leq i \leq \min\lbrace |S|, |T| \rzárót úgy, hogy mindkét következő érvényes legyen:

- (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
- S_i (számszerűen) kisebb, mint T_i.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N K

Kimenet

Nyomtassa ki a kívánt egész sorozatot, szóközzel elválasztva.

Korlátozások

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Minden bemeneti érték egész szám.

minta bemenet 1

2 2

minta kimenet 1

1 2 2 1

Hat jó egész sorozat létezik:

- (1,1,2,2)
- (1,2,1,2)
- (1,2,2,1)
- (2,1,1,2)
- (2,1,2,1)
- (2,2,1,1)

Ezért a válasz a 3. sorrend lexikográfiai sorrendben, (1,2,2,1).

minta bemenet 2

1 5

minta kimenet 2

1 1 1 1 1

Minta bemenet 3

6 1

minta kimenet 3

3 6 5 4 2 1

minta bemenet 4

3 3

minta kimenet 4

2 2 2 1 3 3 3 1 1

Kapsz N és K pozitív egész számokat.
Egy NK hosszúságú egész sorozatot, ahol minden 1-től N-ig terjedő egész szám pontosan K-szer jelenik meg, jó egész sorozatnak nevezzük.
Legyen S a jó egész sorozatok száma.
Keresse meg a \operatorname{floor}((S+1)/2)-edik jó egész sorozatot lexikográfiai sorrendben.
Itt a \operatorname{floor}(x) a legnagyobb egész szám, amely nem haladja meg az x-et.
 Mi a szekvenciák lexikográfiai sorrendje?
Az S = (S_1,S_2,\ldots,S_{|S|}) sorozat lexikográfiailag kisebb, mint a T = (T_1,T_2,\ldots,T_{|T|}) sorozat, ha 1. vagy 2. tart.
Itt, |S| és |T| S és T hosszát jelentik.

- |S| \lt |T| és (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
- Létezik egy egész szám \leq i \leq \min\lbrace |S|, |T| \rzárót úgy, hogy mindkét következő érvényes legyen:

- (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
- S_i (számszerűen) kisebb, mint T_i.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N K

Kimenet

Nyomtassa ki a kívánt egész sorozatot, szóközzel elválasztva.

Korlátozások

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Minden bemeneti érték egész szám.

1. minta bemenet

2 2

1. minta kimenet

1 2 2 1

Hat jó egész sorozat létezik:

- (1,1,2,2)
- (1,2,1,2)
- (1,2,2,1)
- (2,1,1,2)
- (2,1,2,1)
- (2,2,1,1)

Ezért a válasz a 3. sorrend lexikográfiai sorrendben, (1,2,2,1).

2. minta bemenet

1 5

2. minta kimenet

1 1 1 1 1

Minta bemenet 3

6 1

3. minta kimenet

3 6 5 4 2 1

4. minta bemenet

3 3

4. minta kimenet

2 2 2 1 3 3 3 1 1


Van egy fa, amelynek N csúcsa van, és ezek 1-től N-ig vannak számozva.
Az i-edik él összeköti az A_i és B_i csúcsokat.
Itt N páros, ráadásul ez a fa tökéletes párosítás.
Pontosabban, minden i (1 \leq i \leq N/2) esetén garantált, hogy A_i=i \× 2-1 és B_i=i \× 2.
A következő műveletet N/2 alkalommal hajtja végre:

- Válasszon ki két levelet (pontosan 1 fokos csúcsot), és távolítsa el őket a fáról.
Itt a fának az eltávolítás után is tökéletesen illeszkednie kell.
Ebben a feladatban a nulla csúcsú gráfot is fának tekintjük.

Minden műveletnél a pontszám a két kiválasztott csúcs közötti távolság (a két csúcsot összekötő egyszerű útvonal éleinek száma).
Mutasson egy eljárást, amely maximalizálja az összpontszámot.
Bizonyítható, hogy mindig létezik eljárás N/2 művelet végrehajtására a probléma korlátai között.

Bemenet

A bemenetet a szabványos bemenetről adjuk meg a következő formátumban:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Kimenet

Nyomtasson megoldást a következő formátumban:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Itt X_i és Y_i az i-edik műveletben kiválasztott két csúcs.
Ha több megoldás létezik, bármelyiket kinyomtathatja.

Korlátozások

- 2 \leq N \leq 250 000
- N páros.
- 1 \leq A_i < B_i \leq N (1 \leq i \leq N-1)
- A_i=i \x 2 -1, B_i=i \x 2 (1 \leq i \leq N/2)
- A megadott gráf egy fa.
- Minden bemeneti érték egész szám.

1. minta bemenet

4
1 2
3 4
2 3

1. minta kimenet

4 1
2 3

Az eljárás a mintakimenetben a következő:

- 1. művelet: Távolítsa el a 4-es és 1-es csúcsokat. A fennmaradó fának van 2-es és 3-as csúcsa, és tökéletes párosítás. Ennek a műveletnek a pontszáma 3.
- 2. művelet: Távolítsa el a 2-es és 3-as csúcsot. A fennmaradó fának nulla csúcsa van, és tökéletes párosítás. Ennek a műveletnek a pontszáma 1.
- Az összpontszám 3 + 1 = 4.

Lehetetlen, hogy az összpontszám 4-nél nagyobb legyen, ezért ez a kimenet megoldja ezt a mintabevitelt.

2. minta bemenet

8
1 2
3 4
5 6
7 8
2 3
1 5
1 7

2. minta kimenet

4 8
7 6
5 3
2 1

Minta bemenet 3

14
1 2
3 4
5 6
7 8
9 10
11 12
13 14
2 8
4 11
5 12
7 13
11 14
9 13

3. minta kimenet

1 6
5 2
8 12
3 7
10 4
11 9
13 14

4. minta bemenet

20
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
17 18
19 20
8 10
16 18
16 19
5 9
10 17
2 13
7 14
3 7
3 12

4. minta kimenet

6 1
2 15
20 13
14 19
16 4
11 18
17 12
3 5
9 7
8 10

There is a tree with N vertices numbered from 1 to N.
The i-th edge connects vertices A_i and B_i.
Here, N is even, and furthermore, this tree has a perfect matching.
Specifically, for each i (1 \leq i \leq N/2), it is guaranteed that A_i=i \times 2-1 and B_i=i \times 2.
You will perform the following operation N/2 times:

- Choose two leaves (vertices with degree exactly 1) and remove them from the tree.
Here, the tree after removal must still have a perfect matching.
In this problem, we consider a graph with zero vertices to be a tree as well.

For each operation, its score is defined as the distance between the two chosen vertices (the number of edges on the simple path connecting the two vertices).
Show one procedure that maximizes the total score.
It can be proved that there always exists a procedure to complete N/2 operations under the constraints of this problem.

Input

The input is given from Standard Input in the following format:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Output

Print a solution in the following format:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Here, X_i and Y_i are the two vertices chosen in the i-th operation.
If there are multiple solutions, you may print any of them.

Constraints

- 2 \leq N \leq 250000
- N is even.
- 1 \leq A_i < B_i \leq N (1 \leq i \leq N-1)
- A_i=i \times 2 -1, B_i=i \times 2 (1 \leq i \leq N/2)
- The given graph is a tree.
- All input values are integers.

Sample Input 1

4
1 2
3 4
2 3

Sample Output 1

4 1
2 3

The procedure in the sample output is as follows:

- 1st operation: Remove vertices 4 and 1. The remaining tree has vertices 2 and 3, and a perfect matching. The score of this operation is 3.
- 2nd operation: Remove vertices 2 and 3. The remaining tree has zero vertices and a perfect matching. The score of this operation is 1.
- The total score is 3 + 1 = 4.

It is impossible to make the total score greater than 4, so this output solves this sample input.

Sample Input 2

8
1 2
3 4
5 6
7 8
2 3
1 5
1 7

Sample Output 2

4 8
7 6
5 3
2 1

Sample Input 3

14
1 2
3 4
5 6
7 8
9 10
11 12
13 14
2 8
4 11
5 12
7 13
11 14
9 13

Sample Output 3

1 6
5 2
8 12
3 7
10 4
11 9
13 14

Sample Input 4

20
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
17 18
19 20
8 10
16 18
16 19
5 9
10 17
2 13
7 14
3 7
3 12

Sample Output 4

6 1
2 15
20 13
14 19
16 4
11 18
17 12
3 5
9 7
8 10

Van egy fa, amelynek N csúcsai 1-től N-ig vannak számozva.
Az i-edik él összeköti a A_i és B_i csúcsokat.
Itt N páros, ráadásul ez a fa tökéletesen illeszkedik.
Pontosabban, minden i (1 \leq i \leq N/2) esetében garantált, hogy A_i=i \times 2-1 és B_i=i \times 2.
A következő műveleteket kell végrehajtania N/2 alkalommal:

- Válasszon két levelet (csúcsok pontosan 1 fokkal), és távolítsa el őket a fáról.
Itt az eltávolítás után a fának még mindig tökéletesen illeszkednie kell.
Ebben a problémában a nulla csúcsú gráfot is fának tekintjük.

Minden művelet esetében a pontszámot a két kiválasztott csúcs közötti távolságként definiáljuk (a két csúcsot összekötő egyszerű útvonal éleinek száma).
Mutasson be egy eljárást, amely maximalizálja a teljes pontszámot.
Bizonyítható, hogy mindig létezik eljárás N/2 műveletek elvégzésére a probléma korlátai között.

Bemenet

A bemenet a Standard Input a következő formátumban van megadva:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Hozam

Nyomtasson ki egy megoldást a következő formátumban:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Itt X_i és Y_i az i-edik műveletben kiválasztott két csúcs.
Ha több megoldás is létezik, bármelyiket kinyomtathatja.

Korlátok

- 2 \leq N \leq 250000
- N páros.
- 1 \leq A_i < B_i \leq N (1 \leq i \leq N-1)
- A_i=i \times 2 -1, B_i=i \times 2 (1 \leq i \leq N/2)
- Az adott gráf egy fa.
- Minden bemeneti érték egész szám.

1. minta bemenet

4
1 2
3 4
2 3

1.minta kimenet

4 1
2 3

A minta kimenetében szereplő eljárás a következő:

- 1. művelet: Távolítsa el a 4. és 1. csúcsokat. A fennmaradó fa csúcsai 2 és 3, és tökéletesen illeszkednek. A művelet pontszáma 3.
- 2. művelet: Távolítsa el a 2. és 3. csúcsot. A fennmaradó fának nulla csúcsa van, és tökéletesen illeszkedik. A művelet pontszáma 1.
- A teljes pontszám 3 + 1 = 4.

Lehetetlen a teljes pontszámot 4-nél nagyobbra tenni, így ez a kimenet megoldja ezt a mintabemenetet.

2. minta bemenet

8
1 2
3 4
5 6
7 8
2 3
1 5
1 7

2. minta kimenet

4 8
7 6
5 3
2 1

3. minta bemenet

14
1 2
3 4
5 6
7 8
9 10
11 12
13 14
2 8
4 11
5 12
7 13
11 14
9 13

3.minta kimenet

1 6
5 2
8 12
3 7
10 4
11 9
13 14

4.minta bemenet

20
1 2
3 4
5 6
7 8
9 10
11 12
13 14
15 16
17 18
19 20
8 10
16 18
16 19
5 9
10 17
2 13
7 14
3 7
3 12

4.minta kimenet

6 1
2 15
20 13
14 19
16 4
11 18
17 12
3 5
9 7
8 10


Pozitív egész számokat kap n és cél.
Egy tömb nums akkor szép, ha megfelel az alábbi feltételeknek:

nums.length == n.
A nums páronként különálló pozitív egész számokból áll.
A [0, n - 1] tartományban nincs két különböző index, i és j, úgy, hogy nums[i] + nums[j] == target.

Adja vissza azt a minimális összeget, amellyel egy gyönyörű tömb modulo 10^9 + 7 lehet.

1. példa:

Bemenet: n = 2, target = 3
Kimenet: 4
Magyarázat: Láthatjuk, hogy a nums = [1,3] gyönyörű.
- A tömb nums hossza n = 2.
- A tömbszámok páronként különálló pozitív egész számokból állnak.
- Nem létezik két különálló index, i és j, ahol nums[i] + nums[j] == 3.
Bizonyítható, hogy a 4 a lehető legkisebb összeg, amit egy gyönyörű tömb kaphat.

2. példa:

Bemenet: n = 3, target = 3
Kimenet: 8
Magyarázat: Láthatjuk, hogy a nums = [1,3,4] gyönyörű.
- A tömb nums hossza n = 3.
- A tömbszámok páronként különálló pozitív egész számokból állnak.
- Nem létezik két különálló index, i és j, ahol nums[i] + nums[j] == 3.
Bizonyítható, hogy a 8 a lehető legkisebb összeg, amit egy gyönyörű tömb kaphat.

3. példa:

Bemenet: n = 1, target = 1
Kimenet: 1
Magyarázat: Láthatjuk, hogy a nums = [1] gyönyörű.

Korlátok:

1 <= n <= 10^9
1 <= target <= 10^9

Adott pozitív egész számok n és a cél.
Egy tömb szám akkor szép, ha megfelel a következő feltételeknek:

számok.length == n.
nums páronként eltérő pozitív egész számokból áll.
A [0, n - 1] tartományban nem létezik két különálló index, az i és a j, így a nums [i] + nums[j] == target.

Adja vissza azt a minimális lehetséges összeget, amelyet egy gyönyörű tömb modulo 10^9 + 7 lehet.

1. példa:

Bemenet: n = 2, target = 3
Kimenet: 4
Magyarázat: Láthatjuk, hogy a nums = [1,3] szép.
- A tömbszámok hossza n = 2.
- A tömbszámok páronként eltérő pozitív egész számokból állnak.
- Nem létezik két különálló index, az i és a j, amelyek nums [i] + nums[j] == 3.
Bizonyítható, hogy 4 az a minimális összeg, amivel egy szép tömb rendelkezhet.

2. példa:

Bemenet: n = 3, target = 3
Kimenet: 8
Magyarázat: Láthatjuk, hogy a nums = [1,3,4] szép.
- A tömbszámok hossza n = 3.
- A tömbszámok páronként eltérő pozitív egész számokból állnak.
- Nem létezik két különálló index, az i és a j, amelyek nums [i] + nums[j] == 3.
Bizonyítható, hogy 8 az a minimális lehetséges összeg, amivel egy szép tömb rendelkezhet.

3. példa:

Bemenet: n = 1, target = 1
Kimenet: 1
Magyarázat: Láthatjuk, hogy a nums = [1] szép.

Korlátozások:

1 <= n <= 10^9
1 <= target <= 10^9

A következő pozitív egész számokat kapod: n és target.
Egy nums tömb szép, ha teljesíti a következő feltételeket:

nums.length == n.
A nums páronként különböző pozitív egész számokból áll.
Nem létezik két különböző index, i és j, az [0, n - 1] terjedelemben úgy, hogy nums[i] + nums[j] == target.

Add vissza a lehető legkisebb összeget, amelyet egy szép tömb 10^9 + 7 modulo-ban kaphat.

1. példa:
Bemenet: n = 2, target = 3
Kimenet: 4
Magyarázat: Láthatjuk, hogy nums = [1,3] szép.

-A nums tömb hossza n = 2.
-A nums páronként különböző pozitív egész számokból áll.
-Nem létezik két különböző index, i és j, ahol nums[i] + nums[j] == 3.
Bizonyítható, hogy 4 a lehető legkisebb összeg, amit egy szép tömb tartalmazhat.

2. példa:
Bemenet: n = 3, target = 3
Kimenet: 8
Magyarázat: Láthatjuk, hogy nums = [1,3,4] szép.
-A nums tömb hossza n = 3.
-A nums páronként különböző pozitív egész számokból áll.
-Nem létezik két különböző index, i és j, ahol nums[i] + nums[j] == 3.
Bizonyítható, hogy 8 a legkisebb lehetséges összeg, amit egy szép tömb kitehet.

3. példa:
Input: n = 1, target = 1
Output: 1
Magyarázat: Láthatjuk, hogy nums = [1] szép.

Korlátozások:

1 <= n <= 10^9
1 <= target <= 10^9


Kapsz egy s bináris karakterláncot és egy k egész számot.
Egy bináris karakterlánc akkor teljesíti a k-kényszert, ha az alábbi feltételek valamelyike teljesül:

A 0-k száma a karakterláncban legfeljebb k.
A karakterlánc 1-eseinek száma legfeljebb k.

Egy egész számot ad vissza, amely jelöli az s azon részkarakterláncainak számát, amelyek teljesítik a k-kényszert.

1. példa:

Bemenet: s = "10101", k = 1
Kimenet: 12
Magyarázat:
Az „1010”, „10101” és „0101” részkarakterláncok kivételével minden s karakterlánc megfelel a k-kényszernek.

2. példa:

Bemenet: s = "1010101", k = 2
Kimenet: 25
Magyarázat:
Az 5-nél nagyobb hosszúságú részkarakterláncok kivételével minden s részkarakterlánc megfelel a k-kényszernek.

3. példa:

Bemenet: s = "11111", k = 1
Kimenet: 15
Magyarázat:
Az s összes részkarakterlánca kielégíti a k-kényszert.

Korlátozások:

1 <= s.length <= 50
1 <= k <= s.length
s[i] vagy '0' vagy '1'.

Kapsz egy s bináris karakterláncot és egy k egész számot.
Egy bináris karakterlánc akkor teljesíti a k-kényszert, ha az alábbi feltételek valamelyike teljesül:

A 0-k száma a stringben legfeljebb k.
Az 1-k száma a stringben legfeljebb k.

Egy egész számot ad vissza, amely jelöli az s azon részkarakterláncainak számát, amelyek teljesítik a k-kényszert.

1. példa:

Bemenet: s = "10101", k = 1
Kimenet: 12
Magyarázat:
Az „1010”, „10101” és „0101” részkarakterláncok kivételével minden s karakterlánc megfelel a k-kényszernek.

2. példa:

Bemenet: s = "1010101", k = 2
Kimenet: 25
Magyarázat:
Az 5-nél nagyobb hosszúságú részkarakterláncok kivételével minden s részkarakterlánc megfelel a k-kényszernek.

3. példa:

Bemenet: s = "11111", k = 1
Kimenet: 15
Magyarázat:
Az s összes részkarakterlánca kielégíti a k-kényszert.

Korlátozások:

1 <= s.length <= 50
1 <= k <= s.length
s[i] '0' vagy '1'.

Kapsz egy s bináris karakterláncot és egy k egész számot.
Egy bináris karakterlánc akkor felel meg a k-megszorításnak, ha az alábbi feltételek valamelyike teljesül:

A karakterláncban a 0-k száma legfeljebb k.
A karakterláncban az 1-esek száma legfeljebb k.

Egy egész számot ad eredményül, amely az s azon részsztringjeinek számát jelöli, amelyek kielégítik a k-megszorítást.

1. példa:

Bemenet: s = "10101", k = 1
Kimenet: 12
Magyarázat:
Az s minden részkarakterlánca, kivéve az "1010", "10101" és "0101" részsztringeket, kielégíti a k-korlátozást.

2. példa:

Bemenet: s = "1010101", k = 2
Kimenet: 25
Magyarázat:
Az s minden részkarakterlánca, kivéve az 5-nél hosszabb részsztringeket, kielégíti a k-kényszert.

3. példa:

Bemenet: s = "11111", k = 1
Kimenet: 15
Magyarázat:
Az s minden részsztringje kielégíti a k-kényszert.

Korlátok:

1 <= s.length <= 50
1 <= k <= s.length
s[i] értéke "0" vagy "1".


Egy futurisztikus sporttudóstól két azonos hosszúságú n egész tömböt ad az energyDrinkA és energyDrinkB. Ezek a tömbök két különböző energiaital, az A és B energiaitalok óránkénti energianövekedését jelentik.
Óránként egy energiaital megivásával szeretné maximalizálni a teljes energialöketet. Ha azonban az egyik energiaital fogyasztásáról a másikra szeretne váltani, várnia kell egy órát, hogy megtisztuljon a rendszere (ami azt jelenti, hogy ebben az órában nem kap energialöketet).
Adja vissza a maximális teljes energianövekedést, amelyet a következő n órában elérhet.
Vegye figyelembe, hogy a két energiaital bármelyikét elkezdheti fogyasztani.

1. példa:

Bemenet: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Kimenet: 5
Magyarázat:
Az 5-ös energialökés eléréséhez csak az A (vagy csak a B) energiaitalt igya.

2. példa:

Bemenet: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Kimenet: 7
Magyarázat:
A 7-es energialöket eléréséhez:

Az első órában igya az A energiaitalt.
Válts a B energiaitalra, és elveszítjük a második óra energialöketét.
Szerezze meg a B ital energialöketét a harmadik órában.

Korlátozások:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5

Két egész tömböt kapunk, az energyDrinkA és az energyDrinkB azonos hosszúságú n-t egy futurisztikus sporttudóstól. Ezek a tömbök két különböző energiaital, az A és a B által óránként biztosított energialöketeket képviselik.
Szeretné maximalizálni a teljes energialöketet óránként egy energiaital elfogyasztásával. Ha azonban át akarsz váltani az egyik energiaital fogyasztásáról a másikra, akkor várnod kell egy órát, hogy megtisztítsd a rendszeredet (ami azt jelenti, hogy abban az órában nem kapsz energialöketet).
Adja vissza a maximális teljes energialöketet, amelyet a következő n órában nyerhet.
Ne feledje, hogy elkezdheti fogyasztani a két energiaital bármelyikét.

1. példa:

Bemenet: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Kimenet: 5
Magyarázat:
Ahhoz, hogy 5-ös energialöketet nyerj, csak az A (vagy csak B) energiaitalt igyál.

2. példa:

Bemenet: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Kimenet: 7
Magyarázat:
A 7-es energialöket eléréséhez:

Igyál az A energiaitalt az első órában.
Váltson át a B energiaitalra, és elveszítjük a második óra energialöketét.
Nyerje el a B ital energialöketét a harmadik órában.

Korlátok:

n == energyDrinkA.length == energyDrinkB.length
3 <= n <= 10^5
1 <= energyDrinkA[i], energyDrinkB[i] <= 10^5


Adott két pozitív egész szám, n és k.
Egy x egész számot k-palindromikusnak nevezünk, ha:

x egy palindrom.
x osztható k-val.

Adja meg a legnagyobb n számjegyű egész számot (karakterlánc formájában), amely k-palindromos.
Megjegyezzük, hogy az egész számnak nem lehetnek vezető nullái.

1. példa:

Bemenet: n = 3, k = 5
Kimenet: "595"
Magyarázat:
595 a legnagyobb k-palindromos egész szám 3 számjeggyel.

2. példa:

Bemenet: n = 1, k = 4
Kimenet: "8"
Magyarázat:
A 4 és a 8 az egyetlen k-palindromos egész számok, amelyeknek 1 számjegye van.

3. példa:

Bemenet: n = 5, k = 6
Kimenet: "89898"

Korlátozások:

1 <= n <= 10^5
1 <= k <= 9

Két pozitív egész számot kapsz: n és k.
Egy x egész számot k-palindromikusnak nevezünk, ha:

x palindrom.
x osztható k-val.

Adjuk vissza a legnagyobb n számjegyű k-palindromikus számot (karakterláncként).
Ne feledd, hogy a számnak nem lehetnek kezdő nullái.

Példa 1:

Bemenet: n = 3, k = 5
Kimenet: "595"
Magyarázat:
A 595 a legnagyobb k-palindromikus egész szám 3 számjeggyel.

Példa 2:

Bemenet: n = 1, k = 4
Kimenet: "8"
Magyarázat:
Csak a 4 és 8 k-palindromikus egy számjeggyel.

Példa 3:

Bemenet: n = 5, k = 6
Kimenet: "89898"

Korlátozások:

1 <= n <= 10^5
1 <= k <= 9

Kapsz két pozitív egész számot, n és k.
Egy x egész számot k-palindromnak nevezünk, ha:

x egy palindrom.
x osztható k-val.

A legnagyobb n számjegyű egész számot adja vissza (karakterláncként), amely k-palindrom.
Vegye figyelembe, hogy az egész számnak nem lehetnek kezdő nullái.

1. példa:

Bemenet: n = 3, k = 5
Kimenet: "595"
Magyarázat:
Az 595 a legnagyobb k-palindrom egész szám, 3 számjegyből áll.

2. példa:

Bemenet: n = 1, k = 4
Kimenet: "8"
Magyarázat:
A 4 és a 8 az egyetlen k-palindrom egész szám, amelynek 1 számjegye van.

3. példa:

Bemenet: n = 5, k = 6
Kimenet: "89898"

Korlátozások:

1 <= n <= 10^5
1 <= k <= 9


Egy egész számokból álló tömböt, nums-t kapsz, valamint egy egész szám k-t és egy egész szám multiplier-t.
k műveletet kell végrehajtanod a nums tömbön. Minden egyes művelet során:

Keresd meg az x minimum értéket a nums tömbben. Ha többször is előfordul a minimum érték, válaszd ki azt, amelyik először jelenik meg.
Cseréld ki a kiválasztott minimum értéket x a következőre: x * multiplier.

Adj vissza egy egész számokból álló tömböt, amely a nums végső állapotát jelzi az összes k művelet elvégzése után.

Példa 1:

Bemenet: nums = [2,1,3,5,6], k = 5, multiplier = 2
Kimenet: [8,4,6,5,6]
Magyarázat:

Művelet
Eredmény

Az 1. művelet után
[2, 2, 3, 5, 6]

A 2. művelet után
[4, 2, 3, 5, 6]

A 3. művelet után
[4, 4, 3, 5, 6]

A 4. művelet után
[4, 4, 6, 5, 6]

Az 5. művelet után
[8, 4, 6, 5, 6]

Példa 2:

Bemenet: nums = [1,2], k = 3, multiplier = 4
Kimenet: [16,8]
Magyarázat:

Művelet
Eredmény

Az 1. művelet után
[4, 2]

A 2. művelet után
[4, 8]

A 3. művelet után
[16, 8]

Korlátozások:

1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= multiplier <= 5

Adunk egy egész tömb számot, egy k egész számot és egy egész számszorzót.
K műveletet kell végrehajtania a számokkal. Minden műveletnél:

Keresse meg a minimális x értéket számokban. Ha a minimális érték többször is előfordul, válassza ki az elsőként megjelenőt.
Cserélje ki a kiválasztott minimális x értéket x * szorzóval.

Egy egész szám tömböt ad vissza, amely a számok végső állapotát jelöli az összes k művelet végrehajtása után.

1. példa:

Bemenet: nums = [2,1,3,5,6], k = 5, multiplier = 2
Kimenet: [8,4,6,5,6]
Magyarázat:

Művelet
Eredmény

Műtét után 1
[2, 2, 3, 5, 6]

Műtét után 2
[4, 2, 3, 5, 6]

Műtét után 3
[4, 4, 3, 5, 6]

Műtét után 4
[4, 4, 6, 5, 6]

Műtét után 5
[8, 4, 6, 5, 6]

2. példa:

Bemenet: nums = [1,2], k = 3, multiplier = 4
Kimenet: [16,8]
Magyarázat:

Művelet
Eredmény

Műtét után 1
[4, 2]

Műtét után 2
[4, 8]

Műtét után 3
[16, 8]

Korlátozások:

1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= multiplier <= 5

Kap egy egész tömb számát, egy k egész számot és egy egész szorzót.
K műveletet kell végrehajtania a számokon. Minden műveletnél:

Keresse meg a minimális x értéket számban. Ha a minimális értéknek több előfordulása van, válassza ki azt, amelyik először jelenik meg.
Cserélje ki a kiválasztott minimális x értéket x * szorzóra.

Egy egész tömböt ad vissza, amely a számok végső állapotát jelöli az összes k művelet végrehajtása után.

1. példa:

Bemenet: nums = [2,1,3,5,6], k = 5, multiplier = 2
Kimenet: [8,4,6,5,6]
Magyarázat:

Művelet
Eredmény

Művelet után 1
[2, 2, 3, 5, 6]

A 2. művelet után
[4, 2, 3, 5, 6]

Művelet után 3
[4, 4, 3, 5, 6]

Műtét után 4
[4, 4, 6, 5, 6]

Művelet után 5
[8, 4, 6, 5, 6]

2. példa:

Bemenet: nums = [1,2], k = 3, multiplier = 4
Kimenet: [16,8]
Magyarázat:

Művelet
Eredmény

Művelet után 1
[4, 2]

A 2. művelet után
[4, 8]

Művelet után 3
[16, 8]

Korlátok:

1 <= nums.length <= 100
1 <= nums[i] <= 100
1 <= k <= 10
1 <= multiplier <= 5


Kapsz egy pozitív egész számokból álló tömböt.
Ebben a feladatban két x és y egész számot majdnem egyenlőnek nevezünk, ha mindkét egész szám egyenlővé válhat a következő művelet legfeljebb egyszeri végrehajtása után:

Válassza ki az x vagy az y értéket, és cserélje fel bármelyik két számjegyet a kiválasztott számon belül.

Adja vissza az i és j indexek számát számokban, ahol i < j úgy, hogy a számok[i] és a számok[j] majdnem egyenlőek.
Vegye figyelembe, hogy a művelet végrehajtása után egy egész szám kezdő nullákat tartalmazhat.

1. példa:

Bemenet: nums = [3,12,30,17,21]
Kimenet: 2
Magyarázat:
A majdnem egyenlő elempárok a következők:

3 és 30. Ha felcseréli a 3-at és a 0-t 30-ra, akkor 3-at kap.
12 és 21. Ha 12-ben felcseréli az 1-et és a 2-t, 21-et kap.

2. példa:

Bemenet: nums = [1,1,1,1,1]
Kimenet: 10
Magyarázat:
A tömbben minden két elem majdnem egyenlő.

3. példa:

Bemenet: nums = [123,231]
Kimenet: 0
Magyarázat:
A 123 vagy 231 két számjegyét nem tudjuk felcserélni, hogy elérjük a másikat.

Korlátozások:

2 <= nums.length <= 100
1 <= nums[i] <= 10^6

Kapsz egy tömbszámot, amely pozitív egész számokból áll.
Ebben a problémában két x és y egész számot majdnem egyenlőnek nevezünk, ha mindkét egész szám egyenlővé válhat a következő művelet legfeljebb egyszeri végrehajtása után:

Válassza az x vagy az y lehetőséget, és cserélje fel a kiválasztott számon belüli két számjegyet.

Adjuk vissza az i és j indexek számát számban, ahol i < j úgy, hogy a nums[i] és a nums[j] majdnem egyenlő legyen.
Vegye figyelembe, hogy egy egész számnak megengedett, hogy egy művelet végrehajtása után vezető nullák legyenek.

1. példa:

Bemenet: szám = [3,12,30,17,21]
Kimenet: 2
Magyarázat:
A majdnem egyenlő elempárok a következők:

3 és 30. Ha 3-at és 0-t cserél 30-ra, 3-at kap.
12 és 21. Ha 1-et és 2-t cserél 12-ben, 21-et kap.

2. példa:

Bemenet: nums = [1,1,1,1,1]
Kimenet: 10
Magyarázat:
A tömb minden két eleme majdnem egyenlő.

3. példa:

Bemenet: nums = [123,231]
Kimenet: 0
Magyarázat:
Nem cserélhetjük fel a 123 vagy 231 két számjegyét, hogy elérjük a másikat.

Korlátok:

2 <= szám.hossz <= 100
1 <= szám[i] <= 10^6

Kapsz egy tömbszámot, amely pozitív egész számokból áll.
Ebben a problémában két x és y egész számot majdnem egyenlőnek nevezünk, ha mindkét egész szám egyenlővé válhat a következő művelet legfeljebb egyszeri végrehajtása után:

Válassza az x vagy az y lehetőséget, és cserélje fel a kiválasztott számon belüli két számjegyet.

Adjuk vissza az i és j indexek számát számban, ahol i < j úgy, hogy a nums[i] és a nums[j] majdnem egyenlő legyen.
Vegye figyelembe, hogy egy egész számnak megengedett, hogy egy művelet végrehajtása után vezető nullák legyenek.

1. példa:

Bemenet: nums = [3,12,30,17,21]
Kimenet: 2
Magyarázat:
A majdnem egyenlő elempárok a következők:

3 és 30. Ha 3-at és 0-t cserél 30-ra, 3-at kap.
12 és 21. Ha 1-et és 2-t cserél 12-ben, 21-et kap.

2. példa:

Bemenet: nums = [1,1,1,1,1]
Kimenet: 10
Magyarázat:
A tömb minden két eleme majdnem egyenlő.

3. példa:

Bemenet: nums = [123,231]
Kimenet: 0
Magyarázat:
Nem cserélhetjük fel a 123 vagy 231 két számjegyét, hogy elérjük a másikat.

Korlátok:

2 <= nums.length <= 100
1 <= nums[i] <= 10^6


Adott két karakterlánc, a koordináta1 és a koordináta2, amelyek egy 8 x 8-as sakktábla egy négyzetének koordinátáit jelölik.
Az alábbiakban a sakktáblát mutatjuk be.

Adjon vissza true értéket, ha a két négyzetnek ugyanaz a színe, ellenkező esetben false értéket.
A koordináta mindig egy érvényes sakktábla négyzetet fog képviselni. A koordinátában mindig a betű lesz az első (az oszlopot jelzi), és a szám a második (a sort jelzi).

Példa 1:

Bemenet: coordinate1 = "a1", coordinate2 = "c3"
Kimenet: true
Magyarázat:
Mindkét négyzet fekete.

Példa 2:

Bemenet: coordinate1 = "a1", coordinate2 = "h3"
Kimenet: false
Magyarázat:
Az "a1" négyzet fekete, a "h3" pedig fehér.

Korlátozások:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'

Két karakterláncot kapsz, a koordináta1-et és a koordináta2-t, amelyek egy 8 x 8-as sakktáblán lévő négyzet koordinátáit jelentik.
Alább található a sakktábla referenciaként.

Igaz, ha ez a két négyzet azonos színű, ellenkező esetben hamis.
A koordináták mindig érvényes sakktábla négyzetet jelentenek. A koordinátán mindig a betű lesz az első (az oszlopot jelölve), a szám pedig a második (a sorát jelzi).

Példa 1:

Bemenet: coordinate1 = "a1", coordinate2 = "c3"
Kimenet: true
Magyarázat:
Mindkét négyzet fekete.

Példa 2:

Bemenet: coordinate1 = "a1", coordinate2 = "h3"
Kimenet: false
Magyarázat:
Az "a1" négyzet fekete, a "h3" pedig fehér.

Korlátozások:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'

Két karakterláncot kap, koordináta1 és koordináta2, amelyek egy négyzet koordinátáit képviselik egy 8 x 8-as sakktáblán.
Az alábbiakban a sakktábla referenciaként szolgál.

Igaz értéket ad vissza, ha a két négyzet azonos színű, egyébként hamis.
A koordináta mindig érvényes sakktábla-négyzetet képvisel. A koordináta mindig az első betűvel (az oszlopát jelezve) és a második számmal (a sorát jelezve) lesz.

1. példa:

Bemenet: koordináta1 = "a1", koordináta2 = "c3"
Kimenet: true
Magyarázat:
Mindkét négyzet fekete.

2. példa:

Bemenet: coordinate1 = "a1", coordinate2 = "h3"
Kimenet: hamis
Magyarázat:
Az "a1" négyzet fekete, a "h3" pedig fehér.

Korlátok:

coordinate1.length == coordinate2.length == 2
'a' <= coordinate1[0], coordinate2[0] <= 'h'
'1' <= coordinate1[1], coordinate2[1] <= '8'


Van egy végtelen 2D sík.
Kapsz egy k pozitív egész számot. Egy 2D tömb lekérdezéseket is kap, amely a következő lekérdezéseket tartalmazza:

queries[i] = [x, y]: Építsen akadályt az (x, y) koordinátán a síkban. A lekérdezéskor garantáltan nincs akadály ezen a koordinátán.

Minden lekérdezés után meg kell találni a k. legközelebbi akadály távolságát az origótól.
Adjon vissza egy egész számokból álló tömböt, ahol eredmények[i] a k. legközelebbi akadályt jelöli az i. lekérdezés után, vagy -1, ha kevesebb, mint k akadály van.
Vegye figyelembe, hogy kezdetben sehol nincs akadály.
az (x, y) koordinátán lévő akadály origótól való távolsága |x| + |y|.

1. példa:

Bemenet: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Kimenet: [-1,7,5,3]
Magyarázat:

Kezdetben 0 akadály van.
A queries[0] után kevesebb mint 2 akadály van.
Lekérdezések[1] után akadályok vannak a 3. és 7. távolságon.
A lekérdezések[2] után akadályok vannak a 3., 5. és 7. távolságon.
A lekérdezések[3] után akadályok vannak a 3., 3., 5. és 7. távolságon.

2. példa:

Bemenet: queries = [[5,5],[4,4],[3,3]], k = 1
Kimenet: [10,8,6]
Magyarázat:

A lekérdezések[0] után egy akadály van a 10-es távolságban.
Lekérdezések[1] után akadályok vannak a 8. és 10. távolságon.
A lekérdezések[2] után akadályok vannak a 6., 8. és 10. távolságon.

Korlátozások:

1 <= queries.length <= 2 * 10^5
Minden lekérdezés[i] egyedi.
-10^9 <= lekérdezések[i][0], lekérdezések[i][1] <= 10^9
1 <= k <= 10^5

Van egy végtelen 2D sík.
Kapsz egy k pozitív egész számot. Egy 2D tömb lekérdezéseket is kap, amely a következő lekérdezéseket tartalmazza:

queries[i] = [x, y]: Építsen akadályt az (x, y) koordinátán a síkban. A lekérdezéskor garantáltan nincs akadály ezen a koordinátán.

Minden lekérdezés után meg kell találni a k-adik legközelebbi akadály távolságát az origótól.
Olyan egész tömb eredményét adja vissza, ahol az eredmények[i] a k-adik legközelebbi akadályt jelöli az i lekérdezés után, vagy eredmények[i] == -1, ha knál kevesebb akadály van.
Vegye figyelembe, hogy kezdetben sehol nincs akadály.
az (x, y) koordinátán lévő akadály origótól való távolsága |x| + |y|.

1. példa:

Bemenet: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Kimenet: [-1,7,5,3]
Magyarázat:

Kezdetben 0 akadály van.
A queries[0] után kevesebb mint 2 akadály van.
A queries[1] után a távolságok 3 és 7.
A queries[2] után a távolságok 3, 5 és 7.
A queries[3] után a távolságok 3, 3, 5 és 7.

2. példa:

Bemenet: queries = [[5,5],[4,4],[3,3]], k = 1
Kimenet: [10,8,6]
Magyarázat:

A queries[0] után az akadály távolsága 10.
A queries[1] után a távolságok 8 és 10.
A queries[2] után a távolságok 6, 8 és 10.

Korlátozások:

1 <= queries.length <= 2 * 10^5
Minden lekérdezés[i] egyedi.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

Van egy végtelen 2D-sík.
Adott egy pozitív egész szám k. Adott továbbá egy 2D-s tömb lekérdezések, amely a következő lekérdezéseket tartalmazza:

queries[i] = [x, y]: Építsünk egy akadályt az (x, y) koordinátán a síkban. Garantáltan nincs akadály ezen a koordinátán, amikor ez a lekérdezés megtörténik.

Minden egyes lekérdezés után meg kell találni a k^-edik legközelebbi akadály távolságát az origótól.
Egy egész szám tömböt ad vissza, ahol results[i] az i lekérdezés utáni k^-edik legközelebbi akadályt jelöli, vagy results[i] == -1, ha k-nál kevesebb akadály van.
Vegyük észre, hogy kezdetben sehol sincsenek akadályok.
Az (x, y) koordinátán lévő akadály távolsága az origótól: |x| + |y|.

Példa 1:

Bemenet: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Kimenet: [-1,7,5,3]
Magyarázat:

Kezdetben 0 akadály van.
A queries[0] lekérdezés után kevesebb mint 2 akadály van.
A queries[1] lekérdezés után a 3 és 7 távolságban vannak akadályok.
A queries[2] lekérdezés után a 3, 5 és 7 távolságban vannak akadályok.
A queries[3] lekérdezés után 3, 3, 5 és 7 távolságban vannak akadályok.

Példa 2:

Bemenet: queries = [[5,5],[4,4],[3,3]], k = 1
Kimenet: [10,8,6]
Magyarázat:

A queries[0] után a 10-es távolságban van egy akadály.
A queries[1] lekérdezés után a 8 és 10 távolságban vannak akadályok.
A[2] lekérdezések után a 6, 8 és 10 távolságban vannak akadályok.

Korlátozások:

1 <= queries.length <= 2 * 10^5
Minden queries[i] egyedi.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5


Kapsz egy 2D-s mátrixrácsot, amely pozitív egész számokból áll.
A mátrixból ki kell választania egy vagy több cellát úgy, hogy a következő feltételek teljesüljenek:

Nincs két kijelölt cella a mátrix ugyanazon sorában.
A kijelölt cellák halmazában lévő értékek egyediek.

A pontszám a kiválasztott cellák értékeinek összege lesz.
Adja vissza az elérhető maximális pontszámot.

1. példa:

Bemenet: grid = [[1,2,3],[4,3,2],[1,1,1]]
Kimenet: 8
Magyarázat:

Kiválaszthatjuk a fenti 1., 3. és 4. értékű cellákat.

2. példa:

Bemenet: grid = [[8,7,6],[8,3,2]]
Kimenet: 15
Magyarázat:

Kiválaszthatjuk a fenti 7-es és 8-as értékű cellákat.

Korlátok:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Egy pozitív egész számokból álló 2D-s mátrixrácsot kapsz.
Ki kell választani egy vagy több cellát a mátrixból úgy, hogy a következő feltételek teljesüljenek:

Nincs két kijelölt cella a mátrix egy sorában.
A kiválasztott cellák halmazában lévő értékek egyediek.

Az Ön pontszáma a kiválasztott cellák értékeinek összege lesz.
Adja vissza az elérhető maximális pontszámot.

1. példa:

Bemenet: grid = [[1,2,3],[4,3,2],[1,1,1]]
Kimenet: 8
Magyarázat:

Kiválaszthatjuk az 1-es, 3-as és 4-es értékű cellákat, amelyek a fenti színnel vannak ellátva.

2. példa:

Bemenet: grid = [[8,7,6],[8,3,2]]]
Kimenet: 15
Magyarázat:

Kiválaszthatjuk a 7-es és 8-as értékű cellákat, amelyek a fenti színnel vannak ellátva.

Korlátozások:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100

Kapsz egy pozitív egész számokból álló 2D mátrixrácsot.
Ki kell választani egy vagy több cellát a mátrixból úgy, hogy a következő feltételek teljesüljenek:

Nincs két kijelölt cella a mátrix egy sorában.
A kijelölt cellák halmazában lévő értékek egyediek.

Az Ön pontszáma a kiválasztott cellák értékeinek összege lesz.
Adja vissza az elérhető maximális pontszámot.

1. példa:

Bemenet: grid = [[1,2,3],[4,3,2],[1,1,1]]
Kimenet: 8
Magyarázat:

Kiválaszthatjuk az 1-es, 3-as és 4-es értékű cellákat, amelyek a fenti színnel vannak ellátva.

2. példa:

Bemenet: grid = [[8,7,6], [8,3,2]]
Kimenet: 15
Magyarázat:

Kiválaszthatjuk a 7-es és 8-as értékű cellákat, amelyek a fenti színnel vannak ellátva.

Korlátozások:

1 <= grid.length, grid[i].length <= 10
1 <= grid[i][j] <= 100


Meg van adva egy nums tömb, amely n egész számot tartalmaz, és egy kétdimenziós lekérdezés egész számokat tartalmazó tömb q méretben, ahol queries[i] = [l_i, r_i].
Minden lekérdezéshez meg kell találni a nums[l_i..r_i] bármely részhalmazának maximális XOR eredményét.
Mindengyik tömb XOR eredményét az alábbi műveletek ismételt alkalmazásával lehet megtalálni, így csak egy elem marad, amely az eredmény:

Egyszerre cserélje le a[i] értéket a[i] XOR a[i + 1]-re az összes i index esetén, kivéve az utolsót.
Távolítsa el a tömb utolsó elemét.

Adjon vissza egy q méretű válasz tömböt, ahol answer[i] a lekérdezés válasza.

1. példa:
Bemenet: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Kimenet: [12,60,60]
Magyarázat:
Az első lekérdezésben a nums[0..2] 6 részhalmazt tartalmaz: [2], [8], [4], [2, 8], [8, 4], és [2, 8, 4], mindegyiknek a XOR eredménye: 2, 8, 4, 10, 12, és 6. A lekérdezés válasza 12, ami a legnagyobb az összes XOR eredmény közül.
A második lekérdezésben a nums[1..4] részhalmaz, amelynek a legnagyobb XOR eredménye van, nums[1..4] és az eredmény 60.
A harmadik lekérdezésben a nums[0..5] részhalmaz, amelynek a legnagyobb XOR eredménye van, nums[1..4] és az eredmény 60.

2. példa:
Bemenet: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Kimenet: [7,14,11,14,5]
Magyarázat:

Index
nums[l_i..r_i]
Maximum XOR Eredmény Részhalmaz
Maximum Részhalmaz XOR Eredmény

0
[0, 7, 3, 2]
[7]
7

1
[7, 3, 2, 8, 5]
[7, 3, 2, 8]
14

2
[3, 2, 8]
[3, 2, 8]
11

3
[3, 2, 8, 5, 1]
[2, 8, 5, 1]
14

4
[5, 1]
[5]
5

Korlátozások:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

Adott egy n egész számból álló tömb és egy q méretű 2D egész tömb lekérdezést, ahol a queries[i] = [l_i, r_i].
Minden lekérdezéshez meg kell találnia a nums[l_i.. r_i].
Egy a tömb XOR pontszámát úgy kapjuk meg, hogy ismételten alkalmazzuk a következő műveleteket az a-n, hogy csak egy elem maradjon, ez pedig a pontszám:

Egyidejűleg cserélje ki a[i]-t a[i] XOR-ra a[i + 1] minden i indexre, kivéve az utolsót.
Távolítsa el az a utolsó elemét.

Visszaad egy q méretű tömböt, ahol az answer[i] az i lekérdezésre adott válasz.

1. példa:

Bemenet: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Kimenet: [12,60,60]
Magyarázat:
Az első lekérdezésben a nums[0..2] 6 résztömböt [2], [8], [4], [2, 8], [8, 4] és [2, 8, 4] tartalmaz, amelyek XOR pontszáma 2, 8, 4, 10, 12 és 6. A lekérdezésre adott válasz 12, az összes XOR-pontszám közül a legnagyobb.
A második lekérdezésben a nums[1..4] legnagyobb XOR pontszámmal rendelkező résztömbje nums[1..4] 60 pontszámmal.
A harmadik lekérdezésben a nums[0..5] legnagyobb XOR pontszámmal rendelkező résztömbje a nums[1..4] 60 pontszámmal.

2. példa:

Bemenet: nums = [0,7,3,2,8,5,1], lekérdezések = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Kimenet: [7,14,11,14,5]
Magyarázat:

Index
szám[l_i.. r_i]
XOR pontszám maximális résztömbje
Maximális Subarray XOR pontszám

0
[0, 7, 3, 2]
[7]
7

1
[7, 3, 2, 8, 5]
[7, 3, 2, 8]
14

2
[3, 2, 8]
[3, 2, 8]
11

3
[3, 2, 8, 5, 1]
[2, 8, 5, 1]
14

4
[5, 1]
[5]
5

Korlátok:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1

Kap egy n egész számból álló tömbszámot és egy q méretű 2D egész tömb lekérdezést, ahol a queries[i] = [l_i, r_i].
Minden lekérdezéshez meg kell találnia a nums[l_i.. r_i].
Egy a tömb XOR pontszámát úgy kapjuk meg, hogy ismételten alkalmazzuk a következő műveleteket az a-n, hogy csak egy elem maradjon, ez pedig a pontszám:

Egyidejűleg cserélje ki a[i]-t a[i] XOR-ra a[i + 1] minden i indexre, kivéve az utolsót.
Távolítsa el az a utolsó elemét.

Egy q méretű tömbválaszt ad vissza, ahol az answer[i] az i lekérdezésre adott válasz.

1. példa:

Bemenet: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Kimenet: [12,60,60]
Magyarázat:
Az első lekérdezésben a nums[0..2] 6 résztömböt [2], [8], [4], [2, 8], [8, 4] és [2, 8, 4] tartalmaz, amelyek XOR pontszáma 2, 8, 4, 10, 12 és 6. A lekérdezésre adott válasz 12, az összes XOR-pontszám közül a legnagyobb.
A második lekérdezésben a nums[1..4] legnagyobb XOR pontszámmal rendelkező résztömbje nums[1..4] 60 pontszámmal.
A harmadik lekérdezésben a nums[0..5] legnagyobb XOR pontszámmal rendelkező résztömbje a nums[1..4] 60 pontszámmal.

2. példa:

Bemenet: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Kimenet: [7,14,11,14,5]
Magyarázat:

Index
nums[l_i.. r_i]
XOR pontszám maximális résztömbje
Maximális Subarray XOR pontszám

0
[0, 7, 3, 2]
[7]
7

1
[7, 3, 2, 8, 5]
[7, 3, 2, 8]
14

2
[3, 2, 8]
[3, 2, 8]
11

3
[3, 2, 8, 5, 1]
[2, 8, 5, 1]
14

4
[5, 1]
[5]
5

Korlátok:

1 <= n == nums.length <= 2000
0 <= nums[i] <= 2^31 - 1
1 <= q == queries.length <= 10^5
queries[i].length == 2
queries[i] = [l_i, r_i]
0 <= l_i <= r_i <= n - 1


Egy karakterláncot kapsz, amely a Gergely-naptár egy dátumát ábrázolja az éééé-hh-nn formátumban.
A dátum megadható bináris ábrázolásában is, amelyet az év, hónap és nap bináris ábrázolásának átalakításával kapunk, vezető nullák nélkül, és azokat az év-hónap-nap formátumban írjuk le.
Térj vissza a dátum bináris ábrázolásával.

Példa 1:

Bemenet: date = "2080-02-29"
Kimenet: "100000100000-10-11101"
Magyarázat:
A 2080, 02 és 29 bináris ábrázolása sorrendben 100000100000, 10, és 11101.

Példa 2:

Bemenet: date = "1900-01-01"
Kimenet: "11101101100-1-1"
Magyarázat:
A 1900, 1 és 1 bináris ábrázolása sorrendben 11101101100, 1, és 1.

Korlátozások:

date.length == 10
date[4] == date[7] == '-', és a többi date[i] karakter számjegy.
A bemenet garantáltan érvényes Gergely-naptár szerinti dátumot jelöl 1900. január 1-je és 2100. december 31-e között (mindkettő beleértve).

Adott egy karakterlánc, amely egy dátumot képvisel, amely egy Gregorius-naptár dátumát képviseli éééé-hh-nn formátumban.
A dátum bináris ábrázolásban írható le, amelyet úgy kapunk, hogy az évet, hónapot és napot bináris ábrázolásukká alakítjuk át vezető nullák nélkül, és év-hónap-nap formátumban írjuk le őket.
A dátum bináris ábrázolását adja eredményül.

1. példa:

Bemenet: date  = "2080-02-29"
Kimenet: "100000100000-10-11101"
Magyarázat:
100000100000, 10 és 11101 a 2080, 02 és 29 bináris ábrázolása.

2. példa:

Bemenet: date  = "1900-01-01"
Kimenet: "11101101100-1-1"
Magyarázat:
11101101100, 1 és 1 az 1900, 1 és 1 bináris ábrázolásai.

Korlátok:

date.length == 10
date[4] == date[7] == '-', és a többi karakter számjegy.
A bemenet úgy jön létre, hogy a dátum érvényes Gregorius-naptár szerinti dátumot képvisel 1900. január 1. január és 2100. december 31. december között (mindkettőt beleértve).

Kap egy karakterlánc dátumot, amely egy Gergely-naptár dátumát képviseli éééé-hh-nn formátumban.
A dátum bináris ábrázolásban írható le, amelyet úgy kapunk, hogy az évet, hónapot és napot bináris ábrázolásukká alakítjuk át vezető nullák nélkül, és év-hónap-nap formátumban írjuk le őket.
A dátum bináris ábrázolását adja eredményül.

1. példa:

Bemenet: date = "2080-02-29"
Kimenet: "100000100000-10-11101"
Magyarázat:
100000100000, 10 és 11101 a 2080, 02 és 29 bináris ábrázolása.

2. példa:

Bemenet: date = "1900-01-01"
Kimenet: "11101101100-1-1"
Magyarázat:
11101101100, 1 és 1 az 1900, 1 és 1 bináris ábrázolásai.

Korlátok:

date.length == 10
date[4] == date[7] == '-', és minden más date[i]-je számjegy.
A bemenet úgy jön létre, hogy a dátum érvényes Gergely-naptár szerinti dátumot képvisel 1900. január 1^st és 2100. december 31^st között (mindkettőt beleértve).


Kapunk egy egész start és egy d egész számot, amelyek n intervallumot képviselnek [start[i], start[i] + d].
A rendszer megkéri, hogy válasszon n egész számot, ahol az i^edik egész számnak az i^edik intervallumhoz kell tartoznia. A kiválasztott egész számok pontszáma bármely két kiválasztott egész szám közötti minimális abszolút különbségként definiálható.
A kiválasztott egész számok maximális lehetséges pontszámát adja vissza.

1. példa:

Bemenet: start = [6,0,3], d = 2
Kimenet: 4
Magyarázat:
A maximális pontszám a következő egész számok kiválasztásával érhető el: 8, 0 és 4. Ezeknek a kiválasztott egészeknek a pontszáma min(|8 - 0|, |8 - 4|, |0 - 4|), ami 4-gyel egyenlő.

2. példa:

Bemenet: start = [2,6,13,13], d = 5
Kimenet: 5
Magyarázat:
A maximális pontszám a következő egész számok kiválasztásával érhető el: 2, 7, 13 és 18. Ezeknek a kiválasztott egészeknek a pontszáma min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), amely 5-tel egyenlő.

Korlátozások:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Kapunk egy egész számokból álló tömböt, start, és egy d egész számot, amelyek n intervallumot képviselnek [start[i], start[i] + d].
A rendszer megkéri, hogy válasszon n egész számot, ahol az i^edik egész számnak az i^edik intervallumhoz kell tartoznia. A kiválasztott egész számok pontszáma bármely két kiválasztott egész szám közötti minimális abszolút különbségként definiálható.
A kiválasztott egész számok maximális lehetséges pontszámát adja vissza.

Példa 1:

Bemenet: start = [6,0,3], d = 2
Kimenet: 4
Magyarázat:
A maximális pontszám a következő egész számok kiválasztásával érhető el: 8, 0 és 4. Ezeknek a kiválasztott egészeknek a pontszáma min(|8 - 0|, |8 - 4|, |0 - 4|), ami 4-gyel egyenlő.

Példa 2:

Bemenet: start = [2,6,13,13], d = 5
Kimenet: 5
Magyarázat:
A maximális pontszám a következő egész számok kiválasztásával érhető el: 2, 7, 13 és 18. Ezeknek a kiválasztott egészeknek a pontszáma min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), amely 5-tel egyenlő.

Korlátozások:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9

Adott egy egész számokból álló tömb start és egy egész szám d, amely n intervallumot [start[i], start[i] + d] reprezentál.
Feladatunk, hogy válasszunk ki n egész számot, ahol az i^-edik egész számnak az i^-edik intervallumba kell tartoznia. A választott egész számok pontszámát úgy határozzuk meg, hogy a két választott egész szám közötti legkisebb abszolút különbség.
A kiválasztott egész számok maximálisan lehetséges pontszámát adja vissza.

1. példa:

Bemenet: start = [6,0,3], d = 2
Kimenet: 4
Magyarázat:
A lehető legnagyobb pontszámot a következő egész számok kiválasztásával érhetjük el: 8, 0 és 4. Ezeknek a választott egész számoknak a pontszáma min(|8 - 0|, |8 - 4|, |0 - 4|), ami egyenlő 4-el.

2. példa:

Bemenet: start = [2,6,13,13], d = 5
Kimenet: 5
Magyarázat:
A lehető legnagyobb pontszámot a következő egész számok kiválasztásával érhetjük el: 2, 7, 13 és 18. Ezeknek a választott egész számoknak a pontszáma min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|), ami egyenlő 5-tel.

Korlátozások:

2 <= start.length <= 10^5
0 <= start[i] <= 10^9
0 <= d <= 10^9


Egy egész számokat tartalmazó nums tömböt kapsz, amelynek hossza n.
A cél az, hogy a 0 indexről induljon, és elérje az n - 1 indexet. Csak az aktuális indexénél nagyobb indexekre ugorhat.
Az i indexről a j indexre történő ugrás pontszámát a következőképpen számítjuk ki: (j - i) * nums[i].
Adja vissza a maximális lehetséges összpontszámot, mire eléri az utolsó indexet.

1. példa:

Bemenet: nums = [1,3,1,5]
Kimenet: 7
Magyarázat:
Először ugorjon az 1-es indexre, majd az utolsó indexre. A végeredmény: 1 * 1 + 2 * 3 = 7.

2. példa:

Bemenet: nums = [4,3,1,3,2]
Kimenet: 16
Magyarázat:
Ugrás közvetlenül az utolsó indexre. A végeredmény: 4 * 4 = 16.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

Adott egy n hosszúságú nums egész számtömb.
A célod az, hogy a 0 indexről indulva elérd az n - 1 indexet. Csak az aktuális indexnél nagyobb indexekre tudsz ugrani.
Az i indexről j indexre történő ugrás pontszámát a következőképpen számoljuk ki: (j - i) * nums[i].
Az utolsó index eléréséig a maximálisan lehetséges összpontszámot adja vissza.

Példa 1:

Bemenet: nums = [1,3,1,5]
Kimenet: 7
Magyarázat:
Először az 1-es indexre, majd az utolsó indexre ugrik. A végső eredmény 1 * 1 + 2 * 3 = 7.

2. példa:

Input: nums = [4,3,1,3,3,2]
Kimenet: 16
Magyarázat:
Ugrás közvetlenül az utolsó indexre. A végeredmény 4 * 4 = 16.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5

Egy n hosszúságú egész tömböt kapunk.
A cél az, hogy a 0 indexről induljon, és elérje az n - 1 indexet. Csak az aktuális indexénél nagyobb indexekre ugorhat.
Az i indexről a j indexre történő ugrás pontszáma (j - i) * szám[i].
Adja vissza a maximális lehetséges összpontszámot, mire eléri az utolsó indexet.

1. példa:

Bemenet: nums = [1,3,1,5]
Kimenet: 7
Magyarázat:
Először ugorjon az 1-es indexre, majd ugorjon az utolsó indexre. A végeredmény: 1 * 1 + 2 * 3 = 7.

2. példa:

Bemenet: nums = [4,3,1,3,2]
Kimenet: 16
Magyarázat:
Ugrás közvetlenül az utolsó indexre. A végeredmény 4 * 4 = 16.

Korlátozások:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^5


Van egy 50 x 50-es sakktábla, amelyen egy huszár és néhány gyalog van. Adott két egész szám, kx és ky, ahol (kx, ky) a huszár helyzetét jelöli, és egy 2D-s tömb, positions, ahol positions[i] = [x_i, y_i] a gyalogok helyzetét jelöli a sakktáblán.
Alice és Bob egy soros játékot játszanak, ahol Alice kezd. Mindkét játékos sorra kerül:

A játékos kiválaszt egy még a táblán lévő gyalogot, és a huszárral a lehető legkevesebb lépéssel leüti azt. Megjegyzendő, hogy a játékos bármilyen gyalogot választhat, nem biztos, hogy olyat, amelyik a legkevesebb lépéssel leüthető.
A kiválasztott gyalog leütése közben a huszár más gyalogok mellett is elmehet anélkül, hogy leütné őket. Ebben a körben csak a kiválasztott gyalogot lehet leütni.

Alice megpróbálja maximalizálni a két játékos által végrehajtott lépések összegét, amíg nincs több gyalog a táblán, míg Bob megpróbálja minimalizálni azokat.
Adja meg a játék során végrehajtott lépések maximális összlétszámát, amelyet Alice elérhet, feltéve, hogy mindkét játékos optimálisan játszik.
Vegyük észre, hogy egy sakkhuszár egy lépés alatt nyolc lehetséges pozícióba léphet, amint azt az alábbi ábra mutatja. Minden lépés két cellát jelent egy kardinális irányban, majd egy cellát egy ortogonális irányban.

1. példa:

Bemenet: kx = 1, ky = 1, positions = [[0,0]]
Kimenet: 4
Magyarázat:

A huszárnak 4 lépésre van szüksége, hogy elérje a (0, 0) állásban lévő gyalogot.

2. példa:

Bemenet: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Kimenet: 8
Magyarázat:

Alice a (2, 2) ponton lévő gyalogot választja, és két lépésben leüti: (0, 2) -> (1, 4) -> (2, 2).
Bob a (3, 3)-nál lévő gyalogot választja, és két lépéssel üti le: (2, 2) -> (4, 1) -> (3, 3).
Alice az (1, 1)-nél lévő gyalogot választja, és négy lépésben üti le: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1).

3. példa:

Bemenet: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Kimenet: 3
Magyarázat:

Alice a (2, 4) ponton lévő gyalogot választja, és két lépésben leüti: (0, 0) -> (1, 2) -> (2, 4). Figyeljük meg, hogy az (1, 2)-nél lévő gyalogot nem üti le.
Bob az (1, 2)-nél lévő gyalogot választja, és egy lépéssel leüti: (2, 4) -> (1, 2).

Korlátozások:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Minden pozíció[i] egyedi.
A bemenetet úgy generáljuk, hogy positions[i] != [kx, ky] minden 0 <= i < positions.length esetén.

Van egy 50 x 50-es sakktábla, rajta egy lovag és néhány gyalog. Két kx és ky egész számot kapsz, ahol (kx, ky) a lovag pozícióját jelöli, és egy 2D tömb pozíciókat, ahol a pozíciók[i] = [x_i, y_i] a gyalogok helyzetét jelöli a sakktáblán.
Alice és Bob körökre osztott játékot játszanak, ahol Alice megy először. Minden játékos körében:

A játékos kiválaszt egy gyalogot, amely még mindig a táblán van, és a lehető legkevesebb lépéssel elkapja a lovaggal együtt. Ne feledje, hogy a játékos bármelyik gyalogot kiválaszthatja, nem biztos, hogy a legkevesebb mozdulattal elkapható.
A kiválasztott gyalog elfogása során a lovag átadhat más gyalogokat anélkül, hogy elfogná őket. Ebben a körben csak a kiválasztott gyalogot lehet elfogni.

Alice megpróbálja maximalizálni a két játékos által végrehajtott lépések összegét, amíg már nem lesz több gyalog a táblán, míg Bob megpróbálja minimalizálni őket.
Adja vissza a játék során végrehajtott mozgások maximális számát, amelyet Alice elérhet, feltételezve, hogy mindkét játékos optimálisan játszik.
Ne feledje, hogy egy mozdulattal egy sakklovagnak nyolc lehetséges pozíciója van, ahová az alábbi ábrán látható módon el tud lépni. Minden lépés két cella kardinális irányban, majd egy cella merőleges irányban.

1. példa:

Bemenet: kx = 1, ky = 1, positions = [[0,0]]
Kimenet: 4
Magyarázat:

A lovagnak 4 lépésre van szüksége, hogy elérje a gyalogot (0, 0).

2. példa:

Bemenet: kx = 0, ky = 2, positions = [[1,1], [2,2], [3,3]]
Kimenet: 8
Magyarázat:

Alice felveszi a gyalogot a (2, 2) pontnál, és két mozdulattal elkapja: (0, 2) -> (1, 4) -> (2, 2).
Bob felveszi a gyalogot a (3, 3) pontnál, és két mozdulattal elkapja: (2, 2) -> (4, 1) -> (3, 3).
Alice felveszi a gyalogot (1, 1) és négy mozdulattal elkapja: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) .

3. példa:

Bemenet: kx = 0, ky = 0, positions = [[1,2], [2,4]]
Kimenet: 3
Magyarázat:

Alice felveszi a gyalogot a (2, 4) pontnál, és két mozdulattal elkapja: (0, 0) -> (1, 2) -> (2, 4). Figyeld meg, hogy az (1, 2) gyalogot nem fogták el.
Bob felveszi a gyalogot az (1, 2) pontnál, és egy mozdulattal elkapja: (2, 4) -> (1, 2).

Korlátozások:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Minden pozíció[i] egyedi.
A bemenetet úgy állítjuk elő, hogy pozíciók[i] != [kx, ky] minden 0 <= i < pozícióra.hossz.

Van egy 50 x 50-es sakktábla, rajta egy lovag és néhány gyalog. Két kx és ky egész számot kapsz, ahol (kx, ky) a lovag pozícióját jelöli, és egy 2D tömb pozíciókat, ahol a pozíciók[i] = [x_i, y_i] a gyalogok helyzetét jelöli a sakktáblán.
Alice és Bob körökre osztott játékot játszanak, ahol Alice megy először. Minden játékos körében:

A játékos kiválaszt egy gyalogot, amely még mindig a táblán van, és a lehető legkevesebb lépéssel elkapja a lovaggal együtt. Ne feledje, hogy a játékos bármelyik gyalogot kiválaszthatja, nem biztos, hogy a legkevesebb mozdulattal elkapható.
A kiválasztott gyalog elfogása során a lovag átadhat más gyalogokat anélkül, hogy elfogná őket. Ebben a körben csak a kiválasztott gyalogot lehet elfogni.

Alice megpróbálja maximalizálni a két játékos által végrehajtott lépések összegét, amíg már nem lesz több gyalog a táblán, míg Bob megpróbálja minimalizálni őket.
Adja vissza a játék során végrehajtott mozgások maximális számát, amelyet Alice elérhet, feltételezve, hogy mindkét játékos optimálisan játszik.
Ne feledje, hogy egy mozdulattal egy sakklovagnak nyolc lehetséges pozíciója van, ahová az alábbi ábrán látható módon el tud lépni. Minden lépés két cella kardinális irányban, majd egy cella merőleges irányban.

1. példa:

Bemenet: kx = 1, ky = 1, positions = [[0,0]]
Kimenet: 4
Magyarázat:

A lovagnak 4 lépésre van szüksége, hogy elérje a gyalogot (0, 0).

2. példa:

Bemenet: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
Kimenet: 8
Magyarázat:

Alice felveszi a gyalogot a (2, 2) pontnál, és két mozdulattal elkapja: (0, 2) -> (1, 4) -> (2, 2).
Bob felveszi a gyalogot a (3, 3) pontnál, és két mozdulattal elkapja: (2, 2) -> (4, 1) -> (3, 3).
Alice felveszi a gyalogot (1, 1) és négy mozdulattal elkapja: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) .

3. példa:

Bemenet: kx = 0, ky = 0, positions = [[1,2],[2,4]]
Kimenet: 3
Magyarázat:

Alice felveszi a gyalogot a (2, 4) pontnál, és két mozdulattal elkapja: (0, 0) -> (1, 2) -> (2, 4). Figyeld meg, hogy az (1, 2) gyalogot nem fogták el.
Bob felveszi a gyalogot az (1, 2) pontnál, és egy mozdulattal elkapja: (2, 4) -> (1, 2).

Korlátozások:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
Minden positions[i] egyedi.
A bemeneti adat úgy van generálva, hogy positions[i] != [kx, ky] minden 0 <= i < positions.length esetén.


Kap egy 4-es méretű a egész tömböt és egy legalább 4-es méretű b egész tömböt.
4 indexet kell választania i_0, i_1, i_2 és i_3 a b tömbből úgy, hogy i_0 < i_1 < i_2 < i_3. A pontszám értéke a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
Adja vissza az elérhető maximális pontszámot.

1. példa:

Bemenet: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Kimenet: 26
Magyarázat:
Választhatjuk a 0, 1, 2 és 5 indexeket. A pontszám 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26 lesz.

2. példa:

Bemenet: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Kimenet: -1
Magyarázat:
Választhatjuk a 0, 1, 3 és 4 indexeket. A pontszám (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1 lesz.

Korlátok:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5

Kapunk egy 4-es méretű a egész szám tömböt és egy másik legalább 4 méretű b egész szám tömböt.
A b tömbből 4 i_0, i_1, i_2 és i_3 indexet kell kiválasztania úgy, hogy i_0 < i_1 < i_2 < i_3. Az Ön pontszáma megegyezik az a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3] értékkel.
Adja vissza az elérhető maximális pontszámot.

1. példa:

Bemenet: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
Kimenet: 26
Magyarázat:
Választhatjuk a 0, 1, 2 és 5 indexeket. A pontszám 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26 lesz.

2. példa:

Bemenet: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
Kimenet: -1
Magyarázat:
Kiválaszthatjuk a 0, 1, 3 és 4 indexeket. A pontszám (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) ) = -1.

Korlátozások:

a.length == 4
4 <= b.length <= 10^5
-10^5 <= a[i], b[i] <= 10^5


Kapsz egy sor karakterláncot és egy karakterlánc célt.
Az x karakterláncot érvényesnek nevezzük, ha x bármely szóban szereplő karakterlánc előtagja.
Adja vissza az érvényes karakterláncok minimális számát, amely összefűzhető a célként. Ha nem lehetséges a cél kialakítása, adjon vissza -1-et.

1. példa:

Bemenet: words= ["abc","aaaaa","bcdef"], target = "aabcdabc"
Kimenet: 3
Magyarázat:
A célkarakterlánc összefűzésével hozható létre:

A szavak 2 hosszúságú előtagja[1], azaz "aa".
A szavak 3 hosszúságú előtagja[2], azaz "bcd".
A szavak 3 hosszúságú előtagja[0], azaz "abc".

2. példa:

Bemenet: words = ["abababab","ab"], target = "ababaababa"
Kimenet: 2
Magyarázat:
A célkarakterlánc összefűzésével hozható létre:

A szavak[0] 5-ös hosszúságú előtagja, azaz "ababa".
A szavak[0] 5-ös hosszúságú előtagja, azaz "ababa".

3. példa:

Bemenet: words = ["abcdef"], target = "xyz"
Kimenet: -1

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
A bemenet úgy jön létre, hogy sum(words[i].length) <= 10^5.
A szavak[i] csak kisbetűket tartalmaz angolul.
1 <= target.length <= 5 * 10^3
A cél csak kisbetűs angol betűkből áll.

Kapsz egy Tömb karakterláncok és egy célkarakterlánc.
Az x karakterláncot érvényesnek nevezzük, ha x bármelyik szó előtagja.
Adja vissza az érvényes karakterláncok minimális számát, amelyek összefűzésével a célkarakterlánc kialakítható. Ha nem lehetséges a cél kialakítása, adjon vissza -1-et.

1. példa:

Bemenet: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Kimenet: 3
Magyarázat:
A célkarakterlánc összefűzésével hozható létre:

A szavak[1] 2 hosszúságú előtagja, azaz "aa“.
A szavak[3] hosszúságú előtagja[2], azaz "bcd".
A szavak[3] hosszúságú előtagja[0], azaz "abc".

2. példa:

Bemenet: words = ["abababab","ab"], target = "ababaababa"
Kimenet: 2
Magyarázat:
A célkarakterlánc összefűzésével hozható létre:

A szavak[0] 5-ös hosszúságú előtagja, azaz "ababa".
A szavak[0] 5-ös hosszúságú előtagja, azaz "ababa".

3. példa:

Bemenet: words = ["abcdef"], target = "xyz"
Kimenet: -1

Korlátozások:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
A bemenet úgy jön létre, hogy sum(words[i].length) <= 10^5.
A szavak[i] csak kisbetűket tartalmaz angolul.
1 <= target.length <= 5 * 10^3
A cél csak kisbetűs angol betűkből áll.

Kap egy karakterláncokat tartalmazó tömböt (words) és egy célkarakterláncot (target).
Az x karakterláncot akkor nevezzük érvényesnek, ha x bármelyik szó előtagja a words tömbben.
A cél létrehozásához összefűzhető érvényes karakterláncok minimális számát adja vissza. Ha nem lehet célt kialakítani, térjen vissza -1.

1. példa:

Bemenet: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Kimenet: 3
Magyarázat:
A célkarakterlánc a következők összefűzésével alakítható ki:

A words[1] 2 hosszúságú előtagja, azaz "aa".
A words[2] 3 hosszúságú előtagja, azaz "bcd".
A words[0] 3 hosszúságú előtagja, azaz "abc".

2. példa:

Bemenet: words = ["abababab","ab"], target = "ababaababa"
Kimenet: 2
Magyarázat:
A célkarakterlánc a következők összefűzésével alakítható ki:

A words 5 hosszúságú előtagja[0], azaz "ababa".
A words 5 hosszúságú előtagja[0], azaz "ababa".

3. példa:

Bemenet:words = ["abcdef"], target = "xyz"
Kimenet: -1

Korlátok:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
A bemenet úgy van generálva, hogy sum(words[i].length) <= 10^5.
words[i] csak kisbetűs angol betűkből áll.
1 <= target.length <= 5 * 10^3
A target csak kisbetűs angol betűkből áll.


Adott egy n hosszúságú nums egész számokból álló tömb és egy k pozitív egész szám.
Egy tömb hatványa a következőképpen definiált:

A legnagyobb eleme, ha minden eleme egymás után következik és növekvő sorrendbe van rendezve.
-1 egyébként.

Meg kell találni a nums k méretű összes altömbjének hatványát.
Adjon vissza egy n - k + 1 méretű egész számtömböt results, ahol results[i] a nums[i...(i + k - 1)] hatványa.

Példa 1:

Bemenet: nums = [1,2,3,4,3,2,5], k = 3
Kimenet: [3,4,-1,-1,-1]
Magyarázat:
A nums 5 db 3 méretű altábla:

[1, 2, 3], amelynek maximális eleme 3.
[2, 3, 4], amelynek maximális eleme 4.
[3, 4, 3], amelyek elemei nem egymás után következnek.
[4, 3, 2], amelyek elemei nem soroltak.
[3, 2, 5], amelynek elemei nem egymás után következnek.

Példa 2:

Bemenet: nums = [2,2,2,2,2], k = 4
Kimenet: [-1,-1]

Példa 3:

Bemenet: nums = [3,2,3,2,3,2], k = 2
Kimenet: [-1,3,-1,3,-1]

Korlátozások:

1 <= n == nums.length <= 500
1 <= nums[i] <= 10^5
1 <= k <= n

Kapunk egy n hosszúságú egész számokat és egy k pozitív egész számot.
Egy tömb teljesítményét a következőképpen határozzuk meg:

Maximális eleme, ha minden eleme egymást követő és növekvő sorrendben van rendezve.
-1 egyébként.

Meg kell találnia az összes k méretű altömb hatványát.
Egy n - k + 1 méretű egész tömb eredményét adja vissza, ahol az eredmények[i] a számok [i..(i + k - 1)] hatványa.

1. példa:

Bemenet: nums = [1,2,3,4,3,2,5], k = 3
Kimenet: [3,4,-1,-1,-1]
Magyarázat:
5 3-as méretű altömb van:

[1, 2, 3] a 3-as maximális elemmel.
[2, 3, 4] a 4-es maximális elemmel.
[3, 4, 3], amelynek elemei nem egymást követik.
[4, 3, 2], amelynek elemei nincsenek rendezve.
[3, 2, 5], amelynek elemei nem egymást követik.

2. példa:

Bemenet: nums = [2,2,2,2,2], k = 4
Kimenet: [-1,-1]

3. példa:

Bemenet: nums = [3,2,3,2,3,2], k = 2
Kimenet: [-1,3,-1,3,-1]

Korlátozások:

1 <= n == nums.length <= 500
1 <= nums[i] <= 10^5
1 <= k <= n

Egy egész számokat tartalmazó nums tömböt, amely hossza n, és egy pozitív egész számot, k kapsz.
Egy tömb teljesítményét a következőképpen határozzuk meg:

Maximális eleme, ha minden eleme egymást követő és növekvő sorrendben van rendezve.
-1 egyébként.

Meg kell találnod a nums összes k méretű részhalmazának erejét.
Egy n - k + 1 méretű egész tömb eredményét adja vissza, ahol az eredmények[i] a nums [i..(i + k - 1)] hatványa.

1. példa:

Bemenet: nums = [1,2,3,4,3,2,5], k = 3
Kimenet: [3,4,-1,-1,-1]
Magyarázat:
5 részhalmaza van a nums-nak 3 méretben:

[1, 2, 3] a 3-as maximális elemmel.
[2, 3, 4] a 4-es maximális elemmel.
[3, 4, 3], amelynek elemei nem egymást követik.
[4, 3, 2], amelynek elemei nincsenek rendezve.
[3, 2, 5], amelynek elemei nem egymást követik.

2. példa:

Bemenet: nums = [2,2,2,2,2], k = 4
Kimenet: [-1,-1]

3. példa:

Bemenet: nums = [3,2,3,2,3,2], k = 2
Kimenet: [-1,3,-1,3,-1]

Korlátozások:

1 <= n == nums.length <= 500
1 <= nums[i] <= 10^5
1 <= k <= n


Adott egy sakktáblát ábrázoló m x n 2D-s tömb, ahol a tábla[i][j] a (i, j) cella értékét jelöli.
Az azonos sorban vagy oszlopban lévő bástyák egymást támadják. Három bástyát kell elhelyezned a sakktáblán úgy, hogy a bástyák ne támadják egymást.
Adja vissza azoknak a celláknak a maximális összegét, amelyeken a bástyák vannak elhelyezve.

Példa 1:

Bemenet:board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Kimenet: 4
Magyarázat:

A bástyákat a (0, 2), (1, 3) és (2, 1) cellákba helyezhetjük el, így a bástyák összege 1 + 1 + 2 = 4 lesz.

2. példa:

Input: board = [[1,2,3],[4,5,6],[7,8,9]]
Kimenet: 15
Magyarázat:
A bástyákat a (0, 0), (1, 1) és (2, 2) cellákba helyezhetjük el, így a bástyák összege 1 + 5 + 9 = 15 lesz.

3. példa:

Bemenet: board = [[1,1,1],[1,1,1],[1,1,1]]
Kimenet: 3
Magyarázat:
A bástyákat a (0, 2), (1, 1) és (2, 0) cellákba helyezhetjük el, így a bástyák összege 1 + 1 + 1 = 3 lesz.

Korlátozások:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Kapsz egy m x n 2D tömbtáblát, amely egy sakktáblát reprezentál, ahol a board[i][j] az (i, j) cella értékét jelöli.
Az ugyanabban a sorban vagy oszlopban lévő bástya megtámadja egymást. Három bástya kell a sakktáblára helyezni úgy, hogy a bástya ne támadja meg egymást.
Visszaadja azoknak a cellaértékeknek a maximális összegét, amelyeken a bástya található.

1. példa:

Bemenet: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Kimenet: 4
Magyarázat:

A bástyákat a (0, 2), (1, 3) és (2, 1) cellákba 1 + 1 + 2 = 4 összegre helyezhetjük.

2. példa:

Bemenet: board = [[1,2,3],[4,5,6],[7,8,9]]
Kimenet: 15
Magyarázat:
A bástyákat a (0, 0), (1, 1) és (2, 2) cellákba helyezhetjük 1 + 5 + 9 = 15 összegre.

3. példa:

Bemenet: board = [[1,1,1],[1,1,1],[1,1,1]]
Kimenet: 3
Magyarázat:
A bástyákat a (0, 2), (1, 1) és (2, 0) cellákba helyezhetjük 1 + 1 + 1 = 3 összegre.

Korlátozások:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9

Kapsz egy m x n 2D tömbtáblát, amely egy sakktáblát képvisel, ahol a tábla[i][j] a cella értékét (i, j) jelöli.
Az ugyanabban a sorban vagy oszlopban lévő bástyák megtámadják egymást. Három bástyát kell elhelyeznie a sakktáblán úgy, hogy a bástyák ne támadják meg egymást.
Azon cellaértékek maximális összegét adja eredményül, amelyekre az újoncok kerülnek.

1. példa:

Bemenet: board = [[-3,1,1,1],[-3,1,-3,1],[-3,2,1,1]]
Kimenet: 4
Magyarázat:

A bástyákat a (0, 2), (1, 3) és (2, 1) cellákba helyezhetjük 1 + 1 + 2 = 4 összegre.

2. példa:

Bemenet: board= [[1,2,3],[4,5,6],[7,8,9]]
Kimenet: 15
Magyarázat:
A bástyákat a (0, 0), (1, 1) és (2, 2) cellákba helyezhetjük 1 + 5 + 9 = 15 összegre.

3. példa:

Bemenet: board = [[1,1,1],[1,1,1],[1,1,1]]
Kimenet: 3
Magyarázat:
A bástyákat a (0, 2), (1, 1) és (2, 0) cellákba helyezhetjük 1 + 1 + 1 = 3 összegben.

Korlátok:

3 <= m == board.length <= 100
3 <= n == board[i].length <= 100
-10^9 <= board[i][j] <= 10^9


Három pozitív egész számot kap: num1, num2 és num3.
A num1, num2 és num3 kulcsa négyjegyű számként van definiálva úgy, hogy:

Kezdetben, ha bármely szám kevesebb, mint négy számjegyből áll, akkor a vezető nullákkal van kitöltve.
A kulcs i^-edik számjegyét (1 <= i <= 4) úgy állítjuk elő, hogy a num1, num2 és num3 i^edik számjegyei közül a legkisebb számjegyet vesszük.

A három szám kulcsát adja vissza kezdő nullák nélkül (ha vannak).

1. példa:

Bemenet: num1 = 1, num2 = 10, num3 = 1000
Kimenet: 0
Magyarázat:
Kitöltéskor a num1 "0001", a num2 "0010", a num3 pedig "1000" marad.

A kulcs 1^. számjegye min(0, 0, 1).
A kulcs 2^. számjegye min(0, 0, 0).
A kulcs 3^. számjegye min(0, 1, 0).
A kulcs 4^. számjegye min(1, 0, 0).

Ezért a kulcs "0000", azaz 0.

2. példa:

Bemenet: num1 = 987, num2 = 879, num3 = 798
Kimenet: 777

3. példa:

Bemenet: num1 = 1, num2 = 2, num3 = 3
Kimenet: 1

Korlátok:

1 <= num1, num2, num3 <= 9999

Adott három pozitív egész szám num1, num2 és num3.
A num1, num2 és num3 kulcsát úgy határozzuk meg, hogy a négyjegyű számot úgy határozzuk meg, hogy:

Kezdetben, ha valamelyik szám négy számjegynél kevesebbet tartalmaz, akkor azt vezető nullákkal töltjük fel.
A kulcs i^-edik számjegyét (1 <= i <= 4) úgy generáljuk, hogy a num1, num2 és num3 i^-edik számjegyei közül a legkisebbet vesszük.

A három szám kulcsát adja vissza vezető nullák nélkül (ha van ilyen).

1. példa:

Bemenet: num1 = 1, num2 = 10, num3 = 1000
Kimenet: 0
Magyarázat:
num1 a „0001”, num2 a „0010”, num3 pedig az „1000” marad.

A kulcs 1^st számjegye min(0, 0, 1).
A kulcs 2^. számjegye min(0, 0, 0).
A kulcs 3^. számjegye min(0, 1, 0).
A kulcs 4^. számjegye min(1, 0, 0).

A kulcs tehát „0000”, azaz 0.

2. példa:

Bemenet: num1 = 987, num2 = 879, num3 = 798
Kimenet: 777

3. példa:

Bemenet: num1 = 1, num2 = 2, num3 = 3
Kimenet: 1

Korlátozások:

1 <= num1, num2, num3 <= 9999