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

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

Input: power = [1,1,3,4]
Output: 6
คำอธิบาย:
ความเสียหายสูงสุดที่เป็นไปได้คือ 6 โดยการใช้เวท 0, 1, 3 ที่มีความเสียหาย 1, 1, 4

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

Input: power = [7,1,6,6]
Output: 13
คำอธิบาย:
ความเสียหายสูงสุดที่เป็นไปได้คือ 13 โดยการใช้เวท 1, 2, 3 ที่มีความเสียหาย 1, 6, 6

ข้อจำกัด:

1 <= power.length <= 10^5
1 <= power[i] <= 10^9

นักเวทย์มนตร์มีคาถาหลายคาถา
คุณจะได้รับพลังเวทย์มนตร์หลายคาถา โดยแต่ละธาตุจะแสดงถึงความเสียหายของคาถานั้นๆ คาถาหลายๆ คาถาสามารถมีค่าความเสียหายเท่ากันได้
เป็นที่ทราบกันดีว่าหากนักเวทย์มนตร์ตัดสินใจร่ายคาถาที่มีค่าความเสียหายเป็นพลัง[i] พวกเขาจะไม่สามารถร่ายคาถาใดๆ ที่มีค่าความเสียหายเป็นพลัง[i] - 2, พลัง[i] - 1, พลัง[i] + 1 หรือพลัง[i] + 2 ได้
คาถาแต่ละคาถาสามารถร่ายได้เพียงครั้งเดียวเท่านั้น
คืนความเสียหายรวมสูงสุดที่เป็นไปได้ที่นักเวทย์มนตร์สามารถร่ายได้

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

อินพุต: power = [1,1,3,4]
เอาต์พุต: 6
คำอธิบาย:
ความเสียหายสูงสุดที่เป็นไปได้ 6 เกิดจากการร่ายคาถา 0, 1, 3 ด้วยความเสียหาย 1, 1, 4

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

อินพุต: power = [7,1,6,6]
เอาต์พุต: 13
คำอธิบาย:
ความเสียหายสูงสุดที่เป็นไปได้ 13 เกิดจากการร่ายคาถา 1, 2, 3 ด้วยความเสียหาย 1, 6, 6

ข้อจำกัด:

1 <= power.length <= 10^5
1 <= power[i] <= 10^9

นักมายากลมีเวทมนตร์หลายประเภท
คุณได้รับอาร์เรย์ power ซึ่งแต่ละองค์ประกอบแสดงถึงความเสียหายของเวทมนตร์ เวทมนตร์หลายๆ คาถาอาจมีค่าความเสียหายเท่ากัน
เป็นที่ทราบกันดีว่าหากนักมายากลตัดสินใจที่จะร่ายเวทมนตร์ที่มีความเสียหายเท่ากับ power[i] พวกเขาจะไม่สามารถร่ายเวทมนตร์ใดๆ ที่มีความเสียหายเท่ากับ power[i] - 2, power[i] - 1, power[i] + 1 หรือ power[i] + 2
แต่ละเวทมนตร์สามารถร่ายได้เพียงครั้งเดียว
ส่งคืนความเสียหายรวมสูงสุดที่นักมายากลสามารถร่ายได้

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

Input: power = [1,1,3,4]
Output: 6
คำอธิบาย:
ความเสียหสูงสุดที่เป็นไปได้คือ 6 ซึ่งเกิดจากการใช้เวทมนตร์ 0, 1, 3 ที่มีความเสียหาย 1, 1, 4 ตามลำดับ

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

Input: power = [7,1,6,6]
Output: 13
คำอธิบาย:
ความเสียหายสูงสุดที่เป็นไปได้คือ 13 ซึ่งเกิดจากการใช้เวทมนตร์หมายเลข 1, 2, 3 ที่มีความเสียหาย 1, 6, 6 ตามลำดับ

ข้อจำกัด:

1 <= power.length <= 10^5
1 <= power[i] <= 10^9


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

คิวรี[i] = [1, l_i, r_i] กำหนดจำนวนองค์ประกอบพีคในซับอาร์เรย์ nums[l_i..r_i]
คิวรี[i] = [2, index_i, val_i] เปลี่ยน nums[index_i] เป็น val_i

ส่งคืนคำตอบของอาร์เรย์ที่มีผลลัพธ์ของคิวรีประเภทแรกตามลำดับ
หมายเหตุ:

องค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์หรือซับอาร์เรย์ไม่สามารถเป็นพีคได้

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

อินพุต: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
เอาต์พุต: [0]
คำอธิบาย:
คิวรีแรก: เปลี่ยน nums[3] เป็น 4 และ nums จะกลายเป็น [3,1,4,4,5] แบบสอบถามที่สอง: จำนวนจุดสูงสุดใน [3,1,4,4,5] คือ 0

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

อินพุต: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
เอาต์พุต: [0,1]
คำอธิบาย:
แบบสอบถามแรก: nums[2] ควรเป็น 4 แต่ถูกตั้งค่าเป็น 4 ไปแล้ว
แบบสอบถามที่สอง: จำนวนจุดสูงสุดใน [4,1,4] คือ 0
แบบสอบถามที่สาม: 4 ที่สองคือจุดสูงสุดใน [4,1,4,2,1]

ข้อจำกัด:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= queries.length <= 10^5
queries[i][0] == 1 or queries[i][0] == 2
สำหรับ i ทั้งหมดที่:

queries[i][0] == 1: 0 <= queries[i][1] <= queries[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= queries[i][1] <= nums.length - 1, 1 <= queries[i][2] <= 10^5

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

คิวรี[i] = [1, l_i, r_i] กำหนดจำนวนองค์ประกอบพีคในซับอาร์เรย์ nums[l_i..r_i]
คิวรี[i] = [2, index_i, val_i] เปลี่ยน nums[index_i] เป็น val_i

ส่งคืนคำตอบของอาร์เรย์ที่มีผลลัพธ์ของคิวรีประเภทแรกตามลำดับ
หมายเหตุ:

องค์ประกอบแรกและองค์ประกอบสุดท้ายของอาร์เรย์หรือซับอาร์เรย์ไม่สามารถเป็นพีคได้
ตัวอย่างที่ 1:

อินพุต: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
เอาต์พุต: [0]
คำอธิบาย:
คิวรีแรก: เปลี่ยน nums[3] เป็น 4 และ nums จะกลายเป็น [3,1,4,4,5] แบบสอบถามที่สอง: จำนวนจุดสูงสุดใน [3,1,4,4,5] คือ 0

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

อินพุต: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
เอาต์พุต: [0,1]
คำอธิบาย:
แบบสอบถามแรก: nums[2] ควรเป็น 4 แต่ถูกตั้งค่าเป็น 4 ไปแล้ว
แบบสอบถามที่สอง: จำนวนจุดสูงสุดใน [4,1,4] คือ 0
แบบสอบถามที่สาม: 4 ที่สองคือจุดสูงสุดใน [4,1,4,2,1]
ข้อจำกัด:

3 <= nums.length <= 10^5
1 <= nums[i] <= 10^5
1 <= query.length <= 10^5
queries[i][0] == 1 หรือ query[i][0] == 2
สำหรับ i ทั้งหมดที่:

queries[i][0] == 1: 0 <= query[i][1] <= query[i][2] <= nums.length - 1
queries[i][0] == 2: 0 <= query[i][1] <= nums.length - 1, 1 <= query[i][2] <= 10^5

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

queries[i] = [1, l_i, r_i] ให้กำหนดจำนวนจุดสูงสุดในซับอาร์เรย์ nums[l_i..r_i]
queries[i] = [2, index_i, val_i] เปลี่ยน nums[index_i] เป็น val_i

ส่งคืนอาร์เรย์ answer ที่ประกอบด้วยผลลัพธ์ของคำถามประเภทแรกตามลำดับ
หมายเหตุ:

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

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

```
Input: nums = [3,1,4,2,5], queries = [[2,3,4],[1,0,4]]
Output: [0]
Explanation:
คำถามแรก: เราทำการเปลี่ยน nums[3] เป็น 4 และ nums กลายเป็น [3,1,4,4,5].
คำถามที่สอง: จำนวนยอดเขาใน [3,1,4,4,5] คือ 0.
```

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

```
Input: nums = [4,1,4,2,1,5], queries = [[2,2,4],[1,0,2],[1,0,4]]
Output: [0,1]
Explanation:
คำถามแรก: nums[2] ควรจะเป็น 4 แต่ตอนนี้มันถูกตั้งค่าเป็น 4 อยู่แล้ว
คำถามที่สอง: จำนวนยอดใน [4,1,4] คือ 0
คำถามที่สาม: 4 ตัวที่สองเป็นยอดใน [4,1,4,2,1]

ข้อจำกัด:

- \( 3 \leq \text{nums.length} \leq 10^5 \)
- \( 1 \leq \text{nums[i]} \leq 10^5 \)
- \( 1 \leq \text{queries.length} \leq 10^5 \)
- \( \text{queries[i][0]} == 1 \) หรือ \( \text{queries[i][0]} == 2 \)
สำหรับทุก \( i \) ที่:

- \( \text{queries[i][0]} == 1: 0 \leq \text{queries[i][1]} \leq \text{queries[i][2]} \leq \text{nums.length} - 1 \)
- \( \text{queries[i][0]} == 2: 0 \leq \text{queries[i][1]} \leq \text{nums.length} - 1, 1 \leq \text{queries[i][2]} \leq 10^5 \)


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

นำสมาชิกที่เล็กที่สุด, minElement, และสมาชิกที่ใหญ่ที่สุด, maxElement ออกจาก nums
เพิ่ม (minElement + maxElement) / 2 ไปยัง averages

ส่งคืนสมาชิกที่เล็กที่สุดใน averages

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

Input: nums = [7,8,3,4,15,13,4,1]
Output: 5.5
คำอธิบาย:

step
nums
averages

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

สมาชิกที่เล็กที่สุดของ averages คือ 5.5 ถูกส่งคืน
ตัวอย่างที่ 2:

Input: nums = [1,9,8,3,10,5]
Output: 5.5
คำอธิบาย:

step
nums
averages

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

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

Input: nums = [1,2,3,7,8,9]
Output: 5.0
คำอธิบาย:

step
nums
averages

0
[1,2,3,7,8,9]
[]

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

2
[3,7]
[5,5]

3
[]
[5,5,5]

ข้อจำกัด:

2 <= n == nums.length <= 50
n เป็นเลขคู่
1 <= nums[i] <= 50

คุณมีอาร์เรย์ของค่าเฉลี่ยของจำนวนจุดลอยตัวซึ่งในตอนแรกจะว่างเปล่า คุณจะได้รับอาร์เรย์จำนวนเต็ม n จำนวน โดยที่ n เป็นเลขคู่
คุณทำซ้ำขั้นตอนต่อไปนี้ n / 2 ครั้ง:

ลบองค์ประกอบที่เล็กที่สุด minElement และองค์ประกอบที่ใหญ่ที่สุด maxElement จาก nums
เพิ่ม (minElement + maxElement) / 2 ลงในค่าเฉลี่ย

ส่งคืนองค์ประกอบที่น้อยที่สุดในค่าเฉลี่ย

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

อินพุต: nums = [7,8,3,4,15,13,4,1]
เอาต์พุต: 5.5
คำอธิบาย:

step
nums
averages

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

องค์ประกอบที่เล็กที่สุดของค่าเฉลี่ย 5.5 จะถูกส่งคืน
ตัวอย่างที่ 2:

อินพุต: nums = [1,9,8,3,10,5]
เอาต์พุต: 5.5
คำอธิบาย:

step
nums
averages

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

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

อินพุต: nums = [1,2,3,7,8,9]
เอาต์พุต: 5.0
คำอธิบาย:

step
nums
averages

0
[1,2,3,7,8,9]
[]

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

2
[3,7]
[5,5]

3
[]
[5,5,5]

ข้อจำกัด:

2 <= n == nums.length <= 50
n เป็นเลขคู่
1 <= nums[i] <= 50

คุณมีอาร์เรย์ของตัวเลขจุดลอยตัวที่เรียกว่า averages ซึ่งตอนแรกว่างเปล่า คุณจะได้รับอาร์เรย์ nums ของจำนวนเต็ม n ที่ n คือแม้
คุณทำซ้ำขั้นตอนต่อไปนี้ n / 2 ครั้ง
ลบองค์ประกอบที่เล็กที่สุด (minElement) และองค์ประกอบที่ใหญ่ที่สุด (maxElement) ออกจาก nums
เพิ่ม (minElement + maxElement) / 2 ลงใน averages

งคืนองค์ประกอบที่เล็กที่สุดใน averages

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

อินพุต: nums = [7,8,3,4,15,13,4,1]
เอาท์พุท: 5.5
คำอธิบาย:

ขั้นตอน
nums
ค่าเฉลี่ย

0
[7,8,3,4,15,13,4,1]
[]

1
[7,8,3,4,13,4]
[8]

2
[7,8,4,4]
[8,8]

3
[7,4]
[8,8,6]

4
[]
[8,8,6,5.5]

องค์ประกอบที่เล็กที่สุดใน averages คือ 5.5 จะถูกส่งคืน
ตัวอย่างที่ 2:

อินพุต: nums = [1,9,8,3,10,5]
เอาท์พุท: 5.5
คำอธิบาย:

ขั้นตอน
nums
ค่าเฉลี่ย

0
[1,9,8,3,10,5]
[]

1
[9,8,3,5]
[5.5]

2
[8,5]
[5.5,6]

3
[]
[5.5,6,6.5]

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

อินพุต: nums = [1,2,3,7,8,9]
เอาท์พุท: 5.0
คำอธิบาย:

ขั้นตอน
nums
ค่าเฉลี่ย

0
[1,2,3,7,8,9]
[]

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

2
[3,7]
[5,5]

3
[]
[5,5,5]

ข้อ จำกัด :

2 <= n == nums.length <= 50
n คือแม้
1 <= nums [i] <= 50


คุณจะได้รับตารางอาร์เรย์ไบนารี 2 มิติ ค้นหารูปสี่เหลี่ยมผืนผ้าที่มีด้านแนวนอนและแนวตั้งที่มีพื้นที่น้อยที่สุด โดยที่เลข 1 ทั้งหมดในตารางอยู่ภายในรูปสี่เหลี่ยมผืนผ้านี้
ส่งคืนพื้นที่น้อยที่สุดที่เป็นไปได้ของรูปสี่เหลี่ยมผืนผ้า

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

อินพุต: grid = [[0,1,0],[1,0,1]]
เอาต์พุต: 6
คำอธิบาย:

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีความสูง 2 และความกว้าง 3 ดังนั้นจึงมีพื้นที่ 2 * 3 = 6

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

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

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีทั้งความสูงและความกว้าง 1 ดังนั้นพื้นที่คือ 1 * 1 = 1

ข้อจำกัด:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] จะเป็น 0 หรือ 1
อินพุตจะสร้างขึ้นเพื่อให้มี 1 อย่างน้อยหนึ่งตัวในกริด

คุณจะได้รับตารางอาร์เรย์ไบนารี 2 มิติ ค้นหาสี่เหลี่ยมผืนผ้าที่มีด้านแนวนอนและแนวตั้งที่มีพื้นที่น้อยที่สุด โดยที่เลข 1 ทั้งหมดในตารางอยู่ภายในสี่เหลี่ยมผืนผ้านี้
คืนค่าพื้นที่ที่น้อยที่สุดที่เป็นไปได้ของสี่เหลี่ยมผืนผ้านี้

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

Input: grid = [[0,1,0],[1,0,1]]
Output: 6
คำอธิบาย:

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีความสูง 2 และความกว้าง 3 ดังนั้นพื้นที่คือ 2 * 3 = 6

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

Input: grid = [[1,0],[0,0]]
Output: 1
คำอธิบาย:

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีทั้งความสูงและความกว้าง 1 ดังนั้นพื้นที่คือ 1 * 1 = 1

ข้อจำกัด:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] เป็น 0 หรือ 1
ข้อมูลนำเข้ารับประกันว่าจะมี 1 อย่างน้อยหนึ่งตัวใน grid

คุณจะได้รับตารางอาร์เรย์ไบนารี 2D ค้นหาสี่เหลี่ยมผืนผ้าที่มีด้านแนวนอนและแนวตั้งที่มีพื้นที่เล็กที่สุด เพื่อให้ 1 ทั้งหมดในตารางอยู่ภายในสี่เหลี่ยมผืนผ้านี้
ส่งคืนพื้นที่ขั้นต่ําที่เป็นไปได้ของสี่เหลี่ยมผืนผ้า

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

อินพุต: grid= [[0,1,0],[1,0,1]]
เอาท์พุต: 6
การอธิบาย:

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีความสูง 2 และกว้าง 3 ดังนั้นจึงมีพื้นที่ 2 * 3 = 6

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

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

สี่เหลี่ยมผืนผ้าที่เล็กที่สุดมีทั้งความสูงและความกว้าง 1 ดังนั้นพื้นที่ของมันคือ 1 * 1 = 1

ข้อจํากัด:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] เป็น 0 หรือ 1
อินพุตถูกสร้างขึ้นเพื่อให้มีอย่างน้อย 1 ในกริด


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ที่มีความยาว n
ต้นทุนของซับอาร์เรย์ nums[l..r] โดยที่ 0 <= l <= r < n ถูกกำหนดเป็น:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
งานของคุณคือแยก nums ออกเป็นซับอาร์เรย์เพื่อให้ต้นทุนรวมของซับอาร์เรย์สูงสุด โดยให้แน่ใจว่าแต่ละองค์ประกอบอยู่ในซับอาร์เรย์เพียงอันเดียว ตามรูปแบบ ถ้า nums ถูกแบ่งออกเป็นซับอาร์เรย์ k ชุด โดยที่ k > 1 ที่ดัชนี i_1, i_2, ..., i_k − 1 โดยที่ 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1 ดังนั้นต้นทุนรวมจะเป็นดังนี้:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
ส่งคืนจำนวนเต็มที่แสดงถึงต้นทุนรวมสูงสุดของซับอาร์เรย์หลังจากแบ่งอาร์เรย์อย่างเหมาะสมแล้ว
หมายเหตุ: ถ้า nums ไม่ได้ถูกแบ่งออกเป็นซับอาร์เรย์ กล่าวคือ k = 1 ต้นทุนรวมจะเป็นเพียงแค่ cost(0, n - 1)

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

อินพุต: nums = [1,-2,3,4]
เอาต์พุต: 10
คำอธิบาย:
วิธีหนึ่งในการเพิ่มต้นทุนรวมให้สูงสุดคือการแยก [1, -2, 3, 4] ออกเป็นซับอาร์เรย์ [1, -2, 3] และ [4] ต้นทุนรวมจะเป็น (1 + 2 + 3) + 4 = 10

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

อินพุต: nums = [1,-1,1,-1]
เอาต์พุต: 4
คำอธิบาย:
วิธีหนึ่งในการเพิ่มต้นทุนรวมให้สูงสุดคือการแยก [1, -1, 1, -1] ออกเป็นซับอาร์เรย์ [1, -1] และ [1, -1] ต้นทุนรวมจะเป็น (1 + 1) + (1 + 1) = 4

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

อินพุต: nums = [0]
เอาต์พุต: 0
คำอธิบาย:
เราไม่สามารถแยกอาร์เรย์เพิ่มเติมได้ ดังนั้นคำตอบคือ 0

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

อินพุต: nums = [1,-1]
เอาต์พุต: 2
คำอธิบาย:
การเลือกอาร์เรย์ทั้งหมดจะให้ต้นทุนรวม 1 + 1 = 2 ซึ่งเป็นค่าสูงสุด

ข้อจำกัด:

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

คุณมีอาเรย์ของจำนวนเต็ม nums ที่มีความยาว n
ค่าใช้จ่ายของซับอาเรย์ nums[l..r] โดยที่ 0 <= l <= r < n กำหนดไว้ว่า:
cost(l, r) = nums[l] - nums[l + 1] + ... + nums[r] * (−1)^r − l
งานของคุณคือการแบ่ง nums เป็นซับอาเรย์เพื่อให้ค่าใช้จ่ายรวมของซับอาเรย์มีค่าสูงสุด โดยที่แต่ละองค์ประกอบอยู่ในซับอาเรย์อย่างน้อยหนึ่งเดียว
ในรูปแบบทางการ ถ้า nums ถูกแบ่งเป็น k ซับอาเรย์ โดยที่ k > 1 ที่ดัชนี i_1, i_2, ..., i_k − 1 โดยที่ 0 <= i_1 < i_2 < ... < i_k - 1 < n - 1 ค่าใช้จ่ายรวมจะเป็น:
cost(0, i_1) + cost(i_1 + 1, i_2) + ... + cost(i_k − 1 + 1, n − 1)
ส่งคืนจำนวนเต็มที่ระบุค่าใช้จ่ายรวมสูงสุดของซับอาเรย์หลังการแบ่งอาเรย์อย่างเหมาะสม
หมายเหตุ: ถ้า nums ไม่ถูกแบ่งเป็นซับอาเรย์คือ i.e. k = 1 ค่าใช้จ่ายทั้งหมดจะเป็น(0, n - 1).

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

Input: nums = [1,-2,3,4]
Output: 10
คำอธิบาย:
วิธีหนึ่งที่จะเพิ่มค่าใช้จ่ายรวมให้สูงสุดคือ โดยการแบ่ง [1, -2, 3, 4] เป็นซับอาเรย์ [1, -2, 3] และ [4] ค่าใช้จ่ายรวมจะเป็น (1 + 2 + 3) + 4 = 10

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

Input: nums = [1,-1,1,-1]
Output: 4
คำอธิบาย:
วิธีหนึ่งที่จะเพิ่มค่าใช้จ่ายรวมให้สูงสุดคือ โดยการแบ่ง [1, -1, 1, -1] เป็นซับอาเรย์ [1, -1] และ [1, -1] ค่าใช้จ่ายรวมจะเป็น (1 + 1) + (1 + 1) = 4

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

Input: nums = [0]
Output: 0
คำอธิบาย:
เราไม่สามารถแบ่งอาเรย์เป็นซับอาเรย์ได้อีก ดังนั้นคำตอบคือ 0

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

Input: nums = [1,-1]
Output: 2
คำอธิบาย:
การเลือกอาเรย์ทั้งชุดให้ค่าใช้จ่ายรวมเป็น 1 + 1 = 2 ซึ่งเป็นค่าที่สูงสุด

ข้อจำกัด:

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


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

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

อินพุต: red = 2, blue = 4
เอาต์พุต: 3
คำอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงวิธีเดียวแสดงไว้ด้านบน

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

อินพุต: red = 2, blue = 1
เอาต์พุต: 2
คำอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงวิธีเดียวแสดงไว้ด้านบน

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

อินพุต: red = 1, blue = 1
เอาต์พุต: 1

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

อินพุต: red = 10, blue = 1
เอาต์พุต: 2
คำอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงวิธีเดียวแสดงไว้ด้านบน

ข้อจำกัด:

1 <= red, blue <= 100

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

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

ข้อมูลนำเข้า: red = 2, blue= 4
ข้อมูลผลลัพธ์: 3
คำอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงอย่างเดียวแสดงไว้ด้านบน

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

ข้อมูลนำเข้า: red = 2, blue = 1
ข้อมูลผลลัพธ์: 2
การอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงอย่างเดียวแสดงไว้ด้านบน

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

ข้อมูลนำเข้า: red = 1, blue = 1
ข้อมูลผลลัพธ์: 1

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

อินพุต: red = 10, blue = 1
ข้อมูลผลลัพธ์: 2
การอธิบาย:

การจัดเรียงที่เป็นไปได้เพียงอย่างเดียวแสดงไว้ด้านบน

ข้อจํากัด:

1 <= red, blue <= 100


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

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2

ส่งคืนความยาวของลำดับย่อยที่ถูกต้องที่ยาวที่สุดของ nums
ลำดับย่อยคืออาร์เรย์ที่สามารถอนุมานได้จากอาร์เรย์อื่นโดยลบองค์ประกอบบางส่วนหรือลบองค์ประกอบทั้งหมดโดยไม่เปลี่ยนลำดับขององค์ประกอบที่เหลือ

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 4
คำอธิบาย:
ลำดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 2, 3, 4]

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

อินพุต: nums = [1,2,1,1,2,1,2]
เอาต์พุต: 6
คำอธิบาย:
ลำดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 2, 1, 2, 1, 2]

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

อินพุต: nums = [1,3]
เอาต์พุต: 2
คำอธิบาย:
ลำดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 3]

ข้อจำกัด:

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

คุณจะได้รับตัวเลขอาร์เรย์จํานวนเต็ม
ลําดับย่อยของ nums ที่มีความยาว x เรียกว่าถูกต้องหากเป็นไปตาม:

(sub[0] + sub[1]) % 2 == (sub[1] + sub[2]) % 2 == ... == (sub[x - 2] + sub[x - 1]) % 2.

ส่งกลับความยาวของลําดับย่อยที่ถูกต้องที่สุดของ nums
ลําดับย่อยคืออาร์เรย์ที่สามารถรับมาจากอาร์เรย์อื่นโดยการลบองค์ประกอบบางส่วนหรือไม่มีเลยโดยไม่เปลี่ยนลําดับขององค์ประกอบที่เหลือ

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

อินพุต: nums = [1,2,3,4]
เอาท์พุต: 4
การอธิบาย:
ลําดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 2, 3, 4]

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

อินพุต: nums = [1,2,1,1,2,1,2]
เอาท์พุต: 6
การอธิบาย:
ลําดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 2, 1, 2, 1, 2]

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

อินพุต: nums = [1,3]
เอาท์พุต: 2
การอธิบาย:
ลําดับย่อยที่ถูกต้องที่ยาวที่สุดคือ [1, 3]

ข้อจํากัด:

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


มีต้นไม้ที่ไม่มีทิศทางสองต้นที่มีโหนด n และ m ซึ่งมีหมายเลขตั้งแต่ 0 ถึง n - 1 และจาก 0 ถึง m - 1 ตามลําดับ คุณจะได้รับขอบจํานวนเต็ม 2 มิติสองขอบ edges1 และ edges2 ที่มีความยาว n - 1 และ m - 1 ตามลําดับ โดยที่ edges1[i] = [a_i, b_i] บ่งชี้ว่ามีขอบระหว่างโหนด a_i และ b_i ในต้นไม้แรก และ edges2[i] = [u_i, v_i] บ่งชี้ว่ามีขอบระหว่างโหนด u_i และ v_i ในต้นไม้ที่สอง
คุณต้องเชื่อมต่อโหนดหนึ่งจากต้นไม้แรกกับโหนดหนึ่งจากต้นไม้ที่สองด้วยขอบ
ส่งคืนเส้นผ่านศูนย์กลางต่ําสุดที่เป็นไปได้ของต้นไม้ที่ได้
เส้นผ่านศูนย์กลางของต้นไม้คือความยาวของเส้นทางที่ยาวที่สุดระหว่างสองโหนดในต้นไม้

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

อินพุต: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
เอาท์พุต: 3
การอธิบาย:
เราสามารถรับต้นไม้ที่มีเส้นผ่านศูนย์กลาง 3 ได้โดยเชื่อมต่อโหนด 0 จากต้นไม้ต้นแรกกับโหนดใดก็ได้จากต้นไม้ที่สอง

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

อินพุต: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
เอาท์พุต: 5
การอธิบาย:
เราสามารถรับต้นไม้ที่มีเส้นผ่านศูนย์กลาง 5 ได้โดยเชื่อมต่อโหนด 0 จากต้นไม้ต้นแรกกับโหนด 0 จากต้นไม้ที่สอง

ข้อจํากัด:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
อินพุตถูกสร้างขึ้นเพื่อให้ edges1 และ edges2 แสดงถึงต้นไม้ที่ถูกต้อง

มีต้นไม้ที่ไม่มีทิศทางสองต้นที่มีโหนด n และ m หมายเลขตั้งแต่ 0 ถึง n - 1 และ 0 ถึง m - 1 ตามลำดับ คุณจะได้รับสองอาเรย์จำนวนเต็ม 2 มิติ edges1 และ edges2 ที่มีความยาว n - 1 และ m - 1 ตามลำดับ โดยที่ edges1[i] = [a_i, b_i] ระบุว่ามีเส้นเชื่อมระหว่างโหนด a_i และ b_i ในต้นไม้แรก และ edges2[i] = [u_i, v_i] ระบุว่ามีเส้นเชื่อมระหว่างโหนด u_i และ v_i ในต้นไม้ที่สอง
คุณต้องเชื่อมโหนดหนึ่งจากต้นไม้แรกกับอีกโหนดหนึ่งจากต้นไม้ที่สองด้วยเส้นเชื่อม
ให้คืนค่าความกว้างของต้นไม้ที่เป็นไปได้ที่มีขนาดน้อยที่สุด
ความกว้างของต้นไม้คือความยาวของเส้นทางที่ยาวที่สุดระหว่างโหนดสองโหนดใด ๆ ในต้นไม้

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

Input: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
Output: 3
คำอธิบาย:
เราสามารถสร้างต้นไม้ที่มีความกว้าง 3 โดยเชื่อมโหนด 0 จากต้นไม้แรกกับโหนดใด ๆ ในต้นไม้ที่สอง

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

Input: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
Output: 5
คำอธิบาย:
เราสามารถสร้างต้นไม้ที่มีความกว้าง 5 โดยเชื่อมโหนด 0 จากต้นไม้แรกกับโหนด 0 จากต้นไม้ที่สอง

เงื่อนไข:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
ข้อมูลที่ป้อนมาการันตีว่า edges1 และ edges2 แทนต้นไม้ที่ถูกต้อง

มีต้นไม้ที่ไม่มีทิศทางอยู่สองต้นที่มีโหนด n และ m โหนด โดยมีหมายเลขตั้งแต่ 0 ถึง n - 1 และตั้งแต่ 0 ถึง m - 1 ตามลำดับ คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติสองอาร์เรย์ ได้แก่ edges1 และ edges2 ที่มีความยาว n - 1 และ m - 1 ตามลำดับ โดยที่ edges1[i] = [a_i, b_i] ระบุว่ามีขอบระหว่างโหนด a_i และ b_i ในต้นไม้แรก และ edges2[i] = [u_i, v_i] ระบุว่ามีขอบระหว่างโหนด u_i และ v_i ในต้นไม้ที่สอง
คุณต้องเชื่อมต่อโหนดหนึ่งจากต้นไม้แรกกับโหนดอื่นจากต้นไม้ที่สองที่มีขอบ
ส่งกลับเส้นผ่านศูนย์กลางขั้นต่ำที่เป็นไปได้ของต้นไม้ที่ได้
เส้นผ่านศูนย์กลางของต้นไม้คือความยาวของเส้นทางที่ยาวที่สุดระหว่างโหนดสองโหนดในต้นไม้
ตัวอย่างที่ 1:

อินพุต: edges1 = [[0,1],[0,2],[0,3]], edges2 = [[0,1]]
เอาต์พุต: 3
คำอธิบาย:
เราสามารถหาต้นไม้ที่มีเส้นผ่านศูนย์กลาง 3 ได้โดยเชื่อมต่อโหนด 0 จากต้นไม้ต้นแรกกับโหนดใดๆ จากต้นไม้ต้นที่สอง

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

อินพุต: edges1 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]], edges2 = [[0,1],[0,2],[0,3],[2,4],[2,5],[3,6],[2,7]]
เอาต์พุต: 5
คำอธิบาย:
เราสามารถหาต้นไม้ที่มีเส้นผ่านศูนย์กลาง 5 ได้โดยเชื่อมต่อโหนด 0 จากต้นไม้ต้นแรกกับโหนด 0 จากต้นไม้ต้นที่สอง
ข้อจำกัด:

1 <= n, m <= 10^5
edges1.length == n - 1
edges2.length == m - 1
edges1[i].length == edges2[i].length == 2
edges1[i] = [a_i, b_i]
0 <= a_i, b_i < n
edges2[i] = [u_i, v_i]
0 <= u_i, v_i < m
อินพุตจะถูกสร้างขึ้นเพื่อให้ edges1 และ edges2 แสดงถึงต้นไม้ที่ถูกต้อง


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

สำหรับอักขระ c แต่ละตัวใน s ให้แทนที่ c ด้วยอักขระตัวที่ k หลังจาก c ในสตริง (ในลักษณะวนซ้ำ)

ส่งคืนสตริงที่เข้ารหัสแล้ว

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

อินพุต: s = "dart", k = 3
เอาต์พุต: "tdar"
คำอธิบาย:

สำหรับ i = 0 อักขระตัวที่ 3 หลังจาก 'd' คือ 't'
สำหรับ i = 1 อักขระตัวที่ 3 หลังจาก 'a' คือ 'd'
สำหรับ i = 2 อักขระตัวที่ 3 หลังจาก 'r' คือ 'a'
สำหรับ i = 3 อักขระตัวที่ 3 หลังจาก 't' คือ 'r'

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

อินพุต: s = "aaa", k = 1
เอาต์พุต: "aaa"
คำอธิบาย:
เนื่องจากอักขระทั้งหมดเหมือนกัน สตริงที่เข้ารหัสจึงเหมือนกันด้วย

ข้อจำกัด:

1 <= s.length <= 100
1 <= k <= 10^4
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

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

สำหรับตัวละครแต่ละตัวใน s ให้แทนที่ c ด้วยตัวละคร k^th หลังจาก c ในสตริง (ในลักษณะวงจร)

ส่งคืนสตริงที่เข้ารหัส

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

อินพุต: s = "dart", k = 3
เอาท์พุท: "tdar"
คำอธิบาย:

For i = 0, the 3^rd character after 'd' is 't'.
For i = 1, the 3^rd character after 'a' is 'd'.
For i = 2, the 3^rd character after 'r' is 'a'.
For i = 3, the 3^rd character after 't' is 'r'.

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

อินพุต: s = "aaa", k = 1
เอาท์พุท: "aaa"
คำอธิบาย:
เนื่องจากอักขระทั้งหมดเหมือนกันสตริงที่เข้ารหัสจะเหมือนกัน

ข้อ จำกัด :

1 <= s.length <= 100
1 <= k <= 10^4
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณได้รับสตริง s และจำนวนเต็ม k ให้เข้ารหัสสตริงโดยใช้ขั้นตอนดังต่อไปนี้:

สำหรับแต่ละตัวอักษร c ใน s ให้แทนที่ c ด้วยตัวอักษรที่อยู่หลัง c ในสตริงเป็นจำนวน k ตัว (ในลักษณะวนรอบ)

ส่งคืนสตริงที่ถูกเข้ารหัส.

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

Input: s = "dart", k = 3
Output: "tdar"
คำอธิบาย:

สำหรับ i = 0 ตัวอักษรที่ 3 หลังจาก 'd' คือ 't'
สำหรับ i = 1 ตัวอักษรที่ 3 หลังจาก 'a' คือ 'd'
สำหรับ i = 2 ตัวอักษรที่ 3 หลังจาก 'r' คือ 'a'
สำหรับ i = 3 ตัวอักษรที่ 3 หลังจาก 't' คือ 'r'

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

Input: s = "aaa", k = 1
Output: "aaa"
คำอธิบาย:
เนื่องจากตัวอักษรทั้งหมดเหมือนกัน สตริงที่เข้ารหัสก็จะเหมือนกันด้วย

ข้อจำกัด:

1 <= s.length <= 100
1 <= k <= 10^4
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณได้รับจำนวนเต็มบวก n
สตริงไบนารี x จะถูกต้องก็ต่อเมื่อซับสตริงทั้งหมดของ x ที่มีความยาว 2 มี "1" อย่างน้อยหนึ่งตัว
ส่งคืนสตริงที่ถูกต้องทั้งหมดที่มีความยาว n ในลำดับใดก็ได้

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

อินพุต: n = 3
เอาต์พุต: ["010","011","101","110","111"]
คำอธิบาย:
สตริงที่ถูกต้องที่มีความยาว 3 คือ: "010", "011", "101", "110" และ "111"

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

อินพุต: n = 1
เอาต์พุต: ["0","1"]
คำอธิบาย:
สตริงที่ถูกต้องที่มีความยาว 1 คือ: "0" และ "1"

ข้อจำกัด:

1 <= n <= 18

คุณได้รับจำนวนเต็มบวก n

สตริงไบนารี x จะถือว่าถูกต้องถ้าส่วนย่อยทั้งหมดของ x ที่มีความยาว 2 มี "1" อย่างน้อยหนึ่งตัว

ส่งคืนสตริงที่ถูกต้องทั้งหมดที่มีความยาว n ในลำดับใดก็ได้

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

Input: n = 3

Output: ["010","011","101","110","111"]

คำอธิบาย:

สตริงที่ถูกต้องความยาว 3 คือ: "010", "011", "101", "110", และ "111"

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

Input: n = 1

Output: ["0","1"]

คำอธิบาย:

สตริงที่ถูกต้องที่มีความยาว 1 คือ: "0" และ "1"

ข้อจำกัด:

1 <= n <= 18


ให้พิจารณาเมทริกซ์ตัวอักษร 2 มิติที่มีค่า grid[i][j] เป็น 'X', 'Y' หรือ '.' ให้คืนค่าจำนวนซับเมทริกซ์ที่มีคุณสมบัติดังต่อไปนี้:

- grid[0][0]
- มีความถี่ของ 'X' และ 'Y' เท่ากัน
- มี 'X' อย่างน้อยหนึ่งตัว

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

Input: grid = [["X","Y","."],["Y",".","."]]
Output: 3
คำอธิบาย:

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

Input: grid = [["X","X"],["X","Y"]]
Output: 0
คำอธิบาย:
ไม่มีซับแมทริกซ์ใดที่มีความถี่ของ 'X' และ 'Y' เท่ากัน

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

Input: grid = [[".","."],[".","."]]
Output: 0
คำอธิบาย:
ไม่มีซับแมทริกซ์ใดที่มี 'X' อย่างน้อยหนึ่งตัว

ข้อจำกัด:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] คือ 'X', 'Y', หรือ '.'

ให้เมทริกซ์อักขระ 2D ชื่อ grid โดยที่ grid[i][j] คือ 'X', 'Y', หรือ '.' ให้คืนค่าจำนวนเมทริกซ์ย่อยที่มี:

grid[0][0]
ความถี่เท่ากันของ 'X' และ 'Y'
มีอย่างน้อยหนึ่ง 'X'

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

Input: grid = [["X","Y","."],["Y",".","."]]
Output: 3
คำอธิบาย:

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

Input: grid = [["X","X"],["X","Y"]]
Output: 0
คำอธิบาย:
ไม่มีเมทริกซ์ย่อยที่มีความถี่เท่ากันของ 'X' และ 'Y'

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

Input: grid = [[".","."],[".","."]]
Output: 0
คำอธิบาย:
ไม่มีเมทริกซ์ย่อยใดที่มี'X'อย่างน้อยหนึ่งตัว

ข้อจำกัด:

1 <= grid.length, grid[i].length <= 1000
grid[i][j] คือ 'X', 'Y', หรือ '.'

ได้รับกริดเมทริกซ์ตัวละคร 2 มิติโดยที่กริด [i] [j] เป็น 'X', 'Y', หรือ '.', ส่งคืนจำนวน submatrices ที่มี:

กริด [0] [0]
ความถี่เท่ากันของ 'X' และ 'Y'
อย่างน้อยหนึ่ง 'X'

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

อินพุต: grid = [["X","Y","."],["Y",".","."]]
เอาท์พุท: 3
คำอธิบาย:

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

อินพุต: grid = [["X","X"],["X","Y"]]
เอาท์พุท: 0
คำอธิบาย:
ไม่มี submatrix มีความถี่เท่ากันของ 'X' และ 'Y'

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

อินพุต: grid = [[".","."],[".","."]]
เอาท์พุท: 0
คำอธิบาย:
ไม่มี submatrix มีอย่างน้อยหนึ่ง 'X'

ข้อ จำกัด :

1 <= grid.length, grid[i].length <= 1000
grid[i][j] is either 'X', 'Y', or '.'.


คุณได้รับสตริงเป้าหมาย (target) อาร์เรย์ของสตริง (words) และอาร์เรย์ของจำนวนเต็ม (costs) ซึ่งทั้งสองอาร์เรย์มีความยาวเท่ากัน
จินตนาการถึงสตริงว่าง ๆ s
คุณสามารถทำการดำเนินการต่อไปนี้ได้หลายครั้ง (รวมถึงศูนย์ครั้ง):

เลือกดัชนี i ในช่วง [0, words.length - 1]
เพิ่ม words[i] ลงใน s
ต้นทุนของการดำเนินการคือ costs[i]

คืนค่าต้นทุนขั้นต่ำเพื่อทำให้ s เท่ากับ target หากไม่สามารถทำได้ ให้คืนค่า -1

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

Input: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
Output: 7
คำอธิบาย:
ต้นทุนขั้นต่ำสามารถทำได้โดยการดำเนินการดังต่อไปนี้:

เลือกดัชนี 1 และเพิ่ม "abc" ลงใน s โดยมีต้นทุน 1 ทำให้ s = "abc"
เลือกดัชนี 2 และเพิ่ม "d" ลงใน s โดยมีต้นทุน 1 ทำให้ s = "abcd"
เลือกดัชนี 4 และเพิ่ม "ef" ลงใน s โดยมีต้นทุน 5 ทำให้ s = "abcdef"

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

Input: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
Output: -1
คำอธิบาย:
ไม่สามารถทำให้ s เท่ากับ target ได้ ดังนั้นเราจึงคืนค่า -1。

ข้อจำกัด:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
ผลรวมทั้งหมดของ words[i].length น้อยกว่าหรือเท่ากับ 5 * 10^4
target และ words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
1 <= costs[i] <= 10^4

คุณจะได้รับสตริงเป้าหมาย, อาร์เรย์ของสตริงคำ, และอาร์เรย์ของค่าจำนวนเต็ม ทั้งสองอาร์เรย์มีความยาวเท่ากัน
ลองนึกภาพสตริงที่ว่างเปล่า
คุณสามารถดำเนินการต่อไปนี้ได้หลายครั้ง (รวมถึงศูนย์):

เลือกดัชนี I ในช่วง [0, words.length - 1]
ต่อท้าย words[i] ไปที่ s
ค่าใช้จ่ายในการดำเนินงานคือค่าใช้จ่าย [i]

ส่งคืนค่าใช้จ่ายขั้นต่ำเพื่อให้ S เท่ากับเป้าหมาย หากเป็นไปไม่ได้ให้กลับมา -1

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

อินพุต: target = "abcdef", words = ["abdef", "abc", "d", "def", "ef"], costs= [100,1,1,10,5]
เอาท์พุท: 7
คำอธิบาย:
ค่าใช้จ่ายขั้นต่ำสามารถทำได้โดยการดำเนินการดังต่อไปนี้:

เลือกดัชนี 1 และผนวก "abc" เป็น S ด้วยราคา 1 ส่งผลให้ s = "abc"
เลือกดัชนี 2 และผนวก "d" เป็น S ด้วยราคา 1 ส่งผลให้ s = "abcd"
เลือกดัชนี 4 และผนวก "ef" เป็น S ด้วยราคา 5 ส่งผลให้ s = "abcdef"

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

อินพุต: target = "aaaa", words = ["z", "zz", "zzz"], costs= [1,10,100]
เอาท์พุท: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะทำให้ S เท่ากับเป้าหมายดังนั้นเราจึงกลับมา -1

ข้อ จำกัด :

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
ผลรวมความยาวของ words[i] น้อยกว่าหรือเท่ากับ 5 * 10^4
เป้าหมายและคำศัพท์ [i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
1 <= costs[i] <= 10^4

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

เลือกดัชนี i ในช่วง [0, words.length - 1]
ผนวก words[i] เข้ากับ s
ต้นทุนการดำเนินการคือ costs[i]

ส่งคืนต้นทุนขั้นต่ำเพื่อให้ s เท่ากับเป้าหมาย หากทำไม่ได้ ให้ส่งคืน -1

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

อินพุต: target = "abcdef", words = ["abdef","abc","d","def","ef"], costs = [100,1,1,10,5]
เอาต์พุต: 7
คำอธิบาย:
สามารถบรรลุต้นทุนขั้นต่ำได้โดยดำเนินการต่อไปนี้:

เลือกดัชนี 1 และผนวก "abc" เข้ากับ s ด้วยต้นทุน 1 ผลลัพธ์คือ s = "abc" เลือกดัชนี 2 และผนวก "d" เข้ากับ s ที่ต้นทุน 1 ส่งผลให้ s = "abcd"
เลือกดัชนี 4 และผนวก "ef" เข้ากับ s ที่ต้นทุน 5 ส่งผลให้ s = "abcdef"

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

อินพุต: target = "aaaa", words = ["z","zz","zzz"], costs = [1,10,100]
เอาต์พุต: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะทำให้ s เท่ากับเป้าหมาย ดังนั้นเราจึงส่งคืน -1

ข้อจำกัด:

1 <= target.length <= 5 * 10^4
1 <= words.length == costs.length <= 5 * 10^4
1 <= words[i].length <= target.length
ผลรวมทั้งหมดของ words[i].length น้อยกว่าหรือเท่ากับ 5 * 10^4
target และ words[i] ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น 1 <= ต้นทุน[i] <= 10^4


กำหนดสตริง s ที่มีเฉพาะตัวเลข ให้ส่งคืนสตริงที่เล็กที่สุดในเชิงพจนานุกรมที่สามารถรับได้หลังจากสลับตัวเลขที่อยู่ติดกันใน s ด้วยพาริตี้เดียวกันสูงสุดหนึ่งครั้ง
ตัวเลขจะมีพาริตี้เท่ากันหากทั้งคู่เป็นคี่หรือทั้งคู่ ตัวอย่างเช่น 5 และ 9 รวมถึง 2 และ 4 มีพาริตี้เท่ากัน ในขณะที่ 6 และ 9 ไม่มี

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

อินพุต: s = "45320"
เอาต์พุต: "43520"
คำอธิบาย:
s[1] == '5' และ s[2] == '3' ทั้งคู่มีพาริตี้เท่ากัน และการสลับจะทำให้ได้สตริงที่เล็กที่สุดในเชิงพจนานุกรม

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

อินพุต: s = "001"
เอาต์พุต: "001"
คำอธิบาย:
ไม่จำเป็นต้องสลับเนื่องจาก s เป็นค่าที่เล็กที่สุดในเชิงพจนานุกรมอยู่แล้ว

ข้อจำกัด:

2 <= s.length <= 100
s ประกอบด้วยตัวเลขเท่านั้น

ให้สตริง s ที่ประกอบด้วยตัวเลขเท่านั้น คืนค่าสตริงที่เล็กที่สุดตามลำดับพจนานุกรมที่สามารถได้รับหลังจากการสลับตัวเลขที่อยู่ติดกันใน s ที่มีพาริตี้เดียวกันได้ไม่เกินหนึ่งครั้ง ตัวเลขมีพาริตี้เดียวกันหากทั้งคู่เป็นเลขคี่หรือทั้งคู่เป็นเลขคู่ ตัวอย่างเช่น 5 และ 9 รวมถึง 2 และ 4 มีพาริตี้เดียวกัน ในขณะที่ 6 และ 9 ไม่มีพาริตี้เดียวกัน

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

Input: s = "45320"
Output: "43520"
คำอธิบาย:
s[1] == '5' และ s[2] == '3' ทั้งคู่มีพาริตี้เดียวกัน และการสลับพวกมันจะทำให้ได้สตริงที่เล็กที่สุดในเชิงลำดับอักขระ

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

Input: s = "001"
Output: "001"
คำอธิบาย:
ไม่มีความจำเป็นต้องทำการสลับ เพราะ s เป็นลำดับที่เล็กที่สุดในเชิงพจนานุกรมอยู่แล้ว

ข้อจำกัด:

2 <= s.length <= 100
s ประกอบด้วยเฉพาะตัวเลขเท่านั้น

ด้วยสตริง s ที่มีตัวเลขเท่านั้นให้ส่งคืนสตริงที่เล็กที่สุดในการทำพจนานุกรมที่สามารถรับได้หลังจากการสลับตัวเลขที่อยู่ติดกันใน s ด้วยความเท่าเทียมกันอย่างมากที่สุดครั้งหนึ่ง
ตัวเลขมีความเท่าเทียมกันถ้าทั้งคู่แปลกหรือทั้งคู่ ตัวอย่างเช่น 5 และ 9 เช่นเดียวกับ 2 และ 4 มีความเท่าเทียมกันเหมือนกันในขณะที่ 6 และ 9 ไม่ได้

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

อินพุต: s = "45320"
เอาท์พุท: "43520"
คำอธิบาย:
s [1] == '5' และ s [2] == '3' ทั้งคู่มีความเท่าเทียมกันเหมือนกันและการสลับพวกเขาส่งผลให้สตริงที่เล็กที่สุดของพจนานุกรม

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

อินพุต: s = "001"
เอาท์พุท: "001"
คำอธิบาย:
ไม่จำเป็นต้องทำการแลกเปลี่ยนเนื่องจาก S นั้นเล็กที่สุดแล้ว

ข้อ จำกัด :

2 <= s.length <= 100
s ประกอบด้วยตัวเลขเท่านั้น


มีเค้กขนาด m x n ที่ต้องตัดเป็นชิ้น 1 x 1
คุณจะได้รับจำนวนเต็ม m, n และอาร์เรย์สองชุด:

horizontalCut ขนาด m - 1 โดยที่ horizontalCut[i] แทนค่าที่ต้องตัดตามเส้นแนวนอน i
verticalCut ขนาด n - 1 โดยที่ verticalCut[j] แทนค่าที่ต้องตัดตามเส้นแนวตั้ง j

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

ตัดตามเส้นแนวนอน i ด้วยค่าของ horizontalCut[i]

ตัดตามเส้นแนวตั้ง j ด้วยค่าของ verticalCut[j]

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

อินพุต: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
เอาต์พุต: 13
คำอธิบาย:

ตัดตามเส้นแนวตั้ง 0 ด้วยต้นทุน 5 ต้นทุนรวมปัจจุบันคือ 5
ตัดตามเส้นแนวนอน 0 บนซับกริด 3 x 1 ด้วยต้นทุน 1
ตัดตามเส้นแนวนอน 0 บนซับกริด 3 x 1 ด้วยต้นทุน 1
ตัดตามเส้นแนวนอน 1 บนซับกริด 2 x 1 ด้วยต้นทุน 3
ตัดตามเส้นแนวนอน 1 บนซับกริด 2 x 1 ด้วยต้นทุน 3

ต้นทุนรวมคือ 5 + 1 + 1 + 3 + 3 = 13

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

อินพุต: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
เอาต์พุต: 15
คำอธิบาย:

ตัดตามเส้นแนวนอน 0 ด้วยต้นทุน 7
ตัดตามเส้นแนวตั้ง 0 บนซับกริด 1 x 2 ด้วยต้นทุน 4
ตัดตามเส้นแนวตั้ง 0 บนซับกริด 1 x 2 ด้วยต้นทุน 4

ต้นทุนรวมคือ 7 + 4 + 4 = 15

ข้อจำกัด:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

มีเค้กขนาด m x n ที่ต้องตัดเป็นชิ้น 1 x 1
คุณจะได้รับจำนวนเต็ม m, n และอาร์เรย์สองชุด:

horizontalCut ขนาด m - 1 โดยที่ horizontalCut[i] แทนค่าที่ต้องตัดตามเส้นแนวนอน i
verticalCut ขนาด n - 1 โดยที่ verticalCut[j] แทนค่าที่ต้องตัดตามเส้นแนวตั้ง j

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

ตัดตามเส้นแนวนอน i ด้วยค่าของ horizontalCut[i]
ตัดตามเส้นแนวตั้ง j ด้วยค่าของ verticalCut[j]

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

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

อินพุต: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
เอาต์พุต: 13
คำอธิบาย:

ตัดตามเส้นแนวตั้ง 0 ด้วยต้นทุน 5 ต้นทุนรวมปัจจุบันคือ 5
ตัดตามเส้นแนวนอน 0 บนซับกริด 3 x 1 ด้วยต้นทุน 1
ตัดตามเส้นแนวนอน 0 บนซับกริด 3 x 1 ด้วยต้นทุน 1
ตัดตามเส้นแนวนอน 1 บนซับกริด 2 x 1 ด้วยต้นทุน 3
ตัดตามเส้นแนวนอน 1 บนซับกริด 2 x 1 ด้วยต้นทุน 3

ต้นทุนรวมคือ 5 + 1 + 1 + 3 + 3 = 13

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

อินพุต: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
เอาต์พุต: 15
คำอธิบาย:

ตัดตามเส้นแนวนอน 0 ด้วยต้นทุน 7
ตัดตามเส้นแนวตั้ง 0 บนซับกริด 1 x 2 ด้วยต้นทุน 4
ตัดตามเส้นแนวตั้ง 0 บนซับกริด 1 x 2 ด้วยต้นทุน 4

ต้นทุนรวมคือ 7 + 4 + 4 = 15

ข้อจำกัด:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3

มีเค้ก m x n ที่ต้องหั่นเป็น 1 x 1 ชิ้น
คุณจะได้รับจํานวนเต็ม m, n และสองอาร์เรย์:

horizontalCut ขนาด m - 1 โดยที่ horizontalCut[i] แสดงถึงต้นทุนในการตัดตามเส้นแนวนอน i
verticalCut ขนาด n - 1 โดยที่ verticalCut[j] แสดงถึงต้นทุนในการตัดตามเส้นแนวตั้ง j

ในแต่ละการดำเนินการคุณสามารถเลือกเค้กชิ้นใดก็ได้ที่ยังไม่ได้เป็นสี่เหลี่ยมจัตุรัส 1 x 1 และทําการตัดอย่างใดอย่างหนึ่งต่อไปนี้:

ตัดตามเส้นแนวนอน i โดยเสียค่าใช้จ่ายของ horizontalCut[i]
ตัดตามเส้นแนวตั้ง j ในราคา verticalCut[j]

หลังจากตัดเค้กชิ้นจะแบ่งออกเป็นสองชิ้นที่แตกต่างกัน
ค่าใช้จ่ายในการตัดขึ้นอยู่กับต้นทุนเริ่มต้นของสายเท่านั้นและไม่เปลี่ยนแปลง
คืนต้นทุนรวมขั้นต่ําเพื่อหั่นเค้กทั้งหมดเป็น 1 x 1 ชิ้น

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

อินพุต: m = 3, n = 2, horizontalCut = [1,3], verticalCut = [5]
เอาท์พุต: 13
การอธิบาย:

ทำการตัดตามเส้นแนวตั้ง 0 ด้วยค่าใช้จ่าย 5, ต้นทุนรวมปัจจุบันคือ 5
ทำการตัดตามเส้นแนวนอน 0 บนแผ่นย่อยขนาด 3 x 1 ด้วยค่าใช้จ่าย 1
ทำการตัดตามเส้นแนวนอน 0 บนแผ่นย่อยขนาด 3 x 1 ด้วยค่าใช้จ่าย 1
ทำการตัดตามเส้นแนวนอน 1 บนแผ่นย่อยขนาด 2 x 1 ด้วยค่าใช้จ่าย 3
ทำการตัดตามเส้นแนวนอน 1 บนแผ่นย่อยขนาด 2 x 1 ด้วยค่าใช้จ่าย 3

ต้นทุนรวมคือ 5 + 1 + 1 + 3 + 3 = 13

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

Input: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]
Output: 15
คำอธิบาย:

ทำการตัดตามเส้นแนวนอน 0 ด้วยค่าใช้จ่าย 7
ทำการตัดตามเส้นแนวตั้ง 0 บนแผ่นย่อยขนาด 1 x 2 ด้วยค่าใช้จ่าย 4
ทำการตัดตามเส้นแนวตั้ง 0 บนแผ่นย่อยขนาด 1 x 2 ด้วยค่าใช้จ่าย 4

ต้นทุนรวมคือ 7 + 4 + 4 = 15

เงื่อนไข:

1 <= m, n <= 20
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 <= horizontalCut[i], verticalCut[i] <= 10^3


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

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

Input: n = 13, k = 4
Output: 2
คำอธิบาย:
ในตอนแรก การแทนค่าแบบไบนารีของ n และ k คือ n = (1101)_2 และ k = (0100)_2
เราสามารถเปลี่ยนบิตที่หนึ่งและบิตที่สี่ของ n ได้ ผลลัพธ์ที่ได้คือ n = (0100)_2 = k.

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

Input: n = 21, k = 21
Output: 0
คำอธิบาย:
n และ k เท่ากันแล้ว ดังนั้นไม่จำเป็นต้องมีการเปลี่ยนแปลงใด ๆ

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

Input: n = 14, k = 13
Output: -1
คำอธิบาย:
ไม่สามารถทำให้ n เท่ากับ k ได้

ข้อจำกัด:

1 <= n, k <= 10^6

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

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

อินพุต: n = 13, k = 4
เอาต์พุต: 2
คำอธิบาย:
ในตอนแรก การแสดงค่าไบนารีของ n และ k คือ n = (1101)_2 และ k = (0100)_2
เราสามารถเปลี่ยนบิตแรกและบิตที่สี่ของ n ได้ จำนวนเต็มที่ได้คือ n = (0100)_2 = k

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

อินพุต: n = 21, k = 21
เอาต์พุต: 0
คำอธิบาย:
n และ k มีค่าเท่ากันอยู่แล้ว ดังนั้นจึงไม่จำเป็นต้องเปลี่ยนแปลงอะไร
ตัวอย่างที่ 3:

อินพุต: n = 14, k = 13
เอาต์พุต: -1
คำอธิบาย:
ไม่สามารถทำให้ n เท่ากับ k ได้

ข้อจำกัด:

1 <= n, k <= 10^6


Alice และ Bob กำลังเล่นเกมบนสตริง

คุณได้รับสตริง \( s \) โดย Alice และ Bob จะผลัดกันเล่นเกมต่อไปนี้โดยที่ Alice เป็นผู้เริ่มก่อน:

เมื่อถึงคราว Alice เธอต้องลบสตริงย่อยที่ไม่ว่างออกจาก \( s \) ที่มีจำนวนสระเป็นเลขคี่
เมื่อถึงคราว Bob เขาต้องลบสตริงย่อยที่ไม่ว่างออกจาก \( s \) ที่มีจำนวนสระเป็นเลขคู่

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

สระในภาษาอังกฤษคือ: a, e, i, o, และ u

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

Input: s = "leetcoder"
Output: true
คำอธิบาย:
Alice สามารถชนะเกมได้ดังนี้:

Alice เล่นเป็นคนแรก เธอสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน \( s = "leetcoder" \) ซึ่งมี 3 สระ สตริงผลลัพธ์คือ \( s = "der" \)
Bob เล่นเป็นคนที่สอง เขาสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน \( s = "der" \) ซึ่งมี 0 สระ สตริงผลลัพธ์คือ\( s = "er" \)
Alice เล่นเป็นคนที่สามอีกที เธอสามารถลบสตริงทั้งหมดใน \( s = "er" \) ซึ่งมี 1 สระ
Bob เล่นเป็นคนที่สี่ เนื่องจากสภาพสตริงเป็นว่างเปล่า ไม่มีการเล่นที่ถูกต้องสำหรับ Bob ดังนั้น Alice ชนะเกมนี้

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

Input: s = "bbcd"
Output: false
คำอธิบาย:
ไม่มีการเล่นที่ถูกต้องสำหรับ Alice ในเทิร์นแรกของเธอ ดังนั้น Alice แพ้เกมนี้

เงื่อนไข:

1 <= s.length <= 10^5
s  ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

Alice และ Bob กำลังเล่นเกมบนสายสตริง
คุณได้รับสายสตริง s Alice และ Bob จะผลัดกันเล่นเกมต่อไปนี้ โดย Alice เริ่มก่อน:

ในตาของ Alice เธอต้องลบสตริงย่อยที่ไม่ว่างจาก s ซึ่งประกอบด้วยสระจำนวนคี่
ในตาของ Bob เขาต้องลบสตริงย่อยที่ไม่ว่างจาก s ซึ่งประกอบด้วยสระจำนวนคู่

ผู้เล่นคนแรกที่ไม่สามารถเคลื่อนไหวได้ในตาของตนจะแพ้เกม เราถือว่าทั้ง Alice และ Bob เล่นได้ดีที่สุด
คืนค่า true หาก Alice ชนะเกม และคืนค่า false หากไม่ชนะ
สระในภาษาอังกฤษคือ: a, e, i, o และ u

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

อินพุต: s = "leetcoder"
เอาต์พุต: true
คำอธิบาย:
Alice สามารถชนะเกมได้ดังนี้:

Alice เล่นก่อน เธอสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน s = "leetcoder" ซึ่งประกอบด้วยสระ 3 ตัว สตริงที่ได้คือ s = "der"
บ็อบเล่นตัวที่สอง เขาสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน s = "der" ซึ่งมีสระ 0 ตัว สตริงที่ได้คือ s = "er"
อลิซเล่นตัวที่สาม เธอสามารถลบสตริงทั้งหมด s = "er" ซึ่งมีสระ 1 ตัว
บ็อบเล่นตัวที่สี่ เนื่องจากสตริงว่างเปล่า จึงไม่มีการเล่นที่ถูกต้องสำหรับบ็อบ ดังนั้น อลิซจึงชนะเกม

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

อินพุต: s = "bbcd"
เอาต์พุต: false
คำอธิบาย:
ไม่มีการเล่นที่ถูกต้องสำหรับอลิซในเทิร์นแรกของเธอ ดังนั้น อลิซจึงแพ้เกม

ข้อจำกัด:

1 <= s.length <= 10^5
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

อลิซและบ๊อบกำลังเล่นเกมบนสตริง
คุณจะได้รับสตริง S, Alice และ Bob จะผลัดกันเล่นเกมต่อไปนี้ที่ Alice เริ่มต้นก่อน:

ในเทิร์นของอลิซเธอจะต้องถอดสายย่อยที่ไม่ว่างเปล่าออกจาก s ที่มีสระจำนวนคี่
เมื่อถึงตาของบ๊อบเขาจะต้องลบสตริงย่อยที่ไม่ว่างเปล่าออกจาก s ที่มีสระจำนวนเท่ากัน

ผู้เล่นคนแรกที่ไม่สามารถเคลื่อนไหวได้ในเทิร์นของพวกเขาจะสูญเสียเกม เราคิดว่าทั้งอลิซและบ๊อบเล่นได้อย่างดีที่สุด
กลับมาจริงถ้าอลิซชนะเกมและเท็จเป็นอย่างอื่น
สระภาษาอังกฤษคือ: a, e, i, o และ u

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

อินพุต: s = "leetcoder"
เอาท์พุท: true
คำอธิบาย:
อลิซสามารถชนะเกมได้ดังนี้:

อลิซเล่นก่อนเธอสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน s = "leetcoder" ซึ่งมีสระ 3 สระ สตริงผลลัพธ์คือ s = "der"
บ๊อบเล่นที่สองเขาสามารถลบสตริงย่อยที่ขีดเส้นใต้ใน s = "der" ซึ่งมีสระ 0 สตริงผลลัพธ์คือ s = "er"
อลิซเล่นเป็นอันดับสามเธอสามารถลบสตริงทั้งหมด s = "เอ่อ" ซึ่งมีสระ 1
บ๊อบเล่นเป็นอันดับสี่เนื่องจากสตริงว่างเปล่าไม่มีการเล่นที่ถูกต้องสำหรับ Bob ดังนั้นอลิซจึงชนะเกม

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

อินพุต: s = "bbcd"
เอาท์พุท: false
คำอธิบาย:
ไม่มีการเล่นที่ถูกต้องสำหรับอลิซในเทิร์นแรกของเธอดังนั้นอลิซจึงแพ้เกม

ข้อ จำกัด :

1 <= s.length <= 10^5
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับสตริงไบนารี s
คุณสามารถดำเนินการต่อไปนี้กับสตริงได้หลายครั้งเท่าที่ต้องการ:

เลือกดัชนี i ใดก็ได้จากสตริงที่ i + 1 < s.length โดยที่ s[i] == '1' และ s[i + 1] == '0'
ย้ายอักขระ s[i] ไปทางขวาจนกว่าจะถึงจุดสิ้นสุดของสตริงหรือจุด '1' ตัวอื่น ตัวอย่างเช่น สำหรับ s = "010010" ถ้าเราเลือก i = 1 สตริงที่ได้จะเป็น s = "000110"

ส่งคืนจำนวนการดำเนินการสูงสุดที่คุณสามารถทำได้

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

อินพุต: s = "1001101"
เอาต์พุต: 4
คำอธิบาย:
เราสามารถดำเนินการต่อไปนี้ได้:

เลือกดัชนี i = 0 สตริงที่ได้จะเป็น s = "0011101"
เลือกดัชนี i = 4 สตริงผลลัพธ์คือ s = "0011011"
เลือกดัชนี i = 3 สตริงผลลัพธ์คือ s = "0010111"
เลือกดัชนี i = 2 สตริงผลลัพธ์คือ s = "0001111"

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

อินพุต: s = "00111"
เอาต์พุต: 0

ข้อจำกัด:

1 <= s.length <= 10^5
s[i] คือ '0' หรือ '1'

คุณจะได้รับสตริงไบนารี
คุณสามารถดำเนินการต่อไปนี้บนสตริงได้ทุกครั้ง:

เลือกดัชนีใด ๆ i จากสตริงที่i + 1 <s.length เมื่อ s [i] == '1' และ s [i + 1] == '0'
เลื่อนตัวละคร s [i] ไปทางขวาจนกระทั่งถึงจุดสิ้นสุดของสตริงหรืออีก '1' ตัวอย่างเมื่อสำหรับ s = "010010" ถ้าเราเลือก i = 1 สตริงผลลัพธ์จะเป็น s = "000110"

ส่งคืนจำนวนการดำเนินการสูงสุดที่คุณสามารถทำได้

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

อินพุต: s = "1001101"
เอาท์พุท: 4
คำอธิบาย:
เราสามารถดำเนินการต่อไปนี้:

เลือกดัชนี i = 0. สตริงผลลัพธ์คือ s = "0011101"
เลือกดัชนี i = 4 สตริงผลลัพธ์คือ s = "0011011"
เลือกดัชนี i = 3. สตริงผลลัพธ์คือ s = "0010111"
เลือกดัชนี i = 2. สตริงผลลัพธ์คือ s = "0001111"

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

อินพุต: s = "00111"
เอาท์พุท: 0

ข้อ จำกัด :

1 <= s.length <= 10^5
s[i] is either '0' or '1'


คุณมีอาร์เรย์ของจำนวนเต็มบวกสองอาร์เรย์คือ nums และ target ซึ่งมีความยาวเท่ากัน
ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือก subarray ใด ๆ ของ nums และเพิ่มหรือลดแต่ละองค์ประกอบภายใน subarray นั้นได้ครั้งละ 1
จงคืนค่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อทำให้ nums เท่ากับอาร์เรย์ target

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

Input: nums = [3,5,1,2], target = [4,6,2,4]
Output: 2
คำอธิบาย: เราจะดำเนินการดังต่อไปนี้เพื่อทำให้ nums เท่ากับ target:
- เพิ่ม nums[0..3] ครั้งละ 1, nums = [4,6,2,3].
- เพิ่ม nums[3..3] ครั้งละ 1, nums = [4,6,2,4].

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

Input: nums = [1,3,2], target = [2,1,4]
Output: 5
คำอธิบาย: เราจะดำเนินการดังต่อไปนี้เพื่อทำให้ nums เท่ากับ target:
- เพิ่ม nums[0..0] ครั้งละ 1, nums = [2,3,2].
- ลด nums[1..1] ครั้งละ 1, nums = [2,2,2].
- ลด nums[1..1] ครั้งละ 1, nums = [2,1,2].
- เพิ่ม nums[2..2] ครั้งละ 1, nums = [2,1,3].
- เพิ่ม nums[2..2] ครั้งละ 1, nums = [2,1,4].

ข้อจำกัด:

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

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

อินพุต: nums = [3,5,1,2], target = [4,6,2,4]
เอาท์พุท: 2
คำอธิบาย:
เราจะดำเนินการต่อไปนี้เพื่อสร้าง nums เท่ากับเป้าหมาย:
- เพิ่ม nums [0..3] โดย 1, nums= [4,6,2,3]
- เพิ่ม nums [3..3] โดย 1, nums= [4,6,2,4]

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

อินพุต: nums = [1,3,2], target = [2,1,4]
เอาท์พุท: 5
คำอธิบาย:
เราจะดำเนินการต่อไปนี้เพื่อสร้าง nums เท่ากับเป้าหมาย:
- เพิ่ม nums [0..0] โดย 1, nums = [2,3,2]
- ลด nums [1..1] โดย 1, nums = [2,2,2]
- ลด nums[1..1] โดย 1, nums = [2,1,2]
- เพิ่ม nums [2..2] โดย 1, nums = [2,1,3]
- เพิ่ม nums [2..2] โดย 1, nums = [2,1,4]

ข้อ จำกัด :

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

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

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

อินพุต: nums = [3,5,1,2], target = [4,6,2,4]
เอาต์พุต: 2
คำอธิบาย:
เราจะดำเนินการต่อไปนี้เพื่อให้ nums เท่ากับเป้าหมาย:
- เพิ่ม nums[0..3] ทีละ 1, nums = [4,6,2,3]
- เพิ่ม nums[3..3] ทีละ 1, nums = [4,6,2,4]

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

อินพุต: nums = [1,3,2], target = [2,1,4]
เอาต์พุต: 5
คำอธิบาย:
เราจะดำเนินการต่อไปนี้เพื่อให้ nums เท่ากับเป้าหมาย:
- เพิ่ม nums[0..0] ขึ้น 1, nums = [2,3,2]
- ลด nums[1..1] ขึ้น 1, nums = [2,2,2]
- ลด nums[1..1] ขึ้น 1, nums = [2,1,2]
- เพิ่ม nums[2..2] ขึ้น 1, nums = [2,1,3]
- เพิ่ม nums[2..2] ขึ้น 1, nums = [2,1,4]

ข้อจำกัด:

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


คุณได้รับอาร์เรย์ของจำนวนเต็มบวก nums
อาลิซและบ็อบกำลังเล่นเกม ในเกมนี้ อาลิซสามารถเลือกได้ว่าจะเลือกตัวเลขหลักเดียวทั้งหมดหรือตัวเลขสองหลักทั้งหมดจาก nums และตัวเลขที่เหลือจะถูกมอบให้บ็อบ อาลิซจะชนะหากผลรวมของตัวเลขของเธอมากกว่าผลรวมของตัวเลขของบ็อบอย่างเคร่งครัด
คืนค่า true หากอาลิซสามารถชนะเกมนี้ได้ มิฉะนั้น คืนค่า false

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

Input: nums = [1,2,3,4,10]
Output: false
คำอธิบาย:
อาลิซไม่สามารถชนะได้โดยการเลือกหมายเลขหลักเดียวหรือหมายเลขสองหลัก

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

Input: nums = [1,2,3,4,5,14]
Output: true
คำอธิบาย:
อาลิซสามารถชนะได้โดยการเลือกตัวเลขหลักเดียวที่มีผลรวมเท่ากับ 15

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

Input: nums = [5,5,5,25]
Output: true
คำอธิบาย:
อาลิซสามารถชนะได้โดยการเลือกหมายเลขสองหลักที่มีผลรวมเท่ากับ 25

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 99

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

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

Input: nums = [1,2,3,4,10]
Output: false
คำอธิบาย:
อลิซไม่สามารถชนะโดยการเลือกตัวเลขหลักเดียวหรือเลขสองหลักใด ๆ ได้

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

Input: nums = [1,2,3,4,5,14]
Output: true
คำอธิบาย:
อลิซสามารถชนะโดยการเลือกตัวเลขหลักเดียวที่มีผลรวมเท่ากับ 15

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

Input: nums = [5,5,5,25]
Output: true
คำอธิบาย:
อลิซสามารถชนะโดยการเลือกตัวเลขเลขสองหลักซึ่งมีผลรวมเท่ากับ 25

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 99

คุณมีอาร์เรย์ของจำนวนเต็มบวก nums
อลิซและบ๊อบกำลังเล่นเกม ในเกมนี้ อลิซสามารถเลือกได้ว่าจะเอาตัวเลขหลักเดียวทั้งหมดหรือเลขสองหลักทั้งหมดจาก nums ที่เหลือจะเป็นของบ๊อบ อลิซจะชนะถ้าผลรวมของตัวเลขของเธอมากกว่าผลรวมของตัวเลขของบ๊อบ
คืนค่า true ถ้าอลิซสามารถชนะเกมนี้ได้ มิฉะนั้น คืนค่า false

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

Input: nums = [1,2,3,4,10]
Output: false
คำอธิบาย:
อลิซไม่สามารถชนะโดยการเลือกตัวเลขหลักเดียวหรือเลขสองหลักใด ๆ ได้

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

Input: nums = [1,2,3,4,5,14]
Output: true
คำอธิบาย:
อลิซสามารถชนะโดยการเลือกตัวเลขหลักเดียวซึ่งมีผลรวมเท่ากับ 15

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

Input: nums = [5,5,5,25]
Output: true
คำอธิบาย:
อลิซสามารถชนะโดยการเลือกตัวเลขเลขสองหลักซึ่งมีผลรวมเท่ากับ 25

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 99


คุณได้รับจำนวนเต็มบวก 2 ตัวคือ l และ r สำหรับจำนวนใด ๆ x ตัวหารบวกทั้งหมดของ x ยกเว้น x เรียกว่า ตัวหารที่เหมาะสมของ x
จำนวนหนึ่งเรียกว่า พิเศษ หากมันมีตัวหารที่เหมาะสมอยู่ 2 ตัวเท่านั้น ตัวอย่างเช่น:

หมายเลข 4 เป็นหมายเลขพิเศษเพราะมีตัวหารที่เหมาะสมคือ 1 และ 2
หมายเลข 6 ไม่เป็นหมายเลขพิเศษเพราะมีตัวหารที่เหมาะสมคือ 1, 2 และ 3

คืนค่าจำนวนของตัวเลขในช่วง [l, r] ที่ไม่เป็นพิเศษ

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

Input: l = 5, r = 7
Output: 3
คำอธิบาย:
ไม่มีหมายเลขพิเศษในช่วง [5, 7].

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

Input: l = 4, r = 16
Output: 11
คำอธิบาย:
หมายเลขพิเศษในช่วง [4, 16] คือ 4 และ 9.

ข้อจำกัด:

1 <= l <= r <= 10^9

คุณได้รับจำนวนเต็มบวก 2 จำนวนคือ l และ r สำหรับจำนวน x ใดๆ ตัวหารบวกทั้งหมดของ x ยกเว้น x จะถูกเรียกว่าตัวหารเฉพาะของ x
จำนวนจะเรียกว่าพิเศษหากมีตัวหารเฉพาะ 2 ตัวพอดี ตัวอย่างเช่น:

จำนวน 4 เป็นจำนวนพิเศษเนื่องจากมีตัวหารเฉพาะคือ 1 และ 2
จำนวน 6 ไม่พิเศษเนื่องจากมีตัวหารเฉพาะคือ 1, 2 และ 3

ส่งคืนจำนวนตัวเลขในช่วง [l, r] ที่ไม่พิเศษ

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

อินพุต: l = 5, r = 7
เอาต์พุต: 3
คำอธิบาย:
ไม่มีตัวเลขพิเศษในช่วง [5, 7]

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

อินพุต: l = 4, r = 16
เอาต์พุต: 11
คำอธิบาย:
ตัวเลขพิเศษในช่วง [4, 16] คือ 4 และ 9

ข้อจำกัด:

1 <= l <= r <= 10^9


คุณได้รับสตริงทวิภาค s
ให้ส่งคืนจำนวนของสตริงย่อยที่มีจำนวนหนึ่งมากกว่า
สตริงจะมีจำนวนหนึ่งมากกว่าหรือเท่ากับจำนวนศูนย์ยกกำลังสองในสตริง

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

Input: s = "00011"
Output: 5
คำอธิบาย:
สตริงย่อยที่มีจำนวนหนึ่งมากกว่าจะปรากฏในตารางด้านล่างนี้

| i | j | s[i..j] | จำนวนศูนย์ | จำนวนหนึ่ง |
|---|---|--------|-------------|-------------|
| 3 | 3 | 1      | 0           | 1           |
| 4 | 4 | 1      | 0           | 1           |
| 2 | 3 | 01     | 1           | 1           |
| 3 | 4 | 11     | 0           | 2           |
| 2 | 4 | 011    | 1           | 2           |

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

Input: s = "101101"
Output: 16
คำอธิบาย:
สตริงย่อยที่ไม่มีจำนวนหนึ่งมากกว่าจะปรากฏในตารางด้านล่างนี้
เนื่องจากมีสตริงย่อยทั้งหมด 21 ตัว และ 5 ตัวไม่มีจำนวนหนึ่งมากกว่า จึงมีสตริงย่อย 16 ตัวที่มีจำนวนหนึ่งมากกว่า

| i | j | s[i..j] | จำนวนศูนย์ | จำนวนหนึ่ง |
|---|---|--------|-------------|-------------|
| 1 | 1 | 0      | 1           | 0           |
| 4 | 4 | 0      | 1           | 0           |
| 1 | 4 | 0110   | 2           | 2           |
| 0 | 4 | 10110  | 2           | 3           |
| 1 | 5 | 01101  | 2           | 3           |

ข้อจำกัด:

1 <= s.length <= 4 * 10^4
s ประกอบด้วยตัวอักษรเพียง '0' และ '1' เท่านั้น

คุณจะได้รับสตริงไบนารี s
ส่งคืนจำนวนสตริงย่อยที่มีตัวหลัก
สตริงจะมีตัวหลักถ้าจำนวนตัวในสตริงมากกว่าหรือเท่ากับกำลังสองของจำนวนศูนย์ในสตริง

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

อินพุต: s = "00011"
เอาต์พุต: 5
คำอธิบาย:
สตริงย่อยที่มีตัวหลักแสดงอยู่ในตารางด้านล่าง
i
j
s[i..j]
จำนวนศูนย์
จำนวนหนึ่ง

3
3
1
0
1

4
4
1
0
1

2
3
01
1
1

3
4
11
0
2

2
4
011
1
2

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

อินพุต: s = "101101"
เอาต์พุต: 16
คำอธิบาย:
สตริงย่อยที่มีสตริงย่อยที่ไม่ใช่สตริงหลักจะแสดงอยู่ในตารางด้านล่าง
เนื่องจากมีสตริงย่อยทั้งหมด 21 สตริง และมี 5 สตริงที่มีสตริงย่อยที่ไม่ใช่สตริงหลัก จึงสรุปได้ว่ามีสตริงย่อยที่มีสตริงย่อยที่เป็นสตริงหลัก 16 สตริง
i
j
s[i..j]
จำนวนศูนย์
จำนวนหนึ่ง

1
1
0
1
0

4
4
0
1
0

1
4
0110
2
2

0
4
10110
2
3

1
5
01101
2
3

ข้อจำกัด:

1 <= s.length <= 4 * 10^4
s ประกอบด้วยอักขระ '0' และ '1' เท่านั้น


คุณจะได้รับจำนวนเต็มบวกสองจำนวนคือ xCorner และ yCorner และวงกลมอาร์เรย์ 2 มิติ โดยที่ circles[i] = [x_i, y_i, r_i] หมายถึงวงกลมที่มีจุดศูนย์กลางอยู่ที่ (x_i, y_i) และมีรัศมี r_i
มีรูปสี่เหลี่ยมผืนผ้าอยู่ในระนาบพิกัด โดยที่มุมซ้ายล่างอยู่ที่จุดกำเนิด และมุมบนขวาอยู่ที่พิกัด (xCorner, yCorner) คุณต้องตรวจสอบว่ามีเส้นทางจากมุมซ้ายล่างไปยังมุมบนขวาหรือไม่ โดยที่เส้นทางทั้งหมดอยู่ภายในรูปสี่เหลี่ยมผืนผ้า ไม่สัมผัสหรืออยู่ภายในวงกลมใดๆ และสัมผัสรูปสี่เหลี่ยมผืนผ้าที่มุมทั้งสองเท่านั้น

คืนค่า true หากมีเส้นทางดังกล่าว และคืนค่า false หากไม่เช่นนั้น
ตัวอย่างที่ 1:

อินพุต: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
เอาต์พุต: true
คำอธิบาย:

เส้นโค้งสีดำแสดงเส้นทางที่เป็นไปได้ระหว่าง (0, 0) และ (3, 4)

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

อินพุต: xCorner = 3, yCorner = 3, circles= [[1,1,2]]
เอาต์พุต: false
คำอธิบาย:

ไม่มีเส้นทางจาก (0, 0) ถึง (3, 3)

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

อินพุต: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
เอาต์พุต: false
คำอธิบาย:

ไม่มีเส้นทางจาก (0, 0) ถึง (3, 3)
ตัวอย่างที่ 4:

อินพุต: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
เอาต์พุต: true
คำอธิบาย:

ข้อจำกัด:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

คุณจะได้รับจำนวนเต็มบวกสองจำนวนคือ xCorner และ yCorner และวงกลมอาร์เรย์ 2 มิติ โดยที่ circles[i] = [x_i, y_i, r_i] หมายถึงวงกลมที่มีจุดศูนย์กลางอยู่ที่ (x_i, y_i) และมีรัศมี r_i
มีรูปสี่เหลี่ยมผืนผ้าอยู่ในระนาบพิกัด โดยที่มุมซ้ายล่างอยู่ที่จุดกำเนิด และมุมบนขวาอยู่ที่พิกัด (xCorner, yCorner) คุณต้องตรวจสอบว่ามีเส้นทางจากมุมซ้ายล่างไปยังมุมบนขวาหรือไม่ โดยที่เส้นทางทั้งหมดอยู่ภายในรูปสี่เหลี่ยมผืนผ้า ไม่สัมผัสหรืออยู่ภายในวงกลมใดๆ และสัมผัสรูปสี่เหลี่ยมผืนผ้าที่มุมทั้งสองเท่านั้น
ส่งคืนค่า true หากมีเส้นทางดังกล่าว และส่งคืนค่า false หากไม่เช่นนั้น

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

อินพุต: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
เอาต์พุต: true
คำอธิบาย:

เส้นโค้งสีดำแสดงเส้นทางที่เป็นไปได้ระหว่าง (0, 0) และ (3, 4)

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

อินพุต: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
เอาต์พุต: false
คำอธิบาย:

ไม่มีเส้นทางจาก (0, 0) ถึง (3, 3)

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

อินพุต: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
เอาต์พุต: false
คำอธิบาย:

ไม่มีเส้นทางจาก (0, 0) ถึง (3, 3)
ตัวอย่างที่ 4:

อินพุต: xCorner = 4, yCorner = 4, circles = [[5,5,1]]
เอาต์พุต: true
คำอธิบาย:

ข้อจำกัด:

3 <= xCorner, yCorner <= 10^9
1 <= circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9

คุณจะได้รับจํานวนเต็มบวกสองตัว xCorner และ yCorner และวงกลมอาร์เรย์ 2 มิติ โดยที่ circles[i] = [x_i, y_i, r_i] หมายถึงวงกลมที่มีศูนย์กลางอยู่ที่ (x_i, y_i) และรัศมี r_i
มีสี่เหลี่ยมผืนผ้าในระนาบพิกัดโดยมีมุมล่างซ้ายที่จุดเริ่มต้นและมุมขวาบนที่พิกัด (xCorner, yCorner) คุณต้องตรวจสอบว่ามีเส้นทางจากมุมล่างซ้ายไปมุมบนขวาหรือไม่เพื่อให้เส้นทางทั้งหมดอยู่ภายในสี่เหลี่ยมผืนผ้าไม่สัมผัสหรืออยู่ภายในวงกลมใด ๆ และสัมผัสกับสี่เหลี่ยมผืนผ้าที่มุมทั้งสองเท่านั้น
ส่งกลับ true หากมีเส้นทางดังกล่าว และส่งคืน false มิฉะนั้น

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

อินพุต: xCorner = 3, yCorner = 4, circles = [[2,1,1]]
เอาท์พุต: จริง
การอธิบาย:

เส้นโค้งสีดําแสดงเส้นทางที่เป็นไปได้ระหว่าง (0, 0) และ (3, 4)

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

อินพุต: xCorner = 3, yCorner = 3, circles = [[1,1,2]]
เอาต์พุต: เท็จ
การอธิบาย:

ไม่มีเส้นทางตั้งแต่ (0, 0) ถึง (3, 3)

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

อินพุต: xCorner = 3, yCorner = 3, circles = [[2,1,1],[1,2,1]]
เอาต์พุต: เท็จ
การอธิบาย:

ไม่มีเส้นทางตั้งแต่ (0, 0) ถึง (3, 3)

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

อินพุต: xCorner = 4, yCorner = 4,  circles  = [[5,5,1]]
เอาท์พุต: จริง
การอธิบาย:

ข้อจํากัด:

3 <= xCorner, yCorner <= 10^9
1 <=  circles.length <= 1000
circles[i].length == 3
1 <= x_i, y_i, r_i <= 10^9


คุณจะได้รับจำนวนเต็ม n และอาร์เรย์แบบสอบถามจำนวนเต็ม 2 มิติ
มีเมือง n เมืองที่มีหมายเลขตั้งแต่ 0 ถึง n - 1 ในตอนแรกจะมีถนนทิศทางเดียวจากเมือง i ถึงเมือง i + 1 สำหรับ 0 <= i < n - 1 ทั้งหมด
queries[i] = [u_i, v_i] แสดงถึงการเพิ่มถนนทิศทางเดียวใหม่จากเมือง u_i ถึงเมือง v_i หลังจากแบบสอบถามแต่ละครั้ง คุณต้องค้นหาความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1
ส่งคืนอาร์เรย์คำตอบ โดยที่สำหรับแต่ละ i ในช่วง [0, queries.length - 1], answer[i] คือความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1 หลังจากประมวลผลแบบสอบถาม i + 1 ครั้งแรก

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

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

หลังจากบวกถนนจาก 2 เป็น 4 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 3

หลังจากบวกถนนจาก 0 เป็น 2 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 2

หลังจากบวกถนนจาก 0 เป็น 4 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 1

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

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

หลังจากบวกถนนจาก 0 เป็น 3 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 3 คือ 1

หลังจากบวกถนนจาก 0 เป็น 2 ความยาวของเส้นทางที่สั้นที่สุดยังคงอยู่ที่ 1

ข้อจำกัด:

3 <= n <= 500
1 <= queries.length <= 500
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
ไม่มีถนนที่ซ้ำกันระหว่างแบบสอบถาม

คุณจะได้รับจำนวนเต็ม n และอาร์เรย์แบบสอบถามจำนวนเต็ม 2 มิติ
มีเมือง n เมืองที่มีหมายเลขตั้งแต่ 0 ถึง n - 1 ในตอนแรกจะมีถนนทิศทางเดียวจากเมือง i ถึงเมือง i + 1 สำหรับ 0 <= i < n - 1 ทั้งหมด
queries[i] = [u_i, v_i] แสดงถึงการเพิ่มถนนทิศทางเดียวใหม่จากเมือง u_i ถึงเมือง v_i หลังจากแบบสอบถามแต่ละครั้ง คุณต้องค้นหาความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1
ส่งคืนอาร์เรย์คำตอบ โดยที่สำหรับแต่ละ i ในช่วง [0, queries.length - 1], answer[i] คือความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1 หลังจากประมวลผลแบบสอบถาม i + 1 ครั้งแรก

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

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

หลังจากบวกถนนจาก 2 เป็น 4 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 3

หลังจากบวกถนนจาก 0 เป็น 2 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 2

หลังจากบวกถนนจาก 0 เป็น 4 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 4 คือ 1

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

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

หลังจากบวกถนนจาก 0 เป็น 3 ความยาวของเส้นทางที่สั้นที่สุดจาก 0 เป็น 3 คือ 1

หลังจากบวกถนนจาก 0 เป็น 2 ความยาวของเส้นทางที่สั้นที่สุดยังคงอยู่ที่ 1

ข้อจำกัด:

3 <= n <= 500
1 <= query.length <= 500
queries[i].length == 2
0 <= query[i][0] < query[i][1] < n
1 < queries[i][1] - queries[i][0]
ไม่มีถนนที่ซ้ำกันระหว่างแบบสอบถาม

คุณจะได้รับค่าจำนวนเต็ม n และอาร์เรย์จำนวนเต็ม 2 มิติ
มี n เมืองที่มีหมายเลขตั้งแต่ 0 ถึง n - 1 ในตอนแรก จะมีถนนทิศทางเดียวจากเมือง i ไปยังเมือง i + 1 สำหรับ 0 ทั้งหมด <= i < n - 1
Queries[i] = [u_i, v_i] แสดงถึงการเพิ่มถนนทิศทางเดียวใหม่จากเมือง u_i ไปยังเมือง v_i หลังจากการสืบค้นแต่ละครั้ง คุณจะต้องค้นหาความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1
ส่งกลับคำตอบอาร์เรย์โดยที่ i แต่ละตัวอยู่ในช่วง [0, Queries.length - 1] answer[i] คือความยาวของเส้นทางที่สั้นที่สุดจากเมือง 0 ถึงเมือง n - 1 หลังจากประมวลผลคำสั่ง i + 1 แรก

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

อินพุต: n = 5, ข้อความค้นหา = [[2,4],[0,2],[0,4]]
เอาท์พุต: [3,2,1]
คำอธิบาย:

หลังจากเพิ่มถนนจาก 2 เป็น 4 แล้ว ความยาวของเส้นทางที่สั้นที่สุดจาก 0 ถึง 4 คือ 3

หลังจากเพิ่มถนนจาก 0 เป็น 2 แล้ว ความยาวของเส้นทางที่สั้นที่สุดจาก 0 ถึง 4 คือ 2

หลังจากเพิ่มถนนจาก 0 เป็น 4 แล้ว ความยาวของเส้นทางที่สั้นที่สุดจาก 0 ถึง 4 คือ 1

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

อินพุต: n = 4, แบบสอบถาม = [[0,3],[0,2]]
เอาท์พุต: [1,1]
คำอธิบาย:

หลังจากเพิ่มถนนจาก 0 เป็น 3 แล้ว ความยาวของเส้นทางที่สั้นที่สุดจาก 0 ถึง 3 คือ 1

หลังจากเพิ่มถนนจาก 0 เป็น 2 แล้ว ความยาวของเส้นทางที่สั้นที่สุดยังคงอยู่ที่ 1

ข้อจำกัด:

3 <= น <= 500
1 <= แบบสอบถามความยาว <= 500
แบบสอบถาม [i] .length == 2
0 <= แบบสอบถาม [i] [0] < แบบสอบถาม [i] [1] < n
1 < แบบสอบถาม[i][1] - แบบสอบถาม[i][0]
ไม่มีถนนซ้ำระหว่างการค้นหา


มีไทล์สีแดงและสีน้ำเงินบางส่วนจัดเรียงเป็นวงกลม คุณจะได้รับอาร์เรย์ของสีจำนวนเต็มและแบบสอบถามอาร์เรย์จำนวนเต็ม 2 มิติ
สีของไทล์ i แสดงโดย colors[i]:

colors[i] == 0 หมายความว่าไทล์ i เป็นสีแดง
colors[i] == 1 หมายความว่าไทล์ i เป็นสีน้ำเงิน

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

queries[i] = [1, size_i] กำหนดจำนวนกลุ่มสลับกันด้วยขนาด size_i
queries[i] = [2, index_i, color_i] เปลี่ยน colors[index_i] เป็น color_i

ส่งกลับคำตอบแบบอาร์เรย์ที่มีผลลัพธ์ของแบบสอบถามประเภทแรกตามลำดับ โปรดทราบว่าเนื่องจากสีแทนวงกลม ไทล์แรกและไทล์สุดท้ายจึงถือว่าอยู่ติดกัน

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

อินพุต: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
เอาต์พุต: [2]
คำอธิบาย:

คิวรีแรก:
เปลี่ยนcolors[1] เป็น 0

คิวรีที่สอง:
จำนวนกลุ่มที่สลับกันที่มีขนาด 4:

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

อินพุต: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
เอาต์พุต: [2,0]
คำอธิบาย:

คิวรีแรก:
จำนวนกลุ่มที่สลับกันที่มีขนาด 3:

คิวรีที่สอง: สีจะไม่เปลี่ยนแปลง แบบสอบถามที่สาม: ไม่มีกลุ่มสลับที่มีขนาด 5

ข้อจำกัด:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 หรือ queries[i][0] == 2
สำหรับ i ทั้งหมดที่:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

มีไทล์สีแดงและสีน้ำเงินบางส่วนจัดเรียงเป็นวงกลม คุณจะได้รับอาร์เรย์ของสีจำนวนเต็มและแบบสอบถามอาร์เรย์จำนวนเต็ม 2D
สีของไทล์ i แสดงโดย colors[i]:

colors[i] == 0 หมายความว่าไทล์ i เป็นสีแดง
colors[i] == 1 หมายความว่าไทล์ i เป็นสีน้ำเงิน

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

queries[i] = [1, size_i] กำหนดจำนวนกลุ่มสลับกันด้วยขนาด size_i
queries[i] = [2, index_i, color_i] เปลี่ยน colors[index_i] เป็น color_i

ส่งกลับคำตอบแบบอาร์เรย์ที่มีผลลัพธ์ของแบบสอบถามประเภทแรกตามลำดับ โปรดทราบว่าเนื่องจากสีแทนวงกลม ไทล์แรกและไทล์สุดท้ายจึงถือว่าอยู่ติดกัน

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

อินพุต: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
เอาต์พุต: [2]
คำอธิบาย:

คิวรีแรก:
เปลี่ยนcolors[1] เป็น 0

คิวรีที่สอง:
จำนวนกลุ่มที่สลับกันที่มีขนาด 4:

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

อินพุต: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
เอาต์พุต: [2,0]
คำอธิบาย:

คิวรีแรก:
จำนวนกลุ่มที่สลับกันที่มีขนาด 3:

คิวรีที่สอง: สีจะไม่เปลี่ยนแปลง แบบสอบถามที่สาม: ไม่มีกลุ่มสลับที่มีขนาด 5

ข้อจำกัด:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 or queries[i][0] == 2
สำหรับ i ทั้งหมดที่:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1

มีไทล์สีแดงและสีน้ำเงินบางส่วนจัดเรียงเป็นวงกลม คุณจะได้รับอาร์เรย์ของสีจำนวนเต็มและแบบสอบถามอาร์เรย์จำนวนเต็ม 2 มิติ
สีของไทล์ i แสดงโดย colors[i]:

colors[i] == 0 หมายความว่าไทล์ i เป็นสีแดง
colors[i] == 1 หมายความว่าไทล์ i เป็นสีน้ำเงิน

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

queries[i] = [1, size_i] กำหนดจำนวนกลุ่มสลับกันด้วยขนาด size_i
queries[i] = [2, index_i, color_i] เปลี่ยน colors[index_i] เป็น color_i

ส่งกลับคำตอบแบบอาร์เรย์ที่มีผลลัพธ์ของแบบสอบถามประเภทแรกตามลำดับ โปรดทราบว่าเนื่องจากสีแทนวงกลม ไทล์แรกและไทล์สุดท้ายจึงถือว่าอยู่ติดกัน

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

อินพุต: colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]
เอาต์พุต: [2]
คำอธิบาย:

คิวรีแรก:
เปลี่ยนสี[1] เป็น 0

คิวรีที่สอง:
จำนวนกลุ่มที่สลับกันที่มีขนาด 4:

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

อินพุต: colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]
เอาต์พุต: [2,0]
คำอธิบาย:

คิวรีแรก:
จำนวนกลุ่มที่สลับกันที่มีขนาด 3:

คิวรีที่สอง: สีจะไม่เปลี่ยนแปลง แบบสอบถามที่สาม: ไม่มีกลุ่มสลับที่มีขนาด 5

ข้อจำกัด:

4 <= colors.length <= 5 * 10^4
0 <= colors[i] <= 1
1 <= queries.length <= 5 * 10^4
queries[i][0] == 1 หรือ queries[i][0] == 2
สำหรับ i ทั้งหมดที่:

queries[i][0] == 1: queries[i].length == 2, 3 <= queries[i][1] <= colors.length - 1
queries[i][0] == 2: queries[i].length == 3, 0 <= queries[i][1] <= colors.length - 1, 0 <= queries[i][2] <= 1


มีงูอยู่ในตารางขนาด n x n และสามารถเคลื่อนที่ได้ 4 ทิศทาง แต่ละช่องในตารางระบุด้วยตำแหน่ง: grid[i][j] = (i * n) + j
งูเริ่มต้นที่ช่อง 0 และทำตามลำดับคำสั่งที่ให้
คุณได้รับจำนวนเต็ม n ที่แสดงขนาดของตารางและอาร์เรย์ของคำสั่งสตริงซึ่งแต่ละ คำสั่ง[i] คือ "UP", "RIGHT", "DOWN", หรือ "LEFT" โดยมีการรับประกันว่างูจะยังคงอยู่ในขอบเขตตารางในตลอดการเคลื่อนที่
ให้คืนค่าตำแหน่งของช่องสุดท้ายที่งูสิ้นสุดหลังจากดำเนินการตามคำสั่ง

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

Input: n = 2, commands = ["RIGHT","DOWN"]
Output: 3
คำอธิบาย:

0
1

2
3

0
1

2
3

0
1

2
3

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

Input: n = 3, commands = ["DOWN","RIGHT","UP"]
Output: 1
คำอธิบาย:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

ข้อจำกัด:

2 <= n <= 10
1 <= commands.length <= 100
คำสั่งประกอบด้วยแค่ "UP", "RIGHT", "DOWN", และ "LEFT"
input ถูกสร้างขึ้นเพื่อให้งูจะไม่เคลื่อนออกนอกขอบเขต

มีงูอยู่ในตารางขนาด n x n และสามารถเคลื่อนที่ได้ 4 ทิศทาง แต่ละช่องในตารางระบุด้วยตำแหน่ง: grid[i][j] = (i * n) + j
งูเริ่มต้นที่ช่อง 0 และทำตามลำดับคำสั่งที่ให้
คุณได้รับจำนวนเต็ม n ที่แสดงขนาดของตารางและอาร์เรย์ของ strings ที่ชื่อ commands ซึ่งแต่ละ command[i] คือ "UP", "RIGHT", "DOWN", หรือ "LEFT" โดยมีการรับประกันว่างูจะยังคงอยู่ภายในขอบเขตตารางในตลอดการเคลื่อนที่
ให้คืนค่าตำแหน่งของช่องสุดท้ายที่งูสิ้นสุดหลังจากดำเนินการตามคำสั่ง

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

Input: n = 2, commands = ["RIGHT","DOWN"]
Output: 3
คำอธิบาย:

0
1

2
3

0
1

2
3

0
1

2
3

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

Input: n = 3, commands = ["DOWN","RIGHT","UP"]
Output: 1
คำอธิบาย:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

Constraints:

2 <= n <= 10
1 <= commands.length <= 100
commands ประกอบด้วยแค่ "UP", "RIGHT", "DOWN", และ "LEFT"
input ถูกสร้างขึ้นเมื่องูจะไม่เคลื่อนออกนอกขอบเขต

มีงูอยู่ในตารางเมทริกซ์ n x n และสามารถเคลื่อนที่ได้สี่ทิศทางที่เป็นไปได้ แต่ละเซลล์ในตารางจะถูกระบุด้วยตําแหน่ง: grid[i][j] = (i * n) + j
งูเริ่มต้นที่เซลล์ 0 และทําตามลําดับคําสั่ง
คุณจะได้รับจํานวนเต็ม n ที่แสดงถึงขนาดของตารางและอาร์เรย์ของคําสั่งสตริงที่แต่ละคําสั่ง [i] เป็น "UP", "RIGHT", "DOWN" และ "LEFT" รับประกันได้ว่างูจะยังคงอยู่ในขอบเขตกริดตลอดการเคลื่อนไหว
ส่งคืนตําแหน่งของเซลล์สุดท้ายที่งูลงเอยหลังจากดําเนินการคําสั่ง

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

อินพุต: n = 2, commands  = ["ขวา","ลง"]
เอาท์พุต: 3
การอธิบาย:

0
1

2
3

0
1

2
3

0
1

2
3

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

อินพุต: n = 3, commands = ["ลง","ขวา","ขึ้น"]
เอาท์พุต: 1
การอธิบาย:

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

0
1
2

3
4
5

6
7
8

ข้อจํากัด:

2 <= n <= 10
1 <= commands.length <= 100
คําสั่งประกอบด้วย "UP", "RIGHT", "DOWN" และ "LEFT" เท่านั้น
อินพุตถูกสร้างขึ้นเพื่อให้งูจะไม่เคลื่อนออกนอกขอบเขต


ให้คุณอาร์เรย์ของจำนวนเต็มบวก ที่มีความยาว n เราเรียกคู่ของอาร์เรย์ที่เป็นจำนวนเต็มไม่เป็นลบ (arr1, arr2) ว่ามีลักษณะเป็น monotonic ถ้า:

ความยาวของทั้งสองอาร์เรย์เท่ากับ n
arr1 เป็นค่าที่ไม่ลดลงในลำดับ เช่น arr1[0] <= arr1[1] <= ... <= arr1[n - 1]
arr2 เป็นค่าที่ไม่เพิ่มขึ้นในลำดับ เช่น arr2[0] >= arr2[1] >= ... >= arr2[n - 1]
arr1[i] + arr2[i] == nums[i] สำหรับทุก 0 <= i <= n - 1

จงคืนค่าจำนวนคู่ที่มีลักษณะเป็น monotonic เนื่องจากคำตอบอาจมีขนาดใหญ่มาก ให้คืนค่าผลลัพธ์โมดูโล 10^9 + 7

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

Input: nums = [2,3,2]
Output: 4
คำอธิบาย:
คู่ที่ดีคือ:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

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

Input: nums = [5,5,5,5]
Output: 126

ข้อจำกัด:

1 <= n == nums.length <= 2000
1 <= nums[i] <= 50

คุณจะได้รับอาร์เรย์ของจำนวนเต็มบวกจำนวนนับที่มีความยาว n
เราเรียกอาร์เรย์จำนวนเต็มที่ไม่เป็นลบคู่หนึ่ง (arr1, arr2) ว่าเป็นแบบโมโนโทนิกถ้า:

ความยาวของอาร์เรย์ทั้งสองคือ n
arr1 ไม่ลดลงแบบโมโนโทนิก กล่าวอีกนัยหนึ่งคือ arr1[0] <= arr1[1] <= ... <= arr1[n - 1]
arr2 ไม่ลดลงแบบโมโนโทนิก กล่าวอีกนัยหนึ่งคือ arr2[0] >= arr2[1] >= ... >= arr2[n - 1]
arr1[i] + arr2[i] == nums[i] สำหรับ 0 <= i <= n - 1 ทั้งหมด

ส่งคืนจำนวนคู่โมโนโทนิก เนื่องจากคำตอบอาจมีค่ามาก ให้คืนค่าโมดูโล 10^9 + 7

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

อินพุต: nums = [2,3,2]
เอาต์พุต: 4
คำอธิบาย:
คู่ที่ดีคือ:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

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

อินพุต: nums = [5,5,5,5]
เอาต์พุต: 126

ข้อจำกัด:

1 <= n == nums.length <= 2000
1 <= nums[i] <= 50

คุณได้รับอาร์เรย์ของจำนวนเต็มบวก nums ที่มีความยาว n
เราจะเรียกคู่ของอาร์เรย์จำนวนเต็มไม่เป็นลบ (arr1, arr2) ว่าเป็นโมโนโทนิก หาก:

ความยาวของอาร์เรย์ทั้งสองคือ n.
arr1 เป็นอาร์เรย์ที่ไม่ลดลงอย่างต่อเนื่อง กล่าวคือ arr1[0] <= arr1[1] <= ... <= arr1[n - 1].
arr2 เป็นอาร์เรย์ที่ไม่เพิ่มขึ้นอย่างต่อเนื่อง กล่าวคือ arr2[0] >= arr2[1] >= ... >= arr2[n - 1].
arr1[i] + arr2[i] == nums[i] สำหรับทุก 0 <= i <= n - 1.

ให้คืนค่าจำนวนคู่ที่เป็นโมโนโทนิก
เนื่องจากคำตอบอาจมีค่ามาก จึงให้คืนค่าเป็นโมดูล 10^9 + 7.

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

Input: nums = [2,3,2] Output: 4 คำอธิบาย: คู่ที่ดีคือ:

([0, 1, 1], [2, 2, 1])
([0, 1, 2], [2, 2, 0])
([0, 2, 2], [2, 1, 0])
([1, 2, 2], [1, 1, 0])

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

Input: nums = [5,5,5,5] Output: 126

ข้อจำกัด:

1 <= n == nums.length <= 2000
1 <= nums[i] <= 50


คุณได้รับสตริง s
งานของคุณคือการลบตัวเลขทั้งหมดโดยทำการดำเนินการนี้ซ้ำ:

ลบตัวเลขตัวแรกและอักขระที่ไม่ใช่ตัวเลขที่ใกล้ที่สุดทางด้านซ้าย

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

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

Input: s = "abc"
Output: "abc"
คำอธิบาย:
ไม่มีตัวเลขในสตริง

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

Input: s = "cb34"
Output: ""
คำอธิบาย:
ก่อนอื่น เรานำการดำเนินการไปใช้กับ s[2] และ s กลายเป็น "c4"
จากนั้นเรานำการดำเนินการไปใช้กับ s[1] และ s กลายเป็น ""

ข้อจำกัด:

1 <= s.length <= 100
s ประกอบด้วยเฉพาะตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กและตัวเลข
อินพุตถูกสร้างขึ้นเพื่อให้สามารถลบตัวเลขทั้งหมดได้

คุณจะได้รับสตริง s
งานของคุณคือการลบตัวเลขทั้งหมดโดยดําเนินการนี้ซ้ําๆ

ลบหลักแรกและอักขระที่ไม่ใช่ตัวเลขที่ใกล้ที่สุดทางด้านซ้าย

ส่งคืนสตริงผลลัพธ์หลังจากลบตัวเลขทั้งหมด

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

อินพุต: s = "abc"
เอาต์พุต: "abc"
การอธิบาย:
ไม่มีตัวเลขในสตริง

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

อินพุต: s = "cb34"
เอาท์พุต: ""
การอธิบาย:
ขั้นแรก เราใช้การดําเนินการกับ s[2] และ s จะกลายเป็น "c4"
จากนั้นเราใช้การดําเนินการกับ s[1] และ s จะกลายเป็น ""

ข้อจํากัด:

1 <=s.length <= 100
s ประกอบด้วยตัวอักษรและตัวเลขภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น
อินพุตถูกสร้างขึ้นเพื่อให้สามารถลบตัวเลขทั้งหมดได้


การแข่งขันประกอบด้วยผู้เล่น n คนซึ่งกำหนดหมายเลขตั้งแต่ 0 ถึง n - 1
คุณจะได้รับอาร์เรย์จำนวนเต็มของทักษะที่มีขนาด n และจำนวนเต็มบวก k โดยที่ทักษะ[i] คือระดับทักษะของผู้เล่น i จำนวนเต็มทั้งหมดในทักษะจะไม่ซ้ำกัน
ผู้เล่นทุกคนยืนต่อคิวตามลำดับจากผู้เล่น 0 ถึงผู้เล่น n - 1
กระบวนการแข่งขันมีดังนี้:

ผู้เล่นสองคนแรกในคิวเล่นเกม และผู้เล่นที่มีระดับทักษะสูงกว่าจะเป็นผู้ชนะ
หลังจากเกมจบลง ผู้ชนะจะอยู่ที่จุดเริ่มต้นของคิว และผู้แพ้จะอยู่ที่จุดสิ้นสุดของคิว

ผู้ชนะการแข่งขันคือผู้เล่นคนแรกที่ชนะเกมติดต่อกัน k เกม
ส่งคืนดัชนีเริ่มต้นของผู้เล่นที่ชนะ

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

อินพุต: skills = [4,2,6,3,9], k = 2
เอาต์พุต: 2
คำอธิบาย:
ในตอนแรก คิวของผู้เล่นคือ [0,1,2,3,4] กระบวนการต่อไปนี้เกิดขึ้น:

ผู้เล่น 0 และ 1 เล่นเกม เนื่องจากทักษะของผู้เล่น 0 สูงกว่าผู้เล่น 1 ผู้เล่น 0 จึงชนะ คิวที่ได้คือ [0,2,3,4,1]
ผู้เล่น 0 และ 2 เล่นเกม เนื่องจากทักษะของผู้เล่น 2 สูงกว่าผู้เล่น 0 ผู้เล่น 2 จึงชนะ คิวที่ได้คือ [2,3,4,1,0]

ผู้เล่น 2 และ 3 เล่นเกม เนื่องจากทักษะของผู้เล่น 2 สูงกว่าผู้เล่น 3 ผู้เล่น 2 จึงชนะ คิวที่ได้คือ [2,4,1,0,3]

ผู้เล่น 2 ชนะ k = 2 เกมติดต่อกัน ดังนั้นผู้ชนะคือผู้เล่น 2

ตัวอย่าง 2:

อินพุต: skills = [2,5,4], k = 3
เอาต์พุต: 1
คำอธิบาย:
ในตอนแรก คิวของผู้เล่นคือ [0,1,2] กระบวนการต่อไปนี้เกิดขึ้น:

ผู้เล่น 0 และ 1 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าทักษะของผู้เล่น 0 ผู้เล่น 1 จึงเป็นผู้ชนะ คิวที่ได้คือ [1,2,0]
ผู้เล่น 1 และ 2 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าทักษะของผู้เล่น 2 ผู้เล่น 1 จึงเป็นผู้ชนะ คิวที่ได้คือ [1,0,2]

ผู้เล่น 1 และ 0 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าทักษะของผู้เล่น 0 ผู้เล่น 1 จึงเป็นผู้ชนะ คิวที่ได้คือ [1,2,0]

ผู้เล่น 1 ชนะ k = 3 เกมติดต่อกัน ดังนั้นผู้ชนะคือผู้เล่น 1

เงื่อนไข:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
จำนวนเต็มทั้งหมดในทักษะจะไม่ซ้ำกัน

การแข่งขันประกอบด้วยผู้เล่น n คนที่มีหมายเลขตั้งแต่ 0 ถึง n - 1
คุณจะได้รับทักษะอาร์เรย์จํานวนเต็มขนาด n และจํานวนเต็มบวก k โดยที่ skills[i] คือระดับทักษะของผู้เล่น i จํานวนเต็มทั้งหมดในทักษะนั้นไม่ซ้ํากัน
ผู้เล่นทุกคนยืนอยู่ในคิวตามลําดับจากผู้เล่น 0 ถึงผู้เล่น n - 1
ขั้นตอนการแข่งขันมีดังนี้:

ผู้เล่นสองคนแรกในคิวเล่นเกม และผู้เล่นที่มีระดับทักษะสูงกว่าจะเป็นผู้ชนะ
หลังจบเกม ผู้ชนะจะอยู่ที่จุดเริ่มต้นของคิว และผู้แพ้จะไปจนจบ

ผู้ชนะการแข่งขันคือผู้เล่นคนแรกที่ชนะ k เกมติดต่อกัน
ส่งคืนดัชนีเริ่มต้นของผู้เล่นที่ชนะ

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

อินพุต: skills = [4,2,6,3,9], k = 2
เอาท์พุต: 2
การอธิบาย:
ในขั้นต้น คิวของผู้เล่นคือ [0,1,2,3,4] กระบวนการต่อไปนี้เกิดขึ้น:

ผู้เล่น 0 และ 1 เล่นเกม เนื่องจากทักษะของผู้เล่น 0 สูงกว่าผู้เล่น 1 ผู้เล่น 0 จะชนะ คิวผลลัพธ์คือ [0,2,3,4,1]
ผู้เล่น 0 และ 2 เล่นเกม เนื่องจากทักษะของผู้เล่น 2 สูงกว่าผู้เล่น 0 ผู้เล่น 2 จึงชนะ คิวผลลัพธ์คือ [2,3,4,1,0]
ผู้เล่น 2 และ 3 เล่นเกม เนื่องจากทักษะของผู้เล่น 2 สูงกว่าผู้เล่น 3 ผู้เล่น 2 จึงชนะ คิวผลลัพธ์คือ [2,4,1,0,3]

ผู้เล่น 2 ชนะ k = 2 เกมติดต่อกัน ดังนั้นผู้ชนะคือผู้เล่น 2

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

อินพุต:skills = [2,5,4], k = 3
เอาท์พุต: 1
การอธิบาย:
ในขั้นต้น คิวของผู้เล่นคือ [0,1,2] กระบวนการต่อไปนี้เกิดขึ้น:

ผู้เล่น 0 และ 1 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าผู้เล่น 0 ผู้เล่น 1 จึงชนะ คิวผลลัพธ์คือ [1,2,0]
ผู้เล่น 1 และ 2 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าผู้เล่น 2 ผู้เล่น 1 จึงชนะ คิวผลลัพธ์คือ [1,0,2]
ผู้เล่น 1 และ 0 เล่นเกม เนื่องจากทักษะของผู้เล่น 1 สูงกว่าผู้เล่น 0 ผู้เล่น 1 จึงชนะ คิวผลลัพธ์คือ [1,2,0]

ผู้เล่น 1 ชนะ k = 3 เกมติดต่อกัน ดังนั้นผู้ชนะคือผู้เล่น 1

ข้อจํากัด:

n == skills.length
2 <= n <= 10^5
1 <= k <= 10^9
1 <= skills[i] <= 10^6
จํานวนเต็มทั้งหมดในทักษะนั้นไม่ซ้ํากัน


ให้คุณมีอาร์เรย์ของจำนวนเต็มที่ชื่อ nums และจำนวนเต็มที่ไม่เป็นลบ k ลำดับของจำนวนเต็ม seq จะเรียกว่า "ดี" ถ้ามีดัชนี i ที่ไม่เกิน k ในช่วง [0, seq.length - 2] ซึ่งทำให้ seq[i] != seq[i + 1]

จงหาความยาวสูงสุดที่เป็นไปได้ของลำดับย่อยที่ดีจาก nums

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

Input: nums = [1,2,1,1,3], k = 2
Output: 4
คำอธิบาย:
ลำดับที่ยาวที่สุดคือ [1,2,1,1,3].

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

Input: nums = [1,2,3,4,5,1], k = 0
Output: 2
คำอธิบาย:
ลำดับที่ยาวที่สุดคือ [1,2,3,4,5,1].

ข้อจำกัด:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

คุณจะได้รับอาร์เรย์จำนวนเต็ม nums และจำนวนเต็มที่ไม่เป็นลบ k ลำดับของจำนวนเต็ม seq จะถูกเรียกว่า good ถ้ามีดัชนี i ไม่เกิน k ในช่วง [0, seq.length - 2] ที่ทำให้ seq[i] != seq[i + 1]
ส่งคืนความยาวสูงสุดที่เป็นไปได้ของลำดับย่อยที่ดีของ nums

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

อินพุต: nums = [1,2,1,1,3], k = 2
เอาต์พุต: 4
คำอธิบาย:
ลำดับย่อยความยาวสูงสุดคือ [1,2,1,1,3]

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

อินพุต: nums = [1,2,3,4,5,1], k = 0
เอาต์พุต: 2
คำอธิบาย:
ลำดับย่อยความยาวสูงสุดคือ [1,2,3,4,5,1]

ข้อจำกัด:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)

คุณได้รับอาเรย์จำนวนเต็ม nums และจำนวนเต็มไม่เป็นลบ k ลำดับของจำนวนเต็ม seq จะถูกเรียกว่าดีถ้ามีดัชนี i สูงสุด k ดัชนีในช่วง [0, seq.length - 2] ที่ seq[i] ไม่เท่ากับ seq[i + 1]
คืนค่าความยาวสูงสุดที่เป็นไปได้ของอนุกรมย่อยที่ดีของ nums

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

Input: nums = [1,2,1,1,3], k = 2
Output: 4
คำอธิบาย:
ลำดับย่อยที่ยาวที่สุดคือ [1,2,1,1,3].

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

Input: nums = [1,2,3,4,5,1], k = 0
Output: 2
คำอธิบาย:
ลำดับย่อยที่ยาวที่สุดคือ [1, 2] หรือ [2, 3] หรือ [3, 4] หรือ [4, 5] หรือ [5, 1].

ข้อจำกัด:

1 <= nums.length <= 500
1 <= nums[i] <= 10^9
0 <= k <= min(nums.length, 25)


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ในการดำเนินการครั้งหนึ่ง คุณสามารถเพิ่มหรือลบ 1 จากองค์ประกอบใดๆ ของ nums ได้
ส่งกลับจำนวนการดำเนินการขั้นต่ำเพื่อทำให้องค์ประกอบทั้งหมดของ nums หารด้วย 3 ลงตัว

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

อินพุต: nums = [1,2,3,4]
เอาต์พุต: 3
คำอธิบาย:
องค์ประกอบอาร์เรย์ทั้งหมดสามารถทำให้หารด้วย 3 ลงตัวได้โดยใช้การดำเนินการ 3 ประการ:

ลบ 1 จาก 1
บวก 1 กับ 2
ลบ 1 จาก 4

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

อินพุต: nums = [3,6,9]
เอาต์พุต: 0

ข้อจำกัด:

1 <= nums.length <= 50
1 <= nums[i] <= 50

คุณจะได้รับอาร์เรย์จำนวนเต็ม ในการดำเนินการครั้งเดียวคุณสามารถเพิ่มหรือลบ 1 จากองค์ประกอบของ nums ใด ๆ
ส่งคืนจำนวนขั้นต่ำของการดำเนินการเพื่อให้องค์ประกอบทั้งหมดของ nums หารด้วย 3

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

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

ลบ 1 จาก 1
เพิ่ม 1 ถึง 2
ลบ 1 จาก 4

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

อินพุต: nums = [3,6,9]
เอาท์พุท: 0

ข้อ จำกัด :

1 <= nums.length <= 50
1 <= nums [i] <= 50

ให้คุณอาเรย์ของจำนวนเต็ม nums ในการดำเนินการหนึ่งครั้ง คุณสามารถบวกหรือลบ 1 จากองค์ประกอบใด ๆ ของ nums ได้
คืนค่าจำนวนการดำเนินการขั้นต่ำเพื่อทำให้องค์ประกอบทั้งหมดของ nums หารด้วย 3 ลงตัว

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

Input: nums = [1,2,3,4]
Output: 3
คำอธิบาย:
องค์ประกอบทั้งหมดในอาเรย์สามารถทำให้หารด้วย 3 ลงตัวโดยใช้การดำเนินการ 3 ครั้ง:

ลบ 1 จาก 1
บวก 1 ไปที่ 2
ลบ 1 จาก 4

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

Input: nums = [3,6,9]
Output: 0

ข้อจำกัด:

1 <= nums.length <= 50
1 <= nums[i] <= 50


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

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

การพลิกองค์ประกอบหมายถึงการเปลี่ยนค่าเป็น 0 เป็น 1 และจาก 1 เป็น 0
ส่งคืนจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อทำให้ทุกองค์ประกอบใน nums เท่ากับ 1 หากไม่สามารถทำได้ ให้ส่งคืน -1

ตัวอย่าง 1:

Input: nums = [0,1,1,1,0,0]
Output: 3
คำอธิบาย:
เราสามารถทำการดำเนินการต่อไปนี้ได้:

เลือกองค์ประกอบที่ดัชนี 0, 1 และ 2 อาร์เรย์ที่ได้คือ nums = [1,0,0,1,0,0].
เลือกองค์ประกอบที่ดัชนี 1, 2 และ 3 อาร์เรย์ที่ได้คือ nums = [1,1,1,0,0,0].
เลือกองค์ประกอบที่ดัชนี 3, 4 และ 5 อาร์เรย์ที่ได้คือ nums = [1,1,1,1,1,1].

ตัวอย่าง 2:

Input: nums = [0,1,1,1]
Output: -1
คำอธิบาย:
ไม่สามารถทำให้ทุกองค์ประกอบเท่ากับ 1 ได้

ข้อจำกัด:

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

คุณได้รับอาเรย์เลขฐานสอง nums
คุณสามารถดำเนินการต่อไปนี้ในอาร์เรย์ได้ทุกครั้ง (อาจเป็นศูนย์):

เลือกองค์ประกอบติดต่อกัน 3 รายการจากอาร์เรย์และพลิกทั้งหมด

การพลิกองค์ประกอบหมายถึงการเปลี่ยนค่าจาก 0 เป็น 1 และจาก 1 เป็น 0
ส่งคืนจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการสร้างองค์ประกอบทั้งหมดใน nums เท่ากับ 1 ถ้าเป็นไปไม่ได้ให้ส่งคืน -1

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

อินพุต: nums = [0,1,1,1,0,0]
เอาท์พุท: 3
คำอธิบาย:
เราสามารถดำเนินการต่อไปนี้:

เลือกองค์ประกอบที่ดัชนี 0, 1 และ 2 อาร์เรย์ที่ได้คือ nums = [1,0,0,1,0,0]
เลือกองค์ประกอบที่ดัชนี 1, 2 และ 3 อาร์เรย์ที่ได้คือ nums = [1,1,1,0,0,0]
เลือกองค์ประกอบที่ดัชนี 3, 4 และ 5 อาร์เรย์ที่ได้คือ nums = [1,1,1,1,1,1]

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

อินพุต: nums = [0,1,1,1]
เอาท์พุท: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะทำให้องค์ประกอบทั้งหมดเท่ากับ 1

ข้อ จำกัด :

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

คุณจะได้รับอาร์เรย์ไบนารี
คุณสามารถดำเนินการต่อไปนี้กับอาร์เรย์ได้หลายครั้ง (อาจเป็นศูนย์):

เลือกองค์ประกอบติดต่อกัน 3 รายการจากอาร์เรย์และพลิกค่าของทั้งหมด

การพลิกองค์ประกอบหมายถึงการเปลี่ยนค่าจาก 0 เป็น 1 และจาก 1 เป็น 0
ส่งคืนจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการสร้างองค์ประกอบทั้งหมดใน nums เท่ากับ 1 ถ้าเป็นไปไม่ได้ให้ส่งคืน -1

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

อินพุต: nums = [0,1,1,1,1,0,0]
เอาท์พุท: 3
คำอธิบาย:
เราสามารถดำเนินการต่อไปนี้:

เลือกองค์ประกอบที่ดัชนี 0, 1 และ 2 อาร์เรย์ที่ได้คือ [1,0,0,1,0,0]
เลือกองค์ประกอบที่ดัชนี 1, 2 และ 3 อาร์เรย์ที่ได้คือ nums = [1,1,1,0,0,0]
เลือกองค์ประกอบที่ดัชนี 3, 4 และ 5 อาร์เรย์ที่ได้คือ nums = [1,1,1,1,1,1]

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

อินพุต: nums = [0,1,1,1]
เอาท์พุท: -1
คำอธิบาย:
เป็นไปไม่ได้ที่จะทำให้องค์ประกอบทั้งหมดเท่ากับ 1

ข้อ จำกัด :

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


คุณจะได้รับจำนวนเต็ม n และข้อกำหนดของอาร์เรย์ 2 มิติ โดยที่ requirements[i] = [end_i, cnt_i] แสดงถึงดัชนีสิ้นสุดและจำนวนการผกผันของข้อกำหนดแต่ละรายการ
คู่ของดัชนี (i, j) จากอาร์เรย์จำนวนเต็ม nums เรียกว่าการผกผันหาก:

i < j และ nums[i] > nums[j]

ส่งคืนจำนวนการเรียงสับเปลี่ยน perm ของ [0, 1, 2, ..., n - 1] โดยที่สำหรับ requirements[i] ทั้งหมด perm[0..end_i] จะมีการผกผัน cnt_i พอดี เนื่องจากคำตอบอาจมีค่ามาก ให้คืนค่าโมดูโล 10^9 + 7

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

อินพุต: n = 3, requirements = [[2,2],[0,0]]
เอาต์พุต: 2
คำอธิบาย:
การเรียงสับเปลี่ยนสองแบบคือ:

[2, 0, 1]

คำนำหน้า [2, 0, 1] มีการผกผัน (0, 1) และ (0, 2)
คำนำหน้า [2] มีการผกผัน 0 ครั้ง

[1, 2, 0]

คำนำหน้า [1, 2, 0] มีการผกผัน (0, 2) และ (1, 2)
คำนำหน้า [1] มีการผกผัน 0 ครั้ง
ตัวอย่างที่ 2:

อินพุต: n = 3, requirements = [[2,2],[1,1],[0,0]]
เอาต์พุต: 1
คำอธิบาย:
การเรียงสับเปลี่ยนที่ตรงตามเงื่อนไขเพียงแบบเดียวคือ [2, 0, 1]:

คำนำหน้า [2, 0, 1] มีการผกผัน (0, 1) และ (0, 2)
คำนำหน้า [2, 0] มีการผกผัน (0, 1)
คำนำหน้า [2] มีการผกผัน 0 ครั้ง

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

อินพุต: n = 2, requirements = [[0,0],[1,0]]
เอาต์พุต: 1
คำอธิบาย:
การเรียงสับเปลี่ยนที่ตรงตามเงื่อนไขเพียงแบบเดียวคือ [0, 1]:

คำนำหน้า [0] มีการผกผัน 0 ครั้ง
คำนำหน้า [0, 1] มีการผกผัน (0, 1)
ข้อจำกัด:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
อินพุตจะถูกสร้างขึ้นเพื่อให้มีอย่างน้อยหนึ่ง i ที่ทำให้ end_i == n - 1
อินพุตจะถูกสร้างขึ้นเพื่อให้ end_i ทั้งหมดไม่ซ้ำกัน

คุณจะได้รับจํานวนเต็ม n และข้อกําหนดอาร์เรย์ 2 มิติ โดยที่ requirements[i] = [end_i, cnt_i] แสดงถึงดัชนีสิ้นสุดและจํานวนการผกผันของแต่ละข้อกําหนด
ดัชนีคู่หนึ่ง (i, j) จากอาร์เรย์จํานวนเต็ม nums เรียกว่าการผกผันหาก:

i < j และ nums[i] > nums[j]

ส่งคืนจํานวนการเรียงสับเปลี่ยนของ [0, 1, 2, ..., n - 1] เพื่อให้สําหรับข้อกําหนดทั้งหมด[i], perm[0..end_i] มีการผกผัน cnt_i พอดี
เนื่องจากคําตอบอาจใหญ่มาก ให้ส่งคืนโมดูโล 10^9 + 7

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

อินพุต: n = 3, requirements = [[2,2],[0,0]]
เอาท์พุต: 2
การอธิบาย:
การเรียงสับเปลี่ยนทั้งสองคือ:

[2, 0, 1]

คํานําหน้า [2, 0, 1] มีการผกผัน (0, 1) และ (0, 2) ตามลำดับ
คํานําหน้า [2] มีการผกผัน 0 ครั้ง

[1, 2, 0]

คํานําหน้า [1, 2, 0] มีการผกผัน (0, 2) และ (1, 2)
คํานําหน้า [1] มีการผกผัน 0 ครั้ง

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

อินพุต: n = 3, requirements = [[2,2],[1,1],[0,0]]
เอาท์พุต: 1
การอธิบาย:
การเรียงสับเปลี่ยนที่น่าพอใจเพียงอย่างเดียวคือ [2, 0, 1]:

คํานําหน้า [2, 0, 1] มีการผกผัน (0, 1) และ (0, 2)
คํานําหน้า [2, 0] มีการผกผัน (0, 1)
คํานําหน้า [2] มีการผกผัน 0 ครั้ง

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

อินพุต: n = 2, requirements = [[0,0],[1,0]]
เอาท์พุต: 1
การอธิบาย:
การเรียงสับเปลี่ยนที่น่าพอใจเพียงอย่างเดียวคือ [0, 1]:

คํานําหน้า [0] มีการผกผัน 0 ครั้ง
คํานําหน้า [0, 1] มีการผกผัน (0, 1)

ข้อจํากัด:

2 <= n <= 300
1 <= requirements.length <= n
requirements[i] = [end_i, cnt_i]
0 <= end_i <= n - 1
0 <= cnt_i <= 400
อินพุตถูกสร้างขึ้นเพื่อให้มีอย่างน้อยหนึ่ง i ที่ end_i == n - 1
อินพุตถูกสร้างขึ้นเพื่อให้ end_i ทั้งหมดไม่ซ้ํากัน


มีวงกลมที่เต็มไปด้วยกระเบื้องสีแดงและสีน้ำเงิน คุณจะได้รับอาร์เรย์ของสีจำนวนเต็ม สีของกระเบื้อง i แสดงโดย colors[i]:

colors[i] == 0 หมายความว่ากระเบื้อง i เป็นสีแดง
colors[i] == 1 หมายความว่ากระเบื้อง i เป็นสีน้ำเงิน

กระเบื้อง 3 แผ่นที่ติดกันในวงกลมที่มีสีสลับกัน (กระเบื้องตรงกลางมีสีที่ต่างจากกระเบื้องด้านซ้ายและขวา) เรียกว่ากลุ่มสลับกัน
ส่งคืนจำนวนกลุ่มสลับกัน
โปรดทราบว่าเนื่องจากสีแสดงถึงวงกลม กระเบื้องแผ่นแรกและแผ่นสุดท้ายจึงถือว่าอยู่ติดกัน
ตัวอย่างที่ 1:

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

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

อินพุต: colors = [0,1,0,0,1]
เอาต์พุต: 3
คำอธิบาย:

กลุ่มสลับกัน:

ข้อจำกัด:

3 <= colors.length <= 100
0 <= colors[i] <= 1

มีวงกลมของกระเบื้องสีแดงและสีน้ําเงิน คุณจะได้รับอาร์เรย์ของสีจํานวนเต็ม สีของกระเบื้อง i แสดงด้วยสี[i]:

colors[i] == 0 หมายความว่าไทล์ i เป็นสีแดง
colors[i] == 1 หมายความว่าไทล์ i เป็นสีน้ําเงิน

ทุกๆ 3 กระเบื้องที่อยู่ติดกันในวงกลมที่มีสีสลับกัน (กระเบื้องตรงกลางมีสีแตกต่างจากกระเบื้องซ้ายและขวา) เรียกว่ากลุ่มสลับกัน
ส่งกลับจํานวนกลุ่มสลับกัน
โปรดทราบว่าเนื่องจากสีเป็นวงกลม กระเบื้องแรกและแผ่นสุดท้ายจึงถือว่าอยู่ติดกัน

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

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

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

อินพุต: colors = [0,1,0,0,1]
เอาท์พุต: 3
การอธิบาย:

สลับกลุ่ม:

ข้อจํากัด:

3 <= colors.length <= 100
0 <= colors[i] <= 1


คุณจะได้รับอาร์เรย์จำนวนเต็มของ enemyEnergies ซึ่งระบุค่าพลังงานของศัตรูต่างๆ
คุณยังได้รับ currentEnergy จำนวนเต็ม ซึ่งระบุจำนวนพลังงานที่คุณมีในตอนแรก
คุณเริ่มต้นด้วย 0 คะแนน และศัตรูทั้งหมดจะไม่ถูกทำเครื่องหมายในตอนแรก
คุณสามารถดำเนินการต่อไปนี้อย่างใดอย่างหนึ่งหรือหลายครั้งเพื่อรับคะแนน:

เลือกศัตรูที่ไม่ได้ทำเครื่องหมาย i โดยที่ currentEnergy >= enemyEnergies[i] เมื่อเลือกตัวเลือกนี้:

คุณจะได้รับ 1 คะแนน
พลังงานของคุณจะลดลงตามพลังงานของศัตรู กล่าวคือ currentEnergy = currentEnergy - enemyEnergies[i]

หากคุณมีอย่างน้อย 1 คะแนน คุณสามารถเลือกศัตรูที่ไม่ได้ทำเครื่องหมาย i ได้ เมื่อเลือกตัวเลือกนี้:

พลังงานของคุณจะเพิ่มขึ้นตามพลังงานของศัตรู กล่าวคือ currentEnergy = currentEnergy + enemyEnergies[i]
ศัตรู i จะถูกทำเครื่องหมาย

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

ตัวอย่าง 1:

อินพุต: enemyEnergies = [3,2,2], currentEnergy = 2
เอาต์พุต: 3
คำอธิบาย:
สามารถดำเนินการต่อไปนี้เพื่อรับ 3 คะแนน ซึ่งเป็นคะแนนสูงสุด:

การดำเนินการครั้งแรกกับศัตรูที่ 1: คะแนนเพิ่มขึ้น 1 และ currentEnergy ลดลง 2 ดังนั้น คะแนน = 1 และ currentEnergy = 0
การดำเนินการครั้งที่สองกับศัตรูที่ 0: currentEnergy เพิ่มขึ้น 3 และศัตรูที่ 0 ถูกทำเครื่องหมาย ดังนั้น คะแนน = 1, currentEnergy = 3 และศัตรูที่ถูกทำเครื่องหมาย = [0]
การดำเนินการครั้งแรกกับศัตรู 2: คะแนนเพิ่มขึ้น 1 และ currentEnergy ลดลง 2 ดังนั้น คะแนน = 2, currentEnergy = 1 และศัตรูที่ถูกทำเครื่องหมาย = [0]
การดำเนินการครั้งที่สองกับศัตรู 2: currentEnergy เพิ่มขึ้น 2 และศัตรูที่ถูกทำเครื่องหมาย 2 ดังนั้น คะแนน = 2, พลังงานปัจจุบัน = 3 และศัตรูที่ทำเครื่องหมายไว้ = [0, 2]
การดำเนินการครั้งแรกกับศัตรูที่ 1: คะแนนเพิ่มขึ้น 1 และพลังงานปัจจุบันลดลง 2 ดังนั้น คะแนน = 3, พลังงานปัจจุบัน = 1 และศัตรูที่ทำเครื่องหมายไว้ = [0, 2]

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

อินพุต: enemyEnergies = [2], currentEnergy = 10
เอาต์พุต: 5
คำอธิบาย:
การดำเนินการครั้งแรก 5 ครั้งกับศัตรูที่ 0 ส่งผลให้ได้คะแนนสูงสุด

ข้อจำกัด:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

คุณจะได้รับอาร์เรย์จำนวนเต็มของ enemyEnergies ซึ่งระบุค่าพลังงานของศัตรูต่างๆ
คุณยังได้รับ currentEnergy จำนวนเต็ม ซึ่งระบุจำนวนพลังงานที่คุณมีในตอนแรก
คุณเริ่มต้นด้วย 0 คะแนน และศัตรูทั้งหมดจะไม่ถูกทำเครื่องหมายในตอนแรก
คุณสามารถดำเนินการต่อไปนี้อย่างใดอย่างหนึ่งหรือหลายครั้งเพื่อรับคะแนน:

เลือกศัตรูที่ไม่ได้ทำเครื่องหมาย i โดยที่ currentEnergy >= enemyEnergies[i] เมื่อเลือกตัวเลือกนี้:

คุณจะได้รับ 1 คะแนน
พลังงานของคุณจะลดลงตามพลังงานของศัตรู กล่าวคือ currentEnergy = currentEnergy - enemyEnergies[i]

หากคุณมีอย่างน้อย 1 คะแนน คุณสามารถเลือกศัตรูที่ไม่ได้ทำเครื่องหมาย i ได้ เมื่อเลือกตัวเลือกนี้:

พลังงานของคุณจะเพิ่มขึ้นตามพลังงานของศัตรู กล่าวคือ currentEnergy = currentEnergy + enemyEnergies[i]
ศัตรู i จะถูกทำเครื่องหมาย

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

ตัวอย่าง 1:

อินพุต: enemyEnergies = [3,2,2], currentEnergy = 2
เอาต์พุต: 3
คำอธิบาย:
สามารถดำเนินการต่อไปนี้เพื่อรับ 3 คะแนน ซึ่งเป็นคะแนนสูงสุด:

การดำเนินการครั้งแรกกับศัตรู 1: คะแนนเพิ่มขึ้น 1 และ currentEnergy ลดลง 2 ดังนั้น คะแนน = 1 และ currentEnergy = 0
การดำเนินการครั้งที่สองกับศัตรู 0: currentEnergy เพิ่มขึ้น 3 และศัตรู 0 ถูกทำเครื่องหมาย ดังนั้น คะแนน = 1, currentEnergy = 3 และศัตรูที่ถูกทำเครื่องหมาย = [0]
การดำเนินการครั้งแรกกับศัตรู 2: คะแนนเพิ่มขึ้น 1 และ currentEnergy ลดลง 2 ดังนั้น คะแนน = 2, currentEnergy = 1 และศัตรูที่ถูกทำเครื่องหมาย = [0]
การดำเนินการครั้งที่สองกับศัตรู 2: currentEnergy เพิ่มขึ้น 2 และศัตรูที่ถูกทำเครื่องหมาย 2 ดังนั้น คะแนน = 2, พลังงานปัจจุบัน = 3 และศัตรูที่ทำเครื่องหมายไว้ = [0, 2]
การดำเนินการครั้งแรกกับศัตรู 1: คะแนนเพิ่มขึ้น 1 และพลังงานปัจจุบันลดลง 2 ดังนั้น คะแนน = 3, พลังงานปัจจุบัน = 1 และศัตรูที่ทำเครื่องหมายไว้ = [0, 2]

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

อินพุต: พลังงานศัตรู = [2], พลังงานปัจจุบัน = 10
เอาต์พุต: 5
คำอธิบาย:
การดำเนินการครั้งแรก 5 ครั้งกับศัตรู 0 ส่งผลให้ได้คะแนนสูงสุด

ข้อจำกัด:

1 <= enemyEnergies.length <= 10^5
1 <= enemyEnergies[i] <= 10^9
0 <= currentEnergy <= 10^9

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

เลือกศัตรูที่ไม่มีเครื่องหมาย i เพื่อให้พลังงานปัจจุบัน >= พลังงานของศัตรู[i] โดยเลือกตัวเลือกนี้:

คุณได้รับ 1 คะแนน
พลังงานของคุณจะลดลงตามพลังงานของศัตรู เช่น พลังงานปัจจุบัน = พลังงานปัจจุบัน - พลังงานของศัตรู[i]

หากคุณมีอย่างน้อย 1 แต้ม คุณสามารถเลือกศัตรูที่ไม่มีเครื่องหมายได้ โดยเลือกตัวเลือกนี้:

พลังงานของคุณเพิ่มขึ้นตามพลังงานของศัตรู เช่น พลังงานปัจจุบัน = พลังงานปัจจุบัน + พลังงานของศัตรู[i]
ศัตรู i ถูกทําเครื่องหมาย

ส่งคืนจํานวนเต็มที่แสดงถึงจุดสูงสุดที่คุณจะได้รับในตอนท้ายโดยการดําเนินการอย่างเหมาะสมที่สุด

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

อินพุต: enemyEnergies = [3,2,2], currentEnergy = 2
เอาท์พุต: 3
การอธิบาย:
การดําเนินการต่อไปนี้สามารถทําได้เพื่อรับ 3 คะแนนซึ่งเป็นคะแนนสูงสุด:

ปฏิบัติการครั้งแรกกับศัตรู 1: คะแนนเพิ่มขึ้น 1 และพลังงานปัจจุบันลดลง 2 ดังนั้น จุด = 1 และพลังงานปัจจุบัน = 0
ปฏิบัติการครั้งที่สองกับศัตรู 0: กระแสพลังงานเพิ่มขึ้น 3 และศัตรู 0 จะถูกทําเครื่องหมาย ดังนั้น จุด = 1, พลังงานปัจจุบัน = 3 และศัตรูที่ทําเครื่องหมายไว้ = [0]
ปฏิบัติการครั้งแรกกับศัตรู 2: คะแนนเพิ่มขึ้น 1 และพลังงานปัจจุบันลดลง 2 ดังนั้น จุด = 2, พลังงานปัจจุบัน = 1 และศัตรูที่ทําเครื่องหมายไว้ = [0]
ปฏิบัติการครั้งที่สองกับศัตรู 2: กระแสพลังงานเพิ่มขึ้น 2 และศัตรู 2 จะถูกทําเครื่องหมาย ดังนั้น จุด = 2, พลังงานปัจจุบัน = 3 และศัตรูที่ทําเครื่องหมายไว้ = [0, 2]
ปฏิบัติการครั้งแรกกับศัตรู 1: คะแนนเพิ่มขึ้น 1 และพลังงานปัจจุบันลดลง 2 ดังนั้น จุด = 3, พลังงานปัจจุบัน = 1 และศัตรูที่ทําเครื่องหมายไว้ = [0, 2]

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

อินพุต: enemyEnergies = [2], currentEnergy = 10
เอาท์พุต: 5
การอธิบาย:
การดําเนินการครั้งแรก 5 ครั้งกับศัตรู 0 ส่งผลให้มีจํานวนคะแนนสูงสุด

ข้อจํากัด:

1 <= ศัตรูพลังงาน.ความยาว <= 10^5
1 <= พลังงานของศัตรู[i] <= 10^9
0 <= กระแสพลังงาน <= 10^9


กำหนดอาร์เรย์ของจำนวนเต็ม nums และจำนวนเต็ม k ให้ส่งคืนจำนวนซับอาร์เรย์ของ nums โดยที่ค่า AND ตามบิตขององค์ประกอบของซับอาร์เรย์เท่ากับ k

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

อินพุต: nums = [1,1,1], k = 1
เอาต์พุต: 6
คำอธิบาย:
ซับอาร์เรย์ทั้งหมดมีเฉพาะ 1 เท่านั้น

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

อินพุต: nums = [1,1,2], k = 1
เอาต์พุต: 3
คำอธิบาย:
ซับอาร์เรย์ที่มีค่า AND เท่ากับ 1 ได้แก่: [1,1,2], [1,1,2], [1,1,2]

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

อินพุต: nums = [1,2,3], k = 2
เอาต์พุต: 2
คำอธิบาย:
ซับอาร์เรย์ที่มีค่า AND เท่ากับ 2 คือ: [1,2,3], [1,2,3]

ข้อจำกัด:

1 <= nums.length <= 10^5
0 <= nums[i], k <= 10^9

ให้กำหนดอาร์เรย์ของจำนวนเต็ม nums และจำนวนเต็ม k ให้คืนค่าจำนวนของ อาร์เรย์ย่อยของ nums ที่ bitwise AND ของสมาชิกใน อาร์เรย์ย่อยเท่ากับ k

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

Input: nums = [1,1,1], k = 1
Output: 6
คำอธิบาย:
อาร์เรย์ย่อยทั้งหมดมีสมาชิกเป็น 1 เท่านั้น

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

Input: nums = [1,1,2], k = 1
Output: 3
คำอธิบาย:
อาร์เรย์ย่อยที่มีค่า AND เท่ากับ 1 คือ: [1], [1], [1,1]

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

Input: nums = [1,2,3], k = 2
Output: 2
คำอธิบาย:
อาร์เรย์ย่อยที่มีค่า AND เท่ากับ 2 คือ: [2], [1,2]

ข้อจำกัด:

1 <= nums.length <= 10^5
0 <= nums[i], k <= 10^9

ได้รับอาร์เรย์ของจำนวนเต็ม nums และจำนวนเต็ม k ให้ส่งคืนจำนวน subarrays ของ nums ที่ bitwise และองค์ประกอบของ subarray เท่ากับ k

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

อินพุต: nums = [1,1,1], k = 1
เอาท์พุท: 6
คำอธิบาย:
subarrays ทั้งหมดประกอบด้วยเฉพาะ 1

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

อินพุต: nums = [1,1,2], k = 1
เอาท์พุท: 3
คำอธิบาย:
Subarrays ที่มีค่า AND เท่ากับ 1 คือ: [1,1,2], [1,1,2], [1,1,2].

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

อินพุต: nums = [1,2,3], k = 2
เอาท์พุท: 2
คำอธิบาย:
Subarrays ที่มีค่า 2 คือ: [1,2,3], [1,2,3]

ข้อ จำกัด :

1 <= nums.length <= 10^5
0 <= nums [i], k <= 10^9


คุณได้รับจำนวนเต็มบวกสองจำนวนคือ x และ y ซึ่งแสดงถึงจำนวนเหรียญที่มีค่า 75 และ 10 ตามลำดับ
Alice และ Bob กำลังเล่นเกม ในแต่ละตา เริ่มต้นด้วย Alice ผู้เล่นจะต้องหยิบเหรียญที่มีค่ารวม 115 หากผู้เล่นไม่สามารถทำเช่นนั้นได้ พวกเขาจะแพ้เกม
หากผู้เล่นทั้งสองเล่นได้ดีที่สุด ให้ส่งคืนชื่อของผู้เล่นที่ชนะเกม
ตัวอย่างที่ 1:

อินพุต: x = 2, y = 7
เอาต์พุต: "อลิซ"
คำอธิบาย:
เกมจะจบลงใน 1 ตา:

อลิซหยิบเหรียญ 1 เหรียญที่มีค่า 75 และ 4 เหรียญที่มีค่า 10

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

อินพุต: x = 4, y = 11
เอาต์พุต: "บ็อบ"
คำอธิบาย:
เกมจะจบลงใน 2 ตา:

อลิซหยิบเหรียญ 1 เหรียญที่มีค่า 75 และ 4 เหรียญที่มีค่า 10
บ็อบหยิบเหรียญ 1 เหรียญที่มีค่า 75 และ 4 เหรียญที่มีค่า 10

ข้อจำกัด:

1 <= x, y <= 100

คุณได้รับจำนวนเต็มบวกสองจำนวน x และ y ซึ่งแสดงถึงจำนวนเหรียญที่มีมูลค่า 75 และ 10 ตามลำดับ

อาลิซและบ็อบกำลังเล่นเกม ในแต่ละตา เริ่มจากอาลิซ ผู้เล่นจะต้องหยิบเหรียญที่มีมูลค่ารวม 115 หากผู้เล่นไม่สามารถทำเช่นนั้นได้ พวกเขาจะแพ้เกม

ให้คืนชื่อของผู้เล่นที่ชนะเกมหากผู้เล่นทั้งสองเล่นอย่างดีที่สุด

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

Input: x = 2, y = 7
Output: "Alice"
คำอธิบาย:
เกมจบลงในตาเดียว:

อาลิซหยิบเหรียญ 1 เหรียญที่มีมูลค่า 75 และเหรียญ 4 เหรียญที่มีมูลค่า 10

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

Input: x = 4, y = 11
Output: "Bob"
คำอธิบาย:
เกมจบลงใน 2 เทิร์น:

อาลิซเลือกเหรียญ 1 เหรียญที่มีมูลค่า 75 และเหรียญ 4 เหรียญที่มีมูลค่า 10
บ็อบเลือกเหรียญ 1 เหรียญที่มีมูลค่า 75 และเหรียญ 4 เหรียญที่มีมูลค่า 10

ข้อจำกัด:

1 <= x, y <= 100

ให้คุณสองจำนวนเต็มบวก x และ y ซึ่งแสดงถึงจำนวนเหรียญที่มีมูลค่า 75 และ 10 ตามลำดับ

อลิซและบ็อบกำลังเล่นเกมอยู่ ในแต่ละตา โดยเริ่มที่อลิซ ผู้เล่นต้องหยิบเหรียญที่มีมูลค่ารวม 115 หากผู้เล่นไม่สามารถทำได้ จะถือว่าแพ้เกม

คืนค่าชื่อของผู้เล่นที่ชนะหากผู้เล่นทั้งคู่เล่นอย่างเต็มประสิทธิภาพ

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

Input: x = 2, y = 7
Output: "Alice"
คำอธิบาย:
เกมจะจบภายในหนึ่งตา:

อลิซหยิบเหรียญ 1 เหรียญ ที่มีมูลค่า 75 และ 4 เหรียญที่มีมูลค่า 10

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

Input: x = 4, y = 11
Output: "Bob"
คำอธิบาย:
เกมจะจบภายใน 2 ตา:

อลิซหยิบเหรียญ 1 เหรียญ ที่มีมูลค่า 75 และ 4 เหรียญที่มีมูลค่า 10
บ็อบหยิบเหรียญ 1 เหรียญ ที่มีมูลค่า 75 และ 4 เหรียญที่มีมูลค่า 10

ข้อจำกัด:

1 <= x, y <= 100


ให้คุณพิจารณาสตริง s
คุณสามารถทำกระบวนการต่อไปนี้กับ s ได้หลายครั้งเท่าที่ต้องการ:

เลือกดัชนี i ในสตริงดังกล่าวที่มีอักขระอย่างน้อยหนึ่งตัวทางซ้ายของดัชนี i ที่มีค่าเท่ากับ s[i] และมีอักขระอย่างน้อยหนึ่งตัวทางขวาที่มีค่าเท่ากับ s[i]
ลบอักขระที่ใกล้ที่สุดทางซ้ายของดัชนี i ที่มีค่าเท่ากับ s[i]
ลบอักขระที่ใกล้ที่สุดทางขวาของดัชนี i ที่มีค่าเท่ากับ s[i]

คืนค่าความยาวขั้นต่ำของสตริง s สุดท้ายที่คุณสามารถทำได้

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

Input: s = "abaacbcbb"
Output: 5
คำอธิบาย:
เราทำการดำเนินการต่อไปนี้:

เลือกดัชนี 2 จากนั้นลบอักขระที่ดัชนี 0 และ 3 สตริงที่ได้คือ s = "bacbcbb"
เลือกดัชนี 3 จากนั้นลบอักขระที่ดัชนี 0 และ 5 สตริงที่ได้คือ s = "acbcb"

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

Input: s = "aa"
Output: 2
คำอธิบาย:
เราไม่สามารถทำการดำเนินการใดๆ ได้ ดังนั้นเราคืนค่าความยาวของสตริงเดิม

ข้อจำกัด:

1 <= s.length <= 2 * 10^5
s ประกอบด้วยอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

คุณจะได้รับสตริง s
คุณสามารถดำเนินการต่อไปนี้กับ s ได้หลายครั้ง:

เลือกดัชนี i ในสตริงที่มีอักขระอย่างน้อยหนึ่งตัวทางด้านซ้ายของดัชนี i ที่เท่ากับ s[i] และมีอักขระอย่างน้อยหนึ่งตัวทางด้านขวาที่เท่ากับ s[i] เช่นกัน
ลบอักขระที่ใกล้ที่สุดทางด้านซ้ายของดัชนี i ที่เท่ากับ s[i]
ลบอักขระที่ใกล้ที่สุดทางด้านขวาของดัชนี i ที่เท่ากับ s[i]
ส่งคืนความยาวขั้นต่ำของสตริง s สุดท้ายที่คุณสามารถทำได้

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

อินพุต: s = "abaacbcbb"
เอาต์พุต: 5
คำอธิบาย:
เราทำการดำเนินการต่อไปนี้:

เลือกดัชนี 2 จากนั้นลบอักขระที่ดัชนี 0 และ 3 สตริงที่ได้คือ s = "bacbcbb"
 เลือกดัชนี 3 จากนั้นลบอักขระที่ดัชนี 0 และ 5 สตริงที่ได้คือ s = "acbcb"

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

อินพุต: s = "aa"
เอาต์พุต: 2
คำอธิบาย:
เราไม่สามารถดำเนินการใดๆ ได้ ดังนั้นเราจึงส่งคืนความยาวของสตริงต้นฉบับ

ข้อจำกัด:

1 <= s.length <= 2 * 10^5
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น

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

เลือกดัชนี i ในสตริงเพื่อให้มีตัวละครอย่างน้อยหนึ่งตัวอยู่ทางด้านซ้ายของดัชนีฉันที่เท่ากับ s [i] และอย่างน้อยหนึ่งตัวละครไปทางขวาที่เท่ากับ s[i]
ลบอักขระที่ใกล้เคียงที่สุดทางด้านซ้ายของดัชนี i ที่เท่ากับ s[i]
ลบอักขระที่ใกล้เคียงที่สุดทางด้านขวาของดัชนีฉันซึ่งเท่ากับ s[i]

ส่งคืนความยาวต่ำสุดของสตริงสุดท้ายที่คุณสามารถทำได้

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

อินพุต: s = "abaacbcbb"
เอาท์พุท: 5
คำอธิบาย:
เราดำเนินการต่อไปนี้:

เลือกดัชนี 2 จากนั้นลบอักขระที่ดัชนี 0 และ 3 สตริงผลลัพธ์คือ s = "bacbcbb".
เลือกดัชนี 3 จากนั้นลบอักขระที่ดัชนี 0 และ 5 สตริงผลลัพธ์คือ s = "acbcb".

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

อินพุต: S = "aa"
เอาท์พุท: 2
คำอธิบาย:
เราไม่สามารถดำเนินการใด ๆ ได้ดังนั้นเราจึงส่งคืนความยาวของสตริงต้นฉบับ

ข้อ จำกัด :

1 <= s.length <= 2 * 10^5
s ประกอบด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กเท่านั้น


คุณจะได้รับอาร์เรย์จำนวนเต็ม nums ขนาด n โดยที่ n เป็นจำนวนคู่ และจำนวนเต็ม k
คุณสามารถทำการเปลี่ยนแปลงบางอย่างในอาร์เรย์ได้ โดยในการเปลี่ยนแปลงหนึ่งครั้ง คุณสามารถแทนที่องค์ประกอบใดๆ ในอาร์เรย์ด้วยจำนวนเต็มใดๆ ในช่วงตั้งแต่ 0 ถึง k
คุณต้องทำการเปลี่ยนแปลงบางอย่าง (อาจไม่ต้องเปลี่ยนแปลงเลย) เพื่อให้อาร์เรย์สุดท้ายตรงตามเงื่อนไขต่อไปนี้:

มีจำนวนเต็ม X ที่ทำให้ abs(a[i] - a[n - i - 1]) = X สำหรับทั้งหมด (0 <= i < n)

ส่งคืนจำนวนการเปลี่ยนแปลงขั้นต่ำที่จำเป็นเพื่อให้ตรงตามเงื่อนไขข้างต้น

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

อินพุต: nums = [1,0,1,2,4,3], k = 4
เอาต์พุต: 2
คำอธิบาย:
เราสามารถทำการเปลี่ยนแปลงต่อไปนี้ได้:

แทนที่ nums[1] ด้วย 2 อาร์เรย์ที่ได้คือ nums = [1,2,1,2,4,3]
แทนที่ nums[3] ด้วย 3 อาร์เรย์ที่ได้คือ nums = [1,2,1,3,4,3]

จำนวนเต็ม X จะเป็น 2

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

อินพุต: nums = [0,1,2,3,3,6,5,4], k = 6
เอาต์พุต: 2
คำอธิบาย:
เราสามารถดำเนินการต่อไปนี้ได้:

แทนที่ nums[3] ด้วย 0 อาร์เรย์ที่ได้คือ nums = [0,1,2,0,3,6,5,4]
แทนที่ nums[4] ด้วย 4 อาร์เรย์ที่ได้คือ nums = [0,1,2,0,4,6,5,4]

จำนวนเต็ม X จะเป็น 4

ข้อจำกัด:

2 <= n == nums.length <= 10^5
n เป็นเลขคู่
0 <= nums[i] <= k <= 10^5


คุณจะได้รับจำนวนเต็ม n แทนจำนวนผู้เล่นในเกมและอาร์เรย์ 2 มิติ pick โดยที่ pick[i] = [x_i, y_i] แสดงว่าผู้เล่น x_i เลือกลูกบอลสี y_i
ผู้เล่น i ชนะเกมหากเลือกลูกบอลสีเดียวกันมากกว่า i ลูกอย่างเคร่งครัด กล่าวอีกนัยหนึ่งคือ

ผู้เล่น 0 ชนะหากเลือกลูกบอลใด ๆ
ผู้เล่น 1 ชนะหากเลือกลูกบอลสีเดียวกันอย่างน้อย 2 ลูก
...
ผู้เล่น i ชนะหากพวกเขาเลือกอย่างน้อย i + 1 ลูกบอลในสีเดียวกัน

ส่งคืนจำนวนผู้เล่นที่ชนะเกม
โปรดทราบว่าผู้เล่นหลายคนสามารถชนะเกมได้

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

อินพุต: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
เอาต์พุต: 2
คำอธิบาย:
ผู้เล่น 0 และผู้เล่น 1 ชนะเกม ในขณะที่ผู้เล่น 2 และ 3 ไม่ชนะ

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

อินพุต: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
เอาต์พุต: 0
คำอธิบาย:
ไม่มีผู้เล่นคนใดชนะเกม

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

อินพุต: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
เอาต์พุต: 1
คำอธิบาย:
ผู้เล่น 2 ชนะเกมโดยหยิบลูกบอล 3 ลูกที่มีสี 4

เงื่อนไข:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10

คุณได้รับจำนวนเต็ม n ซึ่งแสดงถึงจำนวนผู้เล่นในเกม และอาเรย์สองมิติ pick ที่ pick[i] = [x_i, y_i] หมายถึงว่าผู้เล่น x_i เลือกลูกบอลสี y_i

ผู้เล่น i จะชนะเกมหากพวกเขาเลือกลูกบอลสีเดียวกันมากกว่า i อย่างเคร่งครัด กล่าวอีกนัยหนึ่ง

ผู้เล่น 0 ชนะหากพวกเขาเลือกลูกบอลใด ๆ
ผู้เล่น 1 ชนะหากพวกเขาเลือกอย่างน้อยสองลูกบอลในสีเดียวกัน
...
ผู้เล่น i ชนะหากพวกเขาเลือกอย่างน้อย i + 1 ลูกบอลในสีเดียวกัน

ให้คุณส่งคืนจำนวนผู้เล่นที่ชนะเกม
หมายเหตุว่าอาจมีผู้เล่นหลายคนที่ชนะเกมได้

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

Input: n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]
Output: 2
คำอธิบาย:
ผู้เล่น 0 และผู้เล่น 1 ชนะเกม ขณะที่ผู้เล่น 2 และ 3 ไม่ชนะ

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

Input: n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]
Output: 0
คำอธิบาย:
ไม่มีผู้เล่นคนใดชนะเกม

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

Input: n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]
Output: 1
คำอธิบาย:
ผู้เล่น 2 ชนะเกมโดยการเลือก 3 ลูกบอลด้วยสี 4

เงื่อนไข:

2 <= n <= 10
1 <= pick.length <= 100
pick[i].length == 2
0 <= x_i <= n - 1
0 <= y_i <= 10


คุณจะได้รับตารางเมทริกซ์ไบนารี m x n
แถวหรือคอลัมน์จะถือว่าเป็นพาลินโดรมหากค่าของแถวหรือคอลัมน์อ่านได้เหมือนกันทั้งไปข้างหน้าและข้างหลัง
คุณสามารถพลิกเซลล์ในตารางจาก 0 เป็น 1 หรือจาก 1 เป็น 0 ได้จำนวนเท่าใดก็ได้
ส่งคืนจำนวนเซลล์ขั้นต่ำที่ต้องพลิกเพื่อให้แถวทั้งหมดเป็นพาลินโดรมหรือคอลัมน์ทั้งหมดเป็นพาลินโดรม

ตัวอย่าง 1:

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

การพลิกเซลล์ที่เน้นจะทำให้แถวทั้งหมดเป็นพาลินโดรม

ตัวอย่าง 2:

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

การพลิกเซลล์ที่เน้นจะทำให้คอลัมน์ทั้งหมดเป็นพาลินโดรม

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

อินพุต: grid = [[1],[0]]
เอาต์พุต: 0
คำอธิบาย:
แถวทั้งหมดเป็นพาลินโดรมแล้ว

ข้อจำกัด:

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1

คุณจะได้รับกริดเมทริกซ์ไบนารี m x n
แถวหรือคอลัมน์ถือว่าเป็น palindromic หากค่าของมันอ่านไปข้างหน้าและย้อนกลับเดียวกัน
คุณสามารถพลิกเซลล์จำนวนใดก็ได้ในกริดตั้งแต่ 0 ถึง 1 หรือจาก 1 ถึง 0
ส่งคืนจำนวนเซลล์ขั้นต่ำที่จำเป็นต้องพลิกเพื่อทำให้ทุกแถว palindromic หรือคอลัมน์ทั้งหมด palindromic

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

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

การพลิกเซลล์ที่ไฮไลต์ทำให้ทุกแถว palindromic

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

อินพุต: grid = [[0,1], [0,1], [0,0]]
เอาท์พุท: 1
คำอธิบาย:

การพลิกเซลล์ที่ไฮไลต์ทำให้คอลัมน์ทั้งหมด palindromic

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

อินพุต: grid = [[1], [0]]
เอาท์พุท: 0
คำอธิบาย:
แถวทั้งหมดมี palindromic อยู่แล้ว

ข้อ จำกัด :

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1

คุณจะได้รับตารางเมทริกซ์ไบนารี m x n
แถวหรือคอลัมน์จะถือว่าเป็นพาลินโดรมหากค่าของแถวหรือคอลัมน์อ่านได้เหมือนกันทั้งไปข้างหน้าและข้างหลัง
คุณสามารถพลิกเซลล์ในตารางจาก 0 เป็น 1 หรือจาก 1 เป็น 0 ได้จำนวนเท่าใดก็ได้
ส่งคืนจำนวนเซลล์ขั้นต่ำที่ต้องพลิกเพื่อให้แถวทั้งหมดเป็นพาลินโดรมหรือคอลัมน์ทั้งหมดเป็นพาลินโดรม

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

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

การพลิกเซลล์ที่เน้นจะทำให้แถวทั้งหมดเป็นพาลินโดรม

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

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

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

อินพุต: grid = [[1],[0]]
เอาต์พุต: 0
คำอธิบาย:
แถวทั้งหมดเป็นพาลินโดรมแล้ว

ข้อจำกัด:

m == grid.length
n == grid[i].length
1 <= m * n <= 2 * 10^5
0 <= grid[i][j] <= 1