Une élection a lieu avec N candidats numérotés 1, 2, \ldots, N. Il y a K votes, dont certains ont été comptés jusqu'à présent.
Jusqu'à maintenant, le candidat i a reçu A_i votes.
Après le comptage de tous les bulletins, le candidat i (1 \leq i \leq N) sera élu si et seulement si le nombre de candidats ayant reçu plus de votes qu'eux est inférieur à M. Il peut y avoir plusieurs candidats élus.
Pour chaque candidat, trouvez le nombre minimum de votes supplémentaires dont ils ont besoin parmi les bulletins restants pour garantir leur victoire, peu importe comment les autres candidats reçoivent des voix.
Formellement, résolvez le problème suivant pour chaque i = 1,2,\ldots,N.
Déterminez s'il existe un entier non négatif X ne dépassant pas K - \displaystyle{\sum_{i=1}^{N}} A_i satisfaisant la condition suivante. S'il existe, trouvez le minimum possible d'un tel entier.

- Si le candidat i reçoit X votes supplémentaires, alors le candidat i sera toujours élu.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
A_1 A_2 \ldots A_N

Sortie

Soit C_i le nombre minimum de votes supplémentaires dont le candidat i a besoin parmi les bulletins restants pour garantir sa victoire peu importe comment les autres candidats reçoivent des voix. Affichez C_1, C_2, \ldots, C_N séparés par des espaces.
Si le candidat i a déjà sécurisé sa victoire, alors C_i = 0. Si le candidat i ne peut sécuriser sa victoire dans aucun cas, alors C_i = -1.

Contraintes

- 1 \leq M \leq N \leq 2 \times 10^5
- 1 \leq K \leq 10^{12}
- 0 \leq A_i \leq 10^{12}
- \displaystyle{\sum_{i=1}^{N} A_i} \leq K
- Toutes les valeurs d'entrée sont des entiers.

Entrée Exemple 1

5 2 16
3 1 4 1 5

Sortie Exemple 1

2 -1 1 -1 0

14 votes ont été comptabilisés jusqu'à présent, et 2 votes restent.
Le C à afficher est (2, -1, 1, -1, 0). Par exemple :

