มีการเลือกตั้งโดยมีผู้สมัคร N หมายเลข 1, 2, \ldots, N มีคะแนนเสียง K ซึ่งบางส่วนได้รับการนับแล้ว
จนถึงตอนนี้ ผู้สมัคร i ได้รับคะแนนโหวต A_i
หลังจากนับบัตรลงคะแนนทั้งหมดแล้ว ผู้สมัคร i (1\leq i\leq N) จะได้รับเลือกตั้งก็ต่อเมื่อจํานวนผู้สมัครที่ได้รับคะแนนเสียงมากกว่าพวกเขาน้อยกว่า M  อาจมีผู้สมัครหลายคนที่ได้รับเลือก
สําหรับผู้สมัครแต่ละคน ให้ค้นหาจํานวนคะแนนเสียงเพิ่มเติมขั้นต่ําที่ผู้สมัครต้องการจากบัตรลงคะแนนที่เหลือเพื่อรับประกันชัยชนะโดยไม่คํานึงว่าผู้สมัครคนอื่นจะได้รับคะแนนเสียงอย่างไร
อย่างเป็นทางการ ให้แก้ปัญหาต่อไปนี้สําหรับแต่ละ i = 1,2,\ldots,N
ตรวจสอบว่ามีจํานวนเต็ม X ที่ไม่ใช่ลบไม่เกิน K - \displaystyle{\sum_{i=1}^{N}} A_i เป็นไปตามเงื่อนไขต่อไปนี้หรือไม่  หากมีอยู่ ให้หาจํานวนเต็มขั้นต่ําที่เป็นไปได้

- หากผู้สมัคร i ได้รับคะแนนเสียงเพิ่มเติม X ผู้สมัคร i จะได้รับเลือกเสมอ

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
เอ็นเอ็มเค
A_1 A_2 \ldots A_N

ผลิตภัณฑ์

ให้ C_i เป็นจํานวนคะแนนเสียงขั้นต่ําของผู้สมัครเพิ่มเติมที่ฉันต้องการจากบัตรลงคะแนนที่เหลือเพื่อรับประกันชัยชนะของพวกเขาโดยไม่คํานึงถึงว่าผู้สมัครคนอื่นจะได้รับคะแนนเสียงอย่างไร พิมพ์ C_1, C_2, \ldots C_N คั่นด้วยช่องว่าง
หากผู้สมัคร i ได้รับชัยชนะแล้ว ให้ C_i = 0 ถ้าผู้สมัคร i ไม่สามารถรักษาชัยชนะได้ในกรณีใด ๆ ให้ C_i = -1

ข้อจํากัด

- 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
- ค่าอินพุตทั้งหมดเป็นจํานวนเต็ม

ตัวอย่างข้อมูลเข้า 1

5 2 16
3 1 4 1 5

ตัวอย่างเอาต์พุต 1

2 -1 1 -1 0

นับแล้ว 14 เสียง เหลืออีก 2 เสียง
C ที่ต้องส่งออกคือ (2, -1, 1, -1, 0)  เช่น:

- ผู้สมัครที่ 1 สามารถคว้าชัยชนะได้โดยได้รับคะแนนเสียงเพิ่มอีก 2 คะแนน  ดังนั้น C_1 = 2
- ผู้สมัคร 2 ไม่สามารถ (แม้ว่าพวกเขาจะได้คะแนนเสียงอีก 2 เสียง) เพื่อรักษาชัยชนะของพวกเขา ดังนั้น C_2 = -1

ตัวอย่างข้อมูลเข้า 2

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

ตัวอย่างเอาต์พุต 2

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

มีการเลือกตั้งที่มีผู้สมัคร N คน หมายเลข 1, 2, \ldots, N มีการโหวต K ครั้ง บางส่วนของการโหวตได้ถูกนับจนถึงขณะนี้
จนถึงตอนนี้ ผู้สมัครหมายเลข i ได้รับการโหวต A_i คะแนน
หลังจากนับบัตรทั้งหมดแล้ว ผู้สมัครหมายเลข i (1 \leq i \leq N) จะได้รับการเลือกตั้งก็ต่อเมื่อจำนวนผู้สมัครที่ได้รับการโหวตมากกว่าพวกเขาน้อยกว่า M อาจมีผู้สมัครหลายคนที่ได้รับการเลือกตั้ง
สำหรับผู้สมัครแต่ละคน ค้นหาจำนวนคะแนนเพิ่มขั้นต่ำที่พวกเขาต้องการจากบัตรที่เหลือเพื่อรับประกันการชนะของพวกเขาไม่ว่าจะมีผู้สมัครคนอื่นได้รับโหวตอย่างไร
อย่างเป็นทางการ แก้ปัญหาต่อไปนี้สำหรับแต่ละ i = 1,2,\ldots,N
พิจารณาว่ามีจำนวนเต็มไม่ลบน้อยกว่าหรือเท่ากับ K - \displaystyle{\sum_{i=1}^{N}} A_i ที่เป็นไปตามเงื่อนไขต่อไปนี้หรือไม่ หากมี ให้หาจำนวนเต็มที่น้อยที่สุด

- หากผู้สมัคร i ได้รับการโหวตเพิ่ม X คะแนนแล้ว ผู้สมัคร i จะได้รับเลือกเสมอ

Input

ข้อมูลการเข้าได้รับจาก Standard Input ในรูปแบบดังต่อไปนี้:
N M K
A_1 A_2 \ldots A_N

Output

ให้ C_i เป็นจำนวนการโหวตเพิ่มเติมขั้นต่ำที่ผู้สมัคร i ต้องการจากบัตรที่เหลือเพื่อรับประกันการชนะไม่ว่าจะมีผู้สมัครคนอื่นได้รับการโหวตอย่างไร แสดง C_1, C_2, \ldots, C_N คั่นด้วยช่องว่าง
หากผู้สมัคร i ได้รับการประกันชัยชนะของพวกเขาแล้ว ให้ C_i = 0 หากผู้สมัคร i ไม่สามารถรับประกันชัยชนะในสถานการณ์ใด ๆ ให้ C_i = -1

ข้อจำกัด

- 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
- ค่าทั้งหมดในข้อมูลเข้ามีค่าเป็นจำนวนเต็ม

ตัวอย่างข้อมูลเข้า 1

5 2 16
3 1 4 1 5

ตัวอย่างข้อมูลออก 1

2 -1 1 -1 0

มีการนับ 14 โหวตแล้ว และมีเหลือ 2 โหวต
C ที่จะแสดงคือ (2, -1, 1, -1, 0) สำหรับตัวอย่าง:

- ผู้สมัคร 1 สามารถรับประกันชัยชนะได้โดยการได้รับการโหวตเพิ่ม 2 คะแนน แต่ไม่ใช่โดยการโหวตเพิ่ม 1 คะแนน ดังนั้น C_1 = 2
- ผู้สมัคร 2 ไม่สามารถรับประกันชัยชนะได้ภายใต้อะไรก็ตาม ดังนั้น C_2 = -1

ตัวอย่างInput 2

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

ตัวอย่างOutput 2

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

การเลือกตั้งกำลังดำเนินไปด้วยผู้สมัคร N คน หมายเลข 1, 2, \ldots, N มีคะแนนเสียง K คะแนน ซึ่งบางส่วนได้ถูกนับไปแล้ว
จนถึงขณะนี้ ผู้สมัคร i ได้รับคะแนนเสียง A_i คะแนน
หลังจากนับคะแนนเสียงทั้งหมดแล้ว ผู้สมัคร i (1 \leq i \leq N) จะได้รับเลือกก็ต่อเมื่อจำนวนผู้สมัครที่ได้รับคะแนนเสียงมากกว่าตนน้อยกว่า M อาจมีผู้สมัครหลายคนได้รับเลือก
สำหรับผู้สมัครแต่ละคน หาจำนวนคะแนนเสียงเพิ่มเติมขั้นต่ำที่พวกเขาต้องการจากคะแนนเสียงที่เหลือเพื่อรับประกันชัยชนะของพวกเขาโดยไม่คำนึงว่าผู้สมัครคนอื่นจะได้รับคะแนนเสียงอย่างไร
อย่างเป็นทางการ ให้แก้ปัญหาต่อไปนี้สำหรับแต่ละ i = 1,2,\ldots,N
กำหนดว่ามีจำนวนเต็ม X ที่ไม่ลบไม่เกิน K - \displaystyle{\sum_{i=1}^{N}} A_i ที่ตอบสนองเงื่อนไขต่อไปนี้หรือไม่ หากมีอยู่ ให้หาจำนวนเต็มดังกล่าวที่น้อยที่สุดที่เป็นไปได้
- หากผู้สมัคร i ได้รับคะแนนเสียงเพิ่มเติม X คะแนน ผู้สมัคร i จะได้รับเลือกเสมอ

อินพุต

อินพุตได้จากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M K
A_1 A_2 \ldots A_N

เอาต์พุต

ให้ C_i เป็นจำนวนคะแนนเสียงเพิ่มเติมขั้นต่ำที่ผู้สมัคร i ต้องการจากบัตรลงคะแนนที่เหลือเพื่อรับประกันชัยชนะของพวกเขาไม่ว่าผู้สมัครคนอื่นจะได้รับคะแนนเสียงอย่างไรก็ตาม พิมพ์ C_1, C_2, \ldots, C_N คั่นด้วยช่องว่าง
หากผู้สมัคร i ได้รับชัยชนะแล้ว ให้ C_i = 0 หากผู้สมัคร i ไม่สามารถได้รับชัยชนะภายใต้สถานการณ์ใดๆ ให้ C_i = -1
ข้อจำกัด

- 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
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

5 2 16
3 1 4 1 5

ตัวอย่างผลลัพธ์ 1

2 -1 1 -1 0

มีการนับคะแนนเสียงไปแล้ว 14 คะแนน และเหลือคะแนนเสียง 2 คะแนน
C ที่จะส่งออกคือ (2, -1, 1, -1, 0) ตัวอย่างเช่น:

- ผู้สมัคร 1 สามารถรับประกันชัยชนะได้โดยได้รับคะแนนเสียงเพิ่มอีก 2 คะแนน แต่ไม่สามารถรับประกันชัยชนะได้ด้วยการได้รับคะแนนเสียงเพิ่มอีก 1 คะแนน ดังนั้น C_1 = 2
- ผู้สมัคร 2 ไม่สามารถรับประกันชัยชนะได้ (แม้ว่าจะได้คะแนนเพิ่มอีก 2 คะแนน) ดังนั้น C_2 = -1

ตัวอย่างอินพุต 2

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

ตัวอย่างเอาต์พุต 2

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


คุณได้รับการจัดลำดับ P=(P_1,P_2,\dots,P_N) ของ (1,2,\dots,N)
พิจารณาการดำเนินการต่อไปนี้ k\ (k=2,3,\dots,N) สำหรับการเรียงสับเปลี่ยนนี้

- การดำเนินการ k: สำหรับ i=1,2,\dots,k-1 ในลำดับนี้ ถ้า P_i > P_{i+1} ให้สลับค่าขององค์ประกอบที่ i และ (i+1) ของ P

คุณยังได้รับลำดับ A=(A_1,A_2,\dots,A_M)\ (2 \leq A_i \leq N) ที่ไม่ลดลง ซึ่งมีความยาว M
สำหรับ i=1,2,\dots,M แต่ละอัน ให้หาเลขผกผันของ P หลังจากใช้การดำเนินการ A_1, A_2, \dots, A_i ในลำดับนี้

เลขผกผันของลำดับคือเท่าใด

หมายเลขการผกผันของลำดับ x=(x_1,x_2,\dots,x_n) ที่มีความยาว n คือจำนวนคู่ของจำนวนเต็ม (i,j)\ (1\leq i < j \leq n) ที่ x_i > x_j

อินพุต

อินพุตจะกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N
M
A_1 A_2 \dots A_M

เอาต์พุต

พิมพ์ M บรรทัด บรรทัดที่ k ควรมีคำตอบสำหรับโจทย์สำหรับ i=k

ข้อจำกัด

- 2 \leq N \leq 2 \times 10^5
- 1 \leq M \leq 2 \times 10^5
- 2 \leq A_i \leq N
- P คือการเรียงสับเปลี่ยนของ (1,2,\dots,N)
- A_i \leq A_{i+1} สำหรับ i=1,2,\dots,M-1
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

6
3 2 4 1 6 5
2
4 6

ตัวอย่างเอาต์พุต 1

3
1

ขั้นแรก ดำเนินการ 4 ระหว่างนี้ P จะเปลี่ยนแปลงดังนี้: (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) หมายเลขผกผันของ P ในเวลาต่อมาคือ 3
จากนั้นจึงดำเนินการ 6 ซึ่งในที่สุด P จะกลายเป็น (2,1,3,4,5,6) ซึ่งหมายเลขผกผันคือ 1

ตัวอย่างอินพุต 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

ตัวอย่างเอาต์พุต 2

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


คุณได้รับการกำหนดสอง permutation P=(P_1,P_2,\dots,P_N) และ Q=(Q_1,Q_2,\dots,Q_N) ของ (1,2,\dots,N)
ให้เขียนตัวอักษร 0 หรือ 1 ในแต่ละช่องของตาราง N-by-N เพื่อให้เป็นไปตามเงื่อนไขทั้งหมดดังต่อไปนี้:

- ให้ S_i เป็นสตริงที่ได้จากการต่อกันของตัวอักษรในแถวที่ i-th จากคอลัมน์ที่ 1 ถึงคอลัมน์ที่ N ดังนั้น S_{P_1} < S_{P_2} < \dots < S_{P_N} ในลำดับตามตัวอักษร
- ให้ T_i เป็นสตริงที่ได้จากการต่อกันของตัวอักษรในคอลัมน์ที่ i-th จากแถวที่ 1 ถึงแถวที่ N ดังนั้น T_{Q_1} < T_{Q_2} < \dots < T_{Q_N} ในลำดับตามตัวอักษร

สามารถพิสูจน์ได้ว่ากรณีใดๆ ของ P และ Q จะต้องมีวิธีการเขียนตัวอักษรที่เป็นไปตามเงื่อนไขทั้งหมดอย่างน้อยหนึ่งวิธี
"X < Y ในลำดับตามตัวอักษร" หมายความว่าอย่างไร?
สำหรับสตริง X=X_1X_2\dots X_{|X|} และ Y = Y_1Y_2\dots Y_{|Y|}, "X < Y ในลำดับตามตัวอักษร" หมายความว่าหนึ่งในสองข้อต่อไปนี้ถือว่าเป็นจริง
ที่นี่ |X| และ |Y| หมายถึงความยาวของ X และ Y ตามลำดับ

- |X| \lt |Y| และ X_1X_2\ldots X_{|X|} = Y_1Y_2\ldots Y_{|X|}.
- มีจำนวนเต็มหนึ่ง 1 \leq i \leq \min\lbrace |X|, |Y| \rbrace ที่ทำให้ทั้งสองข้อต่อไปนี้เป็นจริง:

- X_1X_2\ldots X_{i-1} = Y_1Y_2\ldots Y_{i-1}
- X_i น้อยกว่า Y_i

Input

อินพุตถูกให้จาก Standard Input ในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N
Q_1 Q_2 \dots Q_N

Output

พิมพ์วิธีการเติมตารางที่เป็นไปตามเงื่อนไขในรูปแบบต่อไปนี้ โดยที่ A_{ij} คือตัวอักษรที่เขียนที่แถว i-t และคอลัมน์ j-th:
A_{11}A_{12}\dots A_{1N}
\vdots
A_{N1}A_{N2}\dots A_{NN}

หากมีหลายวิธีที่จะทำให้เป็นไปตามเงื่อนไข วิธีใดก็ได้จะได้รับการยอมรับ

ข้อจำกัด

- 2 \leq N \leq 500
- P และ Q เป็น permutation ของ (1,2,\dots,N)
- ค่าทั้งหมดในอินพุตเป็นจำนวนเต็ม

ตัวอย่างInput 1

3
1 2 3
2 1 3

ตัวอย่างOutput 1

001
101
110

ในตัวอย่างนี้ S_1=001, S_2=101, S_3=110, และ T_1=011, T_2=001, T_3=110 ดังนั้น S_1 < S_2 < S_3 และ T_2 < T_1 < T_3 ทำให้เป็นไปตามเงื่อนไข

ตัวอย่างInput 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

ตัวอย่างOutput 2

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

คุณจะได้รับการจัดรูปแบบสองแบบคือ P=(P_1,P_2,\dots,P_N) และ Q=(Q_1,Q_2,\dots,Q_N) ของ (1,2,\dots,N)
เขียนอักขระ 0 และ 1 ตัวใดตัวหนึ่งในแต่ละเซลล์ของตาราง N-by-N เพื่อให้ตรงตามเงื่อนไขต่อไปนี้ทั้งหมด:

- ให้ S_i เป็นสตริงที่ได้จากการต่ออักขระในแถวที่ i จากคอลัมน์ที่ 1 ไปยังคอลัมน์ที่ N จากนั้น S_{P_1} < S_{P_2} < \dots < S_{P_N} ตามลำดับตามพจนานุกรม
- ให้ T_i เป็นสตริงที่ได้จากการต่ออักขระในคอลัมน์ที่ i จากแถวที่ 1 ไปยังแถวที่ N จากนั้น T_{Q_1} < T_{Q_2} < \dots < T_{Q_N} ตามลำดับตามพจนานุกรม

สามารถพิสูจน์ได้ว่าสำหรับ P และ Q ใดๆ มีวิธีอย่างน้อยหนึ่งวิธีในการเขียนอักขระที่ตอบสนองเงื่อนไขทั้งหมด
"X < Y ตามลำดับ" หมายความว่าอย่างไร
สำหรับสตริง X=X_1X_2\dots X_{|X|} และ Y = Y_1Y_2\dots Y_{|Y|} "X < Y ตามลำดับ" หมายความว่า 1. หรือ 2. ด้านล่างเป็นจริง
ในที่นี้ |X| และ |Y| แสดงถึงความยาวของ X และ Y ตามลำดับ

- |X| \lt |Y| และ X_1X_2\ldots X_{|X|} = Y_1Y_2\ldots Y_{|X|}
- มีจำนวนเต็ม 1 \leq i \leq \min\lbrace |X|, |Y| \rbrace เพื่อให้ทั้งสองข้อต่อไปนี้เป็นจริง:

- X_1X_2\ldots X_{i-1} = Y_1Y_2\ldots Y_{i-1}
- X_i น้อยกว่า Y_i

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N
Q_1 Q_2 \dots Q_N

เอาต์พุต

พิมพ์วิธีเติมกริดที่ตรงตามเงื่อนไขในรูปแบบต่อไปนี้ โดยที่ A_{ij} คืออักขระที่เขียนในแถวที่ i และคอลัมน์ที่ j:
A_{11}A_{12}\dots A_{1N}
\vdots
A_{N1}A_{N2}\dots A_{NN}

หากมีหลายวิธีในการตอบสนองเงื่อนไข วิธีใดวิธีหนึ่งจะได้รับการยอมรับ
ข้อจำกัด

- 2 \leq N \leq 500
- P และ Q เป็นการเรียงสับเปลี่ยนของ (1,2,\dots,N)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

3
1 2 3
2 1 3

ตัวอย่างเอาต์พุต 1

001
101
110

ในตัวอย่างนี้ S_1=001, S_2=101, S_3=110 และ T_1=011, T_2=001, T_3=110 ดังนั้น S_1 < S_2 < S_3 และ T_2 < T_1 < T_3 จึงเป็นจริง ซึ่งเป็นไปตามเงื่อนไข
ตัวอย่างอินพุต 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

ตัวอย่างเอาต์พุต 2

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


สำหรับสตริง \( S \) และ \( T \) ที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก และสตริง \( X \) ที่ประกอบด้วย 0 และ 1 กำหนดว่าสตริง \( f(S,T,X) \) ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กดังนี้:

- เริ่มต้นด้วยสตริงว่าง สำหรับแต่ละ \( i=1,2,\dots,|X| \) ให้ต่อท้าย \( S \) ถ้าอักขระลำดับที่ \( i \) ของ \( X \) คือ 0 และต่อท้าย \( T \) ถ้าเป็น 1

คุณได้รับสตริง \( S \) ที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก และสตริง \( X \) และ \( Y \) ที่ประกอบด้วย 0 และ 1
จงตัดสินใจว่ามีสตริง \( T \) (ซึ่งสามารถว่างได้) ที่ทำให้ \( f(S,T,X)=f(S,T,Y) \) หรือไม่
คุณมี \( t \) กรณีทดสอบให้แก้ไข

อินพุต

อินพุตให้จาก Standard Input ในรูปแบบดังนี้:
t
\mathrm{case}_1
\vdots
\mathrm{case}_t

แต่ละกรณีให้ในรูปแบบดังนี้:
S
X
Y

เอาต์พุต

พิมพ์ \( t \) บรรทัด บรรทัดที่ \( i \) ควรจะเป็น Yes ถ้ามี \( T \) ที่ทำให้เงื่อนไขเป็นจริงสำหรับกรณีทดสอบที่ \( i \) และ No ถ้าไม่

ข้อจำกัด

- \( 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 \) เป็นสตริงที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
- \( X \) และ \( Y \) เป็นสตริงที่ประกอบด้วย 0 และ 1
- ผลรวมของ \( |S| \) สำหรับทุกกรณีทดสอบในอินพุตเดียวกันไม่เกิน \( 5 \times 10^5 \)
- ผลรวมของ \( |X| \) สำหรับทุกกรณีทดสอบในอินพุตเดียวกันไม่เกิน \( 5 \times 10^5 \)
- ผลรวมของ \( |Y| \) สำหรับทุกกรณีทดสอบในอินพุตเดียวกันไม่เกิน \( 5 \times 10^5 \)

ตัวอย่างอินพุต 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

ตัวอย่างเอาต์พุต 1

Yes
No
No

ด้านล่างนี้ การต่อสตริงจะถูกแทนด้วย +
สำหรับกรณีทดสอบที่ 1 ถ้า \( T=ara \) แล้ว \( f(S,T,X)=S+T=araaraara \) และ \( f(S,T,Y)=T+T+T=araaraara \) ดังนั้น \( f(S,T,X)=f(S,T,Y) \)
สำหรับกรณีที่ 2 และ 3 ไม่มี \( T \) ที่ทำให้เงื่อนไขเป็นจริง

ตัวอย่างอินพุต 2

2
empty
10101
00
empty
11111
111

ตัวอย่างเอาต์พุต 2

Yes
Yes

\( T \) สามารถว่างได้

สำหรับสตริง S และ T ที่ประกอบด้วยอักษรภาษาอังกฤษตัวพิมพ์เล็ก และสตริง X ที่ประกอบด้วย 0 และ 1 ให้กำหนดสตริง f(S,T,X) ที่ประกอบด้วยอักษรภาษาอังกฤษตัวพิมพ์เล็กดังนี้:

- เริ่มต้นด้วยสตริงว่าง สำหรับแต่ละ i=1,2,\dots,|X| ให้เพิ่ม S ลงท้ายหากอักขระตัวที่ i ของ X เป็น 0 และเพิ่ม T ลงท้ายหากเป็น 1

คุณจะได้รับสตริง S ที่ประกอบด้วยอักษรภาษาอังกฤษตัวพิมพ์เล็ก และสตริง X และ Y ที่ประกอบด้วย 0 และ 1
ตรวจสอบว่ามีสตริง T (ที่สามารถว่างเปล่าได้) ที่ทำให้ f(S,T,X)=f(S,T,Y) อยู่หรือไม่
คุณมีกรณีทดสอบ t กรณีที่ต้องแก้ไข
อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
t
\mathrm{case}_1
\vdots
\mathrm{case}_t

แต่ละกรณีจะได้รับในรูปแบบต่อไปนี้:
S
X
Y

เอาต์พุต

พิมพ์ t บรรทัด บรรทัดที่ i ควรมีคำว่า Yes หากมี T ที่ตรงตามเงื่อนไขสำหรับกรณีทดสอบที่ i และไม่มีในกรณีอื่น

ข้อจำกัด

- 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 คือสตริงที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
- X และ Y คือสตริงที่ประกอบด้วย 0 และ 1
- ผลรวมของ |S| ในกรณีทดสอบทั้งหมดในอินพุตเดียวมีค่าไม่เกิน 5 \times 10^5 - ผลรวมของ |X| ในกรณีทดสอบทั้งหมดในอินพุตเดียวมีค่าไม่เกิน 5 \times 10^5
- ผลรวมของ |Y| ในกรณีทดสอบทั้งหมดในอินพุตเดียวมีค่าไม่เกิน 5 \times 10^5

ตัวอย่างอินพุต 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

ตัวอย่างเอาต์พุต 1

Yes
No
No

ด้านล่าง การเชื่อมต่อสตริงจะแสดงโดยใช้ +
สำหรับกรณีทดสอบที่ 1 หาก T=ara ดังนั้น f(S,T,X)=S+T=araaraara และ f(S,T,Y)=T+T+T=araaraara ดังนั้น f(S,T,X)=f(S,T,Y)
สำหรับกรณีทดสอบที่ 2 และที่ 3 ไม่มี T ที่ตรงตามเงื่อนไข
ตัวอย่างอินพุต 2

2
สตริงว่าง
10101
00
สตริงว่าง
11111
111

ตัวอย่างเอาต์พุต 2

Yes
Yes

T สามารถว่างเปล่าได้

สำหรับสตริง S และ T ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กและสตริง X ประกอบด้วย 0 และ 1 กำหนดสตริง f (S, T X) ซึ่งประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กดังต่อไปนี้:

- เริ่มต้นด้วยสตริงที่ว่างเปล่าสำหรับแต่ละ i = 1,2, \dots, |X|, ผนวก S ถึงจุดสิ้นสุดถ้าอักขระ i-th ของ X คือ 0 และต่อท้าย T ไปยังจุดสิ้นสุดถ้ามันคือ 1

คุณจะได้รับสตริง S ซึ่งประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กและสตริง X และ Y ประกอบด้วย 0 และ 1
ตรวจสอบว่ามีสตริง T(ซึ่งอาจว่างเปล่า) เช่นนั้น f(S,T,X) = f(S,T,Y)
คุณมีกรณีทดสอบเพื่อแก้ไข

ป้อนข้อมูล

อินพุตได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
t
\mathrm {case}_1
\vdots
\mathrm {case}_t

แต่ละกรณีจะได้รับในรูปแบบต่อไปนี้:
S
X
Y

เอาท์พุท

พิมพ์บรรทัด t บรรทัด i-th ควรมีใช่ถ้ามี T ที่เป็นไปตามเงื่อนไขสำหรับกรณีทดสอบ i-th และไม่เป็นอย่างอื่น

ข้อ จำกัด

- 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 เป็นสตริงที่ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก
- X และ Y เป็นสตริงประกอบด้วย 0 และ 1
- ผลรวมของ |S| ในทุกกรณีการทดสอบในอินพุตเดียวนั้นมากที่สุด 5 \times 10^5
- ผลรวมของ |X| ในทุกกรณีการทดสอบในอินพุตเดียวนั้นมากที่สุด 5 \times 10^5
- ผลรวมของ |Y| ในทุกกรณีการทดสอบในอินพุตเดียวนั้นมากที่สุด 5 \times 10^5

อินพุตตัวอย่าง 1

3
araara
01
111
araaaa
100100
0010111
abacabac
0
1111

ตัวอย่างเอาท์พุท 1

Yes
No
No

ด้านล่างการเชื่อมต่อสตริงจะแสดงโดยใช้ +
สำหรับกรณีการทดสอบครั้งที่ 1 ถ้า T=ara ดังนั้น f(S,T,X)=S+T=araaraara และ f(S,T,X)=T+T+T=araaraara ดังนั้น f(S,T,X)=f(S,T,Y).
สำหรับกรณีทดสอบที่ 2 และ 3 ไม่มี T ที่เป็นไปตามเงื่อนไข

อินพุตตัวอย่าง 2

2
empty
10101
00
empty
11111
111

ตัวอย่างเอาท์พุท 2

Yes
Yes

T สามารถว่างเปล่า


คุณได้รับการเรียงสับเปลี่ยน P=(P_1,P_2,\dots,P_N) of (1,2,\dots,N)
คุณต้องการทำให้ P_i=i สำหรับทุก i=1,2,\dots,N โดยดำเนินการต่อไปนี้ 0 ครั้งขึ้นไป:

- เลือกจำนวนเต็ม k ที่ทำให้ 1 \leq k \leq N หาก k \geq 2 ให้เรียงลำดับพจน์ที่ 1 ถึง (k-1) ของ P ตามลำดับจากน้อยไปมาก จากนั้น หาก k \leq N-1 ให้เรียงลำดับพจน์ที่ (k+1) ถึง N ของ P ตามลำดับจากน้อยไปมาก

สามารถพิสูจน์ได้ว่าภายใต้ข้อจำกัดของปัญหานี้ เป็นไปได้ที่จะทำให้ P_i=i เป็นจริงสำหรับทุก i=1,2,\dots,N ด้วยจำนวนการดำเนินการจำกัดสำหรับ P ใดๆ ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็น
คุณมีกรณีทดสอบ T ที่ต้องแก้ไข

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
T
\mathrm{case}_1
\vdots
\mathrm{case}_T

แต่ละกรณีจะได้รับในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N

เอาต์พุต

พิมพ์ T บรรทัด บรรทัดที่ i ควรมีคำตอบสำหรับกรณีทดสอบที่ i

ข้อจำกัด

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P คือการเรียงสับเปลี่ยนของ (1,2,\dots,N)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
- ผลรวมของ N ในกรณีทดสอบในอินพุตเดียวมีค่าไม่เกิน 2 \times 10^5

ตัวอย่างอินพุต 1

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

ตัวอย่างเอาต์พุต 1

1
0
2

สำหรับกรณีทดสอบแรก

-
การดำเนินการด้วย k=1 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=2 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=3 ส่งผลให้ P กลายเป็น (1,2,3,4,5)

-
การดำเนินการด้วย k=4 ส่งผลให้ P กลายเป็น (1,2,3,5,4)

-
การดำเนินการด้วย k=5 ส่งผลให้ P กลายเป็น (1,2,3,5,4)
โดยเฉพาะอย่างยิ่ง การดำเนินการด้วย k=3 ส่งผลให้ P เป็นไปตาม P_i=i สำหรับทุก i=1,2,\dots,5 ดังนั้น จำนวนการดำเนินการขั้นต่ำที่จำเป็นคือ 1
สำหรับกรณีทดสอบที่สาม การดำเนินการด้วย k=4 ตามด้วย k=3 ส่งผลให้ P เปลี่ยนเป็น (3,2,1,7,5,6,4) \rightarrow (1,2,3,7,4,5,6) \rightarrow (1,2,3,4,5,6,7)

คุณได้รับการเรียงสับเปลี่ยน P=(P_1,P_2,\dots,P_N) ของ (1,2,\dots,N)
คุณต้องการให้ P_i=i ตอบสนองสำหรับทุก i=1,2,\dots,N โดยดำเนินการต่อไปนี้เป็นศูนย์ครั้งขึ้นไป:

- เลือกจำนวนเต็ม k ที่ทำให้ 1 \leq k \leq N หาก k \geq 2 ให้เรียงลำดับพจน์ที่ 1 ถึง (k-1) ของ P ตามลำดับจากน้อยไปมาก จากนั้น หาก k \leq N-1 ให้เรียงลำดับพจน์ที่ (k+1) ถึง N ของ P ตามลำดับจากน้อยไปมาก

สามารถพิสูจน์ได้ว่าภายใต้ข้อจำกัดของปัญหานี้ เป็นไปได้ที่จะทำให้ P_i=i เป็นจริงสำหรับทุก i=1,2,\dots,N ด้วยจำนวนการดำเนินการจำกัดสำหรับ P ใดๆ ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็น
คุณมีกรณีทดสอบ T ที่ต้องแก้ไข

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
T
\mathrm{case}_1
\vdots
\mathrm{case}_T

แต่ละกรณีจะได้รับในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N

เอาต์พุต

พิมพ์ T บรรทัด บรรทัดที่ i ควรมีคำตอบสำหรับกรณีทดสอบที่ i

ข้อจำกัด

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P คือการเรียงสับเปลี่ยนของ (1,2,\dots,N)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
- ผลรวมของ N ในกรณีทดสอบในอินพุตเดียวมีค่าไม่เกิน 2 \times 10^5

ตัวอย่างอินพุต 1

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

ตัวอย่างเอาต์พุต 1

1
0
2

สำหรับกรณีทดสอบแรก

-
การดำเนินการด้วย k=1 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=2 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=3 ส่งผลให้ P กลายเป็น (1,2,3,4,5)

-
การดำเนินการด้วย k=4 ส่งผลให้ P กลายเป็น (1,2,3,5,4)

-
การดำเนินการด้วย k=5 ส่งผลให้ P กลายเป็น (1,2,3,5,4)
โดยเฉพาะอย่างยิ่ง การดำเนินการด้วย k=3 ส่งผลให้ P เป็นไปตาม P_i=i สำหรับทุก i=1,2,\dots,5 ดังนั้น จำนวนการดำเนินการขั้นต่ำที่จำเป็นคือ 1
สำหรับกรณีทดสอบที่สาม การดำเนินการด้วย k=4 ตามด้วย k=3 ส่งผลให้ P เปลี่ยนเป็น (3,2,1,7,5,6,4) \rightarrow (1,2,3,7,4,5,6) \rightarrow (1,2,3,4,5,6,7)

คุณได้รับการจัดรูปแบบ P=(P_1,P_2,\dots,P_N) ของ (1,2,\dots,N)
คุณต้องการทำให้ P_i=i เป็นจริงสำหรับทุก i=1,2,\dots,N โดยดำเนินการต่อไปนี้ 0 ครั้งขึ้นไป:

- เลือกจำนวนเต็ม k ที่ทำให้ 1 \leq k \leq N หาก k \geq 2 ให้เรียงลำดับพจน์ที่ 1 ถึง (k-1) ของ P ตามลำดับจากน้อยไปมาก จากนั้น หาก k \leq N-1 ให้เรียงลำดับพจน์ที่ (k+1) ถึง N ของ P ตามลำดับจากน้อยไปมาก

สามารถพิสูจน์ได้ว่าภายใต้ข้อจำกัดของปัญหานี้ เป็นไปได้ที่จะทำให้ P_i=i เป็นจริงสำหรับทุก i=1,2,\dots,N ด้วยจำนวนการดำเนินการจำกัดสำหรับ P ใดๆ ค้นหาจำนวนการดำเนินการขั้นต่ำที่จำเป็น
คุณมีกรณีทดสอบ T ที่ต้องแก้ไข
อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
T
\mathrm{case}_1
\vdots
\mathrm{case}_T

แต่ละกรณีจะได้รับในรูปแบบต่อไปนี้:
N
P_1 P_2 \dots P_N

เอาต์พุต

พิมพ์ T บรรทัด บรรทัดที่ i ควรมีคำตอบสำหรับกรณีทดสอบที่ i

ข้อจำกัด

- 1 \leq T \leq 10^5
- 3 \leq N \leq 2 \times 10^5
- P คือการเรียงสับเปลี่ยนของ (1,2,\dots,N)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
- ผลรวมของ N ในกรณีทดสอบในอินพุตเดียวมีค่าไม่เกิน 2 \times 10^5
ตัวอย่างอินพุต 1

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

ตัวอย่างเอาต์พุต 1

1
0
2

สำหรับกรณีทดสอบแรก

-
การดำเนินการด้วย k=1 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=2 ส่งผลให้ P กลายเป็น (2,1,3,4,5)

-
การดำเนินการด้วย k=3 ส่งผลให้ P กลายเป็น (1,2,3,4,5)

-
การดำเนินการด้วย k=4 ส่งผลให้ P กลายเป็น (1,2,3,5,4)

-
การดำเนินการด้วย k=5 ส่งผลให้ P กลายเป็น (1,2,3,5,4)
โดยเฉพาะอย่างยิ่ง การดำเนินการด้วย k=3 ส่งผลให้ P เป็นไปตาม P_i=i สำหรับทุก i=1,2,\dots,5 ดังนั้น จำนวนการดำเนินการขั้นต่ำที่จำเป็นคือ 1
สำหรับกรณีทดสอบที่สาม การดำเนินการด้วย k=4 ตามด้วย k=3 ส่งผลให้ P เปลี่ยนเป็น (3,2,1,7,5,6,4) \rightarrow (1,2,3,7,4,5,6) \rightarrow (1,2,3,4,5,6,7)


ลำดับจำนวนเต็มที่องค์ประกอบที่อยู่ติดกันไม่มีองค์ประกอบใดเหมือนกันเรียกว่าลำดับที่ดี
คุณจะได้รับลำดับที่ดีสองลำดับที่มีความยาว N: A=(A_1,A_2,\dots,A_N) และ B=(B_1,B_2,\dots,B_N) แต่ละองค์ประกอบของ A และ B อยู่ระหว่าง 0 ถึง M-1 รวม
คุณสามารถดำเนินการต่อไปนี้กับ A ได้หลายครั้งเท่าที่ต้องการ อาจเป็นศูนย์ก็ได้:

- เลือกจำนวนเต็ม i ระหว่าง 1 ถึง N รวม แล้วดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:
- ตั้งค่า A_i \leftarrow (A_i + 1) \bmod M
- ตั้งค่า A_i \leftarrow (A_i - 1) \bmod M โดยที่ (-1) \bmod M = M - 1

อย่างไรก็ตาม คุณไม่สามารถดำเนินการที่ทำให้ A ไม่ใช่ลำดับที่ดีอีกต่อไปได้

ตรวจสอบว่าเป็นไปได้หรือไม่ที่จะทำให้ A เท่ากับ B และหากเป็นไปได้ ให้หาจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อทำเช่นนั้น

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

เอาต์พุต

หากไม่สามารถบรรลุเป้าหมายได้ ให้พิมพ์ -1
มิฉะนั้น ให้พิมพ์จำนวนการดำเนินการขั้นต่ำที่จำเป็นเป็นจำนวนเต็ม

ข้อจำกัด

- 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)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
ตัวอย่างอินพุต 1

3 9
2 0 1
4 8 1

ตัวอย่างเอาต์พุต 1

3

คุณสามารถบรรลุเป้าหมายได้ในสามขั้นตอนดังต่อไปนี้:

- กำหนด A_1 \leftarrow (A_1 + 1) \bmod M ตอนนี้ A = (3, 0, 1)
- กำหนด A_2 \leftarrow (A_2 - 1) \bmod M ตอนนี้ A = (3, 8, 1)
- กำหนด A_1 \leftarrow (A_1 + 1) \bmod M ตอนนี้ A = (4, 8, 1)

เป็นไปไม่ได้ที่จะบรรลุเป้าหมายได้ในสองขั้นตอนหรือน้อยกว่านั้น ดังนั้นคำตอบคือ 3
ตัวอย่างเช่น คุณไม่สามารถกำหนด A_2 \leftarrow (A_2 + 1) \bmod M ในการดำเนินการครั้งแรกได้ เพราะจะทำให้ A = (2, 1, 1) ซึ่งไม่ใช่ลำดับที่ดี
ตัวอย่างอินพุต 2

3 9
1 8 2
1 8 2

ตัวอย่างเอาต์พุต 2

0

A และ B อาจเท่ากันตั้งแต่เริ่มต้น

ตัวอย่างอินพุต 3

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

ตัวอย่างเอาต์พุต 3

811

ลำดับจำนวนเต็มที่ไม่มีองค์ประกอบที่อยู่ติดกันสองตัวเท่ากันเรียกว่าลำดับที่ดี
คุณจะได้รับสองลำดับที่ดีของความยาว N: A=(A_1,A_2,\dots,A_N) และ B=(B_1,B_2,\dots,B_N) แต่ละองค์ประกอบของ A และ B อยู่ระหว่าง 0 ถึง M-1 รวม
คุณสามารถดำเนินการต่อไปนี้ได้หลายครั้งอาจเป็นศูนย์:

- เลือกจำนวนเต็ม I ระหว่าง 1 ถึง N รวมและดำเนินการหนึ่งในสิ่งต่อไปนี้:
- Set A_i \leftarrow (A_i + 1) \bmod M.
- Set A_i \leftarrow (A_i - 1) \bmod M. Here, (-1) \bmod M = M - 1.

อย่างไรก็ตามคุณไม่สามารถดำเนินการที่ทำให้ไม่เป็นลำดับที่ดีอีกต่อไป
ตรวจสอบว่าเป็นไปได้ที่จะทำให้เท่ากับ B หรือไม่และหากเป็นไปได้ให้ค้นหาจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการทำเช่นนั้น

ป้อนข้อมูล

อินพุตได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M
A_1 A_2 \dots A_N
B_1 B_2 \dots B_N

เอาท์พุท

หากเป้าหมายไม่สามารถทำได้ให้พิมพ์ -1
มิฉะนั้นให้พิมพ์จำนวนขั้นต่ำของการดำเนินการที่จำเป็นเป็นจำนวนเต็ม

ข้อ จำกัด

- 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)
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

อินพุตตัวอย่าง 1

3 9
2 0 1
4 8 1

ตัวอย่างเอาท์พุท 1

3

คุณสามารถบรรลุเป้าหมายในการดำเนินการสามครั้งดังนี้:

- ตั้งค่า A_1 \ leftarrow (A_1 + 1) \ bmod M. ตอนนี้ A = (3, 0, 1)
- ตั้งค่า A_2 \ leftarrow (A_2 - 1) \ bmod M. ตอนนี้ A = (3, 8, 1)
- ตั้งค่า A_1 \ leftarrow (A_1 + 1) \ bmod M. ตอนนี้ A = (4, 8, 1)

เป็นไปไม่ได้ที่จะบรรลุเป้าหมายในการดำเนินการสองครั้งหรือน้อยกว่าดังนั้นคำตอบคือ 3
ตัวอย่างเช่นคุณไม่สามารถตั้งค่า A_2 \ leftarrow (A_2 + 1) \ bmod m ในการดำเนินการครั้งแรกเพราะมันจะทำให้ A = (2, 1, 1) ซึ่งไม่ใช่ลำดับที่ดี

อินพุตตัวอย่าง 2

3 9
1 8 2
1 8 2

ตัวอย่างเอาท์พุท 2

0

A และ B อาจเท่ากับจุดเริ่มต้น

อินพุตตัวอย่าง 3

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

ตัวอย่างเอาท์พุท 3

811


คุณได้รับจำนวนเต็มบวก N, M, K จำนวนเต็มไม่เป็นลบ C และลำดับจำนวนเต็ม A=(A_1, A_2, \ldots, A_N) ที่มีความยาว N
หา \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M C K
A_1 A_2 \ldots A_N

เอาต์พุต

พิมพ์คำตอบ

ข้อจำกัด

- 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
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

2 5 3 3
1 3

ตัวอย่างเอาต์พุต 1

4

สำหรับ k=0, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3 ดังนั้น \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1
สำหรับ k=1, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1 ดังนั้น \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1 สำหรับ k=2, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4 ดังนั้น \displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
ดังนั้น คำตอบคือ 1+1+2=4 ดังนั้น ให้พิมพ์ 4

ตัวอย่างอินพุต 2

5 4 3 182
0 3 2 1 2

ตัวอย่างเอาต์พุต 2

0

ตัวอย่างอินพุต 3

5 718 651 193855
3 532 44 109 58

ตัวอย่างเอาต์พุต 3

29484897

ให้จำนวนเต็มบวก N, M, K, จำนวนเต็มไม่เป็นลบ C, และลำดับจำนวนเต็ม A=(A_1, A_2, \ldots, A_N) ที่มีความยาว N
จงหา \displaystyle \sum_{k=0}^{K-1}\min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace

Input

อินพุตรับจาก Standard Input ในรูปแบบต่อไปนี้:
N M C K
A_1\ A_2\ \ldots\ A_N

Output

แสดงผลคำตอบ

เงื่อนไข

- 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
- ค่าทุกค่าของอินพุตเป็นจำนวนเต็ม

ตัวอย่างInput 1

2 5 3 3
1 3

ตัวอย่างOutput 1

4

สำหรับ k=0, \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=1 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=3 ดังนั้น \(\displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
สำหรับ k=1\), \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=4 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=1 ดังนั้น \(\displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=1.
สำหรับ k=2\), \lbrace(3k+1)\ \mathrm{mod}\ 5 \rbrace=2 และ \lbrace(3k+3)\ \mathrm{mod}\ 5 \rbrace=4 ดังนั้น \(\displaystyle \min_{1\le i\le N}\lbrace(Ck+A_i)\ \mathrm{mod}\ M \rbrace=2.
ดังนั้น คำตอบคือ 1+1+2=4. ดังนั้น แสดงผล 4.

ตัวอย่างInput 2

5 4 3 182
0 3 2 1 2

ตัวอย่างOutput 2

0

ตัวอย่างInput 3

5 718 651 193855
3 532 44 109 58

ตัวอย่างOutput 3

29484897


มีลำดับของจำนวนเต็ม S ซึ่งมีความยาว N ในตอนแรกทุกองค์ประกอบของ S เป็น 0
นอกจากนี้ยังมีสองลำดับของจำนวนเต็มที่มีความยาว Q: P=(P_1,P_2,\dots,P_Q) และ V=(V_1,V_2,\dots,V_Q)
Snuke ต้องการทำ Q การดำเนินการกับลำดับ S ตามลำดับ การดำเนินการที่ i-th เป็นดังนี้:

- ทำอย่างใดอย่างหนึ่งต่อไปนี้:
- แทนที่แต่ละองค์ประกอบ S_1, S_2, \dots, S_{P_i} ด้วย V_i แต่ก่อนทำการนี้ ถ้ามีองค์ประกอบใน S_1, S_2, \dots, S_{P_i} ที่มีค่ามากกว่า V_i จะทำให้ Snuke ร้องไห้
- แทนที่แต่ละองค์ประกอบ S_{P_i}, S_{P_i+1}, \dots, S_N ด้วย V_i แต่ก่อนทำการนี้ ถ้ามีองค์ประกอบใน S_{P_i}, S_{P_i+1}, \dots, S_N ที่มีค่ามากกว่า V_i จะทำให้ Snuke ร้องไห้

หาจำนวนลำดับของ Q การดำเนินการที่ Snuke สามารถทำได้โดยไม่ร้องไห้ โมดูโล 998244353 ลำดับของการดำเนินการสองอันจะแตกต่างกันก็ต่อเมื่อมี 1 \leq i \leq Q ที่เลือกต่างกันในครั้งที่ i

Input

อินพุตถูกให้จาก Standard Input ในรูปแบบต่อไปนี้:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

Output

พิมพ์คำตอบเป็นจำนวนเต็ม

ข้อจำกัด

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- ค่าของอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างInput 1

8 3
1 8
8 1
2 1

ตัวอย่างOutput 1

1

Snuke สามารถทำการดำเนินการทั้งสามโดยไม่ร้องไห้ดังนี้:

- แทนที่ S_1 ด้วย 8
- แทนที่ S_8 ด้วย 1
- แทนที่ S_2, S_3, \dots, S_8 ด้วย 1

ไม่มีลำดับของการดำเนินการอื่นที่ตรงตามเงื่อนไข ดังนั้นคำตอบคือ 1 ตัวอย่างเช่น หากเขาแทนที่ S_1, S_2, \dots, S_8 ด้วย 8 ในการดำเนินการแรก เขาจะร้องไห้ในครั้งที่สองไม่ว่าจะเลือกทางไหนก็ตาม

ตัวอย่างInput 2

8 3
8 1
1 8
1 2

ตัวอย่างOutput 2

0

ไม่ว่าจะแสดงตัวเลือกการดำเนินการใดในการทำครั้งแรกและครั้งที่สอง เขาจะร้องไห้ในครั้งที่สาม

ตัวอย่างInput 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

ตัวอย่างOutput 3

682155965

อย่าลืมเอาผลลัพธ์โมดูโล 998244353

มีลำดับจำนวนเต็ม S ที่มีความยาว N ในตอนแรกองค์ประกอบทั้งหมดของ S จะเป็น 0
คุณยังได้รับลำดับจำนวนเต็มสองลำดับที่มีความยาว Q: P=(P_1,P_2,\dots,P_Q) และ V=(V_1,V_2,\dots,V_Q)
Snuke ต้องการดำเนินการ Q กับลำดับ S ตามลำดับ การดำเนินการที่ i มีดังต่อไปนี้:

- ดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:
- แทนที่องค์ประกอบแต่ละองค์ประกอบ S_1, S_2, \dots, S_{P_i} ด้วย V_i อย่างไรก็ตาม ก่อนการดำเนินการนี้ หากมีองค์ประกอบระหว่าง S_1, S_2, \dots, S_{P_i} ที่มากกว่า V_i อย่างเคร่งครัด Snuke จะเริ่มร้องไห้
- แทนที่องค์ประกอบแต่ละองค์ประกอบ S_{P_i}, S_{P_i+1}, \dots, S_N ด้วย V_i อย่างไรก็ตาม ก่อนดำเนินการนี้ หากมีองค์ประกอบระหว่าง S_{P_i}, S_{P_i+1}, \dots, S_N ที่มีค่ามากกว่า V_i อย่างเคร่งครัด Snuke จะเริ่มร้องไห้

หาจำนวนลำดับการดำเนินการ Q ที่ Snuke สามารถทำการดำเนินการทั้งหมดได้โดยไม่ต้องร้องไห้ โมดูโล 998244353
ลำดับการดำเนินการสองลำดับจะแยกความแตกต่างได้ก็ต่อเมื่อมี \leq i \leq Q จำนวน 1 ลำดับ ซึ่งการเลือกสำหรับการดำเนินการที่ i แตกต่างกัน

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

เอาต์พุต

พิมพ์คำตอบเป็นจำนวนเต็ม
ข้อจำกัด

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

8 3
1 8
8 1
2 1

ตัวอย่างเอาต์พุต 1

1

Snuke สามารถทำสามขั้นตอนได้โดยไม่ต้องร้องไห้ ดังนี้

- แทนที่ S_1 ด้วย 8
- แทนที่ S_8 ด้วย 1
- แทนที่ S_2, S_3, \dots, S_8 ด้วย 1

ลำดับการดำเนินการอื่นไม่เป็นไปตามเงื่อนไข ดังนั้นคำตอบคือ 1 ตัวอย่างเช่น หากเขาแทนที่ S_1, S_2, \dots, S_8 ด้วย 8 ในการดำเนินการครั้งแรก เขาจะร้องไห้ในการดำเนินการครั้งที่สองโดยไม่คำนึงถึงตัวเลือก
ตัวอย่างอินพุต 2

8 3
8 1
1 8
1 2

ตัวอย่างเอาต์พุต 2

0

ไม่ว่าเขาจะปฏิบัติสองขั้นตอนแรกอย่างไร เขาก็จะต้องร้องไห้ในขั้นตอนที่สาม
ตัวอย่างอินพุต 3

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

ผลลัพธ์ตัวอย่าง 3

682155965

อย่าลืมนับโมดูโล 998244353

มีลำดับจำนวนเต็ม S ที่มีความยาว N เริ่มต้นองค์ประกอบทั้งหมดของ S คือ 0
นอกจากนี้คุณยังได้รับลำดับความยาวจำนวนเต็มสองครั้ง Q: P=(P_1,P_2,\dots,P_Q) และ V=(V_1,V_2,\dots,V_Q)
Snuke ต้องการดำเนินการ Q ในลำดับ S ตามลำดับ การดำเนินการ i-th มีดังนี้:

- ดำเนินการอย่างใดอย่างหนึ่งต่อไปนี้:
- แทนที่แต่ละองค์ประกอบ S_1, S_2, \dots, S_{P_i}  ด้วย V_i อย่างไรก็ตามก่อนการดำเนินการนี้หากมีองค์ประกอบระหว่าง S_1, S_2, \dots, S_{P_i} ซึ่งสูงกว่า V_i อย่างเคร่งครัด Snuke จะเริ่มร้องไห้
- แทนที่แต่ละองค์ประกอบ S_{P_i}, S_{P_i+1}, \dots, S_N ด้วย V_i อย่างไรก็ตามก่อนการดำเนินการนี้หากมีองค์ประกอบระหว่าง S_{P_i}, S_{P_i+1}, \dots, S_N ที่สูงกว่า V_i, snuke จะเริ่มร้องไห้

ค้นหาจำนวนลำดับของการดำเนินการ Q ที่ Snuke สามารถดำเนินการทั้งหมดได้โดยไม่ต้องร้องไห้ Modulo 998244353
การดำเนินการสองลำดับจะแตกต่างกันไปหากมีเพียง 1 \ leq i \ leq Q ซึ่งตัวเลือกสำหรับการดำเนินการ i-th นั้นแตกต่างกัน

ป้อนข้อมูล

อินพุตได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N Q
P_1 V_1
P_2 V_2
\vdots
P_Q V_Q

เอาท์พุท

พิมพ์คำตอบเป็นจำนวนเต็ม

ข้อ จำกัด

- 2 \leq N \leq 5000
- 1 \leq Q \leq 5000
- 1 \leq P_i \leq N
- 1 \leq V_i \leq 10^9
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

อินพุตตัวอย่าง 1

8 3
1 8
8 1
2 1

ตัวอย่างเอาท์พุท 1

1

Snuke สามารถดำเนินการทั้งสามโดยไม่ต้องร้องไห้ดังนี้:

- Replace S_1 with 8
- Replace S_8 with 1
- Replace S_2, S_3, \dots, S_8 with 1

ไม่มีลำดับการดำเนินการอื่น ๆ ที่ตรงกับเงื่อนไขดังนั้นคำตอบคือ 1 ตัวอย่างเช่นถ้าเขาแทนที่ S_1, S_2, \dots, S_8  กับ 8 ในการดำเนินการครั้งแรกเขาจะร้องไห้ในการดำเนินการที่สองโดยไม่คำนึงถึงทางเลือก

อินพุตตัวอย่าง 2

8 3
8 1
1 8
1 2

ตัวอย่างเอาท์พุท 2

0

ไม่ว่าเขาจะดำเนินการสองครั้งแรกเขาจะร้องไห้ในการปฏิบัติการครั้งที่สาม

อินพุตตัวอย่าง 3

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

ตัวอย่างเอาท์พุท 3

682155965

อย่าลืมใช้ นับโมดูโล 998244353


ลำดับจำนวนเต็มที่มีความยาวระหว่าง 1 ถึง N รวมอยู่ด้วย โดยที่แต่ละองค์ประกอบอยู่ระหว่าง 1 ถึง M รวมอยู่ด้วย จะเรียกว่า "ลำดับที่ดี"
คะแนนของลำดับที่ดีถูกกำหนดให้เป็นจำนวนของตัวหารบวกของ X โดยที่ X คือผลคูณขององค์ประกอบในลำดับนั้น
มี \displaystyle \sum_{k=1}^{N}M^k ลำดับที่ดีอยู่ทั้งหมด จงหาผลรวมของคะแนนของลำดับเหล่านั้น โมดูโล 998244353.

Input

ข้อความที่ให้มาจาก Standard Input ในรูปแบบต่อไปนี้::
N M

Output

พิมพ์คำตอบเป็นจำนวนเต็ม

ข้อจำกัด

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- ค่าของข้อมูลนำเข้าทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างInput  1

1 7

ตัวอย่างOutput 1

16

มีลำดับที่ดีทั้งหมดเจ็ดลำดับ: (1),(2),(3),(4),(5),(6),(7) คะแนนของพวกมันคือ 1, 2, 2, 3, 2, 4, 2 ตามลำดับ ดังนั้นคำตอบคือ 1+2+2+3+2+4+2=16.

ตัวอย่างInput 2

3 11

ตัวอย่าง Output 2

16095

ตัวอย่างเช่น (8,11) และ (1,8,2) เป็นลำดับที่ดี นี่คือกระบวนการในการคำนวณคะแนนของพวกเขา:

- ผลคูณของสมาชิกใน (8,11) คือ 8 × 11 = 88. 88 มีตัวหารบวกทั้งหมดแปดตัว: 1, 2, 4, 8, 11, 22, 44, 88 ดังนั้นคะแนนของ (8,11) คือ 8.
- ผลคูณของสมาชิกใน (1,8,2) คือ 1 × 8 × 2 = 16. 16 มีตัวหารบวกทั้งหมดห้าตัว: 1, 2, 4, 8, 16 ดังนั้นคะแนนของ (1,8,2) คือ 5.

ตัวอย่างInput 3

81131 14

ตัวอย่างOutput  3

182955659

อย่าลืมให้ผลลัพธ์อยู่ในรูปแบบโมดูล 998244353.

ลำดับเต็มยาวตั้งแต่ 1 ถึง N (รวม) ที่แต่ละองค์ประกอบอยู่ระหว่าง 1 ถึง M (รวม) เรียกว่าลำดับดี คะแนนของลำดับดีถูกกำหนดเป็นจำนวนตัวหารบวกของ X โดยที่ X คือผลคูณขององค์ประกอบในลำดับนั้น มี \displaystyle \sum_{k=1}^{N}M^k ลำดับดี ค้นหาผลรวมของคะแนนของลำดับทั้งหมดนั้นแบบโมดูลัส 998244353

Input

ข้อมูลนำเข้าได้รับจาก Standard Input ในรูปแบบดังต่อไปนี้:
N M

Output

พิมพ์คำตอบเป็นจำนวนเต็ม

เงื่อนไข

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- ค่าของข้อมูลนำเข้าทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างInput 1

1 7

ตัวอย่างOutput 1

16

มีลำดับดีเจ็ดลำดับ: (1),(2),(3),(4),(5),(6),(7) คะแนนของพวกมันคือ 1,2,2,3,2,4,2 ตามลำดับ ดังนั้นคำตอบคือ 1+2+2+3+2+4+2=16

ตัวอย่างInput 2

3 11

ตัวอย่างOutput 2

16095

ตัวอย่างเช่น (8,11) และ (1,8,2) เป็นลำดับดี นี่คือกระบวนการคำนวณคะแนนของพวกมัน:

- ผลคูณขององค์ประกอบใน (8,11) คือ 8 \times 11 = 88 ซึ่งมีตัวหารบวกแปดจำนวน: 1,2,4,8,11,22,44,88 ดังนั้นคะแนนของ (8,11) คือ 8
- ผลคูณขององค์ประกอบใน (1,8,2) คือ 1 \times 8 \times 2 = 16 ซึ่งมีตัวหารบวกห้าจำนวน: 1,2,4,8,16 ดังนั้นคะแนนของ (1,8,2) คือ 5

ตัวอย่างInput 3

81131 14

ตัวอย่างOutput 3

182955659

อย่าลืมให้ผลลัพธ์แบบโมดูลัส 998244353

ลำดับจำนวนเต็มที่มีความยาวระหว่าง 1 ถึง N รวมทั้งสิ้น โดยที่แต่ละองค์ประกอบอยู่ระหว่าง 1 ถึง M รวมทั้งสิ้น เรียกว่าลำดับที่ดี
คะแนนของลำดับที่ดีถูกกำหนดให้เป็นจำนวนตัวหารบวกของ X โดยที่ X คือผลคูณขององค์ประกอบในลำดับ
มีลำดับที่ดี \displaystyle \sum_{k=1}^{N}M^k ลำดับ จงหาผลรวมของคะแนนของลำดับทั้งหมดเหล่านั้น โมดูโล 998244353

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M

เอาต์พุต

พิมพ์คำตอบเป็นจำนวนเต็ม

ข้อจำกัด

- 1 \leq N \leq 10^{18}
- 1 \leq M \leq 16
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
ตัวอย่างอินพุต 1

1 7

ตัวอย่างเอาต์พุต 1

16

มีลำดับที่ดี 7 ลำดับ ได้แก่ (1),(2),(3),(4),(5),(6),(7) คะแนนคือ 1,2,2,3,2,4,2 ตามลำดับ ดังนั้นคำตอบคือ 1+2+2+3+2+4+2=16

ตัวอย่างอินพุต 2

3 11

ตัวอย่างเอาต์พุต 2

16095

ตัวอย่างเช่น (8,11) และ (1,8,2) เป็นลำดับที่ดี นี่คือกระบวนการคำนวณคะแนน:

- ผลคูณขององค์ประกอบใน (8,11) คือ 8 \times 11 = 88. 88 มีตัวหารบวกแปดตัว: 1,2,4,8,11,22,44,88 ดังนั้นคะแนนของ (8,11) คือ 8
- ผลคูณขององค์ประกอบใน (1,8,2) คือ 1 \times 8 \times 2 = 16. 16 มีตัวหารบวกห้าตัว: 1,2,4,8,16 ดังนั้นคะแนนของ (1,8,2) คือ 5.

ตัวอย่างอินพุต 3

81131 14

ตัวอย่างเอาต์พุต 3

182955659

อย่าลืมนำผลลัพธ์มาโมดูโล 998244353


คุณจะได้รับลำดับจำนวนเต็มที่มีความยาว N: A=(A_1,A_2,\cdots,A_N) และ B=(B_1,B_2,\cdots,B_N) และจำนวนเต็ม K
คุณสามารถดำเนินการต่อไปนี้ได้ 0 ครั้งขึ้นไป

- เลือกจำนวนเต็ม i และ j (1 \leq i,j \leq N)
ที่นี่ |i-j| \leq K ต้องคงค่าไว้
จากนั้นเปลี่ยนค่าของ A_i เป็น A_j

กำหนดว่าเป็นไปได้หรือไม่ที่จะทำให้ A เหมือนกับ B
มีกรณีทดสอบ T กรณีสำหรับแต่ละอินพุต
อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
T
case_1
case_2
\vdots
case_T

แต่ละกรณีทดสอบจะได้รับในรูปแบบต่อไปนี้:
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

เอาต์พุต

สำหรับกรณีทดสอบแต่ละกรณี ให้พิมพ์ Yes หากสามารถทำให้ A เหมือนกับ B ได้ และพิมพ์ No หากทำได้ในกรณีอื่น

ข้อจำกัด

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- ผลรวมของ N ในทุกกรณีทดสอบในแต่ละอินพุตมีค่าไม่เกิน 250000
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
ตัวอย่างอินพุต 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

ตัวอย่างเอาต์พุต 1

Yes
Yes
No
Yes

พิจารณาเคสทดสอบแรก หากเราดำเนินการกับ i=2 และ j=3 ค่าของ A_2 จะเปลี่ยนเป็น A_3=2 ส่งผลให้ A=(1,2,2)

คุณจะได้รับลำดับจำนวนเต็มที่มีความยาว N: A=(A_1,A_2,\cdots,A_N)) และ B=(B_1,B_2,\cdots,B_N) และจำนวนเต็ม K
คุณสามารถดำเนินการต่อไปนี้เป็นศูนย์หรือมากกว่านั้น