- Le candidat 1 peut sécuriser sa victoire en obtenant 2 votes supplémentaires, mais pas en obtenant 1 vote supplémentaire. Ainsi, C_1 = 2.
- Le candidat 2 ne peut jamais (même s'il obtient 2 votes supplémentaires) sécuriser sa victoire, donc C_2 = -1.

Entrée Exemple 2

12 1 570
81 62 17 5 5 86 15 7 79 26 6 28

Sortie Exemple 2

79 89 111 117 117 74 112 116 80 107 117 106

Une élection est organisée avec N candidats numérotés 1, 2, \ldots, N. Il y a K votes, dont certains ont été comptés jusqu'à présent.
Jusqu'à présent, le candidat i a reçu A_i votes.
Après le dépouillement de tous les bulletins, le candidat i (1 \leq i \leq N) sera élu si et seulement si le nombre de candidats ayant reçu plus de voix que lui est inférieur à M. Il peut y avoir plusieurs candidats élus.
Pour chaque candidat, trouvez le nombre minimum de voix supplémentaires dont il a besoin sur les bulletins restants pour garantir sa victoire, quelle que soit la manière dont les autres candidats obtiennent des voix.
Formellement, résolvez le problème suivant pour chaque i = 1,2,\ldots,N.
Déterminer s'il existe un nombre entier non négatif X ne dépassant pas K - \displaystyle{\sum_{i=1}^{N}} A_i satisfaisant la condition suivante.  S'il existe, trouver le plus petit entier possible.

- Si le candidat i reçoit X voix supplémentaires, il sera toujours élu.

Données d'entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N M K
A_1 A_2 \ldots A_N

Résultats

Soit C_i le nombre minimum de voix supplémentaires dont le candidat i a besoin sur les bulletins restants pour garantir sa victoire, quelle que soit la manière dont les autres candidats obtiennent des voix. Imprimer C_1, C_2, \ldots, C_N séparés par des espaces.
Si le candidat i a déjà assuré sa victoire, laissez C_i = 0. Si le candidat i ne peut en aucun cas assurer sa victoire, laissez C_i = -1.

Contraintes

- 1 \leq M \leq N \leq 2 \times 10^5
- 1 \leq K \leq 10^{12}
- 0 \leq A_i \leq 10^{12}
- \displaystyle{\sum_{i=1}^{N} A_i} \leq K
- Toutes les valeurs d'entrée sont des nombres entiers.

Exemple d'entrée 1

5 2 16
3 1 4 1 5

Exemple de sortie 1

2 -1 1 -1 0

14 votes ont été comptés jusqu'à présent, et il reste 2 votes.
Le C à produire est (2, -1, 1, -1, 0).  Par exemple :

- Le candidat 1 peut assurer sa victoire en obtenant 2 voix de plus, mais pas en obtenant 1 voix de plus.  Ainsi, C_1 = 2.
- Le candidat 2 ne peut jamais (même s'il obtient 2 voix de plus) assurer sa victoire, donc C_2 = -1.

Exemple Entrée 2

12 1 570
81 62 17 5 5 86 15 7 79 26 6 28

Exemple de sortie 2

79 89 111 117 117 74 112 116 80 107 117 106

Une élection a lieu avec N candidats numérotés 1, 2, \ldots, N. Il y a K votes, dont certains ont été comptés jusqu'à présent.
Jusqu'à maintenant, le candidat i a reçu A_i votes.
Après le comptage de tous les bulletins, le candidat i (1 \leq i \leq N) sera élu si et seulement si le nombre de candidats ayant reçu plus de votes qu'eux est inférieur à M.  Il peut y avoir plusieurs candidats élus.
Pour chaque candidat, trouvez le nombre minimum de votes supplémentaires dont ils ont besoin parmi les bulletins restants pour garantir leur victoire, peu importe comment les autres candidats reçoivent des voix.
Formellement, résolvez le problème suivant pour chaque i = 1,2,\ldots,N.
Déterminez s'il existe un entier non négatif X ne dépassant pas K - \displaystyle{\sum_{i=1}^{N}} A_i satisfaisant la condition suivante.  S'il existe, trouvez le minimum possible d'un tel entier.

- Si le candidat i reçoit X votes supplémentaires, alors le candidat i sera toujours élu.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M K
A_1 A_2 \ldots A_N

Sortie

Soit C_i le nombre minimum de votes supplémentaires dont le candidat i a besoin parmi les bulletins restants pour garantir leur victoire peu importe comment les autres candidats reçoivent des voix. Affichez C_1, C_2, \ldots, C_N séparés par des espaces.
Si le candidat i a déjà sécurisé sa victoire, alors C_i = 0. Si le candidat i ne peut sécuriser sa victoire dans aucun cas, alors C_i = -1.

Contraintes

- 1 \leq M \leq N \leq 2 \times 10^5
- 1 \leq K \leq 10^{12}
- 0 \leq A_i \leq 10^{12}
- \displaystyle{\sum_{i=1}^{N} A_i} \leq K
- Toutes les valeurs d'entrée sont des entiers.

Entrée Exemple 1

5 2 16
3 1 4 1 5

Sortie Exemple 1

2 -1 1 -1 0

14 votes ont été comptabilisés jusqu'à présent, et 2 votes restent.
Le C à afficher est (2, -1, 1, -1, 0).  Par exemple :

- Le candidat 1 peut sécuriser sa victoire en obtenant 2 votes supplémentaires, mais pas en obtenant 1 vote supplémentaire.  Ainsi, C_1 = 2.
- Le candidat 2 ne peut jamais (même s'il obtient 2 votes supplémentaires) sécuriser sa victoire, donc C_2 = -1.

Entrée Exemple 2

12 1 570
81 62 17 5 5 86 15 7 79 26 6 28

Sortie Exemple 2

79 89 111 117 117 74 112 116 80 107 117 106


Vous avez une permutation \( P=(P_1,P_2,\dots,P_N) \) de \( (1,2,\dots,N) \).
Considérez les opérations suivantes \( k\ (k=2,3,\dots,N) \) sur cette permutation.

- Opération \( k \) : Pour \( i=1,2,\dots,k-1 \) dans cet ordre, si \( P_i > P_{i+1} \), échangez les valeurs des \( i \)-ème et \( (i+1) \)-ème éléments de \( P \).

On vous donne également une séquence non décroissante \( A=(A_1,A_2,\dots,A_M)\ (2 \leq A_i \leq N) \) de longueur \( M \).
Pour chaque \( i=1,2,\dots,M \), trouvez le nombre d'inversions de \( P \) après avoir appliqué les opérations \( A_1, A_2, \dots, A_i \) dans cet ordre.

Qu'est-ce que le nombre d'inversions d'une séquence ?

Le nombre d'inversions d'une séquence \( x=(x_1,x_2,\dots,x_n) \) de longueur \( n \) est le nombre de paires d'entiers \( (i,j)\ (1\leq i < j \leq n) \) telles que \( x_i > x_j \).

Entrée

L'entrée est donnée depuis l'entrée standard au format suivant :
\( N \)
\( P_1 P_2 \dots P_N \)
\( M \)
\( A_1 A_2 \dots A_M \)

Sortie

Affichez \( M \) lignes. La \( k \)-ème ligne doit contenir la réponse au problème pour \( i=k \).

Contraintes

- \( 2 \leq N \leq 2 \times 10^5 \)
- \( 1 \leq M \leq 2 \times 10^5 \)
- \( 2 \leq A_i \leq N \)
- \( P \) est une permutation de \( (1,2,\dots,N) \).
- \( A_i \leq A_{i+1} \) pour \( i=1,2,\dots,M-1 \).
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

6
3 2 4 1 6 5
2
4 6

Exemple de sortie 1

3
1

Tout d'abord, l'opération 4 est réalisée. Pendant cela, \( P \) change comme suit : \( (3,2,4,1,6,5) \rightarrow (2,3,4,1,6,5) \rightarrow (2,3,4,1,6,5) \rightarrow (2,3,1,4,6,5) \). Le nombre d'inversions de \( P \) ensuite est 3.
Ensuite, l'opération 6 est réalisée, où \( P \) devient finalement \( (2,1,3,4,5,6) \), dont le nombre d'inversions est 1.

Exemple d'entrée 2

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

Exemple de sortie 2

117
116
113
110
108
105
103
99
94
87
79
72
65
58
51

Vous avez une permutation P=(P_1,P_2,\dots,P_N) de (1,2,\dots,N).
Considérez les opérations suivantes k\ (k=2,3,\dots,N) sur cette permutation.

- Opération k : Pour i=1,2,\dots,k-1 dans cet ordre, si P_i > P_{i+1}, échangez les valeurs des i-ème et (i+1)-ème éléments de P.

On vous donne également une séquence non décroissante A=(A_1,A_2,\dots,A_M)\ (2 \leq A_i \leq N) de longueur M.
Pour chaque i=1,2,\dots,M, trouvez le nombre d'inversions de P après avoir appliqué les opérations A_1, A_2, \dots, A_i dans cet ordre.

 Qu'est-ce que le nombre d'inversions d'une séquence ?

Le nombre d'inversions d'une séquence x=(x_1,x_2,\dots,x_n) de longueur n est le nombre de paires d'entiers (i,j)\ (1\leq i < j \leq n) telles que x_i > x_j.

Entrée

L'entrée est donnée depuis l'entrée standard au format suivant :
N
P_1 P_2 \dots P_N
M
A_1 A_2 \dots A_M

Sortie

Affichez M lignes. La k-ème ligne doit contenir la réponse au problème pour i=k.

Contraintes

- 2 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^5
- 2 \leq A_i \leq N
- P est une permutation de (1,2,\dots,N).
- A_i \leq A_{i+1} pour \( i=1,2,\dots,M-1.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

6
3 2 4 1 6 5
2
4 6

Exemple de sortie 1

3
1

Tout d'abord, l'opération 4 est réalisée. Pendant cela, P change comme suit : (3,2,4,1,6,5) \rightarrow (2,3,4,1,6,5) \rightarrow (2,3,4,1,6,5) \rightarrow (2,3,1,4,6,5). Le nombre d'inversions de P ensuite est 3.
Ensuite, l'opération 6 est réalisée, où P devient finalement (2,1,3,4,5,6), dont le nombre d'inversions est 1.

Exemple d'entrée 2

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

Exemple de sortie 2

117
116
113
110
108
105
103
99
94
87
79
72
65
58
51

On vous donne une permutation P=(P_1,P_2,\dots,P_N) de (1,2,\dots,N).
Considérons les opérations suivantes k\ (k=2,3,\dots,N) sur cette permutation.

- Opération k : Pour i=1,2,\dots,k-1 dans cet ordre, si P_i > P_{i+1}, intervertir les valeurs des i-ème et (i+1)-th éléments de P.

On vous donne également une suite non décroissante A=(A_1,A_2,\dots,A_M) (2 \leq A_i \leq N) de longueur M.
Pour chaque i=1,2,\dots,M, déterminez le inversion number de P après avoir appliqué les opérations A_1, A_2, \dots, A_i dans cet ordre.

Quel est le inversion number d’une suite ?

Le inversion number d’une suite x=(x_1,x_2,\dots,x_n) de longueur n est le nombre de paires d’entiers (i,j)\ (1\leq i < j \leq n) tels que x_i > x_j.

Entrée

L’entrée est fournie au format suivant :
N
P_1 P_2 \dots P_N
M
A_1 A_2 \dots A_M

Sortie

Imprimez M lignes. La k-ième ligne doit contenir la réponse au problème pour i=k.

Contraintes

- 2 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^5
- 2 \leq A_i \leq N
- P est une permutation de (1,2,\dots,N).
- A_i \leq A_{i+1} for i=1,2,\dots,M-1.
- Toutes les valeurs d'entrée sont entières.

Exemple d’entrée 1

6
3 2 4 1 6 5
2
4 6

Sortie de l’échantillon 1

3
1

Tout d’abord, l’opération 4 est effectuée. Pendant ce temps, P change comme suit : (3,2,4,1,6,5) flèche droite (2,3,4,1,6,5) flèche droite (2,3,4,1,6,5) flèche droite (2,3,1,4,6,5). Le inversion number de P par la suite est 3.
Ensuite, l’opération 6 est effectuée, où P finit par devenir (2,1,3,4,5,6), dont le inversion number est 1.

Exemple d’entrée 2

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

Exemple de sortie 2

117
116
113
110
108
105
103
99
94
87
79
72
65
58
51


On considère deux permutations P=(P_1,P_2,\dots,P_N) et Q=(Q_1,Q_2,\dots,Q_N) de (1,2,\dots,N).
Écrivez l'un des caractères 0 et 1 dans chaque cellule d'une grille de N par N de sorte que toutes les conditions suivantes soient satisfaites :

- Soit S_i la chaîne obtenue en concaténant les caractères de la i-ème ligne de la 1-ère à la N-ème colonne. Alors, S_{P_1} < S_{P_2} < \dots < S_{P_N} dans l'ordre lexicographique.
- Soit T_i la chaîne obtenue en concaténant les caractères de la i-ème colonne de la 1-ère à la N-ème ligne. Alors, T_{Q_1} < T_{Q_2} < \dots < T_{Q_N} dans l'ordre lexicographique.

On peut prouver que pour tout P et Q, il existe au moins une façon d'écrire les caractères qui satisfait toutes les conditions.
 Que signifie "X < Y dans l'ordre lexicographique" ?
Pour les chaînes X=X_1X_2\dots X_{|X|} et Y = Y_1Y_2\dots Y_{|Y|}, "X < Y dans l'ordre lexicographique" signifie que 1. ou 2. ci-dessous est vrai.
Ici, |X| et |Y| désignent respectivement les longueurs de X et Y.

-  |X| \lt |Y| et X_1X_2\ldots X_{|X|} = Y_1Y_2\ldots Y_{|X|}.
-  Il existe un entier 1 \leq i \leq \min\lbrace |X|, |Y| \rbrace tel que les deux conditions suivantes soient vraies :

  -  X_1X_2\ldots X_{i-1} = Y_1Y_2\ldots Y_{i-1}
  -  X_i est inférieur à Y_i.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
P_1 P_2 \dots P_N
Q_1 Q_2 \dots Q_N

Sortie

Affichez une façon de remplir la grille qui satisfait les conditions dans le format suivant, où A_{ij} est le caractère écrit à la i-ème ligne et j-ème colonne :
A_{11}A_{12}\dots A_{1N}
\vdots
A_{N1}A_{N2}\dots A_{NN}

Si plusieurs façons satisfont les conditions, n'importe laquelle est acceptée.

Contraintes

- 2 \leq N \leq 500
- P et Q sont des permutations de (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
1 2 3
2 1 3

Exemple de sortie 1

001
101
110

Dans cet exemple, S_1=001, S_2=101, S_3=110, et T_1=011, T_2=001, T_3=110. Par conséquent, S_1 < S_2 < S_3 et T_2 < T_1 < T_3 sont vérifiés, satisfaisant les conditions.

Exemple d'entrée 2

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

Exemple de sortie 2

010001111110101
001000000101001
010001001100010
010000011110010
010011101101101
100101110100000
111100011001000
000001001100000
100011011000101
000111101011110
101010101010101
011010101011110
010011000010011
100110010110101
000101101100100

On vous donne deux permutations P=(P_1,P_2,\dots,P_N) et Q=(Q_1,Q_2,\dots,Q_N) de (1,2,\dots,N).
Inscrivez un des caractères 0 et 1 dans chaque cellule d'une grille N-par-N de manière à ce que toutes les conditions suivantes soient remplies :

- Soit S_i la chaîne obtenue en concaténant les caractères de la i-ième ligne de la 1-ième à la N-ième colonne. Dans ce cas, S_{P_1} < S_{P_2} < \dots < S_{P_N} dans l'ordre lexicographique.
- Soit T_i la chaîne obtenue en concaténant les caractères de la i-ième colonne de la première à la N-ième ligne. Alors, T_{Q_1} < T_{Q_2} < \dots < T_{Q_N} dans l'ordre lexicographique.

On peut prouver que pour tout P et Q, il existe au moins une façon d'écrire les caractères qui satisfait à toutes les conditions.
 Que signifie « X < Y dans l'ordre lexicographique » ?
Pour les chaînes X=X_1X_2\dots X_{|X|} et Y = Y_1Y_2\dots Y_{|Y|}, « X < Y dans l'ordre lexicographique » signifie que 1. ou 2. ci-dessous s'applique.
Ici, |X| et |Y| désignent les longueurs de X et Y, respectivement.

- |X| \lt |Y| et X_1X_2\ldots X_{|X|} = Y_1Y_2\ldots Y_{|X|}.
- Il existe un nombre entier 1 \leq i \leq \min\lbrace |X|, |Y| \rbrace tel que les deux choses suivantes sont vraies :

-  X_1X_2\ldots X_{i-1} = Y_1Y_2\ldots Y_{i-1}
-  X_i is less than Y_i.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
N
P_1 P_2 \dots P_N
Q_1 Q_2 \dots Q_N
Sortie

Imprimez une façon de remplir la grille qui satisfait aux conditions dans le format suivant, où A_{ij} est le caractère écrit sur la i-ième ligne et la j-ième colonne :
A_{11}A_{12}\dots A_{1N}
\vdots
A_{N1}A_{N2}\dots A_{NN}

S'il existe plusieurs façons de satisfaire aux conditions, n'importe laquelle d'entre elles sera acceptée.

Contraintes

- 2 \leq N \leq 500
- P and Q are permutations of (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des nombres entiers.
Exemple d'entrée 1

3
1 2 3
2 1 3
Exemple de sortie 1

001
101
110
Dans cet échantillon, S_1=001, S_2=101, S_3=110, et T_1=011, T_2=001, T_3=110. Par conséquent, S_1 < S_2 < S_3 et T_2 < T_1 < T_3 sont valables, ce qui satisfait aux conditions.

Exemple d'entrée 2

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

Exemple de sortie 2

010001111110101
001000000101001
010001001100010
010000011110010
010011101101101
100101110100000
111100011001000
000001001100000
100011011000101
000111101011110
101010101010101
011010101011110
010011000010011
100110010110101
000101101100100

Vous avez deux permutations P=(P_1,P_2,\dots,P_N) et Q=(Q_1,Q_2,\dots,Q_N) de (1,2,\dots,N).
Écrivez l'un des caractères 0 et 1 dans chaque cellule d'une grille de N par N de sorte que toutes les conditions suivantes soient satisfaites :

- Soit S_i la chaîne obtenue en concaténant les caractères de la i-ème ligne de la 1-ère à la N-ème colonne. Alors, S_{P_1} < S_{P_2} < \dots < S_{P_N} dans l'ordre lexicographique.
- Soit T_i la chaîne obtenue en concaténant les caractères de la i-ème colonne de la 1-ère à la N-ème ligne. Alors, T_{Q_1} < T_{Q_2} < \dots < T_{Q_N} dans l'ordre lexicographique.

On peut prouver que pour tout P et Q, il existe au moins une façon d'écrire les caractères qui satisfait toutes les conditions.
 Que signifie "X < Y dans l'ordre lexicographique" ?
Pour les chaînes X=X_1X_2\dots X_{|X|} et Y = Y_1Y_2\dots Y_{|Y|}, "X < Y dans l'ordre lexicographique" signifie que 1. ou 2. ci-dessous est vrai.
Ici, |X| et |Y| désignent les longueurs de X et Y, respectivement.

-  |X| \lt |Y| et X_1X_2\ldots X_{|X|} = Y_1Y_2\ldots Y_{|X|}.
-  Il existe un entier 1 \leq i \leq \min\lbrace |X|, |Y| \rbrace tel que les deux conditions suivantes soient vraies :

  -  X_1X_2\ldots X_{i-1} = Y_1Y_2\ldots Y_{i-1}
  -  X_i est inférieur à Y_i.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
P_1 P_2 \dots P_N
Q_1 Q_2 \dots Q_N

Sortie

Affichez une façon de remplir la grille qui satisfait les conditions dans le format suivant, où A_{ij} est le caractère écrit à la i-ème ligne et j-ème colonne :
A_{11}A_{12}\dots A_{1N}
\vdots
A_{N1}A_{N2}\dots A_{NN}

Si plusieurs façons satisfont les conditions, n'importe laquelle est acceptée.

Contraintes

- 2 \leq N \leq 500
- P et Q sont des permutations de (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3
1 2 3
2 1 3

Exemple de sortie 1

001
101
110

Dans cet exemple, S_1=001, S_2=101, S_3=110, et T_1=011, T_2=001, T_3=110. Par conséquent, S_1 < S_2 < S_3 et T_2 < T_1 < T_3 sont vérifiés, satisfaisant les conditions.

Exemple d'entrée 2

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

Exemple de sortie 2

010001111110101
001000000101001
010001001100010
010000011110010
010011101101101
100101110100000
111100011001000
000001001100000
100011011000101
000111101011110
101010101010101
011010101011110
010011000010011
100110010110101
000101101100100


Pour les chaînes S et T composées de lettres minuscules anglaises, et une chaîne X composée de 0 et 1, définissez la chaîne f(S,T,X) composée de lettres minuscules anglaises comme suit :

- En commençant par une chaîne vide, pour chaque i=1,2,\dots,|X|, ajoutez S à la fin si le i-ème caractère de X est 0, et ajoutez T à la fin si c'est 1.

On vous donne une chaîne S composée de lettres minuscules anglaises, et des chaînes X et Y composées de 0 et 1. Déterminez s'il existe une chaîne T (qui peut être vide) telle que f(S,T,X)=f(S,T,Y). Vous avez t cas de test à résoudre.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
t
\mathrm{case}_1
\vdots
\mathrm{case}_t

Chaque cas est donné dans le format suivant :
S
X
Y

Sortie

Imprimez t lignes. La i-ème ligne doit contenir Yes s'il existe un T qui satisfait la condition pour le i-ème cas de test, et No sinon.

Contraintes

- 1 \leq t \leq 5 \times 10^5
- 1 \leq |S| \leq 5\times 10^5
- 1 \leq |X|,|Y| \leq 5\times 10^5
- S est une chaîne composée de lettres minuscules anglaises.
- X et Y sont des chaînes composées de 0 et 1.
- La somme de |S| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.
- La somme de |X| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.
- La somme de |Y| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.

Exemple d'entrée 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

Exemple de sortie 1

Yes
No
No

Ci-dessous, la concaténation de chaînes est représentée par +.
Pour le premier cas de test, si T=ara, alors f(S,T,X)=S+T=araaraara et f(S,T,Y)=T+T+T=araaraara, donc f(S,T,X)=f(S,T,Y).
Pour le deuxième et troisième cas de test, il n'existe pas de T qui satisfait la condition.

Exemple d'entrée 2

2
empty
10101
00
empty
11111
111

Exemple de sortie 2

Yes
Yes

T peut être vide.

Pour les chaînes S et T composées de lettres minuscules anglaises et une chaîne X composée de 0 et de 1, définissez la chaîne f(S,T,X) composée de lettres minuscules anglaises comme suit :

- En commençant par une chaîne vide, pour chaque i=1,2,\dots,|X|, ajouter S à la fin si le i-ième caractère de X est 0, et ajouter T à la fin s'il est 1.

On vous donne une chaîne S composée de lettres minuscules anglaises, et les chaînes X et Y composées de 0 et de 1.
Déterminez s'il existe une chaîne T (qui peut être vide) telle que f(S,T,X)=f(S,T,Y).
Vous avez t cas de test à résoudre.

Entrée

L'entrée est fournie par l'entrée standard dans le format suivant :
t
\mathrm{case}_1
\vdots
\mathrm{case}_t

Chaque cas est présenté dans le format suivant :
S
X
Y

Sortie

Imprimer t lignes. La i-ième ligne doit contenir Yes s'il existe un T qui satisfait à la condition du i-ième cas de test, et No sinon.

Contraintes
- 1 \ leq t \ leq 5 \ fois 10 ^ 5
- 1 \ leq | s | \ leq 5 \ fois 10 ^ 5
- 1 \ leq | x |, | y | \ leq 5 \ fois 10 ^ 5
- S est une chaîne composée de lettres anglaises minuscules.
- x et y sont des cordes composées de 0 et 1.
- La somme de | S | Dans tous les cas de test en une seule entrée, il y a au plus 5 \ fois 10 ^ 5.
- La somme de | x | Dans tous les cas de test en une seule entrée, il y a au plus 5 \ fois 10 ^ 5.
- La somme de | y | Dans tous les cas de test en une seule entrée, il y a au plus 5 \ fois 10 ^ 5.

Échantillon d'entrée 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

Échantillon de sortie 1

Yes
No
No

Ci-dessous, la concaténation des chaînes est représentée en utilisant +.
Pour le 1er cas de test, si t = ara, alors f(S,T,X)=S+T=araaraara et f(S,T,Y)=T+T+T=araaraara, donc f(S,T,X)=f(S,T,Y).
Pour les 2e et 3e cas de test, il n'y a pas de T qui satisfait la condition.

Échantillon d'entrée 2

2
vide
10101
00
vide
11111
111

Échantillon de sortie 2

Yes
Yes

T peut être vide.

Pour les chaînes S et T composées de lettres minuscules anglaises, et une chaîne X composée de 0 et 1, définissez la chaîne f(S,T,X) composée de lettres minuscules anglaises comme suit :

- En commençant par une chaîne vide, pour chaque i=1,2,\dots,|X|, ajoutez S à la fin si le i-ème caractère de X est 0, et ajoutez T à la fin si c'est 1.

On donne une chaîne S composée de lettres minuscules anglaises, et des chaînes X et Y composées de 0 et 1.
Déterminez s'il existe une chaîne T (qui peut être vide) telle que f(S,T,X)=f(S,T,Y).
Vous avez t cas de test à résoudre.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
t
\mathrm{case}_1
\vdots
\mathrm{case}_t

Chaque cas est donné dans le format suivant :
S
X
Y

Sortie

Affichez t lignes. La i-ème ligne doit contenir Yes s'il existe un T qui satisfait la condition pour le i-ème cas de test, et No sinon.

Contraintes

- 1 \leq t \leq 5 \times 10^5
- 1 \leq |S| \leq 5\times 10^5
- 1 \leq |X|,|Y| \leq 5\times 10^5
- S est une chaîne composée de lettres minuscules anglaises.
- X et Y sont des chaînes composées de 0 et 1.
- La somme de |S| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.
- La somme de |X| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.
- La somme de |Y| sur tous les cas de test dans une seule entrée est au plus 5 \times 10^5.

Exemple d'entrée 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

Exemple de sortie 1

Yes
No
No

Ci-dessous, la concaténation de chaînes est représentée par +.
Pour le premier cas de test, si T=ara, alors f(S,T,X)=S+T=araaraara et f(S,T,Y)=T+T+T=araaraara, donc f(S,T,X)=f(S,T,Y).
Pour le deuxième et troisième cas de test, il n'existe pas de T qui satisfait la condition.

Exemple d'entrée 2

2
empty
10101
00
empty
11111
111

Exemple de sortie 2

Yes
Yes

T peut être vide.


Vous êtes donné une permutation P=(P_1,P_2,\dots,P_N) de (1,2,\dots,N).
Vous voulez satisfaire P_i=i pour tout i=1,2,\dots,N en effectuant l'opération suivante zéro ou plusieurs fois :

- Choisissez un entier k tel que 1 \leq k \leq N. Si k \geq 2, triez les termes de la 1ère à la (k-1)ème position de P par ordre croissant. Ensuite, si k \leq N-1, triez les termes de la (k+1)ème à la Nème position de P par ordre croissant.

Il peut être prouvé que sous les contraintes de ce problème, il est possible de satisfaire P_i=i pour tout i=1,2,\dots,N avec un nombre fini d'opérations pour tout P. Trouvez le nombre minimum d'opérations requises.
Vous avez T cas de test à résoudre.

Entrée

L'entrée est donnée à partir de l'Entrée Standard au format suivant :
T
\mathrm{case}_1
\vdots
\mathrm{case}_T

Chaque cas est donné au format suivant :
N
P_1 P_2 \dots P_N

Sortie

Imprimez T lignes. La ième ligne doit contenir la réponse pour le ième cas de test.

Contraintes

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P est une permutation de (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des entiers.
- La somme de N à travers les cas de test dans une seule entrée est au maximum 2 \times 10^5.

Exemple d'entrée 1

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

Exemple de sortie 1

1
0
2

Pour le premier cas de test,

-
Effectuer l'opération avec k=1 donne P devenant (2,1,3,4,5).

-
Effectuer l'opération avec k=2 donne P devenant (2,1,3,4,5).

-
Effectuer l'opération avec k=3 donne P devenant (1,2,3,4,5).

-
Effectuer l'opération avec k=4 donne P devenant (1,2,3,5,4).

-
Effectuer l'opération avec k=5 donne P devenant (1,2,3,5,4).

En particulier, effectuer l'opération avec k=3 donne P satisfaisant P_i=i pour tout i=1,2,\dots,5. Par conséquent, le nombre minimum d'opérations requises est 1.
Pour le troisième cas de test, effectuer l'opération avec k=4 suivi de k=3 donne P changeant comme (3,2,1,7,5,6,4) \rightarrow (1,2,3,7,4,5,6) \rightarrow (1,2,3,4,5,6,7).

On donne une permutation P=(P_1,P_2,\dots,P_N) de (1,2,\dots,N).
Vous voulez satisfaire P_i=i pour tout i=1,2,\dots,N en effectuant l'opération suivante zéro ou plusieurs fois :

- Choisissez un entier k tel que 1 \leq k \leq N. Si k \geq 2, triez les termes de la 1ère à la (k-1)ème position de P par ordre croissant. Ensuite, si k \leq N-1, triez les termes de la (k+1)ème à la Nème position de P par ordre croissant.

Il peut être prouvé que dans les contraintes de ce problème, il est possible de satisfaire P_i=i pour tout i=1,2,\dots,N avec un nombre fini d'opérations pour tout P. Trouvez le nombre minimum d'opérations requises.
Vous avez T cas de test à résoudre.

Entrée

L'entrée est donnée à partir de l'Entrée Standard au format suivant :
T
\mathrm{case}_1
\vdots
\mathrm{case}_T

Chaque cas est donné au format suivant :
N
P_1 P_2 \dots P_N

Sortie

Affichez T lignes. La ième ligne doit contenir la réponse pour le ième cas de test.

Contraintes

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P est une permutation de (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des entiers.
- La somme de N au sein des cas de test dans une seule entrée est au maximum 2 \times 10^5.

Exemple d'entrée 1

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

Exemple de sortie 1

1
0
2

Pour le premier cas de test,

-
Effectuer l'opération avec k=1 donne P devenant (2,1,3,4,5).

-
Effectuer l'opération avec k=2 donne P devenant (2,1,3,4,5).

-
Effectuer l'opération avec k=3 donne P devenant (1,2,3,4,5).

-
Effectuer l'opération avec k=4 donne P devenant (1,2,3,5,4).

-
Effectuer l'opération avec k=5 donne P devenant (1,2,3,5,4).

En particulier, effectuer l'opération avec k=3 donne P satisfaisant P_i=i pour tout i=1,2,\dots,5. Par conséquent, le nombre minimum d'opérations requises est 1.
Pour le troisième cas de test, effectuer l'opération avec k=4 suivi de k=3 donne P changeant comme (3,2,1,7,5,6,4) \rightarrow (1,2,3,7,4,5,6) \rightarrow (1,2,3,4,5,6,7).

Vous avez une permutation P = (P_1, P_2, \dots, P_n) de (1,2, \dots, n).
Vous voulez satisfaire P_i = i pour tous les i = 1,2, \dots, n en effectuant l'opération suivante zéro ou plus:

- Choisissez un entier k tel que 1 \leq k \leq N. Si k \geq 2, triez les termes 1er à (k-1) -th de P dans l'ordre croissant. Ensuite, si k \leq n-1, triez le (k+1)-th à N-tth Termes de P dans l'ordre croissant.

On peut prouver que sous les contraintes de ce problème, il est possible de satisfaire P_i = i pour tous les i = 1,2, \dots, N avec un nombre fini d'opérations pour tout P. Trouvez le nombre minimum d'opérations requis.
Vous avez des cas de test à résoudre.

Saisir

L'entrée est donnée à partir de l'entrée standard dans le format suivant:
T
\mathrm {case} _1
\vdots
\mathrm {case} _t

Chaque cas est donné dans le format suivant:
N
P_1 P_2 \dots P_N

Sortir

Imprimez les lignes T. La i-ème ligne doit contenir la réponse du i-ème cas de test.

Contraintes

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P is a permutation of (1,2,\dots,N).
- Toutes les valeurs d'entrée sont des entiers.
- La somme de n dans les cas d'essai en une seule entrée est au plus 2 \times 10^5.

Échantillon d'entrée 1

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

Échantillon de sortie 1

1
0
2

Pour le premier cas de test,

-
En effectuant l'opération avec k=1, P devient (2,1,3,4,5).

-
L'exécution de l'opération avec k=2 entraîne le devenir P (2,1,3,4,5).

-
La réalisation de l'opération avec k=3 entraîne le devenir P (1,2,3,4,5).

-
La réalisation de l'opération avec k=4 entraîne le devenant P (1,2,3,5,4).

-
La réalisation de l'opération avec k=5 entraîne le devenir P (1,2,3,5,4).

Plus précisément, l'exécution de l'opération avec k=3 entraîne P_i=i pour tous les i=1,2, \dots, 5. Par conséquent, le nombre minimum d'opérations requis est 1.
Pour le troisième cas de test, effectuer l'opération avec k=4 suivi de k=3 résultats en change de P. , 5,6) \rightarrow (1,2,3,4,5,6,7).


Une séquence d'entiers où aucun élément adjacent n'est identique est appelée une bonne séquence.
On vous donne deux bonnes séquences de longueur N : A=(A_1,A_2,\dots,A_N) et B=(B_1,B_2,\dots,B_N). Chaque élément de A et de B est compris entre 0 et M-1, inclus.
Vous pouvez effectuer les opérations suivantes sur A autant de fois que vous le souhaitez, éventuellement zéro :

- Choisir un entier i entre 1 et N, inclus, et effectuer l'une des opérations suivantes :
- Mettre A_i \leftarrow (A_i + 1) \bmod M.
- Mettre A_i \leftarrow (A_i - 1) \bmod M. Ici, (-1) \bmod M = M - 1.

Cependant, vous ne pouvez pas effectuer une opération qui ferait de A une séquence non bonne.
Déterminez s'il est possible de rendre A égal à B, et si c'est possible, trouvez le nombre minimum d'opérations nécessaires pour le faire.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Sortie

Si l'objectif est inatteignable, affichez -1.
Sinon, affichez le nombre minimum d'opérations nécessaires sous forme d'un entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 9
2 0 1
4 8 1

Exemple de sortie 1

3

Vous pouvez atteindre l'objectif en trois opérations comme suit :

- Mettre A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (3, 0, 1).
- Mettre A_2 \leftarrow (A_2 - 1) \bmod M. Maintenant A = (3, 8, 1).
- Mettre A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (4, 8, 1).

Il est impossible d'atteindre l'objectif en deux opérations ou moins, donc la réponse est 3.
Par exemple, vous ne pouvez pas fixer A_2 \leftarrow (A_2 + 1) \bmod M dans la première opération, car cela donnerait A = (2, 1, 1), ce qui n'est pas une bonne séquence.

Exemple d'entrée 2

3 9
1 8 2
1 8 2

Exemple de sortie 2

0

A et B peuvent être identiques dès le départ.

Exemple d'entrée 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

Exemple de sortie 3

811

Une séquence d'entiers où aucun élément adjacent n'est identique est appelée une bonne séquence.
On vous donne deux bonnes séquences de longueur N : A=(A_1,A_2,\dots,A_N) et B=(B_1,B_2,\dots,B_N). Chaque élément de A et de B est compris entre 0 et M-1, inclus.
Vous pouvez effectuer les opérations suivantes sur A autant de fois que vous le souhaitez, éventuellement zéro :

- Choisir un entier i entre 1 et N, inclus, et effectuer l'une des opérations suivantes :
- Attribuez A_i \leftarrow (A_i + 1) \bmod M.
- Attribuez A_i \leftarrow (A_i - 1) \bmod M. Ici, (-1) \bmod M = M - 1.

Cependant, vous ne pouvez pas effectuer une opération qui rend A non plus une bonne séquence.
Déterminez s'il est possible de rendre A égal à B, et si c'est possible, trouvez le nombre minimum d'opérations nécessaires pour le faire.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Sortie

Si l'objectif est inatteignable, affichez -1.
Sinon, affichez le nombre minimum d'opérations nécessaires en tant qu'entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 9
2 0 1
4 8 1

Exemple de sortie 1

3

Vous pouvez atteindre l'objectif en trois opérations comme suit :

- Attribuez A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (3, 0, 1).
- Attribuez A_2 \leftarrow (A_2 - 1) \bmod M. Maintenant A = (3, 8, 1).
- Attribuez A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (4, 8, 1).

Il est impossible d'atteindre l'objectif en deux opérations ou moins, donc la réponse est 3.
Par exemple, vous ne pouvez pas fixer A_2 \leftarrow (A_2 + 1) \bmod M dans la première opération, car cela rendrait A = (2, 1, 1), ce qui n'est pas une bonne séquence.

Exemple d'entrée 2

3 9
1 8 2
1 8 2

Exemple de sortie 2

0

A et B peuvent être identiques dès le départ.

Exemple d'entrée 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

Exemple de sortie 3

811

Une séquence d'entiers où il n'y a pas deux éléments adjacents identiques est appelée une bonne séquence.
On vous donne deux bonnes séquences de longueur n: A = (A_1, A2, \ dots, A_N) et B = (B_1, B_2, \ dots, B_N). Chaque élément de A et B est compris entre 0 et M-1, inclusif.
Vous pouvez effectuer les opérations suivantes sur un certain nombre de fois, peut-être zéro:

- Choisissez un entier I entre 1 et N, inclusif, et effectuez l'une des éléments suivants:
- Définir A_i \leftarrow (A_i + 1) \bmod M.
- Définir A_i\ Leftarrow (A_i - 1) \ bmod M. ici, (-1) \ bmod m = M - 1.

Cependant, vous ne pouvez pas effectuer une opération qui ferait que A n'est plus une bonne séquence.
Déterminez s'il est possible de faire un égal à B et si cela est possible, trouvez le nombre minimum d'opérations nécessaires pour le faire.

Entrée

L'entrée est donnée par l'entrée standard dans le format suivant:
N M
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

Sortie

Si l'objectif est irréalisable, imprimez -1.
Sinon, imprimez le nombre minimum d'opérations requis en tant qu'entier.

Contraintes

- 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)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 9
2 0 1
4 8 1

Exemple de sortie 1

3

Vous pouvez atteindre l'objectif en trois opérations comme suit:

- Posez A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (3, 0, 1).
- Posez A_2 \leftarrow (A_2 - 1) \bmod M. Maintenant A = (3, 8, 1).
- Posez A_1 \leftarrow (A_1 + 1) \bmod M. Maintenant A = (4, 8, 1).

Il est impossible d'atteindre l'objectif en deux opérations ou moins, donc la réponse est 3.
Par exemple, vous ne pouvez pas définir a_2 \ Leftarrow (A_2 + 1) \ bmod m dans la première opération, car il ferait un = (2, 1, 1), ce qui n'est pas une bonne séquence.

Échantillon d'entrée 2

3 9
1 8 2
1 8 2

Exemple de sortie 2

0

A et B pourraient être égaux depuis le début.

Exemple d'entrée 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

Exemple de sortie 3

811


Vous disposez des entiers positifs N, M, K, d'un entier non négatif C, et d'une séquence d'entiers A=(A_1, A_2, \ldots, A_N) de longueur N.
Trouvez \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M C K
A_1 A_2 \ldots A_N

Sortie

Affichez la réponse.

Contraintes

- 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
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 5 3 3
1 3

Exemple de sortie 1

4

Pour k=0, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=1, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=2, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
Par conséquent, la réponse est 1+1+2=4. Par conséquent, affichez 4.

Exemple d'entrée 2

5 4 3 182
0 3 2 1 2

Exemple de sortie 2

0

Exemple d'entrée 3

5 718 651 193855
3 532 44 109 58

Exemple de sortie 3

29484897

On vous donne des entiers positifs N, M, K, un entier non négatif C et une séquence d'entiers A=(A_1, A_2, \ldots, A_N) de longueur N.
Trouver \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M C K
A_1 A_2 \ldots A_N

Sortie

Imprimer la réponse.

Contraintes

- 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
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 5 3 3
1 3

Exemple de sortie 1

4

Pour k=0, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=1, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=2, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
Par conséquent, la réponse est 1+1+2=4. Par conséquent, imprimez 4.

Exemple d'entrée 2

5 4 3 182
0 3 2 1 2

Exemple de sortie 2

0

Exemple d'entrée 3

5 718 651 193855
3 532 44 109 58

Exemple de sortie 3

29484897

Vous disposez des entiers positifs N, M, K, un entier non négatif C, et une séquence d'entiers A=(A_1, A_2, \ldots, A_N) de longueur N.
Trouvez \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M C K
A_1 A_2 \ldots A_N

Sortie

Affichez la réponse.

Contraintes

- 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
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 5 3 3
1 3

Exemple de sortie 1

4

Pour k=0, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=1, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
Pour k=2, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 et \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4, donc \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
Par conséquent, la réponse est 1+1+2=4. Par conséquent, affichez 4.

Exemple d'entrée 2

5 4 3 182
0 3 2 1 2

Exemple de sortie 2

0

Exemple d'entrée 3

5 718 651 193855
3 532 44 109 58

Exemple de sortie 3

29484897


Il existe une séquence d'entiers \( S \) de longueur \( N \). Initialement, tous les éléments de \( S \) sont égaux à 0.
On vous donne également deux séquences d'entiers de longueur \( Q \) : \( P=(P_1,P_2,\dots,P_Q) \) et \( V=(V_1,V_2,\dots,V_Q) \).
Snuke veut effectuer \( Q \) opérations sur la séquence \( S \) dans l'ordre. La \( i \)-ème opération est la suivante :

- Effectuer l'une des opérations suivantes :
- Remplacer chacun des éléments \( S_1, S_2, \dots, S_{P_i} \) par \( V_i \). Cependant, avant cette opération, si l'un des éléments parmi \( S_1, S_2, \dots, S_{P_i} \) est strictement plus grand que \( V_i \), Snuke se mettra à pleurer.
- Remplacer chacun des éléments \( S_{P_i}, S_{P_i+1}, \dots, S_N \) par \( V_i \). Cependant, avant cette opération, si l'un des éléments parmi \( S_{P_i}, S_{P_i+1}, \dots, S_N \) est strictement plus grand que \( V_i \), Snuke se mettra à pleurer.

Trouvez le nombre de séquences de \( Q \) opérations que Snuke peut effectuer sans pleurer, modulo 998244353.
Deux séquences d'opérations sont distinguées si et seulement si il existe un \( 1 \leq i \leq Q \) tel que le choix de la \( i \)-ème opération soit différent.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
\( N \  Q \)
\( P_1 \ V_1 \)
\( P_2 \ V_2 \)
\vdots
\( P_Q \ V_Q \)

Sortie

Affichez la réponse sous la forme d'un entier.

Contraintes

- \( 2 \leq N \leq 5000 \)
- \( 1 \leq Q \leq 5000 \)
- \( 1 \leq P_i \leq N \)
- \( 1 \leq V_i \leq 10^9 \)
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

8 3
1 8
8 1
2 1

Exemple de sortie 1

1

Snuke peut effectuer les trois opérations sans pleurer comme suit :

- Remplacer \( S_1 \) par 8.
- Remplacer \( S_8 \) par 1.
- Remplacer \( S_2, S_3, \dots, S_8 \) par 1.

Aucune autre séquence d'opérations ne satisfait les conditions, donc la réponse est 1. Par exemple, s'il remplace \( S_1, S_2, \dots, S_8 \) par 8 dans la première opération, il pleurera lors de la deuxième opération, quel que soit le choix.

Exemple d'entrée 2

8 3
8 1
1 8
1 2

Exemple de sortie 2

0

Peu importe comment il effectue les deux premières opérations, il pleurera lors de la troisième opération.

Exemple d'entrée 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

Exemple de sortie 3

682155965

N'oubliez pas de prendre en compte le résultat modulo 998244353.

Il existe une séquence d'entiers S de longueur N. Initialement, tous les éléments de S sont 0.
On vous donne également deux séquences entières de longueur Q : P=(P_1,P_2,\dots,P_Q) et V=(V_1,V_2,\dots,V_Q).
Snuke veut effectuer Q opérations sur la séquence S dans l'ordre. La i-ième opération est la suivante :

- Effectuer l'une des opérations suivantes
- Remplacer chacun des éléments S_1, S_2, \dots, S_{P_i} par V_i. Toutefois, avant cette opération, s'il existe un élément parmi S_1, S_2, \dots, S_{P_i} qui est strictement supérieur à V_i, Snuke commencera à pleurer.
- Remplacer chacun des éléments S_{P_i}, S_{P_i+1}, \dots, S_N par V_i. Cependant, avant cette opération, s'il existe un élément parmi S_{P_i}, S_{P_i+1}, \dots, S_N qui est strictement supérieur à V_i, Snuke se mettra à pleurer.

Trouver le nombre de séquences de Q opérations où Snuke peut effectuer toutes les opérations sans pleurer, modulo 998244353.
Deux séquences d'opérations se distinguent si et seulement s'il y a 1 \leq i \leq Q tel que le choix pour la i-ième opération est différent.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Sortie

Imprime la réponse sous forme d'un nombre entier.

Contraintes

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- Toutes les valeurs d'entrée sont des nombres entiers.

Exemple d'entrée 1

8 3
1 8
8 1
2 1

Exemple de sortie 1

1
Snuke peut effectuer les trois opérations sans pleurer comme suit :

- Remplacer S_1 par 8.
- Remplacer S_8 par 1.
- Remplacer S_2, S_3, \dots, S_8 par 1.

Par exemple, s'il remplace S_1, S_2, \dots, S_8 par 8 lors de la première opération, il pleurera lors de la deuxième opération, quel que soit son choix.

Exemple Entrée 2

8 3
8 1
1 8
1 2

Exemple de sortie 2

0

Quelle que soit la manière dont il effectue les deux premières opérations, il pleurera lors de la troisième opération.

Exemple d'entrée 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

Exemple de sortie 3

682155965

N'oubliez pas de prendre en compte le résultat modulo 998244353.

Il existe une séquence d'entier S de longueur N. Initialement, tous les éléments de S sont 0.
On vous donne également deux séquences d'entiers de longueur Q: P=(P_1,P_2,\dots,P_Q) et V=(V_1,V_2,\dots,V_Q).
Snuke veut effectuer Q opérations sur la séquence S dans l'ordre. La i -ème opération est la suivante :

- Effectuer l'une des opérations suivantes :
- Remplacer chacun des éléments S_1, S_2, \dots, S_{P_i} par  V_i . Cependant, avant cette opération, si l'un des éléments parmi S_1, S_2, \dots, S_{P_i} est strictement plus grand que V_i, Snuke se mettra à pleurer.
- Remplacer chacun des éléments S_{P_i}, S_{P_i+1}, \dots, S_N par V_i . Cependant, avant cette opération, si l'un des éléments parmi S_{P_i}, S_{P_i+1}, \dots, S_N est strictement plus grand que V_i, Snuke se mettra à pleurer.

Trouver le nombre de séquences de Q opérations que Snuke peut effectuer sans pleurer, module 998244353.
Deux séquences d'opérations sont distinguées si et seulement si il existe un 1 \leq i \leq Q  tel que le choix de la i -ème opération soit différent.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Sortie

Afficher la réponse en tant qu'entier.

Contraintes

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

8 3
1 8
8 1
2 1

Exemple de sortie 1

1

Snuke peut effectuer les trois opérations sans pleurer comme suit :

- Remplacer S_1 par 8.
- Remplacer S_8 par 1.
- Remplacer S_2, S_3, \dots, S_8 par 1.

Aucune autre séquence d'opérations ne satisfait les conditions, donc la réponse est 1. Par exemple, s'il remplace S_1, S_2, \dots, S_8 par 8 dans la première opération, il pleurera lors de la deuxième opération, quel que soit le choix.

Exemple d'entrée 2

8 3
8 1
1 8
1 2

Exemple de sortie 2

0

Peu importe comment il effectue les deux premières opérations, il pleurera lors de la troisième opération.

Exemple d'entrée 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

Exemple de sortie 3

682155965

N'oubliez pas de prendre en compte le résultat module 998244353.


Une séquence entière de longueur entre 1 et N, inclusivement, où chaque élément est entre 1 et M, inclusivement, est appelée une bonne séquence.
Le score d'une bonne séquence est défini comme le nombre de diviseurs positifs de X, où X est le produit des éléments de la séquence.
Il y a \displaystyle \sum_{k=1}^{N}M^k bonnes séquences. Trouvez la somme des scores de toutes ces séquences modulo 998244353.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M

Sortie

Affichez la réponse comme un entier.

Contraintes

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

1 7

Exemple de sortie 1

16

Il y a sept bonnes séquences : (1),(2),(3),(4),(5),(6),(7). Leurs scores sont respectivement 1,2,2,3,2,4,2, donc la réponse est 1+2+2+3+2+4+2=16.

Exemple d'entrée 2

3 11

Exemple de sortie 2

16095

Par exemple, (8,11) et (1,8,2) sont de bonnes séquences. Voici le processus de calcul de leurs scores :

- Le produit des éléments dans (8,11) est 8 \times 11 = 88. 88 a huit diviseurs positifs : 1,2,4,8,11,22,44,88, donc le score de (8,11) est 8.
- Le produit des éléments dans (1,8,2) est 1 \times 8 \times 2 = 16. 16 a cinq diviseurs positifs : 1,2,4,8,16, donc le score de (1,8,2) est 5.

Exemple d'entrée 3

81131 14

Exemple de sortie 3

182955659

N'oubliez pas de prendre le résultat modulo 998244353.

Une séquence entière de longueur comprise entre 1 et N inclus, où chaque élément est compris entre 1 et M inclus, est appelée une bonne séquence.
Le score d'une bonne séquence est défini comme le nombre de diviseurs positifs de X, où X est le produit des éléments de la séquence.
Il y a \displaystyle \sum_{k=1}^{N}M^k bonnes séquences. Trouvez la somme des scores de toutes ces séquences modulo 998244353.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M

Sortie

Affichez la réponse sous forme d'entier.

Contraintes

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

1 7

Exemple de sortie 1

16

Il y a sept bonnes séquences : (1),(2),(3),(4),(5),(6),(7). Leurs scores sont respectivement 1,2,2,3,2,4,2, donc la réponse est 1+2+2+3+2+4+2=16.

Exemple d'entrée 2

3 11

Exemple de sortie 2

16095

Par exemple, (8,11) et (1,8,2) sont de bonnes séquences. Voici le processus de calcul de leurs scores :

- Le produit des éléments dans (8,11) est 8 \times 11 = 88. 88 a huit diviseurs positifs : 1,2,4,8,11,22,44,88, donc le score de (8,11) est 8.
- Le produit des éléments dans (1,8,2) est 1 \times 8 \times 2 = 16. 16 a cinq diviseurs positifs : 1,2,4,8,16, donc le score de (1,8,2) est 5.

Exemple d'entrée 3

81131 14

Exemple de sortie 3

182955659

Rappelez-vous de prendre le résultat modulo 998244353.


Vous disposez de séquences entières de longueur N : A=(A_1, A_2, \cdots, A_N) et B=(B_1, B_2, \cdots, B_N), et d'un entier K. Vous pouvez effectuer l'opération suivante zéro ou plusieurs fois.

- Choisissez les entiers i et j (1 \leq i,j \leq N).
Ici, |i-j| \leq K doit être vérifié.
Ensuite, changez la valeur de A_i en A_j.

Déterminez s'il est possible de rendre A identique à B. Il y a T cas de test pour chaque entrée.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
T
cas_1
cas_2
\vdots
cas_T

Chaque cas de test est donné dans le format suivant :
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Sortie

Pour chaque cas de test, affichez Yes s'il est possible de rendre A identique à B, et No sinon.

Contraintes

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- La somme de N pour tous les cas de test dans chaque entrée est au maximum de 250000.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 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

Exemple de sortie 1

Yes
Yes
No
Yes

Considérons le premier cas de test.
Si nous opérons avec i=2 et j=3, la valeur de A_2 sera changée en A_3=2, ce qui donnera A=(1,2,2).

On vous donne des séquences entières de longueur N : A=(A_1,A_2,\cdots,A_N) et B=(B_1,B_2,\cdots,B_N), ainsi qu'un entier K.
Vous pouvez effectuer l'opération suivante zéro ou plusieurs fois.

- Choisissez les entiers i et j (1 \leq i,j \leq N).
Ici, |i-j| \leq K doit être vrai.
Ensuite, remplacez la valeur de A_i par A_j.

Déterminez s'il est possible de rendre A identique à B.
Il existe T cas de test pour chaque entrée.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
T
case_1
case_2
\vdots
case_T

Chaque cas de test est donné au format suivant :
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Sortie

Pour chaque cas de test, imprimez Oui s'il est possible de rendre A identique à B, et Non sinon.

Contraintes

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- La somme de N sur tous les cas de test dans chaque entrée est au plus égale à 250000.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 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

Exemple de sortie 1

Yes
Yes
No
Yes

Considérons le premier cas de test.
Si nous opérons avec i=2 et j=3, la valeur de A_2 sera changée en A_3=2, ce qui donne A=(1,2,2).

Vous disposez de séquences entières de longueur N : A=(A_1, A_2, \cdots, A_N) et B=(B_1, B_2, \cdots, B_N), et d'un entier K.
Vous pouvez effectuer l'opération suivante zéro ou plusieurs fois.

- Choisissez les entiers i et j (1 \leq i,j \leq N).
Ici, |i-j| \leq K doit être vérifié.
Ensuite, changez la valeur de A_i en A_j.

Déterminez s'il est possible de rendre A identique à B. Il y a T cas de test pour chaque entrée.

Entrée

L'entrée est donnée depuis l'entrée standard dans le format suivant :
T
case_1
case_2
\vdots
case_T

Chaque cas de test est donné dans le format suivant :
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

Sortie

Pour chaque cas de test, affichez Yes s'il est possible de rendre A identique à B, et No sinon.

Contraintes

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- La somme de N pour tous les cas de test dans chaque entrée est au maximum de 250000.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 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

Exemple de sortie 1

Yes
Yes
No
Yes

Considérons le premier cas de test. Si nous opérons avec i=2 et j=3, la valeur de A_2 sera changée en A_3=2, ce qui donnera A=(1,2,2).


Trouvez le nombre, modulo 998244353, de permutations P=(P_1,P_2,\cdots,P_N) de (1,2,\cdots,N) qui satisfont toutes les conditions M suivantes.

- La i-ème condition : Le maximum parmi P_{L_i},P_{L_i+1},\cdots,P_{R_i} n'est pas P_{X_i}.
Ici, L_i, R_i et X_i sont des entiers donnés dans l'entrée.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

Sortie

Imprimez la réponse.

Contraintes

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
1 3 2
1 2 1

Exemple de sortie 1

1

Une seule permutation, P=(1,2,3), satisfait les conditions.

Exemple d'entrée 2

5 1
1 1 1

Exemple de sortie 2

0

Exemple d'entrée 3

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

Exemple de sortie 3

1598400

Exemple d'entrée 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

Exemple de sortie 4

921467228

Trouvez le nombre, modulo 998244353, de permutations P=(P_1,P_2,\cdots,P_N) de (1,2,\cdots,N) qui satisfont toutes les M conditions suivantes.

- La i-ème condition : Le maximum parmi P_{L_i},P_{L_i+1},\cdots,P_{R_i} n'est pas P_{X_i}.
Ici, L_i, R_i, et X_i sont des entiers donnés en entrée.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

Sortie

Affichez la réponse.

Contraintes

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

3 2
1 3 2
1 2 1

Exemple de sortie 1

1

Une seule permutation, P=(1,2,3), satisfait les conditions.

Exemple d'entrée 2

5 1
1 1 1

Exemple de sortie 2

0

Exemple d'entrée 3

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

Exemple de sortie 3

1598400

Exemple d'entrée 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

Exemple de sortie 4

921467228


On vous donne des entiers positifs N et K.
Une séquence d'entiers de longueur NK où chaque entier de 1 à N apparaît exactement K fois est appelée une bonne séquence d'entiers.
Soit S le nombre de bonnes séquences d'entiers.
Trouvez la \operatorname{floor}((S+1)/2)-ième bonne séquence d'entiers dans l'ordre lexicographique.
Ici, \operatorname{floor}(x) représente le plus grand entier ne dépassant pas x.
Quel est l'ordre lexicographique des séquences ?
Une séquence S = (S_1,S_2,\ldots,S_{|S|}) est lexicographiquement plus petite qu'une séquence T = (T_1,T_2,\ldots,T_{|T|}) si 1. ou 2. ci-dessous est vrai.
Ici, |S| et |T| représentent les longueurs de S et T, respectivement.

- |S| \lt |T| et (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
- Il existe un entier 1 \leq i \leq \min\lbrace |S|, |T| \rbrace tel que les deux conditions suivantes soient remplies :

- (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
- S_i est (numériquement) plus petit que T_i.

Entrée

L'entrée est donnée à partir de l'entrée standard au format suivant :
N K

Sortie

Imprimez la séquence d'entiers souhaitée, avec les éléments séparés par des espaces.

Contraintes

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 2

Exemple de sortie 1

1 2 2 1

Il existe six bonnes séquences d'entiers :

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

La réponse est donc la 3e séquence dans l'ordre lexicographique, (1,2,2,1).

Exemple d'entrée 2

1 5

Exemple de sortie 2

1 1 1 1 1

Exemple d'entrée 3

6 1

Exemple de sortie 3

3 6 5 4 2 1

Exemple d'entrée 4

3 3

Exemple de sortie 4

2 2 2 1 3 3 3 1 1

On vous donne des entiers positifs N et K.
Une séquence d'entiers de longueur NK où chaque entier de 1 à N apparaît exactement K fois est appelée une bonne séquence d'entiers.
Soit S le nombre de bonnes séquences d'entiers.
Trouvez la \operatorname{floor}((S+1)/2)-ième bonne séquence d'entiers dans l'ordre lexicographique.
Ici, \operatorname{floor}(x) représente le plus grand entier ne dépassant pas x.
Qu'est-ce que l'ordre lexicographique pour les séquences ?
Une séquence S = (S_1,S_2,\ldots,S_{|S|}) est lexicographiquement plus petite qu'une séquence T = (T_1,T_2,\ldots,T_{|T|}) si l'un des deux cas ci-dessous est vérifié.
Ici, |S| et |T| représentent les longueurs de S et T, respectivement.

-  |S| \lt |T| et (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
-  Il existe un entier 1 \leq i \leq \min\lbrace |S|, |T| \rbrace tel que ces deux conditions soient vérifiées :

-  (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
-  S_i est (numériquement) plus petit que T_i.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N K

Sortie

Imprimez la séquence d'entiers souhaitée, avec les éléments séparés par des espaces.

Contraintes

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 2

Exemple de sortie 1

1 2 2 1

Il y a six bonnes séquences d'entiers :

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

Par conséquent, la réponse est la 3ème séquence dans l'ordre lexicographique, (1,2,2,1).

Exemple d'entrée 2

1 5

Exemple de sortie 2

1 1 1 1 1

Exemple d'entrée 3

6 1

Exemple de sortie 3

3 6 5 4 2 1

Exemple d'entrée 4

3 3

Exemple de sortie 4

2 2 2 1 3 3 3 1 1

On vous donne des entiers positifs N et K.
Une séquence d'entiers de longueur NK où chaque entier de 1 à N apparaît exactement K fois est appelée une bonne séquence d'entiers.
Soit S le nombre de bonnes séquences d'entiers.
Trouvez la \operatorname{floor}((S+1)/2)-ième bonne séquence d'entiers dans l'ordre lexicographique.
Ici, \operatorname{floor}(x) représente le plus grand entier ne dépassant pas x.
Qu'est-ce que l'ordre lexicographique pour les séquences ?
Une séquence S = (S_1,S_2,\ldots,S_{|S|}) est lexicographiquement plus petite qu'une séquence T = (T_1,T_2,\ldots,T_{|T|}) si l'un des deux cas ci-dessous est vérifié.
Ici, |S| et |T| représentent les longueurs de S et T, respectivement.

-  |S| \lt |T| et (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
-  Il existe un entier 1 \leq i \leq \min\lbrace |S|, |T| \rbrace tel que ces deux conditions soient vérifiées :

-  (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
-  S_i est (numériquement) plus petit que T_i.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N K

Sortie

Affichez la séquence d'entiers souhaitée, avec les éléments séparés par des espaces.

Contraintes

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

2 2

Exemple de sortie 1

1 2 2 1

Il y a six bonnes séquences d'entiers :

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

Par conséquent, la réponse est la 3ème séquence dans l'ordre lexicographique, (1,2,2,1).

Exemple d'entrée 2

1 5

Exemple de sortie 2

1 1 1 1 1

Exemple d'entrée 3

6 1

Exemple de sortie 3

3 6 5 4 2 1

Exemple d'entrée 4

3 3

Exemple de sortie 4

2 2 2 1 3 3 3 1 1


On considère un arbre avec N sommets numérotés de 1 à N.
La i-ème arête relie les sommets A_i et B_i.
Ici, N est pair, et de plus, cet arbre a un appariement parfait.
En particulier, pour chaque i (1 \leq i \leq N/2), il est garanti que A_i=i \times 2-1 et B_i=i \times 2.
Vous effectuerez l'opération suivante N/2 fois :

- Choisissez deux feuilles (sommets de degré exactement 1) et retirez-les de l'arbre.
Ici, l'arbre après retrait doit encore avoir un appariement parfait.
Dans ce problème, nous considérons un graphe avec zéro sommet comme étant également un arbre.

Pour chaque opération, son score est défini comme la distance entre les deux sommets choisis (le nombre d'arêtes sur le chemin simple reliant les deux sommets).
Montrez une procédure qui maximise le score total.
On peut prouver qu'il existe toujours une procédure pour compléter N/2 opérations dans les contraintes de ce problème.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Sortie

Afficher une solution dans le format suivant :
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Ici, X_i et Y_i sont les deux sommets choisis dans la i-ème opération.
S'il existe plusieurs solutions, vous pouvez imprimer n'importe laquelle d'entre elles.

Contraintes

- 2 \leq N \leq 250000
- N est pair.
- 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)
- Le graphe donné est un arbre.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

4
1 2
3 4
2 3

Exemple de sortie 1

4 1
2 3

La procédure dans la l'exemple de sortie est la suivante :

- 1ère opération : Retirer les sommets 4 et 1. L'arbre restant a les sommets 2 et 3, et un appariement parfait. Le score de cette opération est 3.
- 2ème opération : Retirer les sommets 2 et 3. L'arbre restant a zéro sommet et un appariement parfait. Le score de cette opération est 1.
- Le score total est 3 + 1 = 4.

Il est impossible de faire en sorte que le score total soit supérieur à 4, donc cette sortie résout cet exemple.

Exemple d'entrée 2

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

Exemple de sortie 2

4 8
7 6
5 3
2 1

Exemple d'entrée 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

Exemple de sortie 3

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

Exemple d'entrée 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

Exemple de sortie 4

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

Il existe un arbre avec N sommets numérotés de 1 à N.
La i-ième arête relie les sommets A_i et B_i.
Ici, N est pair et, de plus, cet arbre a une correspondance parfaite.
Plus précisément, pour chaque i (1 \leq i \leq N/2), il est garanti que A_i=i \times 2-1 et B_i=i \times 2.
Vous allez effectuer l'opération suivante N/2 × :

- Choisissez deux feuilles (sommets avec un degré d'exactement 1) et retirez-les de l'arbre.
Ici, l'arbre après suppression doit toujours avoir une correspondance parfaite.
Dans ce problème, nous considérons qu'un graphe avec zéro sommet est également un arbre.

Pour chaque opération, son score est défini comme la distance entre les deux sommets choisis (le nombre d'arêtes sur le chemin simple reliant les deux sommets).
Montrez une procédure qui maximise le score total.
On peut prouver qu'il existe toujours une procédure permettant de réaliser N/2 opérations sous les contraintes de ce problème.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Sortie

Imprimez une solution dans le format suivant :
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Ici, X_i et Y_i sont les deux sommets choisis lors de la i-ième opération.
S'il y a plusieurs solutions, vous pouvez imprimer n'importe laquelle d'entre elles.

Contraintes

- 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)
- Le graphe donné est un arbre.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

4
1 2
3 4
2 3

Exemple de sortie 1

4 1
2 3

La procédure dans l'exemple de sortie est la suivante :

- 1ère opération : Enlever les sommets 4 et 1. L'arbre restant a les sommets 2 et 3, et une correspondance parfaite. Le score de cette opération est de 3.
- 2ème opération : Suppression des sommets 2 et 3. L'arbre restant a zéro sommet et une correspondance parfaite. Le score de cette opération est de 1.
- Le score total est de 3 + 1 = 4.

Il est impossible de faire en sorte que le score total soit supérieur à 4, donc cette sortie résout cet exemple d'entrée.

Exemple d'entrée 2

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

Exemple de sortie 2

4 8
7 6
5 3
2 1

Exemple d'entrée 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

Exemple de sortie 3

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

Exemple d'entrée 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

Exemple de sortie 4

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

Il y a un arbre avec N sommets numérotés de 1 à N.
La i-ème arête connecte les sommets A_i et B_i.
Ici, N est pair, et de plus, cet arbre a un appariement parfait.
En particulier, pour chaque i (1 \leq i \leq N/2), il est garanti que A_i=i \times 2-1 et B_i=i \times 2.
Vous effectuerez l'opération suivante N/2 fois :

- Choisissez deux feuilles (sommets de degré exactement 1) et retirez-les de l'arbre.
Ici, l'arbre après retrait doit encore avoir un appariement parfait.
Dans ce problème, nous considérons un graphe avec zéro sommet comme un arbre également.

Pour chaque opération, son score est défini comme la distance entre les deux sommets choisis (le nombre d'arêtes sur le chemin simple reliant les deux sommets).
Montrez une procédure qui maximise le score total.
On peut prouver qu'il existe toujours une procédure pour compléter N/2 opérations sous les contraintes de ce problème.

Entrée

L'entrée est donnée à partir de l'entrée standard dans le format suivant :
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

Sortie

Affichez une solution dans le format suivant :
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

Ici, X_i et Y_i sont les deux sommets choisis dans la i-ème opération.
S'il existe plusieurs solutions, vous pouvez en imprimer n'importe laquelle.

Contraintes

- 2 \leq N \leq 250000
- N est pair.
- 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)
- Le graphe donné est un arbre.
- Toutes les valeurs d'entrée sont des entiers.

Exemple d'entrée 1

4
1 2
3 4
2 3

Exemple de sortie 1

4 1
2 3

La procédure dans la sortie exemple est la suivante :

- 1ère opération : Retirer les sommets 4 et 1. L'arbre restant a les sommets 2 et 3, et un appariement parfait. Le score de cette opération est 3.
- 2ème opération : Retirer les sommets 2 et 3. L'arbre restant a zéro sommet et un appariement parfait. Le score de cette opération est 1.
- Le score total est 3 + 1 = 4.

Il est impossible de faire en sorte que le score total soit supérieur à 4, donc cette sortie résout cet exemple d'entrée.

Exemple d'entrée 2

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

Exemple de sortie 2

4 8
7 6
5 3
2 1

Exemple d'entrée 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

Exemple de sortie 3

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

Exemple d'entrée 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

Exemple de sortie 4

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


On vous donne des entiers positifs n et target.
Un tableau nums est dit beau s'il remplit les conditions suivantes :

nums.length == n.
nums est constitué d'entiers positifs distincts entre eux.
Il n'existe pas deux indices distincts, i et j, dans la plage [0, n - 1], tels que nums[i] + nums[j] == target.

Retournez la somme minimale possible qu'un tableau beau pourrait avoir modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 2, target = 3
Sortie : 4
Explication : On peut voir que nums = [1,3] est beau.
- Le tableau nums a une longueur n = 2.
- Le tableau nums est constitué d'entiers positifs distincts entre eux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
Il peut être prouvé que 4 est la somme minimale possible qu'un tableau beau pourrait avoir.

Exemple 2 :

Entrée : n = 3, target = 3
Sortie : 8
Explication : On peut voir que nums = [1,3,4] est beau.
- Le tableau nums a une longueur n = 3.
- Le tableau nums est constitué d'entiers positifs distincts entre eux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
Il peut être prouvé que 8 est la somme minimale possible qu'un tableau beau pourrait avoir.

Exemple 3 :

Entrée : n = 1, target = 1
Sortie : 1
Explication : On peut voir que nums = [1] est beau.

Contraintes :

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

On vous donne des entiers positifs n et target.
Un tableau nums est beau s'il remplit les conditions suivantes :

- nums.length == n.
- nums est constitué d'entiers positifs distincts entre eux.
- Il n'existe pas deux indices distincts, i et j, dans la plage [0, n - 1], tels que nums[i] + nums[j] == target.

Retournez la somme minimale possible qu'un tableau beau pourrait avoir modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 2, target = 3
Sortie : 4
Explication : On peut voir que nums = [1,3] est beau.
- Le tableau nums a une longueur n = 2.
- Le tableau nums est constitué d'entiers positifs distincts entre eux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
Il peut être prouvé que 4 est la somme minimale possible qu'un tableau beau pourrait avoir.

Exemple 2 :

Entrée : n = 3, target = 3
Sortie : 8
Explication : On peut voir que nums = [1,3,4] est beau.
- Le tableau nums a une longueur n = 3.
- Le tableau nums est constitué d'entiers positifs distincts entre eux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
Il peut être prouvé que 8 est la somme minimale possible qu'un tableau beau pourrait avoir.

Exemple 3 :

Entrée : n = 1, target = 1
Sortie : 1
Explication : On peut voir que nums = [1] est beau.

Contraintes :

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

On vous donne des entiers positifs n et target.
Un tableau nums est beau s'il remplit les conditions suivantes :

nums.length == n.
nums est constitué d'entiers positifs distincts deux à deux.
Il n'existe pas deux indices distincts, i et j, dans la plage [0, n - 1], tels que nums[i] + nums[j] == target.

Renvoie la somme minimale possible qu'un beau tableau pourrait avoir modulo 10^9 + 7.

Exemple 1 :

Entrée : n = 2, target = 3
Sortie : 4
Explication : Nous pouvons voir que nums = [1,3] est beau.
- Le tableau nums a une longueur n = 2.
- Le tableau nums est constitué d'entiers positifs distincts deux à deux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
On peut prouver que 4 est la somme minimale possible qu'un beau tableau pourrait avoir.

Exemple 2 :

Entrée : n = 3, cible = 3
Sortie : 8
Explication : On voit que nums = [1,3,4] est beau.
- Le tableau nums a une longueur n = 3.
- Le tableau nums est constitué d'entiers positifs distincts deux à deux.
- Il n'existe pas deux indices distincts, i et j, avec nums[i] + nums[j] == 3.
On peut prouver que 8 est la somme minimale possible qu'un beau tableau pourrait avoir.

Exemple 3 :

Entrée : n = 1, cible = 1
Sortie : 1
Explication : On voit que nums = [1] est beau.

Contraintes :

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


On vous donne une chaîne binaire s et un entier k.
Une chaîne binaire satisfait la contrainte k si l'une des conditions suivantes est remplie :

Le nombre de 0 dans la chaîne est au plus k.
Le nombre de 1 dans la chaîne est au plus k.

Retournez un entier représentant le nombre de sous-chaînes de s qui satisfont la contrainte k.

Exemple 1 :

Entrée : s = "10101", k = 1
Sortie : 12
Explication :
Chaque sous-chaîne de s, à l'exception des sous-chaînes "1010", "10101" et "0101", satisfait la contrainte k.

Exemple 2 :

Entrée : s = "1010101", k = 2
Sortie : 25
Explication :
Chaque sous-chaîne de s, à l'exception des sous-chaînes d'une longueur supérieure à 5, satisfait la contrainte k.

Exemple 3 :

Entrée : s = "11111", k = 1
Sortie : 15
Explication :
Toutes les sous-chaînes de s satisfont la contrainte k.

Contraintes :

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

On vous donne une chaîne binaire et un entier k.
Une chaîne binaire satisfait la contrainte K si l'une ou l'autre des conditions suivantes est valable:

Le nombre de 0 dans la chaîne est au plus k.
Le nombre de 1 dans la chaîne est au plus k.

Renvoie un entier désignant le nombre de sous-chaînes de S qui satisfont la contrainte K.

Exemple 1:

Entrée: s = "10101", k = 1
Sortie: 12
Explication:
Chaque sous-chaîne de S à l'exception des sous-chaînes "1010", "10101" et "0101" satisfait la contrainte K.

Exemple 2:

Entrée: s = "1010101", k = 2
Sortie: 25
Explication:
Chaque sous-chaîne de S à l'exception des sous-chaînes avec une longueur supérieure à 5 satisfait la contrainte K.

Exemple 3:

Entrée: s = "11111", k = 1
Sortie: 15
Explication:
Toutes les sous-chaînes de S satisfont la contrainte K.

Contraintes:

1 <= S.Length <= 50
1 <= k <= S.Length
s[i] est soit '0' soit '1'.


Vous disposez de deux tableaux d'entiers, energyDrinkA et energyDrinkB, de même longueur n, fournis par un scientifique sportif futuriste. Ces tableaux représentent les augmentations d'énergie par heure fournies par deux boissons énergétiques différentes, A et B, respectivement. Vous souhaitez maximiser votre augmentation totale d'énergie en buvant une boisson énergétique par heure. Cependant, si vous voulez passer de la consommation d'une boisson énergétique à l'autre, vous devez attendre une heure pour nettoyer votre système (c'est-à-dire que vous ne gagnerez aucune augmentation d'énergie cette heure-là). Retournez le gain d'énergie total maximum que vous pouvez obtenir dans les n prochaines heures. Notez que vous pouvez commencer à consommer l'une ou l'autre des deux boissons énergétiques.

Exemple 1 :

Entrée : energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Sortie : 5
Explication :
Pour obtenir un gain d'énergie de 5, buvez uniquement la boisson énergétique A (ou uniquement B).

Exemple 2 :

Entrée : energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Sortie : 7
Explication :
Pour obtenir un gain d'énergie de 7 :

Buvez la boisson énergétique A pendant la première heure.
Passez à la boisson énergétique B et nous perdons le gain d'énergie de la deuxième heure.
Gagnez le gain d'énergie de la boisson B à la troisième heure.

Contraintes :

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

On vous donne deux tableaux d'entiers, energyDrinkA et energyDrinkB, de même longueur n, fournis par un scientifique des sports du futur. Ces tableaux représentent les gains d'énergie par heure fournis par deux boissons énergétiques différentes, A et B, respectivement.
Vous souhaitez maximiser votre gain total d'énergie en buvant une boisson énergétique par heure. Cependant, si vous voulez passer de la consommation d'une boisson énergétique à l'autre, vous devez attendre une heure pour nettoyer votre système (c'est-à-dire que vous ne recevrez aucun gain pendant cette heure).
Retournez le gain d'énergie total maximum que vous pouvez obtenir dans les n prochaines heures.
Notez que vous pouvez commencer à consommer l'une ou l'autre des deux boissons énergétiques.

Exemple 1 :

Entrée : energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
Sortie : 5
Explication :
Pour obtenir un gain d'énergie de 5, buvez uniquement la boisson énergétique A (ou uniquement B).

Exemple 2 :

Entrée : energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
Sortie : 7
Explication :
Pour obtenir un gain d'énergie de 7 :

Buvez la boisson énergétique A pendant la première heure.
Passez à la boisson énergétique B et nous perdons le gain d'énergie de la deuxième heure.
Obtenez le gain d'énergie de la boisson B à la troisième heure.

Contraintes :

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


On vous donne deux entiers positifs n et k.
Un entier x est appelé k-palindrome si :

x est un palindrome.
x est divisible par k.

Renvoyez le plus grand entier ayant n chiffres (sous forme de chaîne) qui est k-palindrome.
Notez que l'entier ne doit pas avoir de zéros en tête.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : "595"
Explication :
595 est le plus grand entier k-palindrome avec 3 chiffres.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : "8"
Explication :
4 et 8 sont les seuls entiers k-palindromes avec 1 chiffre.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : "89898"

Contraintes :

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

On donne deux entiers positifs n et k.
Un entier x est appelé k-palindromique si :

x est un palindrome.
x est divisible par k.

Retournez le plus grand entier ayant n chiffres (sous forme de chaîne) qui est k-palindromique.
Notez que l'entier ne doit pas avoir de zéros en tête.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : "595"
Explication :
595 est le plus grand entier k-palindromique avec 3 chiffres.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : "8"
Explication :
4 et 8 sont les seuls entiers k-palindromiques avec 1 chiffre.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : "89898"

Contraintes :

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

On vous donne deux entiers positifs n et k.
Un entier x est appelé k-palindrome si :

x est un palindrome.
x est divisible par k.

Retournez le plus grand entier ayant n chiffres (sous forme de chaîne) qui est k-palindrome.
Notez que l'entier ne doit pas avoir de zéros en tête.

Exemple 1 :

Entrée : n = 3, k = 5
Sortie : "595"
Explication :
595 est le plus grand entier k-palindrome avec 3 chiffres.

Exemple 2 :

Entrée : n = 1, k = 4
Sortie : "8"
Explication :
4 et 8 sont les seuls entiers k-palindromes avec 1 chiffre.

Exemple 3 :

Entrée : n = 5, k = 6
Sortie : "89898"

Contraintes :

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


Vous avez un tableau d'entiers nums, un entier k et un entier multiplier.
Vous devez effectuer k opérations sur nums. À chaque opération :

Trouvez la valeur minimale x dans nums. S'il y a plusieurs occurrences de la valeur minimale, sélectionnez celle qui apparaît en premier.
Remplacez la valeur minimale sélectionnée x par x * multiplier.

Retournez un tableau d'entiers représentant l'état final de nums après avoir effectué les k opérations.

Exemple 1 :

Entrée : nums = [2,1,3,5,6], k = 5, multiplier = 2
Sortie : [8,4,6,5,6]
Explication :

Opération
Résultat

Après l'opération 1
[2, 2, 3, 5, 6]

Après l'opération 2
[4, 2, 3, 5, 6]

Après l'opération 3
[4, 4, 3, 5, 6]

Après l'opération 4
[4, 4, 6, 5, 6]

Après l'opération 5
[8, 4, 6, 5, 6]

Exemple 2 :

Entrée : nums = [1,2], k = 3, multiplier = 4
Sortie : [16,8]
Explication :

Opération
Résultat

Après l'opération 1
[4, 2]

Après l'opération 2
[4, 8]

Après l'opération 3
[16, 8]

Contraintes :

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

On vous donne un tableau d'entiers nums, un entier k et un multiplicateur entier.
Vous devez effectuer k opérations sur nums. Dans chaque opération :

Trouvez la valeur minimale x dans nums. S'il existe plusieurs occurrences de la valeur minimale, sélectionnez celle qui apparaît en premier.
Remplacez la valeur minimale sélectionnée x par x * multiplicateur.

Renvoie un tableau d'entiers indiquant l'état final de nums après avoir effectué toutes les k opérations.

Exemple 1 :

Entrée : nums = [2,1,3,5,6], k = 5, multiplier = 2
Sortie : [8,4,6,5,6]
Explication :

Opération
Résultat

Après l'opération 1
[2, 2, 3, 5, 6]

Après l'opération 2
[4, 2, 3, 5, 6]

Après l'opération 3
[4, 4, 3, 5, 6]

Après l'opération 4
[4, 4, 6, 5, 6]

Après l'opération 5
[8, 4, 6, 5, 6]

Exemple 2 :

Entrée : nums = [1,2], k = 3, multiplier = 4
Sortie : [16,8]
Explication :

Opération
Résultat

Après l'opération 1
[4, 2]

Après l'opération 2
[4, 8]

Après l'opération 3
[16, 8]

Contraintes :

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


On vous donne un tableau nums composé d'entiers positifs.
Dans ce problème, nous appelons deux entiers x et y presque égaux si les deux entiers peuvent devenir égaux après avoir effectué l'opération suivante au plus une fois :

Choisissez x ou y et échangez deux chiffres quelconques dans le nombre choisi.

Renvoie le nombre d'indices i et j dans nums où i < j tels que nums[i] et nums[j] soient presque égaux.
Notez qu'il est permis qu'un entier ait des zéros non significatifs après avoir effectué une opération.

Exemple 1 :

Entrée : nums = [3,12,30,17,21]
Sortie : 2
Explication :
Les paires d'éléments presque égales sont :

3 et 30. En échangeant 3 et 0 dans 30, vous obtenez 3.
12 et 21. En échangeant 1 et 2 dans 12, vous obtenez 21.

Exemple 2 :

Entrée : nums = [1,1,1,1,1]
Sortie : 10
Explication :
Tous les deux éléments du tableau sont presque égaux.

Exemple 3 :

Entrée : nums = [123,231]
Sortie : 0
Explication :
Nous ne pouvons pas échanger deux chiffres de 123 ou 231 pour atteindre l'autre.

Contraintes :

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

On donne un tableau nums composé d'entiers positifs.
Dans ce problème, nous appelons deux entiers x et y presque égaux si les deux entiers peuvent devenir égaux après avoir effectué l'opération suivante au maximum une fois :

Choisissez soit x soit y et échangez deux chiffres quelconques à l'intérieur du nombre choisi.

Retournez le nombre d'indices i et j dans nums où i < j tel que nums[i] et nums[j] sont presque égaux.
Notez qu'il est possible qu'un entier ait des zéros en tête après avoir effectué une opération.

Exemple 1 :

Entrée : nums = [3,12,30,17,21]
Sortie : 2
Explication :
Les paires d'éléments presque égaux sont :

3 et 30. En échangeant 3 et 0 dans 30, vous obtenez 3.
12 et 21. En échangeant 1 et 2 dans 12, vous obtenez 21.

Exemple 2 :

Entrée : nums = [1,1,1,1,1]
Sortie : 10
Explication :
Chaque paire d'éléments dans le tableau est presque égale.

Exemple 3 :

Entrée : nums = [123,231]
Sortie : 0
Explication :
Nous ne pouvons pas échanger deux chiffres de 123 ou 231 pour obtenir l'autre.

Contraintes :

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

fr-lcb_v4
Mark according to document rules
Metadata
question_id: 3534
language: fr
Title: count-almost-equal-pairs-i
Please calibrate the provided en to fr translation results. Note that:

Do not translate any LaTeX code.
Do not translate content representing code input/output, or programming language syntax or variable names.
Maintain the original formatting of the text and structure.

You are given an array nums consisting of positive integers.
We call two integers x and y in this problem almost equal if both integers can become equal after performing the following operation at most once:

Choose either x or y and swap any two digits within the chosen number.

Return the number of indices i and j in nums where i < j such that nums[i] and nums[j] are almost equal.
Note that it is allowed for an integer to have leading zeros after performing an operation.

Example 1:

Input: nums = [3,12,30,17,21]
Output: 2
Explanation:
The almost equal pairs of elements are:

3 and 30. By swapping 3 and 0 in 30, you get 3.
12 and 21. By swapping 1 and 2 in 12, you get 21.

Example 2:

Input: nums = [1,1,1,1,1]
Output: 10
Explanation:
Every two elements in the array are almost equal.

Example 3:

Input: nums = [123,231]
Output: 0
Explanation:
We cannot swap any two digits of 123 or 231 to reach the other.

Constraints:

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

Vous avez un tableau nums composé d'entiers positifs.
Dans ce problème, nous appelons deux entiers x et y presque égaux si les deux entiers peuvent devenir égaux après avoir effectué l'opération suivante au maximum une fois :

Choisissez soit x soit y et échangez deux chiffres quelconques à l'intérieur du nombre choisi.

Retournez le nombre d'indices i et j dans nums où i < j tel que nums[i] et nums[j] sont presque égaux.
Notez qu'il est possible qu'un entier ait des zéros initiaux après avoir effectué une opération.

Exemple 1 :

Entrée : nums = [3,12,30,17,21]
Sortie : 2
Explication :
Les paires d'éléments presque égaux sont :

3 et 30. En échangeant 3 et 0 dans 30, vous obtenez 3.
12 et 21. En échangeant 1 et 2 dans 12, vous obtenez 21.

Exemple 2 :

Entrée : nums = [1,1,1,1,1]
Sortie : 10
Explication :
Chaque paire d'éléments dans le tableau est presque égale.

Exemple 3 :

Entrée : nums = [123,231]
Sortie : 0
Explication :
Nous ne pouvons pas échanger deux chiffres de 123 ou 231 pour obtenir l'autre.

Contraintes :

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


Vous avez deux chaînes de caractères, coordinate1 et coordinate2, représentant les coordonnées d'une case sur un échiquier 8 x 8.
Ci-dessous se trouve l'échiquier pour référence.

Retournez true si ces deux cases ont la même couleur et false sinon.
La coordonnée représentera toujours une case valide de l'échiquier. La coordonnée aura toujours la lettre en premier (indiquant sa colonne), et le nombre en second (indiquant sa rangée).

Exemple 1 :

Entrée : coordinate1 = "a1", coordinate2 = "c3"
Sortie : true
Explication :
Les deux cases sont noires.

Exemple 2 :

Entrée : coordinate1 = "a1", coordinate2 = "h3"
Sortie : false
Explication :
La case "a1" est noire et "h3" est blanche.

Contraintes :

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

On vous donne deux chaînes, coordinate1 et coordinate2, représentant les coordonnées d’un carré sur un échiquier 8 x 8.
Ci-dessous se trouve l’échiquier pour référence.

Renvoyer true si ces deux carrés ont la même couleur et false dans le cas contraire.
La coordonnée représentera toujours une case d’échiquier valide. La coordonnée aura toujours la lettre en premier (indiquant sa colonne), et le chiffre en second (indiquant sa ligne).

Exemple 1 :

Input: coordinate1 = "a1", coordinate2 = "c3"
Output: true
Explication:
Les deux carrés sont noirs.

Exemple 2 :

Input: coordinate1 = "a1", coordinate2 = "h3"
Output: false:
La case "a1" est noire et "h3" est blanche.

Contraintes:

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

Vous avez deux chaînes de caractères, coordinate1 et coordinate2, représentant les coordonnées d'une case sur un échiquier 8 x 8.
Ci-dessous se trouve l'échiquier pour référence.

Renvoyez vrai si ces deux cases ont la même couleur et faux sinon.
La coordonnée représentera toujours une case valide de l'échiquier. La coordonnée aura toujours la lettre en premier (indiquant sa colonne), et le nombre en second (indiquant sa rangée).

Exemple 1 :

Entrée: coordinate1 = "a1", coordinate2 = "c3"
Sortie: vrai
Explication :
Les deux cases sont noires.

Exemple 2 :

Entrée: coordinate1 = "a1", coordinate2 = "h3"
Sortie: faux
Explication :
La case "a1" est noire et "h3" est blanche.

Contraintes :

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


Il y a un plan 2D infini.
On vous donne un entier positif k. On vous donne également un tableau 2D queries, qui contient les requêtes suivantes :

queries[i] = [x, y] : Construisez un obstacle à la coordonnée (x, y) dans le plan. Il est garanti qu'il n'y a pas d'obstacle à cette coordonnée lorsque cette requête est faite.

Après chaque requête, vous devez trouver la distance du k^ème obstacle le plus proche de l'origine.
Renvoyez un tableau d'entiers results où results[i] représente le k^ème obstacle le plus proche après la requête i, ou results[i] == -1 s'il y a moins de k obstacles.
Notez qu'au début, il n'y a aucun obstacle nulle part.
La distance d'un obstacle à la coordonnée (x, y) de l'origine est donnée par |x| + |y|.

Exemple 1 :

Entrée : queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Sortie : [-1,7,5,3]
Explication :

Initialement, il y a 0 obstacle.
Après queries[0], il y a moins de 2 obstacles.
Après queries[1], il y a des obstacles aux distances 3 et 7.
Après queries[2], il y a des obstacles aux distances 3, 5, et 7.
Après queries[3], il y a des obstacles aux distances 3, 3, 5, et 7.

Exemple 2 :

Entrée : queries = [[5,5],[4,4],[3,3]], k = 1
Sortie : [10,8,6]
Explication :

Après queries[0], il y a un obstacle à la distance 10.
Après queries[1], il y a des obstacles aux distances 8 et 10.
Après queries[2], il y a des obstacles aux distances 6, 8, et 10.

Contraintes :

1 <= queries.length <= 2 * 10^5
Toutes les queries[i] sont uniques.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

On considère un plan 2D infini.
On donne un entier positif k. On donne également un tableau 2D queries, qui contient les requêtes suivantes :

queries[i] = [x, y] : Construisez un obstacle à la coordonnée (x, y) dans le plan. Il est garanti qu'il n'y a pas d'obstacle à cette coordonnée lorsque cette requête est faite.

Après chaque requête, vous devez trouver la distance du k^ème obstacle le plus proche de l'origine.
Retournez un tableau d'entiers results où results[i] représente le k^ème obstacle le plus proche après la requête i, ou results[i] == -1 s'il y a moins de k obstacles.
Notez qu'au début, il n'y a aucun obstacle nulle part.
La distance d'un obstacle à la coordonnée (x, y) de l'origine est donnée par |x| + |y|.

Exemple 1 :

Entrée : queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Sortie : [-1,7,5,3]
Explication :

Initialement, il y a 0 obstacle.
Après queries[0], il y a moins de 2 obstacles.
Après queries[1], il y a des obstacles aux distances 3 et 7.
Après queries[2], il y a des obstacles aux distances 3, 5, et 7.
Après queries[3], il y a des obstacles aux distances 3, 3, 5, et 7.

Exemple 2 :

Entrée : queries = [[5,5],[4,4],[3,3]], k = 1
Sortie : [10,8,6]
Explication :

Après queries[0], il y a un obstacle à la distance 10.
Après queries[1], il y a des obstacles aux distances 8 et 10.
Après queries[2], il y a des obstacles aux distances 6, 8, et 10.

Contraintes :

1 <= queries.length <= 2 * 10^5
Toutes les queries[i] sont uniques.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

Il existe un plan 2D infini.
On vous donne un entier positif k. On vous donne également un tableau 2D queries, qui contient les requêtes suivantes :

queries[i] = [x, y] : Construisez un obstacle à la coordonnée (x, y) dans le plan. Il est garanti qu'il n'y a aucun obstacle à cette coordonnée lorsque cette requête est effectuée.

Après chaque requête, vous devez trouver la distance du k^ième obstacle le plus proche de l'origine.
Renvoyer un tableau d'entiers results où results[i] désigne le k^ième obstacle le plus proche après la requête i, ou results[i] == -1 s'il y a moins de k obstacles.
Notez qu'initialement, il n'y a aucun obstacle nulle part.
La distance d'un obstacle à la coordonnée (x, y) de l'origine est donnée par |x| + |y|.

Exemple 1 :

Entrée : queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Sortie : [-1,7,5,3]
Explication :

Au départ, il y a 0 obstacle.
Après queries [0], il y a moins de 2 obstacles.
Après queries[1], il y a des obstacles aux distances 3 et 7.
Après queries[2], il y a des obstacles aux distances 3, 5 et 7.
Après queries[3], il y a des obstacles aux distances 3, 3, 5 et 7.

Exemple 2 :

Entrée : queries = [[5,5],[4,4],[3,3]], k = 1
Sortie : [10,8,6]
Explication :

Après queries[0], il y a un obstacle à la distance 10.
Après queries[1], il y a des obstacles aux distances 8 et 10.
Après queries[2], il y a des obstacles aux distances 6, 8 et 10.

Contraintes :

1 <= queries.length <= 2 * 10^5
Toutes les queries[i] sont uniques.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5