- เลือกจำนวนเต็ม i และ j (1 \leq i,j \leq N)
ที่นี่ |i-j| \leq K ต้องถือ
จากนั้นเปลี่ยนค่า A_i เป็น A_j

ตรวจสอบว่าเป็นไปได้หรือNoที่จะทำให้ A เหมือนกับ B
มีกรณีทดสอบสำหรับแต่ละอินพุต

ป้อนข้อมูล

อินพุตได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
T
case_1
case_2
\vdots
case_T

แต่ละกรณีทดสอบจะได้รับในรูปแบบต่อไปนี้:
N K
A_1 A_2 \cdots A_N
B_1 B_2 \cdots B_N

เอาท์พุท

สำหรับกรณีทดสอบแต่ละกรณี พิมพ์ 'Yes' ถ้าเป็นไปได้ที่จะทำให้ A เหมือนกับ B และพิมพ์ 'No' ถ้าNoเป็นไปได้

ข้อ จำกัด

- 1 \leq T \leq 125000
- 1 \leq K < N \leq 250000
- 1 \leq A_i,B_i \leq N
- ผลรวมของ N ในทุกกรณีการทดสอบในแต่ละอินพุตนั้นมากที่สุด 2,50000
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

อินพุตตัวอย่าง 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

ตัวอย่างเอาท์พุท 1

Yes
Yes
No
Yes

พิจารณากรณีทดสอบครั้งแรก
หากเราทำงานกับ i = 2 และ j = 3 ค่าของ A_2 จะถูกเปลี่ยนเป็น A_3 = 2 ส่งผลให้ A = (1,2,2)


หาจำนวนโมดูโล 998244353 ของการเรียงสับเปลี่ยน P=(P_1,P_2,\cdots,P_N) ของ (1,2,\cdots,N) ที่ตอบสนองเงื่อนไข M ต่อไปนี้ทั้งหมด

- เงื่อนไขที่ i: ค่าสูงสุดระหว่าง P_{L_i},P_{L_i+1},\cdots,P_{R_i} ไม่ใช่ P_{X_i}
ในที่นี้ L_i, R_i และ X_i เป็นจำนวนเต็มที่กำหนดไว้ในอินพุต

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

เอาต์พุต

พิมพ์คำตอบ
ข้อจำกัด

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

3 2
1 3 2
1 2 1

ตัวอย่างเอาต์พุต 1

1

มีเพียงการเรียงสับเปลี่ยนเดียวเท่านั้น คือ P=(1,2,3) ที่ตรงตามเงื่อนไข
ตัวอย่างอินพุต 2

5 1
1 1 1

ตัวอย่างเอาต์พุต 2

0

ตัวอย่างอินพุต 3

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

ตัวอย่างเอาต์พุต 3

1598400

ตัวอย่างอินพุต 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

ตัวอย่างเอาต์พุต 4

921467228

หาจำนวนโมดูโล 998244353 ของการเรียงสับเปลี่ยน P=(P_1,P_2,\cdots,P_N) ของ (1,2,\cdots,N) ที่ตอบสนองเงื่อนไข M ต่อไปนี้ทั้งหมด

- เงื่อนไขที่ i: ค่าสูงสุดระหว่าง P_{L_i},P_{L_i+1},\cdots,P_{R_i} ไม่ใช่ P_{X_i}
ในที่นี้ L_i, R_i และ X_i เป็นจำนวนเต็มที่กำหนดไว้ในอินพุต

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N M
L_1 R_1 X_1
L_2 R_2 X_2
\vdots
L_M R_M X_M

เอาต์พุต

พิมพ์คำตอบ

ข้อจำกัด

- 1 \leq N \leq 500
- 1 \leq M \leq 10^5
- 1 \leq L_i \leq X_i \leq R_i \leq N
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

3 2
1 3 2
1 2 1

ตัวอย่างเอาต์พุต 1

1

มีเพียงการเรียงสับเปลี่ยนเดียวเท่านั้น P=(1,2,3) ที่ตรงตามเงื่อนไข

ตัวอย่างอินพุต 2

5 1
1 1 1

ตัวอย่างเอาต์พุต 2

0

ตัวอย่างอินพุต 3

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

ตัวอย่างเอาต์พุต 3

1598400

ตัวอย่างอินพุต 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

ตัวอย่างเอาต์พุต 4

921467228


คุณจะได้รับจํานวนเต็มบวก N และ K
ลําดับจํานวนเต็มที่มีความยาว NK โดยที่แต่ละจํานวนเต็มตั้งแต่ 1 ถึง N ปรากฏ K ครั้ง เรียกว่าลําดับจํานวนเต็มที่ดี
ให้ S เป็นจํานวนลําดับจํานวนเต็มที่ดี
ค้นหาลําดับจํานวนเต็มที่ดีที่ \operatorname{floor}((S+1)/2)-th ตามลําดับพจนานุกรม
ในที่นี้ \operatorname{floor}(x) แสดงถึงจํานวนเต็มที่ใหญ่ที่สุดไม่เกิน x
 ลําดับพจนานุกรมสําหรับลําดับคืออะไร?
ลําดับ S = (S_1,S_2,\ldots,S_{|S|}) มีขนาดเล็กกว่าลําดับ T = (T_1,T_2,\ldots,T_{|T|}) ถ้าอย่างใดอย่างหนึ่งในข้อ 1 หรือ 2 ด้านล่าง
ที่นี่ |S| และ |T| แสดงความยาวของ S และ T ตามลําดับ

-  |S| \lt |T| และ (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|})
- มีจํานวนเต็ม 1 \leq i \leq \min\lbrace |S|, |T| \ rbrace เพื่อให้ทั้งสองต่อไปนี้ถือ:

-  (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
-  S_i (ในเชิงตัวเลข) น้อยกว่า T_i

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N K

ผลิตภัณฑ์

พิมพ์ลําดับจํานวนเต็มที่ต้องการ โดยคั่นองค์ประกอบด้วยช่องว่าง

ข้อจํากัด

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- ค่าอินพุตทั้งหมดเป็นจํานวนเต็ม

ตัวอย่างอินพุต 1

2 2

ตัวอย่างเอาต์พุต 1

1 2 2 1

มีลําดับจํานวนเต็มที่ดีหกลําดับ:

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

ดังนั้นคําตอบคือลําดับที่ 3 ตามลําดับพจนานุกรม (1,2,2,1)

ตัวอย่างอินพุต 2

1 5

ตัวอย่างเอาต์พุต 2

1 1 1 1 1

ตัวอย่างอินพุต 3

6 1

ตัวอย่างเอาต์พุต 3

3 6 5 4 2 1

ตัวอย่างอินพุต 4

3 3

ตัวอย่างเอาต์พุต 4

2 2 2 1 3 3 3 1 1

คุณได้รับจำนวนเต็มบวก N และ K
ลำดับจำนวนเต็มที่มีความยาว NK โดยที่จำนวนเต็มตั้งแต่ 1 ถึง N ปรากฏเท่ากับ K ครั้ง เรียกว่าลำดับจำนวนเต็มที่ดี
ให้ S เป็นจำนวนลำดับจำนวนเต็มที่ดี
หาลำดับจำนวนเต็มที่ดีลำดับที่ \operatorname{floor}((S+1)/2) ในลำดับตามพจนานุกรม
ในที่นี้ \operatorname{floor}(x) แทนจำนวนเต็มที่มากที่สุดที่ไม่เกิน x
ลำดับตามพจนานุกรมของลำดับคืออะไร
ลำดับ S = (S_1,S_2,\ldots,S_{|S|}) มีขนาดเล็กกว่าลำดับ T = (T_1,T_2,\ldots,T_{|T|}) ตามพจนานุกรม หาก 1. หรือ 2. ด้านล่างเป็นจริง
ในที่นี้ |S| และ |T| แทนความยาวของ S และ T ตามลำดับ

- |S| \lt |T| และ (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|})
- มีจำนวนเต็ม 1 \leq i \leq \min\lbrace |S|, |T| \rbrace ที่ทำให้ทั้งสองค่าต่อไปนี้เป็นจริง:

- (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
- S_i มีค่าน้อยกว่า T_i (ในเชิงตัวเลข)

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N K

เอาต์พุต

พิมพ์ลำดับจำนวนเต็มที่ต้องการ โดยคั่นองค์ประกอบด้วยช่องว่าง

ข้อจำกัด

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม
ตัวอย่างอินพุต 1

2 2

ตัวอย่างเอาต์พุต 1

1 2 2 1

มีลำดับจำนวนเต็มที่ดี 6 ลำดับ:

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

ดังนั้น คำตอบคือลำดับที่ 3 ตามลำดับตามพจนานุกรม (1,2,2,1)

ตัวอย่างอินพุต 2

1 5

ตัวอย่างเอาต์พุต 2

1 1 1 1 1

ตัวอย่างอินพุต 3

6 1

ตัวอย่างเอาต์พุต 3

3 6 5 4 2 1

ตัวอย่างอินพุต 4

3 3

ตัวอย่างเอาต์พุต 4

2 2 2 1 3 3 3 1 1

คุณได้รับจำนวนเต็มบวก N และ K
ลำดับจำนวนเต็มยาว NK ที่แต่ละจำนวนเต็มตั้งแต่ 1 ถึง N ปรากฏขึ้น K ครั้งเรียกว่าลำดับจำนวนเต็มที่ดี
ให้ S เป็นจำนวนของลำดับจำนวนเต็มที่ดี
ค้นหาลำดับจำนวนเต็มที่ดีลำดับ \operatorname{floor}((S+1)/2)-th ในลำดับพจนานุกรม
ที่นี่ \operatorname{floor}(x) แทนจำนวนเต็มที่ใหญ่ที่สุดไม่เกิน x
อะไรคือคำสั่งพจนานุกรมสำหรับลำดับ?
ลำดับ S = (S_1,S_2,\ldots,S_{|S|}) มีลำดับพจนานุกรมน้อยกว่าลำดับ T = (T_1,T_2,\ldots,T_{|T|}) ถ้า 1. หรือ 2. ข้างล่างถือว่าเป็นจริง
ที่นี่ |S| และ |T| แทนความยาวของ S และ T ตามลำดับ

-  |S| \lt |T| และ (S_1,S_2,\ldots,S_{|S|}) = (T_1,T_2,\ldots,T_{|S|}).
-  มีจำนวนเต็ม 1 \leq i \leq \min\lbrace |S|, |T| \rbrace ที่ทั้งสองข้อต่อไปนี้เป็นจริง:

-  (S_1,S_2,\ldots,S_{i-1}) = (T_1,T_2,\ldots,T_{i-1})
-  S_i มีค่าน้อยกว่า T_i (ทางตัวเลข)

อินพุต

อินพุตจะได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N K

เอาต์พุต

พิมพ์ลำดับจำนวนเต็มที่ต้องการ โดยให้แต่ละองค์ประกอบแยกกันด้วยช่องว่าง

ข้อจำกัด

- 1 \leq N \leq 500
- 1 \leq K \leq 500
- ค่าของอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

2 2

ตัวอย่างเอาต์พุต 1

1 2 2 1

มีลำดับจำนวนเต็มที่ดีหกแบบ:

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

ดังนั้น คำตอบคือลำดับที่ 3 ในลำดับพจนานุกรม, (1,2,2,1)

ตัวอย่างอินพุต 2

1 5

ตัวอย่างเอาต์พุต 2

1 1 1 1 1

ตัวอย่างอินพุต 3

6 1

ตัวอย่างเอาต์พุต 3

3 6 5 4 2 1

ตัวอย่างอินพุต 4

3 3

ตัวอย่างเอาต์พุต 4

2 2 2 1 3 3 3 1 1


มีต้นไม้ที่มีจุดยอด N จุดซึ่งกำหนดหมายเลขตั้งแต่ 1 ถึง N
ขอบที่ i เชื่อมจุดยอด A_i และ B_i
ในที่นี้ N เป็นเลขคู่ และยิ่งไปกว่านั้น ต้นไม้นี้ยังมีการจับคู่ที่สมบูรณ์แบบ
โดยเฉพาะอย่างยิ่ง สำหรับแต่ละ i (1 \leq i \leq N/2) รับประกันได้ว่า A_i=i \times 2-1 และ B_i=i \times 2
คุณจะทำการดำเนินการต่อไปนี้ N/2 ครั้ง:

- เลือกใบไม้สองใบ (จุดยอดที่มีดีกรีเท่ากับ 1 พอดี) แล้วลบออกจากต้นไม้
ในที่นี้ ต้นไม้หลังจากลบออกแล้วจะต้องมีการจับคู่ที่สมบูรณ์แบบ
ในปัญหานี้ เราถือว่ากราฟที่มีจุดยอดเป็นศูนย์เป็นต้นไม้เช่นกัน

สำหรับการดำเนินการแต่ละครั้ง คะแนนจะถูกกำหนดเป็นระยะห่างระหว่างจุดยอดที่เลือกสองจุด (จำนวนขอบบนเส้นทางธรรมดาที่เชื่อมจุดยอดทั้งสองจุด)
แสดงขั้นตอนหนึ่งที่เพิ่มคะแนนรวมให้สูงสุด สามารถพิสูจน์ได้ว่ามีขั้นตอนในการดำเนินการ N/2 อยู่เสมอภายใต้ข้อจำกัดของปัญหานี้

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

เอาต์พุต

พิมพ์คำตอบในรูปแบบต่อไปนี้:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

ในที่นี้ X_i และ Y_i คือจุดยอดสองจุดที่เลือกในการดำเนินการครั้งที่ i
หากมีคำตอบหลายรายการ คุณสามารถพิมพ์คำตอบใดก็ได้

ข้อจำกัด

- 2 \leq N \leq 250000
- N เป็นเลขคู่ - 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)
- กราฟที่กำหนดเป็นต้นไม้
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

4
1 2
3 4
2 3

ตัวอย่างเอาต์พุต 1

4 1
2 3

ขั้นตอนในเอาต์พุตตัวอย่างเป็นดังนี้:

- การดำเนินการที่ 1: ลบจุดยอด 4 และ 1 ต้นไม้ที่เหลือมีจุดยอด 2 และ 3 และจับคู่ได้อย่างสมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 3
- การดำเนินการที่ 2: ลบจุดยอด 2 และ 3 ต้นไม้ที่เหลือมีจุดยอด 0 จุดและจับคู่ได้อย่างสมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 1
- คะแนนรวมคือ 3 + 1 = 4

ไม่สามารถทำให้คะแนนรวมมากกว่า 4 ได้ ดังนั้นผลลัพธ์นี้จึงช่วยแก้ค่าอินพุตตัวอย่างนี้
ตัวอย่างอินพุต 2

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

ตัวอย่างเอาต์พุต 2

4 8
7 6
5 3
2 1

ตัวอย่างอินพุต 3

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

ตัวอย่างเอาต์พุต 3

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

ตัวอย่างอินพุต 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

ผลลัพธ์ตัวอย่าง 4

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

มีต้นไม้ที่มีจุดยอด N จุดซึ่งกำหนดหมายเลขตั้งแต่ 1 ถึง N
ขอบที่ i เชื่อมจุดยอด A_i และ B_i
ในที่นี้ N เป็นเลขคู่ และยิ่งไปกว่านั้น ต้นไม้นี้ยังมีการจับคู่ที่สมบูรณ์แบบ
โดยเฉพาะอย่างยิ่ง สำหรับแต่ละ i (1 \leq i \leq N/2) รับประกันได้ว่า A_i=i \times 2-1 และ B_i=i \times 2
คุณจะทำการดำเนินการต่อไปนี้ N/2 ครั้ง:

- เลือกใบไม้สองใบ (จุดยอดที่มีดีกรีเท่ากับ 1 พอดี) แล้วลบออกจากต้นไม้
ในที่นี้ ต้นไม้หลังจากลบออกแล้วจะต้องมีการจับคู่ที่สมบูรณ์แบบ
ในปัญหานี้ เราถือว่ากราฟที่มีจุดยอดเป็นศูนย์เป็นต้นไม้เช่นกัน

สำหรับการดำเนินการแต่ละครั้ง คะแนนจะถูกกำหนดเป็นระยะห่างระหว่างจุดยอดที่เลือกสองจุด (จำนวนขอบบนเส้นทางธรรมดาที่เชื่อมจุดยอดทั้งสองจุด)
แสดงขั้นตอนหนึ่งที่เพิ่มคะแนนรวมให้สูงสุด สามารถพิสูจน์ได้ว่ามีขั้นตอนในการดำเนินการ N/2 อยู่เสมอภายใต้ข้อจำกัดของปัญหานี้

อินพุต

อินพุตกำหนดจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

เอาต์พุต

พิมพ์คำตอบในรูปแบบต่อไปนี้:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

ในที่นี้ X_i และ Y_i คือจุดยอดสองจุดที่เลือกในการดำเนินการครั้งที่ i
หากมีคำตอบหลายรายการ คุณสามารถพิมพ์คำตอบใดก็ได้

ข้อจำกัด

- 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)
- กราฟที่กำหนดเป็นต้นไม้
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

ตัวอย่างอินพุต 1

4
1 2
3 4
2 3

ตัวอย่างเอาต์พุต 1

4 1
2 3

ขั้นตอนในเอาต์พุตตัวอย่างเป็นดังนี้:

- การดำเนินการที่ 1: ลบจุดยอด 4 และ 1 ต้นไม้ที่เหลือมีจุดยอด 2 และ 3 และจับคู่ได้อย่างสมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 3
- การดำเนินการที่ 2: ลบจุดยอด 2 และ 3 ต้นไม้ที่เหลือมีจุดยอด 0 จุดและจับคู่ได้อย่างสมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 1
- คะแนนรวมคือ 3 + 1 = 4

ไม่สามารถทำให้คะแนนรวมมากกว่า 4 ได้ ดังนั้นผลลัพธ์นี้จึงช่วยแก้ค่าอินพุตตัวอย่างนี้

ตัวอย่างอินพุต 2

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

ตัวอย่างเอาต์พุต 2

4 8
7 6
5 3
2 1

ตัวอย่างอินพุต 3

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

ตัวอย่างเอาต์พุต 3

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

ตัวอย่างอินพุต 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

ผลลัพธ์ตัวอย่าง 4

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

มีต้นไม้ที่มี N จุดยอดตั้งแต่ 1 ถึง N
เส้นเชื่อม i-th เชื่อมต่อจุดยอด A_I และ B_I
N เป็นเลขคู่และยิ่งไปกว่านั้นต้นไม้นี้มีการจับคู่ที่สมบูรณ์แบบ
โดยเฉพาะสำหรับแต่ละ i (1 \leq i \leq N/2) รับประกันได้ว่า A_i = i \ times 2-1 และ B_i = i \ times 2
คุณจะทำการดำเนินการต่อไปนี้ N/2 ครั้ง:

- เลือกสองจุดยอดที่เป็ใบ (จุดยอดที่มีระดับ 1) และลบออกจากต้นไม้
ที่นี่ต้นไม้หลังการลบจะต้องมีการจับคู่ที่สมบูรณ์แบบ
ในปัญหานี้เราพิจารณาต้นไม้ที่ไม่มีจุดยอดเป็นต้นไม้เช่นกัน

สำหรับการดำเนินการแต่ละครั้งคะแนนของมันจะถูกกำหนดเป็นระยะห่างระหว่างจุดยอดที่เลือกทั้งสอง (จำนวนเส้นเชื่อมบนเส้นทางง่าย ๆ ที่เชื่อมต่อจุดยอดทั้งสอง)
แสดงขั้นตอนหนึ่งที่เพิ่มคะแนนรวมสูงสุด
สามารถพิสูจน์ได้ว่ามีขั้นตอนในการดำเนินการ N/2 ให้เสร็จสมบูรณ์ภายใต้ข้อ จำกัด ของปัญหานี้

ป้อนข้อมูล

อินพุตได้รับจากอินพุตมาตรฐานในรูปแบบต่อไปนี้:
N
A_1 B_1
A_2 B_2
\vdots
A_{N-1} B_{N-1}

เอาท์พุท

พิมพ์โซลูชันในรูปแบบต่อไปนี้:
X_1 Y_1
X_2 Y_2
\vdots
X_{N/2} Y_{N/2}

ที่นี่ X_I และ Y_I เป็นจุดยอดสองจุดที่เลือกในการดำเนินการ ครั้งที่ i
หากมีวิธีแก้ปัญหาหลายอย่างคุณสามารถพิมพ์วิธีแก้ปัญหาใดก็ได้

ข้อ จำกัด

- 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)
- ต้นไม้ที่กำหนดคือต้นไม้
- ค่าอินพุตทั้งหมดเป็นจำนวนเต็ม

อินพุตตัวอย่าง 1

4
1 2
3 4
2 3

ตัวอย่างเอาท์พุท 1

4 1
2 3

ขั้นตอนในเอาต์พุตตัวอย่างมีดังนี้:

- การดำเนินการครั้งที่ 1: ลบจุดยอด 4 และ 1 ต้นไม้ที่เหลือมีจุดยอด 2 และ 3 และการจับคู่ที่สมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 3
- การดำเนินการที่ 2: ลบจุดยอด 2 และ 3 ต้นไม้ที่เหลือมีจุดยอดเป็นศูนย์และการจับคู่ที่สมบูรณ์แบบ คะแนนของการดำเนินการนี้คือ 1
- คะแนนรวมคือ 3 + 1 = 4

มันเป็นไปไม่ได้ที่จะทำให้คะแนนรวมมากกว่า 4 ดังนั้นเอาต์พุตนี้แก้อินพุตตัวอย่างนี้

อินพุตตัวอย่าง 2

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

ตัวอย่างเอาท์พุท 2

4 8
7 6
5 3
2 1

อินพุตตัวอย่าง 3

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

ตัวอย่างเอาท์พุท 3

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

อินพุตตัวอย่าง 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

ตัวอย่างเอาท์พุท 4

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


คุณได้รับจำนวนเต็มบวก n และ target
อาร์เรย์ nums จะสวยงามหากตรงตามเงื่อนไขต่อไปนี้:

nums.length == n
nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่
ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j ในช่วง [0, n - 1] ซึ่ง nums[i] + nums[j] == target

ส่งคืนผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีโมดูโล 10^9 + 7

ตัวอย่างที่ 1:

อินพุต: n = 2, target = 3
เอาต์พุต: 4
คำอธิบาย: เราจะเห็นว่า nums = [1,3] นั้นสวยงาม
- อาร์เรย์ nums มีความยาว n = 2
- อาร์เรย์ nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่ - ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j โดยที่ nums[i] + nums[j] == 3
สามารถพิสูจน์ได้ว่า 4 คือผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีได้

ตัวอย่างที่ 2:

อินพุต: n = 3, เป้าหมาย = 3
เอาต์พุต: 8
คำอธิบาย: เราจะเห็นว่า nums = [1,3,4] นั้นสวยงาม
- อาร์เรย์ nums มีความยาว n = 3
- อาร์เรย์ nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่
- ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j โดยที่ nums[i] + nums[j] == 3
สามารถพิสูจน์ได้ว่า 8 คือผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีได้

ตัวอย่างที่ 3:

อินพุต: n = 1, เป้าหมาย = 1
เอาต์พุต: 1
คำอธิบาย: เราจะเห็นว่า nums = [1] นั้นสวยงาม

ข้อจำกัด:

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

คุณได้รับจำนวนเต็มบวก n และ target
อาร์เรย์ nums จะสวยงามหากตรงตามเงื่อนไขต่อไปนี้:

nums.length == n
nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่
ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j ในช่วง [0, n - 1] ซึ่ง nums[i] + nums[j] == target

ส่งคืนผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีโมดูโล 10^9 + 7

ตัวอย่างที่ 1:

อินพุต: n = 2, target = 3
เอาต์พุต: 4
คำอธิบาย: เราจะเห็นว่า nums = [1,3] นั้นสวยงาม
- อาร์เรย์ nums มีความยาว n = 2
- อาร์เรย์ nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่
- ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j โดยที่ nums[i] + nums[j] == 3
สามารถพิสูจน์ได้ว่า 4 คือผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีได้

ตัวอย่างที่ 2:

อินพุต: n = 3, target = 3
เอาต์พุต: 8
คำอธิบาย: เราจะเห็นว่า nums = [1,3,4] นั้นสวยงาม
- อาร์เรย์ nums มีความยาว n = 3
- อาร์เรย์ nums ประกอบด้วยจำนวนเต็มบวกที่แตกต่างกันเป็นคู่
- ไม่มีดัชนีที่แตกต่างกันสองค่า คือ i และ j โดยที่ nums[i] + nums[j] == 3
สามารถพิสูจน์ได้ว่า 8 คือผลรวมขั้นต่ำที่เป็นไปได้ที่อาร์เรย์ที่สวยงามจะมีได้

ตัวอย่างที่ 3:

อินพุต: n = 1, target = 1
เอาต์พุต: 1
คำอธิบาย: เราจะเห็นว่า nums = [1] นั้นสวยงาม
ข้อจำกัด:

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


คุณได้รับสตริงทวิภาคี \( s \) และจำนวนเต็ม \( k \)
สตริงทวิภาคีจะเป็นไปตามข้อจำกัด \( k \) หากเงื่อนไขต่อไปนี้ข้อใดข้อหนึ่งถือว่าเป็นจริง:

จำนวน '0' ในสตริงต้องไม่เกิน \( k \)
จำนวน '1' ในสตริงต้องไม่เกิน \( k \)

คืนค่าจำนวนเต็มที่แสดงจำนวนสตริงย่อยของ \( s \) ที่เป็นไปตามข้อจำกัด \( k \)

ตัวอย่างที่ 1:

Input: s = "10101", k = 1
Output: 12
คำอธิบาย:
ทุกสตริงย่อยของ \( s \) ยกเว้นสตริงย่อย "1010" , "10101" และ "0101" เป็นไปตามข้อจำกัด \( k \)

ตัวอย่างที่ 2:

Input: s = "1010101", k = 2
Output: 25
คำอธิบาย:
ทุกสตริงย่อยของ \( s \) ยกเว้นสตริงย่อยที่มีความยาวมากกว่า 5 เป็นไปตามข้อจำกัด \( k \)

ตัวอย่างที่ 3:

Input: s = "11111", k = 1
Output: 15
คำอธิบาย:
สตริงย่อยทั้งหมดของ \( s \) เป็นไปตามข้อจำกัด \( k \)

ข้อจำกัด:

1 <= s.length <= 50
1 <= k <= s.length
s[i] เป็น '0' หรือ '1' เสมอ

คุณจะได้รับสตริงไบนารี s และจํานวนเต็ม k
สตริงไบนารีเป็นไปตามข้อจํากัด k-หากเงื่อนไขข้อใดข้อหนึ่งต่อไปนี้ยังคงอยู่:

จํานวน  0' ในสตริงมีมากที่สุด k
จํานวน  1' ในสตริงมีมากที่สุด k

ส่งคืนจํานวนเต็มที่แสดงถึงจํานวนสตริงย่อยของ s ที่ตรงตามข้อจํากัด k

ตัวอย่างที่ 1:

อินพุต: s = "10101", k = 1
เอาท์พุต: 12
การอธิบาย:
ทุกสตริงย่อยของ s ยกเว้นสตริงย่อย "1010", "10101" และ "0101" เป็นไปตามข้อจํากัด k

ตัวอย่างที่ 2:

อินพุต: s = "1010101", k = 2
เอาท์พุต: 25
การอธิบาย:
ทุกสตริงย่อยของ s ยกเว้นสตริงย่อยที่มีความยาวมากกว่า 5 เป็นไปตามข้อจํากัด k

ตัวอย่างที่ 3:

อินพุต: s = "11111", k = 1
เอาท์พุต: 15
การอธิบาย:
สตริงย่อยทั้งหมดของ s เป็นไปตามข้อจํากัด k

ข้อจํากัด:

1 <= s.length <= 50
1 <= k <= s.length
s[i] เป็น '0' หรือ '1'

คุณได้รับสตริงทวิภาคี s และจำนวนเต็ม k
สตริงทวิภาคีจะเป็นไปตามข้อจำกัด k หากเงื่อนไขต่อไปนี้ข้อใดข้อหนึ่งถือว่าเป็นจริง:

จำนวน 0 ในสตริงต้องไม่เกิน k
จำนวน 1 ในสตริงต้องไม่เกิน k

คืนค่าจำนวนเต็มที่แสดงจำนวนสตริงย่อยของ s  ที่เป็นไปตามข้อจำกัด k

ตัวอย่างที่ 1:

Input: s = "10101", k = 1
Output: 12
คำอธิบาย:
ทุกสตริงย่อยของ s  ยกเว้นสตริงย่อย "1010" , "10101" และ "0101" เป็นไปตามข้อจำกัด k

ตัวอย่างที่ 2:

Input: s = "1010101", k = 2
Output: 25
คำอธิบาย:
ทุกสตริงย่อยของ s  ยกเว้นสตริงย่อยที่มีความยาวมากกว่า 5 เป็นไปตามข้อจำกัด k

ตัวอย่างที่ 3:

Input: s = "11111", k = 1
Output: 15
คำอธิบาย:
สตริงย่อยทั้งหมดของ s เป็นไปตามข้อจำกัด k

ข้อจำกัด:

1 <= s.length <= 50
1 <= k <= s.length
s[i] เป็น '0' หรือ '1' เสมอ


นักวิทยาศาสตร์ด้านกีฬาแนวอนาคตได้ให้ energyDrinkA และ energyDrinkB ที่มีความยาวเท่ากัน n แก่คุณ อาร์เรย์เหล่านี้แสดงถึงพลังงานที่เพิ่มขึ้นต่อชั่วโมงที่ได้จากเครื่องดื่มชูกำลัง 2 ชนิดที่แตกต่างกัน คือ A และ B ตามลำดับ
คุณต้องการเพิ่มพลังงานทั้งหมดของคุณให้สูงสุดโดยการดื่มเครื่องดื่มชูกำลัง 1 ชนิดต่อชั่วโมง อย่างไรก็ตาม หากคุณต้องการเปลี่ยนจากการดื่มเครื่องดื่มชูกำลังชนิดใดชนิดหนึ่งไปเป็นอีกชนิดหนึ่ง คุณต้องรอ 1 ชั่วโมงเพื่อทำความสะอาดระบบของคุณ (หมายความว่าคุณจะไม่ได้รับพลังงานเพิ่มขึ้นเลยใน n ชั่วโมงนั้น)
คืนค่าพลังงานรวมสูงสุดที่คุณจะได้รับในอีก n ชั่วโมงข้างหน้า
โปรดทราบว่าคุณสามารถเริ่มดื่มเครื่องดื่มชูกำลังชนิดใดชนิดหนึ่งจาก 2 ชนิดได้

ตัวอย่างที่ 1:

อินพุต: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
เอาต์พุต: 5
คำอธิบาย:
หากต้องการเพิ่มพลังงาน 5 ให้ดื่มเฉพาะเครื่องดื่มชูกำลังชนิด A (หรือชนิด B เท่านั้น)

ตัวอย่างที่ 2:

อินพุต: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
เอาต์พุต: 7
คำอธิบาย:
หากต้องการเพิ่มพลังงาน 7:

ดื่มเครื่องดื่มชูกำลัง A เป็นเวลา 1 ชั่วโมง
เปลี่ยนไปดื่มเครื่องดื่มชูกำลัง B แล้วเราจะสูญเสียพลังงานในชั่วโมงที่ 2
รับพลังงานจากเครื่องดื่ม B ในชั่วโมงที่ 3

ข้อจำกัด:

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

นักวิทยาศาสตร์ด้านกีฬาในอนาคตได้ให้ energyDrinkA และ energyDrinkB ที่มีความยาวเท่ากัน n แก่คุณ อาร์เรย์เหล่านี้แสดงถึงพลังงานที่เพิ่มขึ้นต่อชั่วโมงที่ได้จากเครื่องดื่มชูกำลัง 2 ชนิดที่แตกต่างกัน คือ A และ B ตามลำดับ
คุณต้องการเพิ่มพลังงานทั้งหมดของคุณให้สูงสุดโดยการดื่มเครื่องดื่มชูกำลัง 1 ชนิดต่อชั่วโมง อย่างไรก็ตาม หากคุณต้องการเปลี่ยนจากการดื่มเครื่องดื่มชูกำลังชนิดใดชนิดหนึ่งไปเป็นอีกชนิดหนึ่ง คุณต้องรอ 1 ชั่วโมงเพื่อทำความสะอาดระบบของคุณ (ซึ่งหมายความว่าคุณจะไม่ได้รับพลังงานเพิ่มขึ้นเลยใน n ชั่วโมงนั้น)
คืนค่าพลังงานรวมสูงสุดที่คุณจะได้รับในอีก n ชั่วโมงข้างหน้า
โปรดทราบว่าคุณสามารถเริ่มดื่มเครื่องดื่มชูกำลังชนิดใดชนิดหนึ่งจาก 2 ชนิดได้

ตัวอย่างที่ 1:

อินพุต: energyDrinkA = [1,3,1], energyDrinkB = [3,1,1]
เอาต์พุต: 5
คำอธิบาย:
หากต้องการเพิ่มพลังงาน 5 ให้ดื่มเฉพาะเครื่องดื่มชูกำลังชนิด A (หรือชนิด B เท่านั้น)
ตัวอย่างที่ 2:

อินพุต: energyDrinkA = [4,1,1], energyDrinkB = [1,1,3]
เอาต์พุต: 7
คำอธิบาย:
หากต้องการเพิ่มพลังงาน 7:

ดื่มเครื่องดื่มชูกำลัง A เป็นเวลา 1 ชั่วโมง
เปลี่ยนไปดื่มเครื่องดื่มชูกำลัง B แล้วเราจะสูญเสียพลังงานในชั่วโมงที่ 2
รับพลังงานจากเครื่องดื่ม B ในชั่วโมงที่ 3

ข้อจำกัด:

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


คุณได้รับจำนวนเต็มบวกสองจำนวน n และ k
จำนวนเต็ม x จะถูกเรียกว่า k-palindromic หาก:

x เป็นพาลินโดรม
x หารด้วย k ลงตัว

ให้คืนค่าจำนวนเต็มที่มี n หลัก (ในรูปแบบสตริง) ที่เป็น k-palindromic ที่มีค่ามากที่สุด
โปรดทราบว่าจำนวนเต็มนี้ต้องไม่มีเลขศูนย์นำหน้า

ตัวอย่างที่ 1:

Input: n = 3, k = 5
Output: "595"
คำอธิบาย:
595 เป็นจำนวนเต็ม k-palindromic ที่มี 3 หลักที่ใหญ่ที่สุด

ตัวอย่างที่ 2:

Input: n = 1, k = 4
Output: "8"
คำอธิบาย:
4 และ 8 เป็นจำนวนเต็ม k-palindromic ที่มีหลักเดียวเพียงสองจำนวนเท่านั้น

ตัวอย่างที่ 3:

Input: n = 5, k = 6
Output: "89898"

เงื่อนไข:

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

คุณจะได้รับจำนวนเต็มบวกสองตัว n และ k
จำนวนเต็ม x เรียกว่า k-palindromic ถ้า:

x เป็น palindrome
x หารด้วย k

ส่งคืนจำนวนเต็มที่ใหญ่ที่สุดที่มีตัวเลข n (เป็นสตริง) ที่เป็น k-palindromic
โปรดทราบว่าจำนวนเต็มจะต้องไม่มีศูนย์นำ

ตัวอย่างที่ 1:

อินพุต: n = 3, k = 5
เอาท์พุท: "595"
คำอธิบาย:
595 เป็นจำนวนเต็ม k-palindromic ที่ใหญ่ที่สุดที่มี 3 หลัก

ตัวอย่างที่ 2:

อินพุต: n = 1, k = 4
เอาท์พุท: "8"
คำอธิบาย:
4 และ 8 เป็นจำนวนเต็ม k-palindromic เดียวที่มี 1 หลัก

ตัวอย่างที่ 3:

อินพุต: n = 5, k = 6
เอาท์พุท: "89898"

ข้อ จำกัด :

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

คุณได้รับจำนวนเต็มบวกสองจำนวนคือ n และ k
จำนวนเต็ม x เรียกว่า k-palindromic ถ้า:

x เป็นพาลินโดรม
x หารด้วย k ได้

ส่งคืนจำนวนเต็มที่มากที่สุดที่มี n หลัก (เป็นสตริง) ที่เป็น k-palindromic
โปรดทราบว่าจำนวนเต็มต้องไม่มีเลขศูนย์นำหน้า

ตัวอย่างที่ 1:

อินพุต: n = 3, k = 5
เอาต์พุต: "595"
คำอธิบาย:
595 เป็นจำนวนเต็ม k-palindromic ที่ใหญ่ที่สุดที่มี 3 หลัก

ตัวอย่างที่ 2:

อินพุต: n = 1, k = 4
เอาต์พุต: "8"
คำอธิบาย:
4 และ 8 เป็นจำนวนเต็ม k-palindromic เพียงจำนวนเดียวที่มี 1 หลัก
ตัวอย่างที่ 3:

อินพุต: n = 5, k = 6
เอาต์พุต: "89898"

ข้อจำกัด:

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


คุณได้รับอาร์เรย์ของจำนวนเต็ม nums, จำนวนเต็ม k, และตัวคูณจำนวนเต็ม
คุณจำเป็นต้องดำเนินการ k ครั้งใน nums ในแต่ละการดำเนินการ:

ค้นหาค่าต่ำสุด x ใน nums หากค่าต่ำสุดปรากฏขึ้นหลายครั้ง ให้คุณเลือกอันที่ปรากฏก่อน
แทนที่ค่าต่ำสุดที่เลือก x ด้วย x * multiplier

ส่งคืนอาร์เรย์ของจำนวนเต็มที่แสดงสถานะสุดท้ายของ nums หลังจากทำ k ครั้ง

ตัวอย่างที่ 1:

Input: nums = [2,1,3,5,6], k = 5, multiplier = 2
Output: [8,4,6,5,6]
คำอธิบาย:

| การดำเนินการ       | ผลลัพธ์        |
|---------------------|---------------|
| หลังจากการดำเนินการที่ 1  | [2, 2, 3, 5, 6] |
| หลังจากการดำเนินการที่ 2  | [4, 2, 3, 5, 6] |
| หลังจากการดำเนินการที่ 3  | [4, 4, 3, 5, 6] |
| หลังจากการดำเนินการที่ 4  | [4, 4, 6, 5, 6] |
| หลังจากการดำเนินการที่ 5  | [8, 4, 6, 5, 6] |

ตัวอย่างที่ 2:

Input: nums = [1,2], k = 3, multiplier = 4
Output: [16,8]
คำอธิบาย:

| การดำเนินการ       | ผลลัพธ์      |
|---------------------|-------------|
| หลังจากการดำเนินการที่ 1  | [4, 2]     |
| หลังจากการดำเนินการที่ 2  | [4, 8]     |
| หลังจากการดำเนินการที่ 3  | [16, 8]    |

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums จำนวนเต็ม k และตัวคูณจำนวนเต็ม
คุณต้องดำเนินการ k ครั้งกับ nums ในแต่ละการดำเนินการ:

ค้นหาค่าต่ำสุด x ใน nums หากค่าต่ำสุดเกิดขึ้นหลายครั้ง ให้เลือกค่าที่ปรากฏขึ้นก่อน
แทนที่ค่าต่ำสุดที่เลือก x ด้วยx * ตัวคูณ

ส่งคืนอาร์เรย์จำนวนเต็มที่ระบุสถานะสุดท้ายของ nums หลังจากดำเนินการ k ครั้งทั้งหมด
ตัวอย่างที่ 1:

อินพุต: nums = [2,1,3,5,6], k = 5, multiplier = 2
เอาต์พุต: [8,4,6,5,6]
คำอธิบาย:

การดำเนินการ
ผลลัพธ์

หลังการดำเนินการ 1
[2, 2, 3, 5, 6]

หลังการดำเนินการ 2
[4, 2, 3, 5, 6]

หลังการดำเนินการ 3
[4, 4, 3, 5, 6]

หลังการดำเนินการ 4
[4, 4, 6, 5, 6]

หลังการดำเนินการ 5
[8, 4, 6, 5, 6]

ตัวอย่างที่ 2:

อินพุต: nums = [1,2], k = 3, multiplier = 4
เอาต์พุต: [16,8]
คำอธิบาย:

การดำเนินการ
ผลลัพธ์

หลังการดำเนินการ 1
[4, 2]

หลังการดำเนินการ 2
[4, 8]

หลังการดำเนินการ 3
[16, 8]

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums, จำนวนเต็ม k และตัวคูณจํานวนเต็ม
คุณต้องดําเนินการ k ครั้งกับอาร์เรย์ nums ในแต่ละการดําเนินการ:

ค้นหาค่าต่ําสุด x ใน nums ถ้ามีค่าต่ําสุดเกิดขึ้นหลายครั้ง ให้เลือกค่าที่ปรากฏก่อน
แทนที่ค่าต่ําสุด x ที่เลือกด้วย x * ตัวคูณ

ส่งคืนอาร์เรย์จำนวนเต็มที่แสดงถึงสถานะสุดท้ายของ nums หลังจากดําเนินการ k ทั้งหมด

ตัวอย่างที่ 1:

อินพุต: nums = [2,1,3,5,6], k = 5, multiplier = 2
เอาต์พุต: [8,4,6,5,6]
คำอธิบาย:

การดำเนินการ
ผล

หลังการดำเนินการ 1
[2, 2, 3, 5, 6]

หลังการดำเนินการ 2
[4, 2, 3, 5, 6]

หลังการดำเนินการ 3
[4, 4, 3, 5, 6]

หลังการดำเนินการ 4
[4, 4, 6, 5, 6]

หลังการดำเนินการ 5
[8, 4, 6, 5, 6]

ตัวอย่างที่ 2:

อินพุต: nums = [1,2], k = 3, multiplier = 4
เอาต์พุต: [16,8]
คำอธิบาย

การดำเนินการ
ผล

หลังการดำเนินการ 1
[4, 2]

หลังการดำเนินการ 2
[4, 8]

หลังการดำเนินการ 3
[16, 8]

ข้อจํากัด:

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


คุณจะได้รับอาร์เรย์ nums ที่ประกอบด้วยจำนวนเต็มบวก
ในโจทย์นี้ เราเรียกจำนวนเต็ม x และ y ว่าเกือบเท่ากัน หากจำนวนเต็มทั้งสองสามารถเท่ากันได้หลังจากดำเนินการต่อไปนี้อย่างสูงสุดครั้งเดียว:

เลือก x หรือ y แล้วสลับตัวเลขสองตัวใดก็ได้ภายในตัวเลขที่เลือก

ส่งคืนจำนวนดัชนี i และ j ใน nums โดยที่ i < j โดยที่ nums[i] และ nums[j] เกือบเท่ากัน
โปรดทราบว่าจำนวนเต็มสามารถมีเลขศูนย์นำหน้าได้หลังจากดำเนินการแล้ว
ตัวอย่างที่ 1:

อินพุต: nums = [3,12,30,17,21]
เอาต์พุต: 2
คำอธิบาย:
คู่ขององค์ประกอบที่เกือบเท่ากันคือ:

3 และ 30 หากสลับ 3 และ 0 ใน 30 คุณจะได้ 3
12 และ 21 หากสลับ 1 และ 2 ใน 12 คุณจะได้ 21

ตัวอย่างที่ 2:

อินพุต: nums = [1,1,1,1,1]
เอาต์พุต: 10
คำอธิบาย:
องค์ประกอบทั้งสองในอาร์เรย์เกือบจะเท่ากัน

ตัวอย่างที่ 3:

อินพุต: nums = [123,231]
เอาต์พุต: 0
คำอธิบาย:
เราไม่สามารถสลับตัวเลขสองหลักใดๆ ของ 123 หรือ 231 เพื่อไปถึงอีกตัวหนึ่งได้
ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ nums ซึ่งประกอบด้วยจำนวนเต็มบวก
เราเรียกสองจำนวนเต็ม x และ y ในปัญหานี้เกือบเท่ากันถ้าจำนวนเต็มทั้งสองสามารถเท่ากันหลังจากดำเนินการต่อไปนี้มากที่สุดครั้งเดียว:

เลือก x หรือ y และสลับสองหลักใด ๆ ภายในหมายเลขที่เลือก

ส่งคืนจำนวนดัชนี i และ j ใน nums ที่ i < j เช่นนั้น nums [i] และ nums [j] เกือบเท่ากัน
โปรดทราบว่าได้รับอนุญาตให้จำนวนเต็มมีศูนย์นำหลังจากทำการผ่าตัด

ตัวอย่างที่ 1:

อินพุต: nums= [3,12,30,17,21]
เอาท์พุท: 2
คำอธิบาย:
องค์ประกอบเกือบเท่ากันคือ:

3 และ 30 โดยการสลับ 3 และ 0 ใน 30 คุณจะได้รับ 3
12 และ 21. โดยการสลับ 1 และ 2 ใน 12 คุณจะได้รับ 21

ตัวอย่างที่ 2:

อินพุต: nums = [1,1,1,1,1]
เอาท์พุท: 10
คำอธิบาย:
ทุกองค์ประกอบในอาร์เรย์เกือบเท่ากัน

ตัวอย่างที่ 3:

อินพุต: nums = [123,231]
เอาท์พุท: 0
คำอธิบาย:
เราไม่สามารถสลับตัวเลขสองหลักใด ๆ ที่ 123 หรือ 231 เพื่อไปถึงอื่น ๆ

ข้อ จำกัด :

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

คุณให้ array nums ที่ประกอบด้วยจำนวนเต็มบวก

ในปัญหานี้เราจะเรียกจำนวนเต็มสองจำนวน x และ y ว่าเกือบเท่ากันถ้าทั้งสองจำนวนสามารถกลายเป็นเท่ากันได้หลังจากการดำเนินการดังนี้อย่างมากเพียงหนึ่งครั้ง:

เลือก x หรือ y และสลับเลขโดดใดๆ สองตำแหน่งภายในจำนวนที่เลือก

คืนจำนวน indices i และ j ใน nums ที่ i < j โดยที่ nums[i] และ nums[j] เกือบเท่ากัน
หมายเหตุว่ามีความเป็นไปได้ที่จำนวนเต็มจะมีเลขศูนย์นำหลังจากการดำเนินการ

ตัวอย่างที่ 1:

Input: nums = [3,12,30,17,21]
Output: 2
คำอธิบาย:
คู่ขององค์ประกอบที่เกือบเท่ากันคือ:

3 และ 30. โดยการสลับ 3 และ 0 ใน 30 จะได้ 3
12 และ 21. โดยการสลับ 1 และ 2 ใน 12 จะได้ 21

ตัวอย่างที่ 2:

Input: nums = [1,1,1,1,1]
Output: 10
คำอธิบาย:
ทุกสององค์ประกอบใน array เกือบเท่ากัน

ตัวอย่างที่ 3:

Input: nums = [123,231]
Output: 0
คำอธิบาย:
เราไม่สามารถสลับเลขโดดใดๆ ของ 123 หรือ 231 เพื่อให้ได้อีกอัน

ข้อจำกัด:

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


คุณจะได้รับสตริงสองตัวคือ coordinate1 และ coordinate2 ซึ่งแสดงพิกัดของสี่เหลี่ยมบนกระดานหมากรุกขนาด 8 x 8
ด้านล่างนี้คือกระดานหมากรุกสำหรับการอ้างอิง

คืนค่า true หากสี่เหลี่ยมทั้งสองนี้มีสีเดียวกัน และคืนค่า false หากไม่เป็นเช่นนั้น
พิกัดจะแสดงสี่เหลี่ยมบนกระดานหมากรุกที่ถูกต้องเสมอ พิกัดจะมีตัวอักษรก่อนเสมอ (แสดงถึงคอลัมน์) และตัวเลขหลังเสมอ (แสดงถึงแถว)

ตัวอย่างที่ 1:

อินพุต: coordinate1 = "a1", coordinate2 = "c3"
เอาต์พุต: true
คำอธิบาย:
สี่เหลี่ยมทั้งสองเป็นสีดำ

ตัวอย่างที่ 2:

อินพุต: coordinate1 = "a1", coordinate2 = "h3"
เอาต์พุต: false
คำอธิบาย:
สี่เหลี่ยม "a1" เป็นสีดำ และ "h3" เป็นสีขาว

ข้อจำกัด:

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

คุณจะได้รับสองสตริง, พิกัด 1 และพิกัด 2, เป็นตัวแทนของพิกัดของสี่เหลี่ยมบนกระดานหมากรุก 8 x 8
ด้านล่างนี้เป็นกระดานหมากรุกสำหรับการอ้างอิง

ส่งคืนค่าจริงถ้าสี่เหลี่ยมทั้งสองนี้มีสีเดียวกันและส่งคืนค่าเท็จในกรณีอื่น ๆ
พิกัดจะเป็นตัวแทนของกระดานหมากรุกที่ถูกต้องเสมอ พิกัดจะมีตัวอักษรก่อนเสมอ (ระบุคอลัมน์ของมัน) และหมายเลขที่สอง (ระบุแถวของมัน)

ตัวอย่างที่ 1:

อินพุต: coordinate1 = "a1", coordinate2 = "c3"
เอาท์พุท: จริง
คำอธิบาย:
สี่เหลี่ยมทั้งสองเป็นสีดำ

ตัวอย่างที่ 2:

อินพุต: coordinate1 = "a1", coordinate2 = "h3"
เอาท์พุท: เท็จ
คำอธิบาย:
สี่เหลี่ยม "a1" เป็นสีดำและ "h3" เป็นสีขาว

ข้อ จำกัด :

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


มีระนาบ 2 มิติที่ไม่มีที่สิ้นสุด
คุณได้รับจำนวนเต็มบวก k นอกจากนี้คุณยังได้รับอาร์เรย์ 2 มิติที่ชื่อว่า queries ซึ่งประกอบด้วยคำถามดังต่อไปนี้:

queries[i] = [x, y]: สร้างอุปสรรคที่พิกัด (x, y) ในระนาบ โดยรับประกันว่าจะไม่มีอุปสรรคที่พิกัดนี้เมื่อมีการทำคำถามนี้

หลังจากแต่ละคำถาม คุณต้องหาระยะทางของอุปสรรคที่ใกล้ที่สุดอันดับที่ k จากจุดกำเนิด
ให้คืนค่าเป็นอาร์เรย์จำนวนเต็ม results ซึ่ง results[i] แสดงถึงอุปสรรคที่ใกล้ที่สุดอันดับที่ k หลังจากคำถามที่ i หรือ results[i] == -1 หากมีอุปสรรคไม่ถึง k ตัว
โปรดทราบว่าในตอนเริ่มต้นไม่มีอุปสรรคอยู่ที่ไหนเลย
ระยะทางของอุปสรรคที่ตำแหน่ง (x, y) จากจุดกำเนิดจะคำนวณได้จาก |x| + |y|.

ตัวอย่างที่ 1:

Input: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Output: [-1,7,5,3]
คำอธิบาย:

เริ่มต้นมีอุปสรรค 0 ตัว
หลังจากคำถาม[0] จะมีอุปสรรคไม่ถึง 2 ตัว
หลังจากคำถาม[1] จะมีอุปสรรคที่ระยะทาง 3 และ 7
หลังจากคำถาม[2] จะมีอุปสรรคที่ระยะทาง 3, 5 และ 7
หลังจากคำถาม[3] จะมีอุปสรรคที่ระยะทาง 3, 3, 5 และ 7

ตัวอย่างที่ 2:

Input: queries = [[5,5],[4,4],[3,3]], k = 1
Output: [10,8,6]
คำอธิบาย:

หลังจากคำถาม[0] จะมีอุปสรรคที่ระยะทาง 10.
หลังจากคำถาม[1] จะมีอุปสรรคที่ระยะทาง 8 และ 10.
หลังจากคำถาม[2] จะมีอุปสรรคที่ระยะทาง 6, 8, และ 10.

ข้อจำกัด:

1 <= queries.length <= 2 * 10^5
All queries[i] are unique.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

มีระนาบ 2 มิติที่เป็นอนันต์
คุณได้รับจำนวนเต็มบวก k คุณยังได้รับอาร์เรย์ 2 มิติ queries ซึ่งประกอบด้วยqueriesต่อไปนี้:

queries[i] = [x, y]: สร้างสิ่งกีดขวางที่พิกัด (x, y) ในระนาบ ซึ่งรับประกันว่าจะไม่มีสิ่งกีดขวางที่พิกัดนี้เมื่อมีการสอบถามนี้

หลังจากแต่ละคำถาม คุณต้องหาค่าระยะทางของสิ่งกีดขวางที่ใกล้ที่สุดอันดับที่ k^th จากจุดกำเนิด
คืนค่าอาร์เรย์จำนวนเต็ม results โดยที่ results[i] แสดงถึงสิ่งกีดขวางที่ใกล้ที่สุดอันดับที่ k^th หลังจากคำถามที่ i หรือ results[i] == -1 ถ้ามีสิ่งกีดขวางน้อยกว่า k
โดยเริ่มแรกจะไม่มีสิ่งกีดขวางที่ไหนเลย
ระยะทางของสิ่งกีดขวางที่พิกัด (x, y) จากจุดกำเนิดคือ |x| + |y|

ตัวอย่างที่ 1:

Input: queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2
Output: [-1,7,5,3]
คำอธิบาย:

เริ่มแรกมีสิ่งกีดขวาง 0 ชิ้น
หลังจาก queries[0] มีสิ่งกีดขวางน้อยกว่า 2 ชิ้น
หลังจาก queries[1] มีสิ่งกีดขวางที่ระยะทาง 3 และ 7
หลังจาก queries[2] มีสิ่งกีดขวางที่ระยะทาง 3, 5, และ 7
หลังจาก queries[3] มีสิ่งกีดขวางที่ระยะทาง 3, 3, 5, และ 7

ตัวอย่างที่ 2:

Input: queries = [[5,5],[4,4],[3,3]], k = 1
Output: [10,8,6]
คำอธิบาย:

หลังจาก queries[0] มีสิ่งกีดขวางที่ระยะทาง 10
หลังจาก queries[1] มีสิ่งกีดขวางที่ระยะทาง 8 และ 10
หลังจาก queries[2] มีสิ่งกีดขวางที่ระยะทาง 6, 8, และ 10

ข้อจำกัด:

1 <= queries.length <= 2 * 10^5
All queries[i] are unique.
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5

มีระนาบ 2D ที่ไม่มีที่สิ้นสุด
คุณจะได้รับจำนวนเต็มบวก k นอกจากนี้คุณยังได้รับแบบสอบถาม 2D อาร์เรย์ซึ่งมีการสืบค้นต่อไปนี้:

แบบสอบถาม [i] = [x, y]: สร้างสิ่งกีดขวางที่พิกัด (x, y) ในระนาบ รับประกันว่าไม่มีอุปสรรคที่พิกัดนี้เมื่อมีการสืบค้น

หลังจากการสืบค้นแต่ละครั้งคุณต้องค้นหาระยะทางของอุปสรรคที่ใกล้ที่สุด k^th จากจุดกำเนิด
ส่งคืนผลลัพธ์อาร์เรย์จำนวนเต็มที่ผลลัพธ์ [i] หมายถึงอุปสรรคที่ใกล้ที่สุด k^th หลังจากสอบถาม i หรือผลลัพธ์ [i] == -1 หากมีอุปสรรคน้อยกว่า k
โปรดทราบว่าในขั้นต้นไม่มีอุปสรรคใด ๆ
ระยะทางของสิ่งกีดขวางที่พิกัด (x, y) จากต้นกำเนิดได้รับจาก | x | + | y |

ตัวอย่างที่ 1:

อินพุต: queries = [[1,2], [3,4], [2,3], [-3,0]], k = 2
ผลลัพธ์: [-1,7,5,3]
คำอธิบาย:

เริ่มแรกมีอุปสรรค 0
หลังจากสอบถาม [0] มีอุปสรรคน้อยกว่า 2 อุปสรรค
หลังจากสอบถาม [1] มีอุปสรรคในระยะทาง 3 และ 7
หลังจากสอบถาม [2] มีอุปสรรคในระยะทาง 3, 5 และ 7
หลังจากสอบถาม [3] มีอุปสรรคในระยะทาง 3, 3, 5 และ 7

ตัวอย่างที่ 2:

อินพุต: queries= [[5,5], [4,4], [3,3]], k = 1
เอาท์พุท: [10,8,6]
คำอธิบาย:

หลังจากสอบถาม [0] มีอุปสรรคในระยะทาง 10
หลังจากสอบถาม [1] มีอุปสรรคในระยะทาง 8 และ 10
หลังจากสอบถาม [2] มีอุปสรรคในระยะทาง 6, 8 และ 10

ข้อ จำกัด :

1 <= queries.length <= 2 * 10^5
คำถามทั้งหมด [i] มีเอกลักษณ์
-10^9 <= queries[i][0], queries[i][1] <= 10^9
1 <= k <= 10^5


คุณจะได้รับตารางเมทริกซ์ 2 มิติที่ประกอบด้วยจำนวนเต็มบวก
คุณต้องเลือกเซลล์หนึ่งเซลล์หรือมากกว่านั้นจากเมทริกซ์โดยต้องเป็นไปตามเงื่อนไขต่อไปนี้:

ไม่มีเซลล์ที่เลือกสองเซลล์อยู่ในแถวเดียวกันของเมทริกซ์
ค่าในชุดเซลล์ที่เลือกจะไม่ซ้ำกัน

คะแนนของคุณจะเป็นผลรวมของค่าของเซลล์ที่เลือก
ส่งกลับคะแนนสูงสุดที่คุณสามารถทำได้

ตัวอย่างที่ 1:

อินพุต: grid = [[1,2,3],[4,3,2],[1,1,1]]
เอาต์พุต: 8
คำอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 1, 3 และ 4 ที่มีการระบายสีด้านบน

ตัวอย่างที่ 2:

อินพุต: grid = [[8,7,6],[8,3,2]]
เอาต์พุต: 15
คำอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 7 และ 8 ที่มีการระบายสีด้านบน

ข้อจำกัด:

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

คุณได้รับกริดเมทริกซ์ 2 มิติที่ประกอบด้วยจำนวนเต็มบวก คุณต้องเลือกเซลล์หนึ่งหรือมากกว่าจากเมทริกซ์โดยต้องปฏิบัติตามเงื่อนไขต่อไปนี้:

ไม่มีเซลล์ที่เลือกสองเซลล์อยู่ในแถวเดียวกันของเมทริกซ์
ค่าของเซลล์ที่เลือกจะต้องไม่ซ้ำกัน

คะแนนของคุณจะเป็นผลรวมของค่าของเซลล์ที่เลือก
 คืนค่าคะแนนสูงสุดที่คุณสามารถทำได้

ตัวอย่างที่ 1:

Input: grid = [[1,2,3],[4,3,2],[1,1,1]]
Output: 8
คำอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 1, 3 และ 4 ที่มีสีด้านบนได้

ตัวอย่างที่ 2:

Input: grid = [[8,7,6],[8,3,2]]
Output: 15
คำอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 7 และ 8 ที่มีสีด้านบนได้

ข้อจำกัด:

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

คุณจะได้รับตารางเมทริกซ์ 2 มิติที่ประกอบด้วยจํานวนเต็มบวก
คุณต้องเลือกเซลล์อย่างน้อยหนึ่งเซลล์จากเมทริกซ์ โดยต้องเป็นไปตามเงื่อนไขต่อไปนี้:

ไม่มีเซลล์ที่เลือกสองเซลล์อยู่ในแถวเดียวกันของเมทริกซ์
ค่าในชุดของเซลล์ที่เลือกจะไม่ซ้ํากัน

คะแนนของคุณจะเป็นผลรวมของค่าของเซลล์ที่เลือก
ส่งคืนคะแนนสูงสุดที่คุณสามารถทําได้

ตัวอย่างที่ 1:

อินพุต: grid = [[1,2,3],[4,3,2],[1,1,1]]
เอาท์พุต: 8
การอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 1, 3 และ 4 ที่มีสีด้านบน

ตัวอย่างที่ 2:

อินพุต: grid  = [[8,7,6],[8,3,2]]
เอาท์พุต: 15
การอธิบาย:

เราสามารถเลือกเซลล์ที่มีค่า 7 และ 8 ที่มีสีด้านบน

ข้อจํากัด:

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


คุณได้รับอาร์เรย์ nums ที่มีจำนวนเต็ม n ตัว และอาร์เรย์ 2 มิติ queries ขนาด q โดยที่ queries[i] = [l_i, r_i] สำหรับแต่ละคำถาม คุณต้องหาคะแนน XOR สูงสุดของซับอาร์เรย์ใด ๆ ของ nums[l_i..r_i] คะแนน XOR ของอาร์เรย์ a จะถูกค้นพบโดยการใช้การดำเนินการต่อไปนี้ซ้ำ ๆ บน a จนกว่าจะเหลือเพียงหนึ่งองค์ประกอบ ซึ่งก็คือคะแนน:

แทนที่ a[i] ด้วย a[i] XOR a[i + 1] พร้อมกันสำหรับทุกดัชนี i ยกเว้นตัวสุดท้าย
ลบองค์ประกอบสุดท้ายของ a

ส่งคืนอาร์เรย์ answer ขนาด q โดยที่ answer[i] คือคำตอบสำหรับคำถาม i.

ตัวอย่างที่ 1:

Input: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Output: [12,60,60]
คำอธิบาย:
ในคำถามแรก nums[0..2] มีซับอาเรย์ 6 ตัวคือ [2], [8], [4], [2, 8], [8, 4], และ [2, 8, 4] โดยแต่ละตัวมีคะแนน XOR ที่แตกต่างกันคือ 2, 8, 4, 10, 12, และ 6 คำตอบสำหรับคำถามนี้คือ 12 ซึ่งเป็นคะแนน XOR ที่ใหญ่ที่สุดในทั้งหมด
ในคำถามที่สอง ซับอาเรย์ของ nums[1..4] ที่มีคะแนน XOR ที่ใหญ่ที่สุดคือ nums[1..4] โดยมีคะแนน 60
ในคำถามที่สาม ซับอาเรย์ของ nums[0..5] ที่มีคะแนน XOR ที่ใหญ่ที่สุดคือ nums[1..4] โดยมีคะแนน 60

ตัวอย่างที่ 2:

Input: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Output: [7,14,11,14,5]
คำอธิบาย:

ดัชนี
nums[l_i..r_i]
คะแนน XOR สูงสุดของซับอาเรย์
คะแนน XOR สูงสุดของซับอาเรย์

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

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

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

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

4
[5, 1]
[5]
5

ข้อจำกัด:

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

คุณได้รับอาร์เรย์ nums ที่มีจำนวนเต็ม n และอาร์เรย์2D queries ที่มีขนาด q โดยที่ queries[i] = [l_i, r_i]
สำหรับแต่ละ query ให้คุณหาค่าคะแนน XOR สูงสุดของ subarray ใดๆ ของ nums[l_i..r_i]
คะแนน XOR ของอาร์เรย์ a ถูกหาจากการใช้การดำเนินการต่อไปนี้ซ้ำๆ บน a จนกว่าจะเหลือเพียงหนึ่งองค์ประกอบ ซึ่งเป็นคะแนนนั้น:

แทนที่ a[i] ด้วย a[i] XOR a[i + 1] สำหรับดัชนี i ทั้งหมด ยกเว้นตัวสุดท้าย
นำตัวสุดท้ายของ a ออก

ส่งคืนอาร์เรย์ answer ที่มีขนาด q โดยที่ answer[i] เป็นคำตอบของ query i

ตัวอย่างที่ 1:

Input: nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]]
Output: [12,60,60]
คำอธิบาย:
ใน query แรก, nums[0..2] มี 6 subarrays [2], [8], [4], [2, 8], [8, 4], และ [2, 8, 4] แต่ละอันมีคะแนน XOR ที่เกี่ยวข้องคือ 2, 8, 4, 10, 12, และ 6 คำตอบของ query นี้คือ 12 ซึ่งเป็นคะแนน XOR ที่ใหญ่ที่สุด
ใน query ที่สอง, subarray ของ nums[1..4] ที่มีคะแนน XOR สูงสุดคือ nums[1..4] ที่มีคะแนน 60
ใน query ที่สาม, subarray ของ nums[0..5] ที่มีคะแนน XOR สูงสุดคือ nums[1..4] ที่มีคะแนน 60

ตัวอย่างที่ 2:

Input: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
Output: [7,14,11,14,5]
คำอธิบาย:

Index
nums[l_i..r_i]
subarray คะแนน XOR สูงสุด
คะแนน XOR subarray สูงสุด

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

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

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

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

4
[5, 1]
[5]
5

Constraints:

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

คุณจะได้รับอาร์เรย์ nums ของจำนวนเต็ม N และแบบสอบถามอาร์เรย์จำนวนเต็ม 2D ที่มีขนาด q โดยที่คิวรี [i] =  [l_i, r_i].
สำหรับการสืบค้นแต่ละครั้งคุณต้องค้นหาคะแนน XOR สูงสุดของ subarray ของ nums [l_i..r_i]
คะแนน XOR ของอาร์เรย์ A ถูกค้นพบโดยการใช้การดำเนินการต่อไปนี้ซ้ำ ๆ ใน a เพื่อให้เพียงองค์ประกอบเดียวที่เหลืออยู่นั่นคือคะแนน:

เปลี่ยน [i] พร้อมกับ [i] XOR a [i + 1] สำหรับดัชนีทั้งหมดที่ฉันยกเว้นอันสุดท้าย
ลบองค์ประกอบสุดท้ายของ

ส่งคืนคำตอบอาร์เรย์ของขนาด q โดยที่คำตอบ [i] คือคำตอบสำหรับการสืบค้น i

ตัวอย่างที่ 1:

อินพุต: nums = [2,8,4,32,16,1], queries = [[0,2], [1,4], [0,5]]
เอาท์พุท: [12,60,60]
คำอธิบาย:
ในแบบสอบถามแรก, nums [0..2] มี 6 subarrays [2], [8], [4], [2, 8], [8, 4] และ [2, 8, 4] คะแนน XOR ที่เกี่ยวข้องกับ 2, 8, 4, 10, 12 และ 6 คำตอบสำหรับการสืบค้นคือ 12 ซึ่งใหญ่ที่สุดของคะแนน XOR ทั้งหมด
ในแบบสอบถามที่สอง subarray ของ nums [1..4] ที่มีคะแนน XOR ที่ใหญ่ที่สุดคือ nums[1..4] ด้วยคะแนน 60
ในแบบสอบถามที่สาม subarray ของ nums [0..5] ที่มีคะแนน XOR ที่ใหญ่ที่สุดคือ nums[1..4] ด้วยคะแนน 60

ตัวอย่างที่ 2:

อินพุต: nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]]
ผลผลิต: [7,14,11,14,5]
คำอธิบาย:

ดัชนี
nums [l_i..r_i]
subarray คะแนน XOR สูงสุด
คะแนน XOR subarray สูงสุด

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

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

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

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

4
[5, 1]
[5]
5

ข้อ จำกัด :

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


คุณจะได้รับวันที่ในรูปแบบสตริงที่แสดงวันที่ในปฏิทินเกรโกเรียนในรูปแบบ yyyy-mm-dd
สามารถเขียน date ในรูปแบบไบนารี่ที่ได้จากการแปลงปี เดือน และวันเป็นรูปแบบไบนารี่โดยไม่มีเลขศูนย์นำหน้า และเขียนเป็นรูปแบบปี-เดือน-วัน
ส่งคืนค่าไบนารี่ของวันที่

ตัวอย่างที่ 1:

อินพุต: date = "2080-02-29"
เอาต์พุต: "100000100000-10-11101"
คำอธิบาย:
100000100000, 10 และ 11101 เป็นรูปแบบไบนารี่ของ 2080, 02 และ 29 ตามลำดับ

ตัวอย่างที่ 2:

อินพุต: date = "1900-01-01"
เอาต์พุต: "11101101100-1-1"
คำอธิบาย:
11101101100, 1 และ 1 คือการแสดงเลขฐานสองของ 1900, 1 และ 1 ตามลำดับ

ข้อจำกัด:

date.length == 10
date[4] == date[7] == '-' และ date[i] อื่นๆ ทั้งหมดเป็นตัวเลข
อินพุตจะสร้างขึ้นเพื่อให้ date แสดงวันที่ตามปฏิทินเกรโกเรียนที่ถูกต้องระหว่างวันที่ 1 มกราคม 1900 ถึงวันที่ 31 ธันวาคม 2100 (รวมทั้งคู่)

คุณจะได้รับวันที่ในรูปแบบสตริงที่แสดงวันที่ในปฏิทินเกรโกเรียนในรูปแบบ yyyy-mm-dd
สามารถเขียน date ในรูปแบบไบนารี่ที่ได้จากการแปลงปี เดือน และวันเป็นรูปแบบไบนารี่โดยไม่มีเลขศูนย์นำหน้า และเขียนเป็นรูปแบบปี-เดือน-วัน

ส่งคืนรูปแบบไบนารี่ของ date

ตัวอย่างที่ 1:

อินพุต: date = "2080-02-29"
เอาต์พุต: "100000100000-10-11101"
คำอธิบาย:
100000100000, 10 และ 11101 เป็นรูปแบบไบนารี่ของ 2080, 02 และ 29 ตามลำดับ
ตัวอย่างที่ 2:

อินพุต: date = "1900-01-01"
เอาต์พุต: "11101101100-1-1"
คำอธิบาย:
11101101100, 1 และ 1 คือการแสดงเลขฐานสองของ 1900, 1 และ 1 ตามลำดับ

ข้อจำกัด:

date.length == 10
date[4] == date[7] == '-' และ date[i] อื่นๆ ทั้งหมดเป็นตัวเลข
อินพุตจะถูกสร้างขึ้นเพื่อให้ date แสดงวันที่ตามปฏิทินเกรโกเรียนที่ถูกต้องระหว่างวันที่ 1 มกราคม 1900 ถึงวันที่ 31 ธันวาคม 2100 (รวมทั้งคู่)


คุณได้รับอาร์เรย์ของจำนวนเต็ม start และจำนวนเต็ม d ซึ่งแสดงถึงช่วงเวลา n ช่วง [start[i], start[i] + d]
คุณจะต้องเลือกจำนวนเต็ม n จำนวน โดยที่จำนวนที่ i^th จะต้องอยู่ในช่วงที่ i^th คะแนนของจำนวนที่เลือกจะถูกกำหนดเป็นค่าแตกต่างสัมบูรณ์ขั้นต่ำระหว่างจำนวนเต็มสองจำนวนที่ถูกเลือก
ส่งคืนคะแนนสูงสุดที่เป็นไปได้ของจำนวนที่เลือก

ตัวอย่างที่ 1:

Input: start = [6,0,3], d = 2
Output: 4
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้สามารถหาได้โดยการเลือกจำนวนเต็ม: 8, 0 และ 4 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือ min(|8 - 0|, |8 - 4|, |0 - 4|) ซึ่งเท่ากับ 4

ตัวอย่างที่ 2:

Input: start = [2,6,13,13], d = 5
Output: 5
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้สามารถหาได้โดยการเลือกจำนวนเต็ม: 2, 7, 13 และ 18 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือ min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) ซึ่งเท่ากับ 5

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็มเริ่มต้นและจำนวนเต็ม d ซึ่งเป็นตัวแทนของช่วง n [เริ่ม [i], เริ่ม [i] + d]
คุณถูกขอให้เลือกจำนวนเต็ม n ที่จำนวนเต็ม i^th ต้องเป็นของช่วง i^th คะแนนของจำนวนเต็มที่เลือกนั้นถูกกำหนดให้เป็นความแตกต่างอย่างแน่นอนขั้นต่ำระหว่างจำนวนเต็มสองอันที่ได้รับการคัดเลือก
ส่งคืนคะแนนสูงสุดที่เป็นไปได้ของจำนวนเต็มที่เลือก

ตัวอย่างที่ 1:

อินพุต: start = [6,0,3], d = 2
เอาท์พุท: 4
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้สามารถทำได้โดยการเลือกจำนวนเต็ม: 8, 0 และ 4 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือขั้นต่ำ (| 8 - 0 |, | 8 - 4 |, | 0 - 4 |) ซึ่งเท่ากับ 4

ตัวอย่างที่ 2:

อินพุต: start = [2,6,13,13], d = 5
เอาท์พุท: 5
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้สามารถทำได้โดยการเลือกจำนวนเต็ม: 2, 7, 13 และ 18 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือขั้นต่ำ (| 2 - 7 |, | 2 - 13 |, | 2 - 18 |, | 7 - 13 |, | 7 - 18 |, | 13 - 18 |) ซึ่งเท่ากับ 5

ข้อ จำกัด :

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็ม start และจำนวนเต็ม d ซึ่งแสดงช่วง n ช่วง [start[i], start[i] + d]
คุณจะถูกขอให้เลือกจำนวนเต็ม n จำนวน โดยที่จำนวนเต็มที่ i^ จะต้องอยู่ในช่วงที่ i^ คะแนนของจำนวนเต็มที่เลือกจะถูกกำหนดเป็นความแตกต่างสัมบูรณ์ขั้นต่ำระหว่างจำนวนเต็มสองตัวที่เลือก
ส่งกลับคะแนนสูงสุดที่เป็นไปได้ของจำนวนเต็มที่เลือก
ตัวอย่างที่ 1:

อินพุต: เริ่มต้น = [6,0,3], d = 2
เอาต์พุต: 4
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้จะได้มาจากการเลือกจำนวนเต็ม: 8, 0 และ 4 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือ min(|8 - 0|, |8 - 4|, |0 - 4|) ซึ่งเท่ากับ 4

ตัวอย่างที่ 2:

อินพุต: เริ่มต้น = [2,6,13,13], d = 5
เอาต์พุต: 5
คำอธิบาย:
คะแนนสูงสุดที่เป็นไปได้จะได้มาจากการเลือกจำนวนเต็ม: 2, 7, 13 และ 18 คะแนนของจำนวนเต็มที่เลือกเหล่านี้คือ min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|) ซึ่งเท่ากับ 5.

ข้อจำกัด:

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


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีความยาว n
เป้าหมายของคุณคือเริ่มต้นที่ดัชนี 0 และไปถึงดัชนี n - 1 คุณสามารถข้ามไปที่ดัชนีที่มากกว่าดัชนีปัจจุบันของคุณได้เท่านั้น
คะแนนสำหรับการข้ามจากดัชนี i ไปยังดัชนี j จะคำนวณได้จาก (j - i) * nums[i]
ส่งคืนคะแนนรวมสูงสุดที่เป็นไปได้เมื่อคุณไปถึงดัชนีสุดท้าย

ตัวอย่างที่ 1:

อินพุต: nums = [1,3,1,5]
เอาต์พุต: 7
คำอธิบาย:
ขั้นแรก ให้ข้ามไปที่ดัชนี 1 จากนั้นจึงข้ามไปที่ดัชนีสุดท้าย คะแนนสุดท้ายคือ 1 * 1 + 2 * 3 = 7

ตัวอย่างที่ 2:

อินพุต: nums = [4,3,1,3,2]
เอาต์พุต: 16
คำอธิบาย:
ข้ามไปที่ดัชนีสุดท้ายโดยตรง คะแนนสุดท้ายคือ 4 * 4 = 16

เงื่อนไข:

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

คุณจะได้รับความยาวอาร์เรย์จำนวนเต็ม n
เป้าหมายของคุณคือเริ่มต้นที่ดัชนี 0 และไปถึงดัชนี n - 1 คุณสามารถข้ามไปยังดัชนีมากกว่าดัชนีปัจจุบันของคุณเท่านั้น
คะแนนสำหรับการกระโดดจากดัชนี i ถึงดัชนี j คำนวณเป็น (j - i) * nums [i]
ส่งคืนคะแนนรวมสูงสุดที่เป็นไปได้เมื่อคุณไปถึงดัชนีสุดท้าย

ตัวอย่างที่ 1:

อินพุต: nums  = [1,3,1,5]
เอาท์พุท: 7
คำอธิบาย:
ก่อนอื่นให้ข้ามไปที่ดัชนี 1 จากนั้นข้ามไปที่ดัชนีสุดท้าย คะแนนสุดท้ายคือ 1 * 1 + 2 * 3 = 7

ตัวอย่างที่ 2:

อินพุต: nums = [4,3,1,3,2]
เอาท์พุท: 16
คำอธิบาย:
ข้ามโดยตรงไปยังดัชนีสุดท้าย คะแนนสุดท้ายคือ 4 * 4 = 16

ข้อ จำกัด :

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


มีกระดานหมากรุกขนาด 50 x 50 ที่มีอัศวินหนึ่งคนและเบี้ยอยู่บ้าง คุณจะได้รับจํานวนเต็มสองจํานวน kx และ ky โดยที่ (kx, ky) หมายถึงตําแหน่งของอัศวิน และตําแหน่งอาร์เรย์ 2 มิติที่ positions[i] = [x_i, y_i] หมายถึงตําแหน่งของเบี้ยบนกระดานหมากรุก
อลิซและบ็อบเล่นเกมแบบเทิร์นเบส โดยที่อลิซไปก่อน ในเทิร์นของผู้เล่นแต่ละคน:

ผู้เล่นเลือกเบี้ยที่ยังคงมีอยู่บนกระดานและจับมันด้วยอัศวินในการเคลื่อนไหวที่น้อยที่สุด โปรดทราบว่าผู้เล่นสามารถเลือกเบี้ยใดก็ได้ แต่อาจไม่ใช่เบี้ยที่สามารถจับได้ในจํานวนการเคลื่อนไหวน้อยที่สุด
ในกระบวนการจับเบี้ยที่เลือกอัศวินอาจผ่านเบี้ยอื่นโดยไม่ต้องจับพวกมัน เฉพาะเบี้ยที่เลือกเท่านั้นที่สามารถจับได้ในเทิร์นนี้

อลิซพยายามเพิ่มผลรวมของจํานวนการเคลื่อนไหวที่ผู้เล่นทั้งสองทําจนกว่าจะไม่มีเบี้ยบนกระดานอีกต่อไป
ส่งคืนจํานวนการเคลื่อนไหวทั้งหมดสูงสุดที่ทําระหว่างเกมที่ Alice สามารถทําได้ โดยสมมติว่าผู้เล่นทั้งสองเล่นได้อย่างเหมาะสมที่สุด
โปรดทราบว่าในการเคลื่อนไหวครั้งเดียว อัศวินหมากรุกมีตําแหน่งที่เป็นไปได้แปดตําแหน่งที่สามารถย้ายไปได้ดังที่แสดงด้านล่าง การเคลื่อนไหวแต่ละครั้งเป็นสองเซลล์ในทิศทางที่สําคัญจากนั้นหนึ่งเซลล์ในทิศทางมุมฉาก

ตัวอย่างที่ 1:

อินพุต: kx = 1, ky = 1, positions= [[0,0]]
เอาท์พุต: 4
การอธิบาย:

อัศวินใช้เวลา 4 ก้าวเพื่อไปถึงเบี้ยที่ (0, 0)

ตัวอย่างที่ 2:

อินพุต: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
เอาท์พุต: 8
การอธิบาย:

อลิซหยิบเบี้ยที่ (2, 2) และจับมันในสองท่า: (0, 2) -> (1, 4) -> (2, 2)
บ็อบเลือกเบี้ยที่ (3, 3) และจับมันในสองท่า: (2, 2) -> (4, 1) -> (3, 3)
อลิซเลือกเบี้ยที่ (1, 1) และจับมันในสี่ท่า: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1)

ตัวอย่างที่ 3:

อินพุต: kx = 0, ky = 0, positions = [[1,2],[2,4]]
เอาท์พุต: 3
การอธิบาย:

อลิซเลือกเบี้ยที่ (2, 4) และจับมันในสองท่า: (0, 0) -> (1, 2) -> (2, 4) โปรดทราบว่าเบี้ยที่ (1, 2) จะไม่ถูกจับ
บ็อบเลือกเบี้ยที่ (1, 2) และจับมันในครั้งเดียว: (2, 4) -> (1, 2)

ข้อจํากัด:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
ทุกตําแหน่ง[i] มีเอกลักษณ์เฉพาะตัว
อินพุตถูกสร้างขึ้นเพื่อให้ positions[i] != [kx, ky] สําหรับ 0 ทั้งหมด <= i < positions.length

มีกระดานหมากรุกขนาด 50 x 50 พร้อมอัศวินหนึ่งตัวและเบี้ยอีกจำนวนหนึ่ง คุณจะได้รับจำนวนเต็มสองจำนวนคือ kx และ ky โดยที่ (kx, ky) หมายถึงตำแหน่งของอัศวิน และตำแหน่งอาร์เรย์ 2 มิติ โดยที่ positions[i] = [x_i, y_i] หมายถึงตำแหน่งของเบี้ยบนกระดานหมากรุก
Alice และ Bob เล่นเกมแบบผลัดตา โดย Alice เป็นคนเริ่มก่อน ในตาของผู้เล่นแต่ละคน:

ผู้เล่นเลือกเบี้ยที่ยังอยู่บนกระดานและจับเบี้ยนั้นด้วยอัศวินด้วยจำนวนการเคลื่อนไหวที่น้อยที่สุด โปรดทราบว่าผู้เล่นสามารถเลือกเบี้ยใดก็ได้ เบี้ยนั้นอาจไม่ใช่เบี้ยที่สามารถจับได้ด้วยจำนวนการเคลื่อนไหวที่น้อยที่สุด
ในกระบวนการจับเบี้ยที่เลือก อัศวินอาจผ่านเบี้ยอื่น ๆ โดยไม่จับเบี้ยเหล่านั้นได้ ในตานี้ สามารถจับเบี้ยที่เลือกได้เท่านั้น

อลิซพยายามเพิ่มจำนวนการเคลื่อนไหวที่ผู้เล่นทั้งสองคนทำได้ให้มากที่สุดจนกว่าจะไม่มีเบี้ยเหลืออยู่บนกระดาน ในขณะที่บ็อบพยายามลดจำนวนการเคลื่อนไหวให้เหลือน้อยที่สุด
คืนจำนวนการเคลื่อนไหวทั้งหมดที่อลิซทำได้ในระหว่างเกม โดยถือว่าผู้เล่นทั้งสองคนเล่นได้อย่างเหมาะสมที่สุด
โปรดทราบว่าในการเคลื่อนที่หนึ่งครั้ง อัศวินหมากรุกสามารถเคลื่อนที่ไปได้ 8 ตำแหน่งตามที่แสดงด้านล่าง การเคลื่อนที่แต่ละครั้งคือ 2 ช่องในทิศทางหลัก จากนั้นจึงเคลื่อนที่ 1 ช่องในทิศทางตั้งฉาก

ตัวอย่างที่ 1:

อินพุต: kx = 1, ky = 1, positions = [[0,0]]
เอาต์พุต: 4
คำอธิบาย:

อัศวินใช้เวลา 4 การเคลื่อนที่เพื่อไปถึงเบี้ยที่ (0, 0)

ตัวอย่างที่ 2:

อินพุต: kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]
เอาต์พุต: 8
คำอธิบาย:

อลิซหยิบเบี้ยที่ (2, 2) และจับมันในสองตา: (0, 2) -> (1, 4) -> (2, 2)
บ็อบหยิบเบี้ยที่ (3, 3) และจับมันในสองตา: (2, 2) -> (4, 1) -> (3, 3)
อลิซหยิบเบี้ยที่ (1, 1) และจับมันในสี่ตา: (3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1)

ตัวอย่างที่ 3:

อินพุต: kx = 0, ky = 0, positions = [[1,2],[2,4]]
เอาต์พุต: 3
คำอธิบาย:

อลิซหยิบเบี้ยที่ (2, 4) และจับมันในสองตา: (0, 0) -> (1, 2) -> (2, 4) โปรดทราบว่าเบี้ยที่ (1, 2) ไม่ได้ถูกจับ
บ็อบหยิบเบี้ยที่ (1, 2) และจับมันในหนึ่งตา: (2, 4) -> (1, 2)

ข้อจำกัด:

0 <= kx, ky <= 49
1 <= positions.length <= 15
positions[i].length == 2
0 <= positions[i][0], positions[i][1] <= 49
positions[i] ทั้งหมดไม่ซ้ำกัน อินพุตจะถูกสร้างขึ้นเพื่อให้ positions[i] != [kx, ky] สำหรับ 0 <= i < positions.length ทั้งหมดที่


คุณจะได้รับอาร์เรย์จำนวนเต็ม a ขนาด 4 และอาร์เรย์จำนวนเต็ม b อีกอาร์เรย์ที่มีขนาดอย่างน้อย 4
คุณต้องเลือกดัชนี 4 ตัวคือ i_0, i_1, i_2 และ i_3 จากอาร์เรย์ b โดยที่ i_0 < i_1 < i_2 < i_3 คะแนนของคุณจะเท่ากับค่า a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3]
ส่งคืนคะแนนสูงสุดที่คุณทำได้

ตัวอย่างที่ 1:

อินพุต: a = [3,2,5,6], b = [2,-6,4,-5,-3,2,-7]
เอาต์พุต: 26
คำอธิบาย:
เราสามารถเลือกดัชนี 0, 1, 2 และ 5 คะแนนจะเป็น 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26

ตัวอย่างที่ 2:

อินพุต: a = [-1,4,5,-2], b = [-5,-1,-3,-2,-4]
เอาต์พุต: -1
คำอธิบาย:
เราสามารถเลือกดัชนี 0, 1, 3 และ 4 คะแนนจะเป็น (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4) = -1

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็ม a ขนาด 4 และอาร์เรย์จำนวนเต็มอื่น b ที่มีขนาดอย่างน้อย 4
คุณต้องเลือกดัชนี 4 ดัชนี i_0, i_1, i_2 และ i_3 จากอาร์เรย์ b เช่น i_0 <i_1 <i_2 <i_3 คะแนนของคุณจะเท่ากับค่า a[0] * b[i_0] + a[1] * b[i_1] + a[2] * b[i_2] + a[3] * b[i_3].
ส่งคืนคะแนนสูงสุดที่คุณสามารถทำได้

ตัวอย่างที่ 1:

อินพุต: a = [3,2,5,6], b = [2, -6,4, -5, -3,2, -7]
เอาท์พุท: 26
คำอธิบาย:
เราสามารถเลือกดัชนี 0, 1, 2 และ 5 คะแนนจะเป็น 3 * 2 + 2 * (-6) + 5 * 4 + 6 * 2 = 26

ตัวอย่างที่ 2:

อินพุต: a = [-1,4,5, -2], b = [-5, -1, -3, -2, -4]
เอาท์พุท: -1
คำอธิบาย:
เราสามารถเลือกดัชนี 0, 1, 3 และ 4 คะแนนจะเป็น (-1) * (-5) + 4 * (-1) + 5 * (-2) + (-2) * (-4 ) = -1

ข้อ จำกัด :

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


คุณได้รับอาร์เรย์ของสตริงที่เรียกว่า words และสตริงที่เรียกว่า target
สตริง x จะถูกเรียกว่าถูกต้องหาก x เป็นพรีฟิกของสตริงใด ๆ ใน words
ให้คืนค่าจำนวนสตริงที่ถูกต้องขั้นต่ำที่สุดที่สามารถนำมารวมกันเพื่อสร้าง target หากไม่สามารถสร้าง target ได้ ให้คืนค่า -1

ตัวอย่างที่ 1:

Input: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
Output: 3
คำอธิบาย:
สตริงเป้าหมายสามารถสร้างขึ้นได้โดยการเชื่อมต่อ:

พรีฟิกความยาว 2 ของ words[1] คือ "aa".
พรีฟิกความยาว 3 ของ words[2] คือ "bcd".
พรีฟิกความยาว 3 ของ words[0] คือ "abc"."

ตัวอย่างที่ 2:

Input: words = ["abababab","ab"], target = "ababaababa"
Output: 2
คำอธิบาย:
สตริงเป้าหมายสามารถสร้างขึ้นได้โดยการเชื่อมต่อ:

ส่วนต้นความยาว 5 ของ words[0] คือ "ababa".
ส่วนต้นความยาว 5 ของ words[0] คือ "ababa".

ตัวอย่างที่ 3:

Input: words = ["abcdef"], target = "xyz"
Output: -1

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
ข้อมูลนำเข้าถูกสร้างขึ้นโดยที่ผลรวมของความยาวของ words[i].length <= 10^5
words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
1 <= target.length <= 5 * 10^3
target ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับอาร์เรย์ของสตริงคำและเป้าหมายของสตริง
สตริง x จะถูกเรียกว่าถูกต้องถ้า x เป็นคำนำหน้าของสตริงใดๆ ในคำ
ส่งคืนจำนวนสตริงที่ถูกต้องขั้นต่ำที่สามารถต่อกันเพื่อสร้างเป้าหมายได้ หากไม่สามารถสร้างเป้าหมายได้ ให้ส่งคืน -1

ตัวอย่างที่ 1:

อินพุต: words = ["abc","aaaaa","bcdef"], target = "aabcdabc"
เอาต์พุต: 3
คำอธิบาย:
สามารถสร้างสตริงเป้าหมายได้โดยการเชื่อม:

คำนำหน้าความยาว 2 ของคำ[1] หรือ "aa"
คำนำหน้าความยาว 3 ของคำ[2] หรือ "bcd"
คำนำหน้าความยาว 3 ของคำ[0] หรือ "abc"

ตัวอย่างที่ 2:

อินพุต: words = ["abababab","ab"], target = "ababaababa"
เอาต์พุต: 2
คำอธิบาย:
สตริงเป้าหมายสามารถสร้างขึ้นได้โดยการต่อกัน:

คำนำหน้าความยาว 5 ของ words[0] หรือที่เรียกว่า "ababa"
คำนำหน้าความยาว 5 ของ words[0] หรือที่เรียกว่า "ababa"

ตัวอย่างที่ 3:

อินพุต: words = ["abcdef"], target = "xyz"
เอาต์พุต: -1

ข้อจำกัด:

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
อินพุตจะถูกสร้างขึ้นโดย sum(words[i].length) <= 10^5
words[i] ประกอบด้วยเฉพาะตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
1 <= target.length <= 5 * 10^3
target ประกอบด้วยเฉพาะตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับอาร์เรย์ของคำสตริงและเป้าหมายสตริง
สตริง x เรียกว่าถูกต้องถ้า x เป็นคำนำหน้าของสตริงใด ๆ ในคำ
ส่งคืนจำนวนขั้นต่ำของสตริงที่ถูกต้องที่สามารถต่อกันเพื่อสร้างเป้าหมาย หากเป็นไปไม่ได้ที่จะสร้างเป้าหมายให้ส่งคืน -1

ตัวอย่างที่ 1:

อินพุต: คำ = ["abc", "aaaaa", "bcdef"], target = "aabcdabc"
เอาท์พุท: 3
คำอธิบาย:
สตริงเป้าหมายสามารถเกิดขึ้นได้โดย concatenating:

คำนำหน้าความยาว 2 ของคำ [1], เช่น "aa"
คำนำหน้าความยาว 3 ของคำ [2], เช่น "bcd".
คำนำหน้าความยาว 3 ของคำ [0], เช่น "abc".

ตัวอย่างที่ 2:

อินพุต: คำ =["abababab","ab"], target = "ababaababa"
เอาท์พุท: 2
คำอธิบาย:
สตริงเป้าหมายสามารถเกิดขึ้นได้โดย concatenating:

คำนำหน้าความยาว 5 ของคำ [0], เช่น "ababa".
คำนำหน้าความยาว 5 ของคำ [0], เช่น "ababa".

ตัวอย่างที่ 3:

อินพุต: คำ = ["abcdef"], target = "xyz"
เอาท์พุท: -1

ข้อ จำกัด :

1 <= words.length <= 100
1 <= words[i].length <= 5 * 10^3
อินพุตถูกสร้างขึ้นเช่นนั้น (words [i] .length) <= 10^5
คำ [i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
1 <= target.length <= 5 * 10^3
เป้าหมายประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณได้รับอาเรย์ของจำนวนเต็ม nums ที่มีความยาว n และจำนวนเต็มบวก k
กำลังของอาเรย์ถูกนิยามว่าเป็น:

ค่ามากสุดของอาเรย์ถ้าทุกองค์ประกอบของมันเป็นจำนวนเรียงติดกันและเรียงลำดับจากน้อยไปมาก
-1 ในกรณีอื่น

คุณต้องหากำลังของทุกอาเรย์ย่อยของ nums ที่มีขนาด k
ส่งคืนอาเรย์จำนวนเต็ม results ของขนาด n - k + 1, โดยที่ results[i] เป็นกำลังของ nums[i..(i + k - 1)]

ตัวอย่างที่ 1:

Input: nums = [1,2,3,4,3,2,5], k = 3
Output: [3,4,-1,-1,-1]
คำอธิบาย:
มีอาเรย์ย่อย 5 อันของ nums ที่มีขนาด 3:

[1, 2, 3] ที่มีค่าองค์ประกอบมากสุดเป็น 3.
[2, 3, 4] ที่มีค่าองค์ประกอบมากสุดเป็น 4.
[3, 4, 3] ที่องค์ประกอบไม่เป็นจำนวนเรียงติดกัน.
[4, 3, 2] ที่องค์ประกอบไม่เรียงลำดับ.
[3, 2, 5] ที่องค์ประกอบไม่เป็นจำนวนเรียงติดกัน.

ตัวอย่างที่ 2:

Input: nums = [2,2,2,2,2], k = 4
Output: [-1,-1]

ตัวอย่างที่ 3:

Input: nums = [3,2,3,2,3,2], k = 2
Output: [-1,3,-1,3,-1]

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็มความยาว n และจำนวนเต็มบวก k
พลังของอาร์เรย์หมายถึง:

องค์ประกอบสูงสุดของมันหากองค์ประกอบทั้งหมดของมันติดต่อกันและจัดเรียงตามลำดับจากน้อยไปมาก
-1 มิฉะนั้น

คุณต้องค้นหาพลังของ subarrays ทั้งหมดที่มีขนาด k
ส่งคืนผลลัพธ์อาร์เรย์จำนวนเต็มขนาด n - k + 1, โดยที่ผลลัพธ์ [i] คือพลังของ nums [i .. (i + k - 1)]

ตัวอย่างที่ 1:

อินพุต: nums = [1,2,3,4,3,2,5], k = 3
เอาท์พุท: [3,4, -1, -1, -1]
คำอธิบาย:
มี 5 subarrays ขนาด 3:

[1, 2, 3] กับองค์ประกอบสูงสุด 3
[2, 3, 4] กับองค์ประกอบสูงสุด 4
[3, 4, 3] องค์ประกอบที่ไม่ติดต่อกัน
[4, 3, 2] องค์ประกอบที่ไม่ได้จัดเรียง
[3, 2, 5] องค์ประกอบที่ไม่ติดต่อกัน

ตัวอย่างที่ 2:

อินพุต: nums = [2,2,2,2,2], k = 4
เอาท์พุท: [-1, -1]

ตัวอย่างที่ 3:

อินพุต: nums = [3,2,3,2,3,2], k = 2
ผลลัพธ์: [-1,3, -1,3, -1]

ข้อ จำกัด :

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

คุณจะได้รับอาร์เรย์ของจำนวนเต็ม nums ที่มีความยาว n และจำนวนเต็มบวก k
กำลังของอาร์เรย์ถูกกำหนดให้เป็นดังนี้:

องค์ประกอบสูงสุดหากองค์ประกอบทั้งหมดต่อเนื่องกันและเรียงลำดับจากน้อยไปมาก
หากไม่ต่อเนื่อง ให้ -1

คุณต้องหากำลังของซับอาร์เรย์ทั้งหมดของ nums ที่มีขนาด k
ส่งคืนผลลัพธ์ของอาร์เรย์จำนวนเต็มที่มีขนาด n - k + 1 โดยที่ results[i] คือกำลังของ nums[i..(i + k - 1)]

ตัวอย่างที่ 1:

อินพุต: nums = [1,2,3,4,3,2,5], k = 3
เอาต์พุต: [3,4,-1,-1,-1]
คำอธิบาย:
มี 5 ซับอาร์เรย์ของ nums ขนาด 3:

[1, 2, 3] ที่มีองค์ประกอบสูงสุด 3
[2, 3, 4] ที่มีองค์ประกอบสูงสุด 4
[3, 4, 3] ซึ่งองค์ประกอบไม่ต่อเนื่องกัน
[4, 3, 2] ซึ่งองค์ประกอบไม่เรียงลำดับ
[3, 2, 5] ซึ่งองค์ประกอบไม่ต่อเนื่องกัน

ตัวอย่างที่ 2:

อินพุต: nums = [2,2,2,2,2], k = 4
เอาต์พุต: [-1,-1]

ตัวอย่างที่ 3:

อินพุต: nums = [3,2,3,2,3,2], k = 2
เอาต์พุต: [-1,3,-1,3,-1]

ข้อจำกัด:

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