คุณได้รับสตริงที่ชื่อว่า moves ซึ่งมีความยาว n ประกอบด้วยตัวอักษร 'L', 'R' และ '_' เท่านั้น สตริงนี้แสดงถึงการเคลื่อนไหวของคุณบนเส้นจำนวนโดยเริ่มจากจุดกำเนิด 0 ในการเคลื่อนไหวครั้งที่ i คุณสามารถเลือกทิศทางใดทิศทางหนึ่งจากต่อไปนี้:

เคลื่อนที่ไปทางซ้ายถ้า moves[i] = 'L' หรือ moves[i] = '_'
เคลื่อนที่ไปทางขวาถ้า moves[i] = 'R' หรือ moves[i] = '_'

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

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

Input: moves = "L_RL__R"
Output: 3
อธิบาย: จุดที่ไกลที่สุดที่เราสามารถไปถึงจากจุดเริ่มต้น 0 คือจุด -3 ผ่านลำดับการเคลื่อนไหวต่อไปนี้ "LLRLLLR"

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

Input: moves = "_R__LL_"
Output: 5
อธิบาย: จุดที่ไกลที่สุดที่เราสามารถไปถึงจากจุดเริ่มต้น 0 คือจุด -5 ผ่านลำดับการเคลื่อนไหว "LRLLLLL"

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

Input: moves = "_______"
Output: 7
อธิบาย: จุดที่ไกลที่สุดที่เราสามารถไปถึงจากจุดเริ่มต้น 0 คือจุด 7 ผ่านลำดับการเคลื่อนไหวต่อไปนี้ "RRRRRRR"

ข้อจำกัด:

1 <= moves.length == n <= 50
moves ประกอบด้วยเฉพาะตัวอักษร 'L', 'R' และ '_' เท่านั้น

คุณจะได้รับการย้ายสตริงที่มีความยาว n ซึ่งประกอบด้วยอักขระ 'L', 'R' และ '_' เท่านั้น สตริงแสดงถึงการเคลื่อนไหวของคุณบนเส้นตัวเลขโดยเริ่มจากจุดกําเนิด 0
ในการเคลื่อนไหวที่ i^th คุณสามารถเลือกทิศทางใดทิศทางหนึ่งต่อไปนี้:

เลื่อนไปทางซ้ายถ้า moves[i] = 'L' หรือ moves[i] = '_'
เลื่อนไปทางขวาถ้า moves[i] = 'R' หรือ moves[i] = '_'

คืนระยะทางจากจุดเริ่มต้นของจุดที่ไกลที่สุดที่คุณสามารถไปถึงได้หลังจาก n การเคลื่อนไหว

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

อินพุต: moves = "L_RL__R"
เอาท์พุต: 3
คําอธิบาย: จุดที่ไกลที่สุดที่เราสามารถเข้าถึงได้จากจุดกําเนิด 0 คือจุด -3 ผ่านลําดับการเคลื่อนไหวต่อไปนี้ "LLRLLLR"

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

อินพุต: moves = "_R__LL_"
เอาท์พุต: 5
คําอธิบาย: จุดที่ไกลที่สุดที่เราสามารถเข้าถึงได้จากจุดกําเนิด 0 คือจุด -5 ผ่านลําดับการเคลื่อนไหวต่อไปนี้ "LRLLLLL"

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

อินพุต: moves = "_______"
เอาท์พุต: 7
คําอธิบาย: จุดที่ไกลที่สุดที่เราสามารถเข้าถึงได้จากจุดกําเนิด 0 คือจุด 7 ผ่านลําดับการเคลื่อนไหวต่อไปนี้ "RRRRRRR"

ข้อจํากัด:

1 <= moves.length == n <= 50
moves ประกอบด้วยอักขระ 'L', 'R' และ '_' เท่านั้น

คุณจะได้รับสตริงการเคลื่อนที่ที่มีความยาว n ซึ่งประกอบด้วยอักขระ 'L', 'R' และ '_' เท่านั้น สตริงนี้แสดงถึงการเคลื่อนที่ของคุณบนเส้นจำนวนที่เริ่มจากจุดกำเนิด 0
ในการเคลื่อนที่ครั้งที่ i คุณสามารถเลือกทิศทางใดทิศทางหนึ่งต่อไปนี้ได้:

เคลื่อนที่ไปทางซ้าย ถ้า moves[i] = 'L' หรือ moves[i] = '_'
เคลื่อนที่ไปทางขวา ถ้า moves[i] = 'R' หรือ moves[i] = '_'

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

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

อินพุต: moves = "L_RL__R"
เอาต์พุต: 3
คำอธิบาย: จุดที่ไกลที่สุดที่เราไปถึงได้จากจุดกำเนิด 0 คือจุด -3 ผ่านลำดับการเคลื่อนที่ต่อไปนี้ "LLRLLLR"

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

อินพุต: การเคลื่อนที่ = "_R__LL_"
เอาต์พุต: 5
คำอธิบาย: จุดที่ไกลที่สุดที่เราสามารถเข้าถึงได้จากจุดเริ่มต้น 0 คือจุด -5 ผ่านลำดับการเคลื่อนที่ต่อไปนี้ "LRLLLLL"

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

อินพุต: การเคลื่อนที่ = "_______"
เอาต์พุต: 7
คำอธิบาย: จุดที่ไกลที่สุดที่เราสามารถเข้าถึงได้จากจุดเริ่มต้น 0 คือจุด 7 ผ่านลำดับการเคลื่อนที่ต่อไปนี้ "RRRRRRR"

ข้อจำกัด:

1 <= moves.length == n <= 50
การเคลื่อนที่ประกอบด้วยอักขระ 'L', 'R' และ '_' เท่านั้น


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

ลบคำต่อท้ายของ s ที่มีความยาว l โดยที่ 0 < l < n และผนวกไว้ที่จุดเริ่มต้นของ s
ตัวอย่างเช่น ให้ s = 'abcd' จากนั้นในการดำเนินการครั้งหนึ่ง คุณสามารถลบคำต่อท้าย 'cd' และผนวกไว้ข้างหน้า s ทำให้ s = 'cdab'

คุณจะได้รับจำนวนเต็ม k ด้วย ส่งคืนจำนวนวิธีที่ s สามารถแปลงเป็น t ได้ในการดำเนินการ k ครั้งพอดี เนื่องจากคำตอบสามารถมีค่าได้มาก ให้ส่งคืนโมดูโล 10^9 + 7

ตัวอย่าง 1:

อินพุต: s = "abcd", t = "cdab", k = 2
เอาต์พุต: 2
คำอธิบาย:
วิธีแรก:
ในการดำเนินการครั้งแรก เลือกคำต่อท้ายจากดัชนี = 3 ดังนั้นผลลัพธ์คือ s = "dabc"
ในการดำเนินการครั้งที่สอง เลือกคำต่อท้ายจากดัชนี = 3 ดังนั้นผลลัพธ์คือ s = "cdab"

วิธีที่สอง:
ในการดำเนินการครั้งแรก เลือกคำต่อท้ายจากดัชนี = 1 ดังนั้นผลลัพธ์คือ s = "bcda"
ในการดำเนินการครั้งที่สอง เลือกคำต่อท้ายจากดัชนี = 1 ดังนั้นผลลัพธ์คือ s = "cdab"

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

อินพุต: s = "ababab", t = "ababab", k = 1
เอาต์พุต: 2
คำอธิบาย:
วิธีแรก:
เลือกคำต่อท้ายจากดัชนี = 2 ดังนั้นจะได้ s = "ababab"

วิธีที่สอง:
เลือกคำต่อท้ายจากดัชนี = 4 ดังนั้นจะได้ s = "ababab"

ข้อจำกัด:

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

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

ลบส่วนท้ายของ s ที่มีความยาว l เมื่อ 0 < l < n และนำมาต่อไว้ที่จุดเริ่มต้นของ s
	ตัวอย่างเช่น ให้ s = 'abcd' ในการดำเนินการหนึ่งครั้ง คุณสามารถลบส่วนท้าย 'cd' และนำมาต่อด้านหน้าของ s ทำให้ s = 'cdab'

คุณยังได้รับจำนวนเต็ม k คืนจำนวนวิธีที่ s สามารถแปลงเป็น t ใน k การดำเนินการได้พอดี
เนื่องจากคำตอบอาจมีค่ามาก ให้คืนโมดูลัสด้วย 10^9 + 7

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

Input: s = "abcd", t = "cdab", k = 2
Output: 2
คำอธิบาย:
วิธีที่หนึ่ง:
ในการดำเนินการครั้งแรก เลือกส่วนท้ายจากดัชนี = 3 ดังนั้น s = "dabc"
ในการดำเนินการครั้งที่สอง เลือกส่วนท้ายจากดัชนี = 3 ดังนั้น s = "cdab"

วิธีที่สอง:
ในการดำเนินการครั้งแรก เลือกส่วนท้ายจากดัชนี = 1 ดังนั้น s = "bcda"
ในการดำเนินการครั้งที่สอง เลือกส่วนท้ายจากดัชนี = 1 ดังนั้น s = "cdab"

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

Input: s = "ababab", t = "ababab", k = 1
Output: 2
คำอธิบาย:
วิธีที่หนึ่ง:
เลือกส่วนท้ายจากดัชนี = 2 ดังนั้น s = "ababab"

วิธีที่สอง:
เลือกส่วนท้ายจากดัชนี = 4 ดังนั้น s = "ababab"

ข้อจำกัด:

2 <= s.length <= 5 * 10^5
1 <= k <= 10^15
s.length == t.length
s และ t ประกอบไปด้วยตัวอักษรภาษาอังกฤษตัวเล็กเท่านั้น


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

เลือกองค์ประกอบใดๆ ของอาร์เรย์ nums[i] โดยที่ nums[i] > 1
ลบ nums[i] ออกจากอาร์เรย์
เพิ่ม nums[i] / 2 สองครั้งที่ท้าย nums

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

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

อินพุต: nums = [1,2,8], target = 7
เอาต์พุต: 1
คำอธิบาย: ในการดำเนินการครั้งแรก เราเลือกองค์ประกอบ nums[2] อาร์เรย์จะเท่ากับ nums = [1,2,4,4]
ในขั้นตอนนี้ nums จะมีลำดับย่อย [1,2,4] ซึ่งมีผลรวมเป็น 7
จะเห็นได้ว่าไม่มีลำดับการดำเนินการที่สั้นกว่าซึ่งส่งผลให้เกิดลำดับย่อยที่มีผลรวมเป็น 7

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

อินพุต: nums = [1,32,1,2], target = 12
เอาต์พุต: 2
คำอธิบาย: ในการดำเนินการครั้งแรก เราเลือกองค์ประกอบ nums[1] อาร์เรย์จะเท่ากับ nums = [1,1,2,16,16]
ในการดำเนินการครั้งที่สอง เราเลือกองค์ประกอบ nums[3] อาร์เรย์จะเท่ากับ nums = [1,1,2,16,8,8]
ในขั้นตอนนี้ nums จะมีลำดับย่อย [1,1,2,8] ซึ่งมีผลรวมเป็น 12
จะแสดงให้เห็นว่าไม่มีลำดับการดำเนินการที่สั้นกว่าซึ่งส่งผลให้เกิดลำดับย่อยที่มีผลรวมเป็น 12
ตัวอย่างที่ 3:

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

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums ประกอบด้วยเลขชี้กำลังสองที่ไม่เป็นลบเท่านั้น
1 <= target < 2^31

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

เลือกองค์ประกอบใดก็ได้ของอาร์เรย์ nums[i] โดยที่ nums[i] > 1
ลบ nums[i] ออกจากอาร์เรย์
เพิ่ม nums[i] / 2 สองครั้งที่ท้าย nums

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

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

อินพุต: nums = [1,2,8], target = 7
เอาต์พุต: 1
คำอธิบาย: ในการดำเนินการครั้งแรก เราเลือกองค์ประกอบ nums[2] อาร์เรย์จะเท่ากับ nums = [1,2,4,4]
ในขั้นตอนนี้ nums จะมีลำดับย่อย [1,2,4] ซึ่งมีผลรวมเป็น 7
จะเห็นได้ว่าไม่มีลำดับการดำเนินการที่สั้นกว่าซึ่งส่งผลให้เกิดลำดับย่อยที่มีผลรวมเป็น 7

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

อินพุต: nums = [1,32,1,2], เtarget = 12
เอาต์พุต: 2
คำอธิบาย: ในการดำเนินการครั้งแรก เราเลือกองค์ประกอบ nums[1] อาร์เรย์จะเท่ากับ nums = [1,1,2,16,16]
ในการดำเนินการครั้งที่สอง เราเลือกองค์ประกอบ nums[3] อาร์เรย์จะเท่ากับ nums = [1,1,2,16,8,8]
ในขั้นตอนนี้ nums จะมีลำดับย่อย [1,1,2,8] ซึ่งมีผลรวมเป็น 12
จะแสดงให้เห็นว่าไม่มีลำดับการดำเนินการที่สั้นกว่าซึ่งส่งผลให้เกิดลำดับย่อยที่มีผลรวมเป็น 12
ตัวอย่างที่ 3:

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

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums ประกอบด้วยเลขชี้กำลังสองที่ไม่เป็นลบเท่านั้น
1 <= เป้าหมาย < 2^31

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

เลือกองค์ประกอบใด ๆ ของอาร์เรย์ nums[i] เช่นนั้น nums[i]> 1
ลบ nums[i] ออกจากอาร์เรย์
เพิ่มสองครั้งของ nums[i] / 2 ลงในตอนท้ายของ nums

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

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

อินพุต: nums = [1,2,8], target = 7
เอาท์พุท: 1
คำอธิบาย: ในการดำเนินการครั้งแรกเราเลือกองค์ประกอบ NUMS [2] อาร์เรย์มีค่าเท่ากับ nums = [1,2,4,4]
ในขั้นตอนนี้ nums จะมีลำดับ [1,2,4] ซึ่งมีผลรวมถึง 7
มันสามารถแสดงให้เห็นว่าไม่มีลำดับการดำเนินการที่สั้นลงซึ่งส่งผลให้เกิดผลรวมถึง 7

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

อินพุต: nums = [1,32,1,2], target = 12
เอาท์พุท: 2
คำอธิบาย: ในการดำเนินการครั้งแรกเราเลือกองค์ประกอบ NUMS [1] อาร์เรย์มีค่าเท่ากับ nums = [1,1,2,16,16]
ในการดำเนินการที่สองเราเลือกองค์ประกอบ nums [3] อาร์เรย์มีค่าเท่ากับ nums = [1,1,2,16,8,8]
ในขั้นตอนนี้ nums จะมีลำดับ [1,1,2,8] ซึ่งมีจำนวนมากถึง 12
มันสามารถแสดงให้เห็นว่าไม่มีลำดับการดำเนินการที่สั้นลงซึ่งส่งผลให้ผลที่ตามมาสูงสุดถึง 12
ตัวอย่างที่ 3:

อินพุต: nums = [1,32,1], target = 35
เอาท์พุท: -1
คำอธิบาย: สามารถแสดงให้เห็นว่าไม่มีลำดับของการดำเนินการที่ทำให้ได้ลำดับย่อยซึ่งผลรวมเท่ากับ 35

ข้อ จำกัด :

1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums ประกอบด้วยพลังที่ไม่เป็นลบของสองเท่านั้น
1 <= target < 2^31


กำหนดตารางเมทริกซ์จำนวนเต็ม 2 มิติที่มีดัชนี 0 ขนาด n * m เราจะกำหนดเมทริกซ์ 2 มิติที่มีดัชนี 0 ขนาด n * m เป็นเมทริกซ์ผลคูณของตาราง หากตรงตามเงื่อนไขต่อไปนี้:

องค์ประกอบ p[i][j] แต่ละองค์ประกอบจะคำนวณเป็นผลคูณขององค์ประกอบทั้งหมดในตาราง ยกเว้นองค์ประกอบ grid[i][j] ผลคูณนี้จะถูกนำมาจากโมดูโล 12345

ส่งคืนเมทริกซ์ผลคูณของตาราง

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

อินพุต: grid = [[1,2],[3,4]]
เอาต์พุต: [[24,12],[8,6]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
ดังนั้นคำตอบคือ [[24,12],[8,6]]
ตัวอย่างที่ 2:

อินพุต: grid = [[12345],[2],[1]]
เอาต์พุต: [[2],[0],[0]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. ดังนั้น p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. ดังนั้น p[0][2] = 0.
ดังนั้นคำตอบคือ [[2],[0],[0]]

ข้อจำกัด:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

เมื่อพิจารณาจากตารางเมทริกซ์จำนวนเต็มสองมิติ grid ที่มีการจัดทำดัชนี 0 ขนาด n * m โดยเราจะกำหนดเมทริกซ์ p ขนาด n * m เป็นเมทริกซ์ผลคูณของตารางหากตรงตามเงื่อนไขต่อไปนี้:

แต่ละองค์ประกอบ p[i][j] จะถูกคำนวณเป็นผลคูณของทุกองค์ประกอบในตาราง ยกเว้นตารางองค์ประกอบ[i][j] ผลคูณนี้จะถูกคำนวณตามโมดูโล 12345

ให้คืนค่าเมทริกซ์ผลคูณของตาราง

ตัวอย่าง 1:

Input: grid = [[1,2],[3,4]]
Output: [[24,12],[8,6]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
ดังนั้นคำตอบคือ [[24,12],[8,6]]
ตัวอย่าง 2:

Input: grid = [[12345],[2],[1]]
Output: [[2],[0],[0]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. ดังนั้น p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. ดังนั้น p[0][2] = 0.
ดังนั้นคำตอบคือ [[2],[0],[0]]

ข้อจำกัด:

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9

ได้รับตารางเมทริกซ์จำนวนเต็ม 2D ดัชนี 2D ที่มีขนาด n * m เรากำหนดเมทริกซ์ 2D ดัชนี 0-indexed ขนาด n * m เป็นเมทริกซ์ผลิตภัณฑ์ของกริดหากตรงตามเงื่อนไขต่อไปนี้:

แต่ละองค์ประกอบ p [i] [j] คำนวณเป็นผลิตภัณฑ์ขององค์ประกอบทั้งหมดในกริดยกเว้นสำหรับกริดองค์ประกอบ [i] [j] ผลิตภัณฑ์นี้จะใช้โมดูโล 12345

ส่งคืนเมทริกซ์ผลิตภัณฑ์ของกริด

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

อินพุต: grid = [[1,2], [3,4]]
ผลลัพธ์: [[24,12], [8,6]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
ดังนั้นคำตอบคือ [[24,12], [8,6]]
ตัวอย่างที่ 2:

อินพุต: grid = [[12345], [2], [1]]
เอาท์พุท: [[2], [0], [0]]
คำอธิบาย: p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2.
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0. So p[0][1] = 0.
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0. So p[0][2] = 0.
ดังนั้นคำตอบคือ [[2], [0], [0]]

ข้อ จำกัด :

1 <= n == grid.length <= 10^5
1 <= m == grid[i].length <= 10^5
2 <= n * m <= 10^5
1 <= grid[i][j] <= 10^9


คุณได้รับอาเรย์หมายเลขเต็มที่มีดัชนีเริ่มต้นเป็นศูนย์ receiver ซึ่งมีความยาวเป็น n และจำนวนเต็ม k

มีผู้เล่น n คนที่มีหมายเลข id ที่ไม่ซ้ำกันในช่วง [0, n - 1] ที่จะเล่นเกมส่งลูกบอล และ receiver[i] คือ id ของผู้เล่นที่ได้รับบอลจากผู้เล่นที่มี id i ผู้เล่นสามารถส่งให้ตัวเองได้ เช่น receiver[i] อาจเท่ากับ i

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

สำหรับผู้เล่นที่เริ่มต้นที่มี id x เรากำหนดฟังก์ชัน f(x) ที่แสดงผลรวมของ x และ id ของผู้เล่นทุกคนที่ได้รับบอลในระหว่างที่บอลถูกส่งต่อ k ครั้ง รวมถึงการทำซ้ำ กล่าวอีกนัยหนึ่ง f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x]

งานของคุณคือต้องเลือกผู้เล่นเริ่มต้นที่มี id x ที่ทำให้ค่าของ f(x) สูงสุด

คืนค่าเป็นจำนวนเต็มที่แสดงค่ามากที่สุดของฟังก์ชัน

หมายเหตุ: receiver อาจมีค่าที่ซ้ำกัน

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

| Pass Number | Sender ID | Receiver ID | x + Receiver IDs |
|-------------|-----------|-------------|------------------|
| 2           | 1         | 2           | 1                |
| 3           | 2         | 1           | 3                |
| 0           | 3         | 0           | 5                |
| 2           | 4         | 2           | 6                |

Input: receiver = [2,0,1], k = 4
Output: 6
คำอธิบาย: ตารางด้านบนแสดงการจำลองของเกมที่เริ่มต้นด้วยผู้เล่นที่มี id x = 2 จากตาราง, f(2) เท่ากับ 6 สามารถแสดงได้ว่า 6 เป็นค่าที่มากที่สุดที่สามารถบรรลุได้ของฟังก์ชัน ดังนั้น output คือ 6

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

| Pass Number | Sender ID | Receiver ID | x + Receiver IDs |
|-------------|-----------|-------------|------------------|
| 4           | 1         | 4           | 3                |
| 2           | 3         | 2           | 7                |
| 3           | 2         | 1           | 9                |

Input: receiver = [1,1,1,2,3], k = 3
Output: 10
คำอธิบาย: ตารางด้านบนแสดงการจำลองของเกมที่เริ่มต้นด้วยผู้เล่นที่มี id x = 4 จากตาราง, f(4) เท่ากับ 10 สามารถแสดงได้ว่า 10 เป็นค่าที่มากที่สุดที่สามารถบรรลุได้ของฟังก์ชัน ดังนั้น output คือ 10

ข้อจำกัด:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

คุณจะได้รับอาร์เรย์ตัวรับจำนวนเต็มที่มีดัชนี 0 ที่มีความยาว n และจำนวนเต็ม k
มีผู้เล่น n คนที่มี id เฉพาะตัวในช่วง [0, n - 1] ที่จะเล่นเกมส่งบอล และ receiver[i] คือ id ของผู้เล่นที่รับบอลจากผู้เล่นที่มี id i ผู้เล่นสามารถส่งบอลไปยังตัวเองได้ กล่าวคือ receiver[i] อาจเท่ากับ i
คุณต้องเลือกผู้เล่นหนึ่งคนจาก n คนเป็นผู้เล่นเริ่มต้นของเกม และบอลจะถูกส่งไป k ครั้งพอดีโดยเริ่มจากผู้เล่นที่เลือก
สำหรับผู้เล่นเริ่มต้นที่เลือกซึ่งมี id x เราได้กำหนดฟังก์ชัน f(x) ที่แสดงถึงผลรวมของ x และ id ของผู้เล่นทั้งหมดที่ได้รับบอลระหว่างการส่งบอล k ครั้ง รวมถึงการทำซ้ำ กล่าวอีกนัยหนึ่งคือ f(x) = x + receiver[x] + receiver[receiver[x]] + ... + receiver^(k)[x]
งานของคุณคือเลือกผู้เล่นเริ่มต้นที่มี id x ที่ทำให้ค่าของ f(x) สูงสุด
ส่งกลับค่าจำนวนเต็มที่แสดงถึงค่าสูงสุดของฟังก์ชัน
หมายเหตุ: ผู้รับอาจมีค่าซ้ำกันได้

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

หมายเลขผ่าน
ID ผู้ส่ง
ID ผู้รับ
x + ID ผู้รับ

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

อินพุต: receiver = [2,0,1], k = 4
เอาต์พุต: 6
คำอธิบาย: ตารางด้านบนแสดงการจำลองเกมที่เริ่มต้นด้วยผู้เล่นที่มี id x = 2

จากตาราง f(2) มีค่าเท่ากับ 6

สามารถแสดงให้เห็นได้ว่า 6 คือค่าสูงสุดที่บรรลุได้ของฟังก์ชัน ดังนั้นผลลัพธ์คือ 6

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

หมายเลขผ่าน
IDผู้ส่ง
IDผู้รับ
x + IDผู้รับ

4

1
4
3
7

2
3
2
9

3
2
1
10

อินพุต: receiver= [1,1,1,2,3], k = 3
ผลลัพธ์: 10
คำอธิบาย: ตารางด้านบนแสดงการจำลองเกมโดยเริ่มจากผู้เล่นที่มี id x = 4
จากตาราง f(4) มีค่าเท่ากับ 10
จะแสดงให้เห็นได้ว่า 10 คือค่าสูงสุดที่ทำได้ของฟังก์ชัน
ดังนั้นผลลัพธ์คือ 10

ข้อจำกัด:

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10

คุณจะได้รับอาร์เรย์ตัวรับจำนวนเต็มที่มีดัชนี 0 ที่มีความยาว n และจำนวนเต็ม k
มีผู้เล่น n ที่มี id ที่ไม่ซ้ำกันในช่วง [0, n - 1] ที่จะเล่นเกมบอลผ่านและตัวรับสัญญาณ [i] คือ id ของผู้เล่นที่ได้รับบัตรผ่านจากผู้เล่นด้วย id i.ผู้เล่นสามารถส่งผ่านให้ตัวเองได้ ตัวอย่างเช่น ตัวรับสัญญาณ [i] อาจเท่ากับ i
คุณต้องเลือกหนึ่งในผู้เล่น n ในฐานะผู้เล่นเริ่มต้นสำหรับเกมและลูกบอลจะผ่าน k times อย่างแน่นอนเริ่มต้นจากผู้เล่นที่เลือก
สำหรับผู้เล่นเริ่มต้นที่ได้รับการคัดเลือกที่มี id x เราจะกำหนดฟังก์ชั่น f(x) ที่แสดงถึงผลรวมของ x และ ids ของผู้เล่นทุกคนที่ได้รับลูกบอลในระหว่างการผ่าน k รวมถึงการทำซ้ำ กล่าวอีกนัยหนึ่ง f(x) = x + ตัวรับสัญญาณ [x] + ตัวรับสัญญาณ [ตัวรับสัญญาณ [x]] + ... + ตัวรับ^(k)[x].
งานของคุณคือการเลือกผู้เล่นเริ่มต้นที่มี id x เพื่อให้ค่า f(x) สูงสุด.
ส่งคืนจำนวนเต็มแสดงค่าสูงสุดของฟังก์ชัน
หมายเหตุ: ผู้รับอาจมีซ้ำ

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

หมายเลขผ่าน
ID ผู้ส่ง
ID ตัวรับสัญญาณ
X + ตัวรับสัญญาณ IDs

2

1
2
1
3

2
1
0
3

3
0
2
5

4
2
1
6

อินพุต: ตัวรับสัญญาณ = [2,0,1], k = 4
เอาท์พุท: 6
คำอธิบาย: ตารางด้านบนแสดงการจำลองเกมเริ่มต้นด้วยผู้เล่นที่มี id x = 2
จากตาราง f(2) เท่ากับ 6
มันสามารถแสดงให้เห็นว่า 6 เป็นค่าสูงสุดที่ทำได้ของฟังก์ชั่น
ดังนั้นผลลัพธ์คือ 6

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

หมายเลขผ่าน
ID ผู้ส่ง
ID ตัวรับสัญญาณ
X + ตัวรับสัญญาณ IDs

4

1
4
3
7

2
3
2
9

3
2
1
10

อินพุต: ตัวรับสัญญาณ  = [1,1,1,2,3], k = 3
เอาท์พุท: 10
คำอธิบาย: ตารางด้านบนแสดงการจำลองเกมเริ่มต้นด้วยผู้เล่นที่มี id x = 4.
จากตาราง f(4) เท่ากับ 10
มันสามารถแสดงให้เห็นว่า 10 เป็นค่าสูงสุดที่ทำได้ของฟังก์ชัน
ดังนั้นผลลัพธ์คือ 10

ข้อ จำกัด :

1 <= receiver.length == n <= 10^5
0 <= receiver[i] <= n - 1
1 <= k <= 10^10


คุณได้รับสตริงไบนารีสองตัว s1 และ s2 ซึ่งมีดัชนีเริ่มต้นที่ 0 ทั้งคู่ และมีความยาว n และมีจำนวนเต็มบวก x คุณสามารถทำการดำเนินการใด ๆ ต่อไปนี้กับสตริง s1 ได้หลายครั้ง:

เลือกดัชนีสองตัว i และ j และพลิกทั้ง s1[i] และ s1[j] ค่าใช้จ่ายของการดำเนินการนี้คือ x
เลือกดัชนี i ที่ i < n - 1 และพลิกทั้ง s1[i] และ s1[i + 1] ค่าใช้จ่ายของการดำเนินการนี้คือ 1

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

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

Input: s1 = "1100011000", s2 = "0101001010", x = 2
Output: 4
คำอธิบาย: เราสามารถทำการดำเนินการต่อไปนี้ได้:
- เลือก i = 3 และใช้การดำเนินการที่สอง ผลลัพธ์ที่ได้คือ s1 = "1101111000"
- เลือก i = 4 และใช้การดำเนินการที่สอง ผลลัพธ์ที่ได้คือ s1 = "1101001000"
- เลือก i = 0 และ j = 8 และใช้การดำเนินการแรก ผลลัพธ์ที่ได้คือ s1 = "0101001010" = s2
ต้นทุนรวมคือ 1 + 1 + 2 = 4 สามารถแสดงให้เห็นว่ามันเป็นต้นทุนขั้นต่ำที่เป็นไปได้

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

Input: s1 = "10110", s2 = "00011", x = 4
Output: -1
คำอธิบาย: ไม่สามารถทำให้สองสตริงเท่ากันได้

ข้อจำกัด:

n == s1.length == s2.length
1 <= n, x <= 500
s1 และ s2 ประกอบด้วยเฉพาะตัวอักษร '0' และ '1' เท่านั้น

คุณจะได้รับสตริงไบนารีที่มีดัชนี 0 สองสตริง s1 และ s2 ทั้งคู่มีความยาว n และจํานวนเต็มบวก x
คุณสามารถดําเนินการใดๆ ต่อไปนี้กับสตริง s1 ได้กี่ครั้งก็ได้:

เลือกดัชนี i และ j สองดัชนี แล้วพลิกทั้ง s1[i] และ s1[j] ค่าใช้จ่ายของการดําเนินการนี้คือ x
เลือกดัชนี i เพื่อให้ i < n - 1 แล้วพลิกทั้ง s1[i] และ s1[i + 1] ค่าใช้จ่ายของการดําเนินการนี้คือ 1

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

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

อินพุต: s1 = "1100011000", s2 = "0101001010", x = 2
เอาท์พุต: 4
คําอธิบาย: เราสามารถดําเนินการดังต่อไปนี้:
- เลือก i = 3 และใช้การดําเนินการที่สอง สตริงผลลัพธ์คือ s1 = "1101111000"
- เลือก i = 4 และใช้การดําเนินการที่สอง สตริงผลลัพธ์คือ s1 = "1101001000"
- เลือก i = 0 และ j = 8 และใช้การดําเนินการครั้งแรก สตริงผลลัพธ์คือ s1 = "0101001010" = s2
ค่าใช้จ่ายทั้งหมดคือ 1 + 1 + 2 = 4 สามารถแสดงได้ว่าเป็นต้นทุนขั้นต่ําที่เป็นไปได้

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

อินพุต: s1 = "10110", s2 = "00011", x = 4
เอาท์พุต: -1
คําอธิบาย: เป็นไปไม่ได้ที่จะทําให้ทั้งสองสตริงเท่ากัน

ข้อจํากัด:

n == s1.length == s2.length
1 <= n, x <= 500
s1 และ s2 ประกอบด้วยตัวอักษร '0' และ '1' เท่านั้น

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

เลือกสองดัชนี i และ j และพลิกทั้ง s1[i] และ s1[j] ค่าใช้จ่ายในการดำเนินการนี้คือ x
เลือกดัชนี i โดยที่ i < n - 1 และพลิกทั้ง s1[i] และ s1[i + 1] ค่าใช้จ่ายในการดำเนินการนี้คือ 1

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

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

Input: s1 = "1100011000", s2 = "0101001010", x = 2
Output: 4
คำอธิบาย: เราสามารถทำการดำเนินการต่อไปนี้:
- เลือก i = 3 และใช้การดำเนินการที่สอง สายอักขระที่ได้คือ s1 = "1101111000"
- เลือก i = 4 และใช้การดำเนินการที่สอง สายอักขระที่ได้คือ s1 = "1101001000"
- เลือก i = 0 และ j = 8 และใช้การดำเนินการแรก สายอักขระที่ได้คือ s1 = "0101001010" = s2
ค่าใช้จ่ายรวมคือ 1 + 1 + 2 = 4 สามารถแสดงให้เห็นว่านี่คือค่าใช้จ่ายขั้นต่ำที่เป็นไปได้

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

Input: s1 = "10110", s2 = "00011", x = 4
Output: -1
คำอธิบาย: เป็นไปไม่ได้ที่จะทำให้สายอักขระทั้งสองเท่ากัน

ข้อจำกัด:

n == s1.length == s2.length
1 <= n, x <= 500
s1 และ s2 ประกอบด้วยตัวอักษร '0' และ '1' เท่านั้น


คุณมีอาเรย์สองมิติแบบ 0-indexed ที่ประกอบด้วยจำนวนเต็ม nums ซึ่งแทนพิกัดของรถที่จอดอยู่บนเส้นจำนวนจริง สำหรับดัชนีใดๆ i, nums[i] = [start_i, end_i] โดยที่ start_i คือจุดเริ่มต้นของรถคันที่ i^th และ end_i คือจุดสิ้นสุดของรถคันที่ i^th
ให้คุณหาจำนวนจุดบนเส้นที่ครอบคลุมด้วยส่วนใดส่วนหนึ่งของรถ

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

Input: nums = [[3,6],[1,5],[4,7]]
Output: 7
คำอธิบาย: จุดทั้งหมดตั้งแต่ 1 ถึง 7 ถูกครอบคลุมด้วยรถอย่างน้อยหนึ่งคัน ดังนั้นคำตอบคือ 7

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

Input: nums = [[1,3],[5,8]]
Output: 7
คำอธิบาย: จุดที่ถูกครอบคลุมด้วยรถอย่างน้อยหนึ่งคันคือ 1, 2, 3, 5, 6, 7, 8 รวมทั้งหมด 7 จุด ดังนั้นคำตอบคือ 7

เงื่อนไข:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่มีดัชนีเริ่มต้นที่ 0 ที่แสดงถึงพิกัดของรถที่จอดรถในบรรทัดตัวเลข สำหรับดัชนีใด ๆ i, nums [i] = [start_i, end_i] โดยที่ start_i เป็นจุดเริ่มต้นของรถ i^th และ end_i เป็นจุดสิ้นสุดของรถ i^th
ส่งคืนจำนวนจุดจำนวนเต็มบนบรรทัดที่ปกคลุมด้วยส่วนใดส่วนหนึ่งของรถยนต์

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

อินพุต: nums = [[3,6], [1,5], [4,7]]
เอาท์พุท: 7
คำอธิบาย: จุดทั้งหมดจาก 1 ถึง 7 ตัดกับรถอย่างน้อยหนึ่งคันดังนั้นคำตอบจะเป็น 7

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

อินพุต: nums = [[1,3], [5,8]]
เอาท์พุท: 7
คำอธิบาย: จุดที่ตัดกันอย่างน้อยหนึ่งคันคือ 1, 2, 3, 5, 6, 7, 8. มีทั้งหมด 7 จุดดังนั้นคำตอบจะเป็น 7

ข้อ จำกัด :

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100

คุณจะได้รับอาร์เรย์จำนวนเต็ม 2 มิติที่มีดัชนี 0 nums ที่แสดงพิกัดของรถยนต์ที่จอดบนเส้นจำนวน สำหรับดัชนี i ใดๆ nums[i] = [start_i, end_i] โดยที่ start_i คือจุดเริ่มต้นของรถยนต์คันที่ i และ end_i คือจุดสิ้นสุดของรถยนต์คันที่ i
ส่งคืนจำนวนจุดจำนวนเต็มบนเส้นที่ถูกปกคลุมด้วยส่วนใดๆ ของรถยนต์
ตัวอย่างที่ 1:

อินพุต: nums = [[3,6],[1,5],[4,7]]
เอาต์พุต: 7
คำอธิบาย: จุดทั้งหมดตั้งแต่ 1 ถึง 7 ตัดกับรถอย่างน้อย 1 คัน ดังนั้นคำตอบคือ 7

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

อินพุต: nums = [[1,3],[5,8]]
เอาต์พุต: 7
คำอธิบาย: จุดที่ตัดกับรถอย่างน้อย 1 คันคือ 1, 2, 3, 5, 6, 7, 8 มีทั้งหมด 7 จุด ดังนั้นคำตอบคือ 7

ข้อจำกัด:

1 <= nums.length <= 100
nums[i].length == 2
1 <= start_i <= end_i <= 100


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

ตัวอย่าง 1:

อินพุต: nums = [3,1,5,4,2], k = 2
เอาต์พุต: 4
คำอธิบาย: หลังจากดำเนินการ 4 ครั้ง เราจะรวบรวมองค์ประกอบ 2, 4, 5 และ 1 ตามลำดับนี้ คอลเลกชันของเรามีองค์ประกอบ 1 และ 2 ดังนั้นคำตอบคือ 4

ตัวอย่าง 2:

อินพุต: nums = [3,1,5,4,2], k = 5
เอาต์พุต: 5
คำอธิบาย: หลังจากดำเนินการ 5 ครั้ง เราจะรวบรวมองค์ประกอบ 2, 4, 5, 1 และ 3 ตามลำดับนี้ คอลเล็กชันของเรามีองค์ประกอบตั้งแต่ 1 ถึง 5 ดังนั้นคำตอบคือ 5

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

อินพุต: nums = [3,2,5,3,1], k = 3
เอาต์พุต: 4
คำอธิบาย: หลังจากดำเนินการ 4 ครั้งแล้ว เราจะรวบรวมองค์ประกอบ 1, 3, 5 และ 2 ตามลำดับ คอลเล็กชันของเรามีองค์ประกอบตั้งแต่ 1 ถึง 3 ดังนั้นคำตอบคือ 4

ข้อจำกัด:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
อินพุตจะถูกสร้างขึ้นเพื่อให้คุณรวบรวมองค์ประกอบ 1, 2, ..., k ได้

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

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

Input: nums = [3,1,5,4,2], k = 2
Output: 4
Explanation: หลังจากการดำเนินการ 4 ครั้ง เราเก็บรวบรวมองค์ประกอบ 2, 4, 5 และ 1 ตามลำดับ คอลเลกชันของเรามีองค์ประกอบ 1 และ 2 ดังนั้นคำตอบคือ 4.

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

Input: nums = [3,1,5,4,2], k = 5
Output: 5
Explanation: หลังจากการดำเนินการ 5 ครั้ง เราได้รวบรวมองค์ประกอบ 2, 4, 5, 1 และ 3 ตามลำดับ คอลเลกชันของเรามีองค์ประกอบตั้งแต่ 1 ถึง 5 ดังนั้นคำตอบคือ 5.

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

Input: nums = [3,2,5,3,1], k = 3
Output: 4
Explanation: หลังจากการดำเนินการ 4 ครั้ง เราเก็บรวบรวมองค์ประกอบ 1, 3, 5 และ 2 ตามลำดับ คอลเลกชันของเรามีองค์ประกอบตั้งแต่ 1 ถึง 3 ดังนั้นคำตอบคือ 4.

ข้อจำกัด:

1 <= nums.length <= 50
1 <= nums[i] <= nums.length
1 <= k <= nums.length
ข้อมูลนำเข้าถูกสร้างขึ้นเพื่อให้คุณสามารถรวบรวมองค์ประกอบ 1, 2, ..., k ได้


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

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

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

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

อินพุต: nums = [1,3,5]
เอาต์พุต: 0
คำอธิบาย: nums ได้รับการเรียงลำดับแล้ว ดังนั้นคำตอบคือ 0
ตัวอย่างที่ 3:

อินพุต: nums = [2,1,4]
เอาต์พุต: -1
คำอธิบาย: ไม่สามารถเรียงลำดับอาร์เรย์โดยใช้การเลื่อนขวาได้

ข้อจำกัด:

1 <= nums.length <= 100
1 <= nums[i] <= 100
nums ประกอบด้วยจำนวนเต็มที่แตกต่างกัน


คุณมีสตริงที่มีดัชนีเริ่มต้นเป็น 0 ชื่อ num ซึ่งแทนจำนวนเต็มที่ไม่เป็นลบ ในการดำเนินการหนึ่งครั้ง คุณสามารถเลือกตัวเลขใดๆ ของ num และลบออกได้ ข้อสังเกตคือถ้าคุณลบตัวเลขทั้งหมดของ num, num จะกลายเป็น 0 คืนค่าจำนวนการดำเนินการขั้นต่ำที่จำเป็นเพื่อทำให้ num เป็นพิเศษ จำนวนเต็ม x ถือว่าเป็นพิเศษถ้ามันหารด้วย 25 ลงตัว

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

Input: num = "2245047"
Output: 2
คำอธิบาย: ลบตัวเลข num[5] และ num[6] หมายเลขที่เกิดขึ้นคือ "22450" ซึ่งเป็นพิเศษเพราะหารด้วย 25 ลงตัว สามารถแสดงได้ว่า 2 เป็นจำนวนการดำเนินการขั้นต่ำที่ต้องการเพื่อให้ได้หมายเลขพิเศษ

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

Input: num = "2908305"
Output: 3
คำอธิบาย: ลบตัวเลข num[3], num[4] และ num[6] หมายเลขที่เกิดขึ้นคือ "2900" ซึ่งเป็นพิเศษเพราะหารด้วย 25 ลงตัว สามารถแสดงได้ว่า 3 เป็นจำนวนการดำเนินการขั้นต่ำที่ต้องการเพื่อให้ได้หมายเลขพิเศษ

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

Input: num = "10"
Output: 1
คำอธิบาย: ลบตัวเลข num[0] หมายเลขที่เกิดขึ้นคือ "0" ซึ่งเป็นพิเศษเพราะหารด้วย 25 ลงตัว สามารถแสดงได้ว่า 1 เป็นจำนวนการดำเนินการขั้นต่ำที่ต้องการเพื่อให้ได้หมายเลขพิเศษ

ข้อจำกัด:

1 <= num.length <= 100
num มีเฉพาะตัวเลข '0' ถึง '9'
num ไม่มีศูนย์นำหน้า

คุณจะได้รับสตริง num ที่มีดัชนี 0 ซึ่งแสดงถึงจำนวนเต็มที่ไม่เป็นลบ
ในการดำเนินการครั้งหนึ่ง คุณสามารถเลือกหลักใดๆ ของ num และลบออก โปรดทราบว่าหากคุณลบหลักทั้งหมดของ num num จะกลายเป็น 0
ส่งคืนจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการทำให้ num พิเศษ
จำนวนเต็ม x ถือเป็นจำนวนพิเศษหากหารด้วย 25 ลงตัว

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

อินพุต: num = "2245047"
เอาต์พุต: 2
คำอธิบาย: ลบหลัก num[5] และ num[6] จำนวนที่ได้คือ "22450" ซึ่งเป็นจำนวนพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงได้ว่า 2 คือจำนวนการดำเนินการขั้นต่ำที่จำเป็นในการรับจำนวนพิเศษ ตัวอย่างที่ 2:

อินพุต: num = "2908305"
เอาต์พุต: 3
คำอธิบาย: ลบตัวเลข num[3], num[4] และ num[6] ตัวเลขที่ได้คือ "2900" ซึ่งเป็นตัวเลขพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงให้เห็นว่า 3 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นเพื่อให้ได้ตัวเลขพิเศษ
ตัวอย่างที่ 3:

อินพุต: num = "10"
เอาต์พุต: 1
คำอธิบาย: ลบตัวเลข num[0] ตัวเลขที่ได้คือ "0" ซึ่งเป็นตัวเลขพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงให้เห็นว่า 1 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นเพื่อให้ได้ตัวเลขพิเศษ

ข้อจำกัด:

1 <= num.length <= 100
num ประกอบด้วยตัวเลขตั้งแต่ '0' ถึง '9' เท่านั้น
num ไม่มีเลขศูนย์นำหน้าใดๆ

คุณจะได้รับสตริงตัวเลขที่มีดัชนีเริ่มต้นที่ 0 ซึ่งแสดงถึงจำนวนเต็มที่ไม่เป็นลบ
ในการดำเนินการครั้งเดียวคุณสามารถเลือกตัวเลขใด ๆ ของ num และลบออก โปรดทราบว่าหากคุณลบตัวเลขทั้งหมดของ num, num กลายเป็น 0
ส่งคืนจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการทำ num พิเศษ
จำนวนเต็ม x ถือว่าเป็นพิเศษหากสามารถหารได้ 25

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

อินพุต: num = "2245047"
เอาท์พุท: 2
คำอธิบาย: ลบตัวเลข num[5] และ num[6] จำนวนผลลัพธ์คือ "22450" ซึ่งพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงให้เห็นว่า 2 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการรับหมายเลขพิเศษ
ตัวอย่างที่ 2:

อินพุต: num = "2908305"
เอาท์พุท: 3
คำอธิบาย: ลบตัวเลขจำนวน num[3], num [4] และ num [6] จำนวนผลลัพธ์คือ "2900" ซึ่งพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงให้เห็นว่า 3 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการรับหมายเลขพิเศษ
ตัวอย่างที่ 3:

อินพุต: num = "10"
เอาท์พุท: 1
คำอธิบาย: ลบตัวเลขตัวเลข num[0] จำนวนผลลัพธ์คือ "0" ซึ่งพิเศษเนื่องจากหารด้วย 25 ลงตัว
สามารถแสดงให้เห็นว่า 1 คือจำนวนขั้นต่ำของการดำเนินการที่จำเป็นในการรับหมายเลขพิเศษ

ข้อ จำกัด :

1 <= num.length <= 100
ตัวเลขประกอบด้วยตัวเลข '0' ถึง '9' เท่านั้น
num ไม่มีศูนย์ชั้นนำใด ๆ


คุณได้รับอาเรย์ nums ที่มีขนาด n ซึ่งมีจำนวนเต็มที่มีดัชนีเริ่มต้นที่ 1
ชุดของตัวเลขจะสมบูรณ์ถ้าผลคูณของทุกคู่ของสมาชิกในชุดนั้นเป็นเลขยกกำลังสองที่สมบูรณ์
สำหรับชุดย่อยของดัชนีในชุด {1, 2, ..., n} ที่แสดงเป็น {i_1, i_2, ..., i_k} เรากำหนดผลรวมของสมาชิกเป็น: nums[i_1] + nums[i_2] + ... + nums[i_k]
ส่งคืนผลรวมของสมาชิกสูงสุดของชุดย่อยที่สมบูรณ์จากชุดดัชนี {1, 2, ..., n}
เลขยกกำลังสองที่สมบูรณ์คือเลขที่สามารถแสดงเป็นผลคูณของจำนวนเต็มกับตัวมันเอง

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

Input: nums = [8,7,3,5,7,2,4,9]
Output: 16
คำอธิบาย: นอกจากกลุ่มย่อยที่ประกอบด้วยดัชนีเดียวแล้ว ยังมีกลุ่มย่อยที่สมบูรณ์อีกสองกลุ่มของดัชนี: {1,4} และ {2,8}
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 1 และ 4 เท่ากับ nums[1] + nums[4] = 8 + 5 = 13
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 2 และ 8 เท่ากับ nums[2] + nums[8] = 7 + 9 = 16
ดังนั้น ผลรวมขององค์ประกอบสูงสุดของกลุ่มย่อยที่สมบูรณ์ของดัชนีคือ 16

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

Input: nums = [5,10,3,10,1,13,7,9,4]
Output: 19
คำอธิบาย: นอกจากกลุ่มย่อยที่ประกอบด้วยดัชนีเดียวแล้ว ยังมีกลุ่มย่อยที่สมบูรณ์อีกสี่กลุ่มของดัชนี ได้แก่ {1,4}, {1,9}, {2,8}, {4,9} และ {1,4,9}
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 1 และ 4 เท่ากับ nums[1] + nums[4] = 5 + 10 = 15
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 1 และ 9 เท่ากับ nums[1] + nums[9] = 5 + 4 = 9
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 2 และ 8 เท่ากับ nums[2] + nums[8] = 10 + 9 = 19
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 4 และ 9 เท่ากับ nums[4] + nums[9] = 10 + 4 = 14
ผลรวมขององค์ประกอบที่ตรงกับดัชนี 1, 4 และ 9 เท่ากับ nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19
ดังนั้น ผลรวมขององค์ประกอบสูงสุดของกลุ่มย่อยที่สมบูรณ์ของดัชนีคือ 19

ข้อจำกัด:

1 <= n == nums.length <= 10^4
1 <= nums[i] <= 10^9

คุณจะได้รับอาร์เรย์ที่มีดัชนี 1 จำนวน n จำนวนเต็ม
ชุดตัวเลขจะสมบูรณ์ก็ต่อเมื่อผลคูณขององค์ประกอบแต่ละคู่เป็นกำลังสองสมบูรณ์
สำหรับเซตย่อยของเซตดัชนี {1, 2, ..., n} แสดงเป็น {i_1, i_2, ..., i_k} เราจะกำหนดค่าผลรวมองค์ประกอบเป็น: nums[i_1] + nums[i_2] + ... + nums[i_k]
ส่งคืนค่าผลรวมองค์ประกอบสูงสุดของเซตย่อยที่สมบูรณ์ของเซตดัชนี {1, 2, ..., n}
กำลังสองสมบูรณ์คือตัวเลขที่สามารถแสดงเป็นผลคูณของจำนวนเต็มด้วยตัวมันเอง

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

อินพุต: nums = [8,7,3,5,7,2,4,9]
เอาต์พุต: 16
คำอธิบาย: นอกเหนือจากเซ็ตย่อยที่ประกอบด้วยดัชนีตัวเดียวแล้ว ยังมีเซ็ตย่อยดัชนีที่สมบูรณ์อีกสองเซ็ต ได้แก่ {1,4} และ {2,8} ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 4 เท่ากับ nums[1] + nums[4] = 8 + 5 = 13
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 2 และ 8 เท่ากับ nums[2] + nums[8] = 7 + 9 = 16
ดังนั้น ผลรวมองค์ประกอบสูงสุดของชุดย่อยที่สมบูรณ์ของดัชนีคือ 16

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

อินพุต: nums = [5,10,3,10,1,13,7,9,4]
เอาต์พุต: 19
คำอธิบาย: นอกเหนือจากชุดย่อยที่ประกอบด้วยดัชนีเดียวแล้ว ยังมีชุดย่อยที่สมบูรณ์ของดัชนีอีกสี่ชุด ได้แก่ {1,4}, {1,9}, {2,8}, {4,9} และ {1,4,9} ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 4 เท่ากับ nums[1] + nums[4] = 5 + 10 = 15
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 9 เท่ากับ nums[1] + nums[9] = 5 + 4 = 9
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 2 และ 8 เท่ากับ nums[2] + nums[8] = 10 + 9 = 19
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 4 และ 9 เท่ากับ nums[4] + nums[9] = 10 + 4 = 14
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1, 4 และ 9 เท่ากับ nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19
ดังนั้น ผลรวมองค์ประกอบสูงสุดของ เซตย่อยที่สมบูรณ์ของดัชนีคือ 19

ข้อจำกัด:

1 <= n == nums.length <= 10^4
1 <= nums[i] <= 10^9

คุณจะได้รับอาร์เรย์ 1 ที่ได้รับการจัดทำดัชนีของจำนวนเต็ม n
ชุดตัวเลขเสร็จสมบูรณ์หากผลิตภัณฑ์ขององค์ประกอบทุกคู่เป็นสี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบ
สำหรับชุดย่อยของชุดดัชนี {1, 2, ... , n} แสดงเป็น {i_1, i_2, ... , i_k} เรากำหนดองค์ประกอบของมันเป็น: nums [i_1] + nums [i_2] + ... + nums [i_k]
ส่งคืนผลรวมองค์ประกอบสูงสุดของชุดย่อยที่สมบูรณ์ของชุดดัชนี {1, 2, ... , n}
สี่เหลี่ยมจัตุรัสที่สมบูรณ์แบบคือตัวเลขที่สามารถแสดงเป็นผลิตภัณฑ์ของจำนวนเต็มด้วยตัวเอง

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

อินพุต: nums= [8,7,3,5,7,2,4,9]
เอาท์พุท: 16
คำอธิบาย: นอกเหนือจากชุดย่อยที่ประกอบด้วยดัชนีเดียวมีสองชุดย่อยทั้งหมดของดัชนี: {1,4} และ {2,8}
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 4 เท่ากับ nums[1] + nums[4] = 8 + 5 = 13
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 2 และ 8 เท่ากับ nums[2] + nums[8] = 7 + 9 = 16
ดังนั้นผลรวมองค์ประกอบสูงสุดของชุดย่อยที่สมบูรณ์ของดัชนีคือ 16

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

อินพุต: nums= [5,10,3,10,1,13,7,9,4,4]
เอาท์พุท: 19
คำอธิบาย: นอกเหนือจากชุดย่อยที่ประกอบด้วยดัชนีเดียวมีอีกสี่ชุดย่อยทั้งหมดของดัชนี: {1,4}, {1,9}, {2,8}, {4,9} และ {1,4 , 9}
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 4 เท่ากับ nums [1] + nums [4] = 5 + 10 = 15
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1 และ 9 เท่ากับ nums [1] + nums [9] = 5 + 4 = 9
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 2 และ 8 เท่ากับ nums [2] + nums[8] = 10 + 9 = 19
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 4 และ 9 เท่ากับ nums [4] + nums[9] = 10 + 4 = 14
ผลรวมขององค์ประกอบที่สอดคล้องกับดัชนี 1, 4 และ 9 เท่ากับ nums[1] + nums[4] + nums[9] = 5 + 10 + 4 = 19
ดังนั้นผลรวมองค์ประกอบสูงสุดของชุดย่อยที่สมบูรณ์ของดัชนีคือ 19

ข้อ จำกัด :

1 <= n == nums.length <= 10^4
1 <= nums [i] <= 10^9


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

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

อินพุต: s = "010"
เอาต์พุต: "001"
คำอธิบาย: เนื่องจากมี '1' เพียงตัวเดียว จึงต้องอยู่ในตำแหน่งสุดท้าย ดังนั้นคำตอบคือ "001"

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

อินพุต: s = "0101"
เอาต์พุต: "1001"
คำอธิบาย: '1 ตัวใดตัวหนึ่งจะต้องอยู่ในตำแหน่งสุดท้าย จำนวนสูงสุดที่สามารถสร้างได้จากหลักที่เหลือคือ "100" ดังนั้นคำตอบคือ "1001"

ข้อจำกัด:

1 <= s.length <= 100
s ประกอบด้วย '0' และ '1' เท่านั้น
s ประกอบด้วย '1' อย่างน้อยหนึ่งตัว

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

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

อินพุต: s = "010"
เอาท์พุท: "001"
คำอธิบาย: เนื่องจากมีเพียงหนึ่ง '1' จึงต้องอยู่ในตำแหน่งสุดท้าย ดังนั้นคำตอบคือ "001"

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

อินพุต: s = "0101"
เอาท์พุท: "1001"
คำอธิบาย: หนึ่งใน '1 ต้องอยู่ในตำแหน่งสุดท้าย จำนวนสูงสุดที่สามารถทำได้ด้วยตัวเลขที่เหลือคือ "100" ดังนั้นคำตอบคือ "1001"

ข้อ จำกัด :

1 <= s.length <= 100
S ประกอบด้วย '0' และ '1' เท่านั้น
S มีอย่างน้อยหนึ่ง '1'

คุณได้รับสตริงฐานสอง s ที่มี '1'
อย่างน้อยหนึ่งตัว คุณต้องจัดเรียงบิตใหม่เพื่อให้เลขฐานสองที่ได้เป็นเลขคี่สูงสุดที่สามารถสร้างจากการรวมนี้ได้ ส่งคืนสตริงที่แทนเลขฐานสองคี่สูงสุดที่สามารถสร้างได้จากการรวมที่ให้มา โปรดทราบว่าสตริงผลลัพธ์สามารถมีศูนย์นำหน้าได้

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

Input: s = "010"
Output: "001"
คำอธิบาย: เนื่องจากมี '1' เพียงตัวเดียว จึงต้องอยู่ในตำแหน่งสุดท้าย ดังนั้นคำตอบคือ "001"

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

Input: s = "0101"
Output: "1001"
คำอธิบาย: หนึ่งใน '1' ต้องอยู่ในตำแหน่งสุดท้าย เลขสูงสุดที่สามารถทำได้ด้วยตัวเลขที่เหลือคือ "100" ดังนั้นคำตอบคือ "1001"

ข้อจำกัด:

1 <= s.length <= 100
s ประกอบด้วย '0' และ '1' เท่านั้น
s มี '1' อย่างน้อยหนึ่งตัว


คุณจะได้รับอาร์เรย์ nums ที่ประกอบด้วยจำนวนเต็มที่ไม่เป็นลบ
เราจะกำหนดคะแนนของซับอาร์เรย์ nums[l..r] โดยที่ l <= r เป็น nums[l] AND nums[l + 1] AND ... AND nums[r] โดยที่ AND คือการดำเนินการ AND ตามบิต
ลองพิจารณาแบ่งอาร์เรย์ออกเป็นซับอาร์เรย์หนึ่งรายการหรือมากกว่านั้น โดยที่ตรงตามเงื่อนไขต่อไปนี้:

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

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

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

อินพุต: nums = [1,0,2,0,1,2]
เอาต์พุต: 3
คำอธิบาย: เราสามารถแบ่งอาร์เรย์ออกเป็นซับอาร์เรย์ดังต่อไปนี้:
- [1,0] คะแนนของซับอาร์เรย์นี้คือ 1 AND 0 = 0.
- [2,0] คะแนนของซับอาร์เรย์นี้คือ 2 AND 0 = 0.
- [1,2] คะแนนของซับอาร์เรย์นี้คือ 1 AND 2 = 0.
ผลรวมคะแนนคือ 0 + 0 + 0 = 0 ซึ่งเป็นคะแนนต่ำสุดที่เป็นไปได้ที่เราจะได้รับ
จะเห็นได้ว่าเราไม่สามารถแยกอาร์เรย์ออกเป็นซับอาร์เรย์มากกว่า 3 ซับอาร์เรย์ที่มีคะแนนรวมเป็น 0 ดังนั้นเราจึงส่งคืน 3

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

อินพุต: nums = [5,7,1,3]
เอาต์พุต: 1
คำอธิบาย: เราสามารถแยกอาร์เรย์ออกเป็นซับอาร์เรย์เดียว: [5,7,1,3] โดยมีคะแนน 1 ซึ่งเป็นคะแนนต่ำสุดที่เป็นไปได้ที่เราจะได้รับ จะเห็นได้ว่าเราไม่สามารถแยกอาร์เรย์ออกเป็นซับอาร์เรย์มากกว่า 1 ซับอาร์เรย์ที่มีคะแนนรวมเท่ากับ 1 ดังนั้นเราจึงส่งคืน 1

ข้อจำกัด:

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

ให้คุณอาเรย์ nums ซึ่งประกอบด้วยจำนวนเต็มที่ไม่เป็นลบ

เรากำหนดคะแนนของซับอาเรย์ nums[l..r] ที่ l <= r เป็น nums[l] AND nums[l + 1] AND ... AND nums[r] ซึ่ง AND เป็นการคำนวณ AND แบบบิต

พิจารณาแบ่งอาเรย์ออกเป็นหนึ่งหรือมากกว่าหนึ่งซับอาเรย์ที่เงื่อนไขต่อไปนี้เป็นจริง:

แต่ละองค์ประกอบของอาเรย์จะต้องอยู่ในซับอาเรย์หนึ่งซับอาเรย์เท่านั้น

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

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

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

Input: nums = [1,0,2,0,1,2]
Output: 3
คำอธิบาย: เราสามารถแบ่งอาเรย์เป็นซับอาเรย์ดังต่อไปนี้:
- [1,0]. คะแนนของซับอาเรย์นี้คือ 1 AND 0 = 0.
- [2,0]. คะแนนของซับอาเรย์นี้คือ 2 AND 0 = 0.
- [1,2]. คะแนนของซับอาเรย์นี้คือ 1 AND 2 = 0.
ผลรวมของคะแนนคือ 0 + 0 + 0 = 0 ซึ่งเป็นคะแนนขั้นต่ำที่เราจะได้

สามารถแสดงได้ว่าไม่สามารถแบ่งอาเรย์ออกเป็นมากกว่า 3 ซับอาเรย์ โดยมีผลรวมของคะแนนเป็น 0 ได้ ดังนั้นเราคืนค่า 3

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

Input: nums = [5,7,1,3]
Output: 1
คำอธิบาย: เราสามารถแบ่งอาเรย์เป็นซับอาเรย์เดียว: [5,7,1,3] โดยมีคะแนนเป็น 1 ซึ่งเป็นคะแนนขั้นต่ำที่เราจะได้
สามารถแสดงได้ว่าไม่สามารถแบ่งอาเรย์ออกเป็นมากกว่า 1 ซับอาเรย์ โดยมีผลรวมของคะแนนเป็น 1 ได้ ดังนั้นเราคืนค่า 1

ข้อจำกัด:

1 <= nums.length <= 10^5

0 <= nums[i] <= 10^6


คุณได้รับอาเรย์ของจำนวนเต็มที่เรียงลำดับแล้วซึ่งมีดัชนีเริ่มต้นที่ 0 (0-indexed) ชื่อว่า nums
คุณสามารถทำการดำเนินการต่อไปนี้ได้หลายครั้ง:

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

ส่งคืนจำนวนเต็มที่แสดงถึงความยาวขั้นต่ำของ nums หลังจากทำการดำเนินการใด ๆ จำนวนครั้ง (รวมถึงศูนย์ครั้ง)
หมายเหตุว่า nums ถูกจัดเรียงในลำดับที่ไม่ลดลง

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

Input: nums = [1,3,4,9]
Output: 0
คำอธิบาย:เริ่มต้น nums = [1, 3, 4, 9]
ในการดำเนินการครั้งแรก เราสามารถเลือกดัชนี 0 และ 1 ได้เพราะ nums[0] < nums[1] <=> 1 < 3
ลบดัชนี 0 และ 1 และ nums จะกลายเป็น [4, 9]
 สำหรับการดำเนินการถัดไป เราสามารถเลือกดัชนี 0 และ 1 ได้เพราะ nums[0] < nums[1] <=> 4 < 9
ลบดัชนี 0 และ 1 และ nums จะกลายเป็นอาร์เรย์ว่าง []
ดังนั้น ความยาวขั้นต่ำที่สามารถทำได้คือ 0

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

Input: nums = [2,3,6,9]
Output: 0
คำอธิบาย: เริ่มต้น nums = [2, 3, 6, 9].
ในขั้นตอนแรก เราสามารถเลือกดัชนี 0 และ 2 ได้เพราะ nums[0] < nums[2] <=> 2 < 6.
ลบดัชนี 0 และ 2 และ nums จะกลายเป็น [3, 9].
สำหรับขั้นตอนถัดไป เราสามารถเลือกดัชนี 0 และ 1 ได้เพราะ nums[0] < nums[1] <=> 3 < 9.
ลบดัชนี 0 และ 1 และ nums จะกลายเป็นอาร์เรย์ว่าง [].
ดังนั้น ความยาวขั้นต่ำที่สามารถทำได้คือ 0.

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

Input: nums = [1,1,2]
Output: 1
คำอธิบาย: เริ่มต้น nums = [1, 1, 2].
ในการดำเนินการ เราสามารถเลือกดัชนี 0 และ 2 ได้เพราะ nums[0] < nums[2] <=> 1 < 2.
ลบดัชนี 0 และ 2 และ nums จะกลายเป็น [1].
ไม่สามารถดำเนินการใด ๆ กับอาร์เรย์ได้อีกต่อไป.
ดังนั้น ความยาวขั้นต่ำที่สามารถทำได้คือ 1.

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums ถูกจัดเรียงในลำดับที่ไม่ลดลง

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

เลือกดัชนีสองดัชนีคือiและ j ที่i <j เช่น nums[i] < nums[j]
จากนั้นลบองค์ประกอบที่ดัชนี i และ J ออกจาก nums องค์ประกอบที่เหลือยังคงรักษาลำดับเดิมและอาร์เรย์จะถูกจัดดัชนีอีกครั้ง

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

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

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

อินพุต: nums = [2,3,6,9]
เอาท์พุท: 0
คำอธิบาย: เริ่มแรก, nums = [2, 3, 6, 9]
ในการดำเนินการครั้งแรกเราสามารถเลือกดัชนี 0 และ 2 เนื่องจาก nums [0] <nums [2] <=> 2 <6
ลบดัชนี 0 และ 2 และ nums กลายเป็น [3, 9]
สำหรับการดำเนินการครั้งต่อไปเราสามารถเลือกดัชนี 0 และ 1 เพราะ nums [0] <nums [1] <=> 3 <9
ลบดัชนี 0 และ 1 และ nums กลายเป็นอาร์เรย์ว่าง []
ดังนั้นความยาวขั้นต่ำที่ทำได้คือ 0

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

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

ข้อ จำกัด :

1 <= nums.length <= 10^5
1 <= nums [i] <= 10^9
nums ถูกจัดเรียงตามลำดับที่ไม่ได้ลดลง

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

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

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

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

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

อินพุต: nums = [2,3,6,9]
เอาต์พุต: 0
คำอธิบาย: ในตอนแรก nums = [2, 3, 6, 9] ในการดำเนินการครั้งแรก เราสามารถเลือกดัชนี 0 และ 2 ได้เนื่องจาก nums[0] < nums[2] <=> 2 < 6
ลบดัชนี 0 และ 2 ออก และ nums จะกลายเป็น [3, 9]
สำหรับการดำเนินการครั้งต่อไป เราสามารถเลือกดัชนี 0 และ 1 ได้เนื่องจาก nums[0] < nums[1] <=> 3 < 9
ลบดัชนี 0 และ 1 ออก และ nums จะกลายเป็นอาร์เรย์ว่าง []
ดังนั้น ความยาวขั้นต่ำที่ทำได้คือ 0

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

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

ข้อจำกัด:

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
nums จะถูกเรียงลำดับแบบไม่ลดลง


คุณได้รับมอบอาร์เรย์ nums ซึ่งมีดัชนีเริ่มต้นที่ 0 ประกอบด้วยจำนวนเต็มที่ไม่เป็นลบ และจำนวนเต็มสองจำนวนคือ l และ r
จงหาจำนวนของเซตย่อยทั้งหมดที่เป็นไปได้ของเซต nums โดยที่ผลรวมของสมาชิกในแต่ละเซตย่อยนั้นอยู่ระหว่าง l และ r (รวม l และ r ด้วย)
เนื่องจากคำตอบอาจมีค่ามาก จึงให้ตอบเป็นเศษเหลือจากการหารด้วย 10^9 + 7
ซับมัลติเซ็ตคือการรวบรวมที่ไม่เรียงลำดับขององค์ประกอบในอาร์เรย์ ซึ่งค่าที่กำหนด x สามารถเกิดขึ้นได้ 0, 1, ..., occ[x] ครั้ง โดยที่ occ[x] คือจำนวนครั้งที่ x ปรากฏในอาร์เรย์
ข้อสังเกต:

สองซับมัลติเซ็ตจะเหมือนกันถ้าหากการเรียงลำดับซับมัลติเซ็ตทั้งสองจะได้มัลติเซ็ตที่เหมือนกัน ผลรวมของมัลติเซ็ตที่ว่างเปล่าคือ 0.

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

Input: nums = [1,2,2,3], l = 6, r = 6
Output: 1
คำอธิบาย: ชุดย่อยเพียงชุดเดียวของ nums ที่มีผลรวมเป็น 6 คือ {1, 2, 3}

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

Input: nums = [2,1,4,2,7], l = 1, r = 5
Output: 7
คำอธิบาย: กลุ่มย่อยของ nums ที่มีผลรวมอยู่ในช่วง [1, 5] คือ {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} และ {1, 2, 2}.
ตัวอย่างที่ 3:

Input: nums = [1,2,1,3,5,2], l = 3, r = 5
Output: 9
คำอธิบาย: กลุ่มย่อยของ nums ที่มีผลรวมอยู่ในช่วง [3, 5] คือ {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3}, และ {1, 2, 2}.

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
ผลรวมของตัวเลขไม่เกิน 2 * 10^4.
0 <= l <= r <= 2 * 10^4

คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 เป็นจำนวนเต็มที่ไม่เป็นลบ และจำนวนเต็มสองจำนวนคือ l และ r
ส่งคืนจำนวนซับมัลติเซ็ตภายในจำนวนที่ผลรวมขององค์ประกอบในแต่ละซับเซ็ตอยู่ในช่วงรวมของ [l, r]
เนื่องจากคำตอบอาจมีค่ามาก จึงส่งคืนโมดูโล 10^9 + 7
ซับมัลติเซ็ตคือกลุ่มขององค์ประกอบที่ไม่ได้เรียงลำดับของอาร์เรย์ โดยที่ค่า x ที่กำหนดสามารถเกิดขึ้นได้ 0, 1, ..., occ[x] ครั้ง โดยที่ occ[x] คือจำนวนครั้งของ x ที่เกิดขึ้นในอาร์เรย์
โปรดทราบว่า:

ซับมัลติเซ็ตสองชุดจะเหมือนกันหากการเรียงลำดับซับมัลติเซ็ตทั้งสองชุดจะส่งผลให้เกิดซับเซ็ตที่เหมือนกัน ผลรวมของมัลติเซ็ตว่างคือ 0

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

อินพุต: nums = [1,2,2,3], l = 6, r = 6
เอาต์พุต: 1
คำอธิบาย: เซ็ตย่อยเดียวของ nums ที่มีผลรวมเท่ากับ 6 คือ {1, 2, 3}

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

อินพุต: nums = [2,1,4,2,7], l = 1, r = 5
เอาต์พุต: 7
คำอธิบาย: เซ็ตย่อยของ nums ที่มีผลรวมอยู่ในช่วง [1, 5] คือ {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} และ {1, 2, 2}
ตัวอย่างที่ 3:

อินพุต: nums = [1,2,1,3,5,2], l = 3, r = 5
เอาต์พุต: 9
คำอธิบาย: เซ็ตย่อยของ nums ที่มีผลรวมภายในช่วง [3, 5] คือ {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} และ {1, 2, 2}

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
ผลรวมของ nums ไม่เกิน 2 * 10^4
0 <= l <= r <= 2 * 10^4

คุณจะได้รับอาร์เรย์ที่มีดัชนี 0 เป็นจำนวนเต็มที่ไม่เป็นลบ และจำนวนเต็มสองจำนวนคือ l และ r
ส่งคืนจำนวนซับมัลติเซ็ตภายใน nums โดยที่ผลรวมขององค์ประกอบในแต่ละซับเซ็ตนั้นอยู่ในช่วงรวมของ [l, r]
เนื่องจากคำตอบอาจมีค่ามาก จึงส่งคืนโมดูโล 10^9 + 7
ซับมัลติเซ็ตคือกลุ่มขององค์ประกอบที่ไม่ได้เรียงลำดับของอาร์เรย์ โดยที่ค่า x ที่กำหนดสามารถเกิดขึ้นได้ 0, 1, ..., occ[x] ครั้ง โดยที่ occ[x] คือจำนวนครั้งของ x ที่เกิดขึ้นในอาร์เรย์
โปรดทราบว่า:

ซับมัลติเซ็ตสองชุดจะเหมือนกันหากการเรียงลำดับซับมัลติเซ็ตทั้งสองชุดจะส่งผลให้เกิดซับเซ็ตที่เหมือนกัน ผลรวมของมัลติเซ็ตว่างคือ 0

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

อินพุต: nums = [1,2,2,3], l = 6, r = 6
เอาต์พุต: 1
คำอธิบาย: เซ็ตย่อยเดียวของ nums ที่มีผลรวมเท่ากับ 6 คือ {1, 2, 3}

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

อินพุต: nums = [2,1,4,2,7], l = 1, r = 5
เอาต์พุต: 7
คำอธิบาย: เซ็ตย่อยของ nums ที่มีผลรวมอยู่ในช่วง [1, 5] คือ {1}, {2}, {4}, {2, 2}, {1, 2}, {1, 4} และ {1, 2, 2}
ตัวอย่างที่ 3:

อินพุต: nums = [1,2,1,3,5,2], l = 3, r = 5
เอาต์พุต: 9
คำอธิบาย: เซ็ตย่อยของ nums ที่มีผลรวมภายในช่วง [3, 5] คือ {3}, {5}, {1, 2}, {1, 3}, {2, 2}, {2, 3}, {1, 1, 2}, {1, 1, 3} และ {1, 2, 2}

ข้อจำกัด:

1 <= nums.length <= 2 * 10^4
0 <= nums[i] <= 2 * 10^4
ผลรวมของ nums ไม่เกิน 2 * 10^4
0 <= l <= r <= 2 * 10^4


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

ตัวอย่างเช่น การแสดงแบบไบนารีของ 21 คือ 10101 ซึ่งมีบิตชุด 3 ชุด

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

อินพุต: nums = [5,10,1,5,2], k = 1
เอาต์พุต: 13
คำอธิบาย: การแสดงแบบไบนารีของดัชนีคือ:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
ดัชนี 1, 2 และ 4 มีบิตชุด k = 1 ในการแสดงแบบไบนารี ดังนั้นคำตอบคือ nums[1] + nums[2] + nums[4] = 13
ตัวอย่างที่ 2:

อินพุต: nums = [4,3,2,1], k = 2
เอาต์พุต: 1
คำอธิบาย: การแสดงค่าไบนารีของดัชนีคือ:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
เฉพาะดัชนี 3 เท่านั้นที่มีบิตเซ็ต k = 2 ในการแสดงค่าไบนารี
ดังนั้นคำตอบคือ nums[3] = 1

ข้อจำกัด:

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

คุณจะได้รับ nums อาร์เรย์จํานวนเต็มที่มีดัชนี 0 และจํานวนเต็ม k
ส่งคืนจํานวนเต็มที่แสดงถึงผลรวมขององค์ประกอบในจํานวนที่มีดัชนีที่สอดคล้องกันมีบิตชุด k ในการแสดงไบนารี
บิตที่ตั้งไว้ในจํานวนเต็มคือ 1's ที่มีอยู่เมื่อเขียนเป็นไบนารี

ตัวอย่างเช่น การแสดงไบนารีของ 21 คือ 10101 ซึ่งมี 3 บิตชุด

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

อินพุต: nums = [5,10,1,5,2], k = 1
เอาท์พุต: 13
คําอธิบาย: การแสดงไบนารีของดัชนีคือ:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
ดัชนี 1, 2 และ 4 มี k = 1 บิตชุดในการแสดงไบนารี
ดังนั้นคําตอบคือ nums[1] + nums[2] + nums[4] = 13
ตัวอย่างที่ 2:

อินพุต: nums = [4,3,2,1], k = 2
เอาท์พุต: 1
คําอธิบาย: การแสดงไบนารีของดัชนีคือ:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
เฉพาะดัชนี 3 เท่านั้นที่มี k = 2 บิตชุดในการแสดงไบนารี
ดังนั้นคําตอบคือ nums[3] = 1

ข้อจํากัด:

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

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

ตัวอย่างเช่น การแทนค่าไบนารีของ 21 คือ 10101 ซึ่งมีบิตที่ตั้งค่าเป็น 1 จำนวน 3 บิต

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

Input: nums = [5,10,1,5,2], k = 1
Output: 13
คำอธิบาย: การแทนค่าด้วยเลขฐานสองของดัชนีคือ:
0 = 000_2
1 = 001_2
2 = 010_2
3 = 011_2
4 = 100_2
ดัชนี 1, 2 และ 4 มีบิตที่ตั้งค่าเป็น 1 จำนวน k = 1 ในการแทนค่าแบบไบนารีของพวกเขา
ดังนั้นคำตอบคือ nums[1] + nums[2] + nums[4] = 13.
ตัวอย่างที่ 2:

Input: nums = [4,3,2,1], k = 2
Output: 1
คำอธิบาย: การแทนค่าด้วยเลขฐานสองของดัชนีคือ:
0 = 00_2
1 = 01_2
2 = 10_2
3 = 11_2
เฉพาะดัชนี 3 เท่านั้นที่มี k = 2 บิตที่ตั้งอยู่ในตัวแทนเลขฐานสองของมัน
ดังนั้นคำตอบคือ nums[3] = 1.

ข้อจำกัด:

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


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

เลือกสององค์ประกอบที่มีค่าเท่ากันและลบออกจากอาเรย์
เลือกสามองค์ประกอบที่มีค่าเท่ากันและลบออกจากอาเรย์

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

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

Input: nums = [2,3,3,2,2,4,2,3,4] Output: 4 Explanation: เราสามารถใช้การดำเนินการต่อไปนี้เพื่อให้อาเรย์เป็นว่างเปล่า:
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 3 อาเรย์ที่ได้คือ nums = [3,3,2,4,2,3,4].
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 2 และ 4 อาเรย์ที่ได้คือ nums = [3,3,4,3,4].
- ใช้การดำเนินการที่สองกับองค์ประกอบที่ดัชนี 0, 1 และ 3 อาเรย์ที่ได้คือ nums = [4,4].
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 1 อาเรย์ที่ได้คือ nums = [].
สามารถแสดงได้ว่าไม่สามารถทำให้อาเรย์เป็นว่างเปล่าในน้อยกว่า 4 การดำเนินการ

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

Input: nums = [2,1,2,2,3,3] Output: -1 Explanation: เป็นไปไม่ได้ที่จะทำให้อาเรย์เป็นว่างเปล่า

ข้อจำกัด:

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

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

เลือกสององค์ประกอบที่มีค่าเท่ากันและลบออกจากอาเรย์
เลือกสามองค์ประกอบที่มีค่าเท่ากันและลบออกจากอาเรย์

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

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

Input: nums = [2,3,3,2,2,4,2,3,4] Output: 4 Explanation: เราสามารถใช้การดำเนินการต่อไปนี้เพื่อทำให้อาร์เรย์ว่างเปล่า:
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 3 อาร์เรย์ที่ได้คือ nums = [3,3,2,4,2,3,4].
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 2 และ 4 อาร์เรย์ที่ได้คือ nums = [3,3,4,3,4].
- ใช้การดำเนินการที่สองกับองค์ประกอบที่ดัชนี 0, 1 และ 3 อาร์เรย์ที่ได้คือ nums = [4,4].
- ใช้การดำเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 1 อาร์เรย์ที่ได้คือ nums = [].
สามารถแสดงให้เห็นว่าเราไม่สามารถทำให้อาร์เรย์ว่างเปล่าในเวลาน้อยกว่า 4 การดำเนินการ.

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

Input: nums = [2,1,2,2,3,3] Output: -1 Explanation: ไม่สามารถทำให้อาเรย์ว่างเปล่าได้

ข้อจำกัด:

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

คุณจะได้รับตัวเลขอาร์เรย์ที่มีดัชนี 0 ซึ่งประกอบด้วยจํานวนเต็มบวก
มีการดําเนินการสองประเภทที่คุณสามารถนําไปใช้กับอาร์เรย์ได้กี่ครั้งก็ได้:

เลือกองค์ประกอบสองอย่างที่มีค่าเท่ากันและลบออกจากอาร์เรย์
เลือกองค์ประกอบสามอย่างที่มีค่าเท่ากันและลบออกจากอาร์เรย์

ส่งคืนจํานวนการดําเนินการขั้นต่ําที่จําเป็นในการทําให้อาร์เรย์ว่างเปล่า หรือ -1 หากไม่สามารถทําได้

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

อินพุต: nums = [2,3,3,2,2,4,2,3,4]
เอาท์พุต: 4
คําอธิบาย: เราสามารถใช้การดําเนินการต่อไปนี้เพื่อทําให้อาร์เรย์ว่างเปล่า:
- ใช้การดําเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 3 อาร์เรย์ผลลัพธ์คือ nums = [3,3,2,4,2,3,4]
- ใช้การดําเนินการแรกกับองค์ประกอบที่ดัชนี 2 และ 4 อาร์เรย์ผลลัพธ์คือ nums = [3,3,4,3,4]
- ใช้การดําเนินการที่สองกับองค์ประกอบที่ดัชนี 0, 1 และ 3 อาร์เรย์ผลลัพธ์คือ nums = [4,4]
- ใช้การดําเนินการแรกกับองค์ประกอบที่ดัชนี 0 และ 1 อาร์เรย์ผลลัพธ์คือ nums = []
สามารถแสดงให้เห็นได้ว่าเราไม่สามารถทําให้อาร์เรย์ว่างเปล่าได้น้อยกว่า 4 การดําเนินการ

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

อินพุต: nums = [2,1,2,2,3,3]
เอาท์พุต: -1
คําอธิบาย: เป็นไปไม่ได้ที่จะล้างอาร์เรย์

ข้อจํากัด:

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


คุณได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นที่ 0 ชื่อว่า nums ซึ่งมีความยาว n โดยที่ n คือจำนวนรวมของนักเรียนในชั้นเรียน ครูประจำชั้นพยายามเลือกกลุ่มนักเรียนเพื่อให้ทุกคนมีความสุข
นักเรียนคนที่ i จะมีความสุขหากตรงตามเงื่อนไขใดเงื่อนไขหนึ่งต่อไปนี้:

นักเรียนถูกเลือกและจำนวนรวมของนักเรียนที่ถูกเลือกต้องมากกว่า nums[i] อย่างเคร่งครัด
นักเรียนไม่ได้ถูกเลือกและจำนวนรวมของนักเรียนที่ถูกเลือกต้องน้อยกว่า nums[i] อย่างเคร่งครัด

คืนค่าจำนวนวิธีในการเลือกกลุ่มนักเรียนเพื่อให้ทุกคนมีความสุข

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

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

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

Input: nums = [6,0,3,3,6,7,2,7]
Output: 3
อธิบาย:
สามวิธีที่เป็นไปได้คือ:
ครูประจำชั้นเลือกนักเรียนที่มีดัชนี = 1 เพื่อจัดกลุ่ม
ครูประจำชั้นเลือกนักเรียนที่มีดัชนี = 1, 2, 3, 6 เพื่อจัดกลุ่ม
ครูประจำชั้นเลือกนักเรียนทั้งหมดเพื่อจัดกลุ่ม

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 จำนวน nums ที่มีความยาว n โดยที่ n คือจำนวนนักเรียนทั้งหมดในชั้นเรียน ครูประจำชั้นพยายามเลือกกลุ่มนักเรียนเพื่อให้นักเรียนทุกคนมีความสุข
นักเรียนคนที่ i^ จะมีความสุขหากตรงตามเงื่อนไขสองข้อต่อไปนี้:

นักเรียนถูกเลือกและจำนวนนักเรียนทั้งหมดที่เลือกมากกว่า nums[i] อย่างเคร่งครัด
นักเรียนไม่ได้ถูกเลือกและจำนวนนักเรียนทั้งหมดที่เลือกน้อยกว่า nums[i] อย่างเคร่งครัด

ส่งคืนจำนวนวิธีในการเลือกกลุ่มนักเรียนเพื่อให้ทุกคนมีความสุข

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

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

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

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

ข้อจำกัด:

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

คุณจะได้รับอาร์เรย์จำนวนเต็มที่มีดัชนี 0 ที่มีความยาว n โดยที่ n คือจำนวนนักเรียนทั้งหมดในชั้นเรียน ครูประจำชั้นพยายามเลือกกลุ่มนักเรียนเพื่อให้นักเรียนทุกคนมีความสุข
นักเรียนคนที่ i^th จะมีความสุขหากตรงตามเงื่อนไขสองข้อใดข้อหนึ่ง:

นักเรียนถูกเลือกและจำนวนนักเรียนที่ถูกเลือกทั้งหมดมากกว่า nums[i] อย่างเคร่งครัด
นักเรียนไม่ได้ถูกเลือกและจำนวนนักเรียนที่ถูกเลือกทั้งหมดน้อยกว่า nums[i] อย่างเคร่งครัด

คืนค่าจำนวนวิธีในการเลือกกลุ่มนักเรียนเพื่อให้ทุกคนมีความสุข

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

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

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

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

เงื่อนไข:

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


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

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

อินพุต: nums = [1,2,3,4,5], target = 9
เอาต์พุต: 3
คำอธิบาย: มีลำดับย่อย 3 ลำดับที่ผลรวมเท่ากับ 9: [4,5], [1,3,5] และ [2,3,4] ลำดับย่อยที่ยาวที่สุดคือ [1,3,5] และ [2,3,4] ดังนั้นคำตอบคือ 3

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

อินพุต: nums = [4,1,3,2,1,5], target = 7
เอาต์พุต: 4
คำอธิบาย: มีลำดับย่อย 5 ลำดับที่มีผลรวมเท่ากับ 7: [4,3], [4,1,2], [4,2,1], [1,1,5] และ [1,3,2,1] ลำดับย่อยที่ยาวที่สุดคือ [1,3,2,1] ดังนั้นคำตอบคือ 4

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

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

ข้อจำกัด:

1 <= nums.length <= 1000
1 <= nums[i] <= 1000
1 <= target <= 1000

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

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

อินพุต: nums = [1,2,3,4,5], target = 9
เอาท์พุท: 3
คำอธิบาย: มี 3 ลําดับย่อยที่มีผลรวมเท่ากับ 9: [4,5], [1,3,5] และ [2,3,4] ลําดับย่อยที่ยาวที่สุดคือ [1,3,5] และ [2,3,4] ดังนั้นคำตอบคือ 3

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

อินพุต: nums = [4,1,3,2,1,5], target = 7
เอาท์พุท: 4
คำอธิบาย: มี 5 ลําดับย่อยที่มีผลรวมเท่ากับ 7: [4,3], [4,1,2], [4,2,1], [1,1,5] และ [1,3,2 , 1]. ลำดับที่ยาวที่สุดคือ [1,3,2,1] ดังนั้นคำตอบคือ 4

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

อินพุต: nums = [1,1,5,4,5], target = 3
เอาท์พุท: -1
คำอธิบาย: สามารถแสดงได้ว่า nums ไม่มีลำดับย่อยที่มีผลรวมเท่ากับ 3

ข้อ จำกัด :

1 <= nums.length <= 1000
1 <= nums[i] <= 1000
1 <= target <= 1000


คุณได้รับอาร์เรย์ maxHeights ที่มี n จำนวนเต็ม

คุณได้มอบหมายให้สร้างอาคารหอคอย n แห่งในแนวเส้นพิกัด หอคอยที่ i จะสร้างที่พิกัด i และมีความสูงเท่ากับ heights[i]

การจัดหอคอยจะถือว่าสวยงามถ้าตรงตามเงื่อนไขดังนี้:

1 <= heights[i] <= maxHeights[i]

อาร์เรย์ความสูงเป็นอาร์เรย์ภูเขา

ความสูงของอาร์เรย์ถือว่าเป็นภูเขาถ้ามีดัชนี i ที่ทำให้:

สำหรับทุก 0 < j <= i, heights[j - 1] <= heights[j]

สำหรับทุก i <= k < n - 1, heights[k + 1] <= heights[k]

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

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

Input: maxHeights = [5,3,4,1,1]
Output: 13
คำอธิบาย: การจัดหอคอยที่สวยงามด้วยผลรวมสูงสุดคือ heights = [5,3,3,1,1] การกำหนดค่านี้สวยงาม เนื่องจาก:
- 1 <= heights[i] <= maxHeights[i]
- heights เป็นภูเขาที่มีจุดสูงสุด i = 0
แสดงให้เห็นว่าไม่มีการจัดหอคอยอื่นที่สวยงามและมีผลรวมความสูงมากกว่า 13
ตัวอย่างที่ 2:

Input: maxHeights = [6,5,3,9,2,7]
Output: 22
คำอธิบาย: การจัดหอคอยที่สวยงามด้วยผลรวมสูงสุดคือ heights = [3,3,3,9,2,2] การกำหนดค่านี้สวยงามเนื่องจาก:
- 1 <= heights[i] <= maxHeights[i]
- heights เป็นภูเขาที่มีจุดสูงสุด i = 3
แสดงให้เห็นว่าไม่มีการจัดหอคอยอื่นใดที่สวยงามด้วยผลรวมความสูงที่มากกว่า 22
ตัวอย่างที่ 3:

Input: maxHeights = [3,2,5,5,2,3]
Output: 18
คำอธิบาย: การจัดหอคอยที่สวยงามด้วยผลรวมสูงสุดคือ heights = [2,2,5,5,2,2] การกำหนดค่านี้สวยงามเนื่องจาก:
- 1 <= heights[i] <= maxHeights[i]
- heights เป็นภูเขาที่มีจุดสูงสุด i = 2
ทั้งนี้ สำหรับการกำหนดค่านี้ i = 3 สามารถถือว่าเป็นจุดสูงสุดได้เช่นกัน
แสดงให้เห็นว่าไม่มีการจัดหอคอยอื่นใดที่สวยงามด้วยผลรวมความสูงที่มากกว่า 18

เงื่อนไข:

1 <= n == maxHeights <= 10^3

1 <= maxHeights[i] <= 10^9

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

1 <= heights[i] <= maxHeights[i]
heights คืออาร์เรย์ของภูเขา

อาร์เรย์ heights คือภูเขาหากมีดัชนี i อยู่ซึ่ง:

สำหรับทุก 0 < j <= i, heights[j - 1] <= heights[j]

สำหรับทุก i <= k < n - 1, heights[k + 1] <= heights[k]

ส่งคืนผลรวมความสูงสูงสุดที่เป็นไปได้ของการกำหนดค่าหอคอยที่สวยงาม
ตัวอย่างที่ 1:

อินพุต: maxHeights = [5,3,4,1,1]
เอาต์พุต: 13
คำอธิบาย: การกำหนดค่าที่สวยงามอย่างหนึ่งที่มีผลรวมสูงสุดคือความสูง = [5,3,3,1,1] การกำหนดค่านี้สวยงามเนื่องจาก:
- 1 <= ความสูง[i] <= ความสูงสูงสุด[i]
- ความสูงคือยอดเขา i = 0
สามารถแสดงให้เห็นได้ว่าไม่มีการกำหนดค่าที่สวยงามอื่นใดที่มีผลรวมของความสูงมากกว่า 13
ตัวอย่างที่ 2:

อินพุต: maxHeights = [6,5,3,9,2,7]
เอาต์พุต: 22
คำอธิบาย: การกำหนดค่าที่สวยงามอย่างหนึ่งที่มีผลรวมสูงสุดคือความสูง = [3,3,3,9,2,2] การกำหนดค่านี้สวยงามเนื่องจาก:
- 1 <= heights[i] <= maxHeights[i]
- heights คือยอดเขา i = 3
สามารถแสดงให้เห็นได้ว่าไม่มีการกำหนดค่าที่สวยงามอื่นใดที่มีผลรวมของความสูงมากกว่า 22
ตัวอย่างที่ 3:

อินพุต: maxHeights = [3,2,5,5,2,3]
เอาต์พุต: 18
คำอธิบาย: การกำหนดค่าที่สวยงามหนึ่งแบบที่มีผลรวมสูงสุดคือ heights = [2,2,5,5,2,2] การกำหนดค่านี้สวยงามเนื่องจาก:
- 1 <= heights[i] <= maxHeights[i]
- heights คือยอดเขา i = 2
โปรดทราบว่าสำหรับการกำหนดค่านี้ i = 3 ถือเป็นยอดเขาได้เช่นกัน จะเห็นได้ว่าไม่มีการกำหนดค่าที่สวยงามอื่นใดที่มีผลรวมความสูงมากกว่า 18

ข้อจำกัด:

1 <= n == maxHeights <= 10^3
1 <= maxHeights[i] <= 10^9

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

1 <= heights [i] <= maxHeights [i]
อาร์เรย์ heights เป็นอาร์เรย์ภูเขา

อาร์เรย์ heights เป็นภูเขาหากมีดัชนี i ที่ทำให้:

สำหรับทั้งหมด 0 <j <= i, heights [j - 1] <= heights [j]
สำหรับทั้งหมด i <= k <n - 1, heights [k + 1] <=heights [k]

ส่งคืนผลรวมสูงสุดของความสูงของการกำหนดค่าที่สวยงามของหอคอย

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

อินพุต: MaxHeights = [5,3,4,1,1]
เอาท์พุท: 13
คำอธิบาย: การกำหนดค่าที่สวยงามอย่างหนึ่งที่มีผลรวมสูงสุดคือความสูง = [5,3,3,1,1] การกำหนดค่านี้สวยงามตั้งแต่:
- 1 <=  heights [i] <= maxHeights [i]
- ความสูงเป็นภูเขาแห่งจุดสูงสุด i = 0
มันสามารถแสดงให้เห็นว่าไม่มีการกำหนดค่าที่สวยงามอื่น ๆ ที่มีผลรวมของความสูงมากกว่า 13
ตัวอย่างที่ 2:

อินพุต: MaxHeights = [6,5,3,9,2,7]
เอาท์พุท: 22
คำอธิบาย: การกำหนดค่าที่สวยงามอย่างหนึ่งที่มีผลรวมสูงสุดคือความสูง = [3,3,3,9,2,2] การกำหนดค่านี้สวยงามตั้งแต่:
- 1 <= heights [i] <= maxHeights [i]
- ความสูงเป็นภูเขาแห่งจุดสูงสุด i = 3
มันสามารถแสดงให้เห็นว่าไม่มีการกำหนดค่าที่สวยงามอื่น ๆ ที่มีผลรวมของความสูงมากกว่า 22
ตัวอย่างที่ 3:

อินพุต: MaxHeights = [3,2,5,5,2,3]
เอาท์พุท: 18
คำอธิบาย: การกำหนดค่าที่สวยงามอย่างหนึ่งที่มีผลรวมสูงสุดคือความสูง = [2,2,5,5,2,2] การกำหนดค่านี้สวยงามตั้งแต่:
- 1 <= heights[i] <= maxHeights[i]
- ความสูงเป็นภูเขาแห่งจุดสูงสุด i = 2
โปรดทราบว่าสำหรับการกำหนดค่านี้ i = 3 ยังถือได้ว่าเป็นจุดสูงสุด
มันสามารถแสดงให้เห็นว่าไม่มีการกำหนดค่าที่สวยงามอื่น ๆ ที่มีผลรวมของความสูงมากกว่า 18

ข้อ จำกัด :

1 <= n == maxHeights <= 10^3
1 <= maxheights [i] <= 10^9


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

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

Input: `nums = [1,2,3]`, `target = 5`
Output: 2
คำอธิบาย: ในตัวอย่างนี้ infinite_nums = [1,2,3,1,2,3,1,2,...]
ช่วงย่อยในช่วง [1,2] มีผลรวมเท่ากับ 5 และความยาว = 2
สามารถพิสูจน์ได้ว่า 2 เป็นความยาวที่สั้นที่สุดของช่วงย่อยที่มีผลรวมเท่ากับ 5

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

Input: `nums = [1,1,1,2,3]`, `target = 4`
Output: 2
คำอธิบาย: ในตัวอย่างนี้ infinite_nums = [1,1,1,2,3,1,1,1,2,3,1,1,...]
ช่วงย่อยในช่วง [4,5] มีผลรวมเท่ากับเป้าหมาย = 4 และความยาว = 2
สามารถพิสูจน์ได้ว่า 2 เป็นความยาวที่สั้นที่สุดของช่วงย่อยที่มีผลรวมเท่ากับเป้าหมาย = 4.

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

Input: `nums = [2,4,6,8]`, `target = 3`
Output: -1
คำอธิบาย: ในตัวอย่างนี้ infinite_nums = [2, 4, 6, 8, 2, 4, 6, 8,...]
สามารถพิสูจน์ได้ว่าไม่มีช่วงย่อยที่มีผลรวมเท่ากับเป้าหมาย = 3

ข้อจำกัด:

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

คุณจะได้รับ nums อาร์เรย์ 0-ดัชนีและเป้าหมายจำนวนเต็ม
อาร์เรย์ 0-indexed infinite_nums ถูกสร้างขึ้นโดยการต่อท้ายองค์ประกอบของ nums กับตัวเองอย่างไม่ จำกัด
ส่งคืนความยาวของ subarray ที่สั้นที่สุดของอาร์เรย์ infinite_nums ที่มีผลรวมเท่ากับเป้าหมาย หากไม่มี subarray กลับมา -1

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

อินพุต: nums = [1,2,3], target = 5
เอาท์พุท: 2
คำอธิบาย: ในตัวอย่างนี้ infinite_nums = [1,2,3,1,2,3,1,2, ... ]
subarray ในช่วง [1,2] มีผลรวมเท่ากับเป้าหมาย = 5 และความยาว = 2
สามารถพิสูจน์ได้ว่า 2 เป็นความยาวที่สั้นที่สุดของ subarray ที่มีผลรวมเท่ากับเป้าหมาย = 5

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

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

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

อินพุต: nums = [2,4,6,8], target = 3
เอาท์พุท: -1
คำอธิบาย: ในตัวอย่างนี้ Infinite_nums = [2,4,6,8,2,4,6,8, ... ]
สามารถพิสูจน์ได้ว่าไม่มี subarray ที่มีผลรวมเท่ากับเป้าหมาย = 3

ข้อ จำกัด :

1 <= nums.length <= 10^5
1 <= nums [i] <= 10^5
1 <= เป้าหมาย <= 10^9

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

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

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

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

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

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

อินพุต: nums = [2,4,6,8], target = 3
เอาต์พุต: -1
คำอธิบาย: ในตัวอย่างนี้ infinite_nums = [2,4,6,8,2,4,6,8,...]
สามารถพิสูจน์ได้ว่าไม่มีซับอาร์เรย์ที่มีผลรวมเท่ากับเป้าหมาย = 3

ข้อจำกัด:

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


คุณได้รับสตริงไบนารี s และจำนวนเต็มบวก k
ซับสตริงของ s จะสวยงามถ้าจำนวน 1 ในซับสตริงนั้นมีค่าเท่ากับ k
ให้ len เป็นความยาวของซับสตริงที่สวยงามที่สั้นที่สุด
คืนค่าซับสตริงที่สวยงามที่มีขนาดเล็กที่สุดตามลำดับพจนานุกรมจากสตริง s ที่มีความยาวเท่ากับ len หาก s ไม่มีซับสตริงที่สวยงาม
ให้คืนค่าสตริงว่าง สตริง a จะมีค่าสูงกว่าสตริง b (ที่มีความยาวเท่ากัน) ตามลำดับพจนานุกรม หากในตำแหน่งแรกที่ a และ b แตกต่างกัน a มีอักขระที่มีค่าสูงกว่าตัวอักษรที่ตรงกันใน b
ตัวอย่างเช่น "abcd" มีค่าสูงกว่า "abcc" ตามลำดับพจนานุกรม เพราะตำแหน่งแรกที่พวกเขาแตกต่างกันคือที่ตัวอักษรตัวที่สี่ และ d มีค่าสูงกว่า c.

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

Input: s = "100011001", k = 3
Output: "11001"
มี 7 สตริงย่อยที่สวยงามในตัวอย่างนี้:
1. สตริงย่อย "100011001"
2. สตริงย่อย "100011001"
3. สตริงย่อย "100011001"
4. สตริงย่อย "100011001"
5. สตริงย่อย "100011001"
6. สตริงย่อย "100011001"
7. สตริงย่อย "100011001"
ความยาวของซับสตริงที่สวยงามที่สั้นที่สุดคือ 5.
ซับสตริงที่สวยงามในลำดับพจนานุกรมที่มีความยาว 5 คือซับสตริง "11001".

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

Input: s = "1011", k = 2
Output: "11"
มี 3 สตริงย่อยที่สวยงามในตัวอย่างนี้:
1. สตริงย่อย "1011"
2. สตริงย่อย "1011"
3. สตริงย่อย "1011"
ความยาวของซับสตริงที่สวยงามที่สั้นที่สุดคือ 2.
ซับสตริงที่สวยงามที่มีความยาว 2 และมีลำดับพจนานุกรมที่เล็กที่สุดคือซับสตริง "11".

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

Input: s = "000", k = 1
Output: ""
คำอธิบาย: ไม่มีซับสตริงที่สวยงามในตัวอย่างนี้

ข้อจำกัด:

1 <= s.length <= 100
1 <= k <= s.length

คุณจะได้รับสตริงไบนารีและจำนวนเต็มบวก k
สตริงย่อยของ s นั้นสวยงามถ้าจำนวน 1 ในนั้นเท่ากับ k
ให้ len เป็นความยาวของสตริงย่อยที่สวยงามที่สั้นที่สุด
ส่งคืนสตริงย่อยที่สวยงามที่สุดตามพจนานุกรมที่มีขนาดเล็กที่สุดที่มีความยาวเท่ากับเลน หาก s ไม่มีสตริงย่อยที่สวยงามให้ส่งคืนสตริงเปล่า
สตริง A มีขนาดใหญ่กว่าสตริง b (ของความยาวเท่ากัน) หากอยู่ในตำแหน่งแรกที่ A และ b แตกต่างกัน A มีอักขระที่ใหญ่กว่าอักขระที่สอดคล้องกันอย่างเคร่งครัดใน b

ตัวอย่างเช่น "abcd" มีขนาดใหญ่กว่า "abcc" เพราะตำแหน่งแรกที่พวกเขาแตกต่างกันคือตัวละครที่สี่และ d มากกว่า c

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

อินพุต: s = "100011001", k = 3
เอาท์พุท: "11001"
คำอธิบาย: มี 7 ส่วนย่อยที่สวยงามในตัวอย่างนี้:
1. สายย่อย "100011001"
2. สายย่อย "100011001"
3. ย่อย "100011001"
4. สายย่อย "100011001"
5. ย่อย "100011001"
6. ย่อย "100011001"
7. ย่อย "100011001"
ความยาวของสตริงย่อยที่สวยงามที่สุดคือ 5
สตริงย่อยที่สวยงามที่สุดที่มีความยาว 5 คือสายย่อย "11001"

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

อินพุต: s = "1011", k = 2
เอาท์พุท: "11"
คำอธิบาย: มี 3 ส่วนย่อยที่สวยงามในตัวอย่างนี้:
1. สายย่อย "1011"
2. สายย่อย "1011"
3. ย่อย "1011"
ความยาวของสายย่อยที่สวยงามที่สุดคือ 2
สตริงย่อยที่สวยงามที่สุดที่มีความยาว 2 คือสายย่อย "11"

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

อินพุต: s = "000", k = 1
เอาท์พุท: ""
คำอธิบาย: ไม่มีส่วนย่อยที่สวยงามในตัวอย่างนี้

ข้อ จำกัด :

1 <= s.length <= 100
1 <= k <= s.length

คุณได้รับสตริงไบนารี ￼ และจำนวนเต็มบวก ￼
คำย่อย (substring) ของ ￼ จะเรียกว่า สวยงาม (beautiful) หากมีจำนวน 1’s ในคำย่อยนั้นเท่ากับ ￼
ให้ ￼ เป็นความยาวของคำย่อยที่สวยงามที่สั้นที่สุด
ให้คุณคืนคำย่อยที่สวยงามซึ่งมีความยาวเท่ากับ ￼ และเรียงตามลำดับพจนานุกรม (lexicographically) ที่เล็กที่สุดของสตริง ￼
หาก ￼ ไม่มีคำย่อยที่สวยงาม ให้คืนสตริงว่าง

การเปรียบเทียบลำดับพจนานุกรม:
สตริง ￼ จะถือว่าเรียงลำดับพจนานุกรมใหญ่กว่าสตริง ￼ (ที่มีความยาวเท่ากัน) หากในตำแหน่งแรกที่ ￼ และ ￼ ต่างกัน ￼ มีตัวอักษรที่ใหญ่กว่าตัวอักษรในตำแหน่งเดียวกันของ ￼

ตัวอย่างเช่น
	•	“abcd” เรียงลำดับพจนานุกรมใหญ่กว่า “abcc” เพราะตำแหน่งที่ต่างกันคือตัวที่ 4 และ ￼

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

Input: s = "100011001", k = 3
Output: "11001"
Explanation:
มีคำย่อยที่สวยงาม 7 คำในตัวอย่างนี้:
	1.	คำย่อย “100011001”
	2.	คำย่อย “100011001”
	3.	คำย่อย “100011001”
	4.	คำย่อย “100011001”
	5.	คำย่อย “100011001”
	6.	คำย่อย “100011001”
	7.	คำย่อย “100011001”
ความยาวของคำย่อยที่สวยงามที่สั้นที่สุดคือ 5
คำย่อยที่เรียงลำดับพจนานุกรมเล็กที่สุดที่มีความยาว 5 คือ “11001”

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

Input: s = "1011", k = 2
Output: "11"
Explanation:
มีคำย่อยที่สวยงาม 3 คำในตัวอย่างนี้:
	1.	คำย่อย “1011”
	2.	คำย่อย “1011”
	3.	คำย่อย “1011”
ความยาวของคำย่อยที่สวยงามที่สั้นที่สุดคือ 2
คำย่อยที่เรียงลำดับพจนานุกรมเล็กที่สุดที่มีความยาว 2 คือ “11”

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

Input: s = "000", k = 1
Output: ""
Explanation:
ไม่มีคำย่อยที่สวยงามในตัวอย่างนี้

ข้อจำกัด:
	1 <= s.length <= 100
1 <= k <= s.length￼


คุณมีโปรเซสเซอร์ n ตัว แต่ละตัวมี 4 คอร์ และมี n * 4 งานที่ต้องการการประมวลผล โดยแต่ละคอร์จะทำงานเพียงงานเดียวเท่านั้น
โดยมีอาเรย์หมายเลขเต็ม 0-indexed ชื่อ processorTime ที่แสดงเวลาที่โปรเซสเซอร์แต่ละตัวพร้อมใช้งานครั้งแรก และอาเรย์หมายเลขเต็ม 0-indexed ชื่อ tasks ที่แสดงเวลาที่ใช้ในการประมวลผลแต่ละงาน ให้คืนค่าเวลาขั้นต่ำเมื่อทุกงานได้ถูกประมวลผลโดยโปรเซสเซอร์
หมายเหตุ: แต่ละคอร์ประมวลผลงานอย่างอิสระจากคอร์อื่น

ตัวอย่าง 1:

Input: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
Output: 16
คำอธิบาย:
จัดการให้เหมาะสมที่สุดโดยกำหนดงานที่อินเด็กซ์ 4, 5, 6, 7 ให้กับโปรเซสเซอร์แรกซึ่งพร้อมใช้งานเมื่อเวลา = 8 และงานที่อินเด็กซ์ 0, 1, 2, 3 ให้กับโปรเซสเซอร์ที่สองซึ่งพร้อมใช้งานเมื่อเวลา = 10
เวลาที่ใช้โดยโปรเซสเซอร์แรกในการประมวลผลงานทั้งหมด = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16
เวลาที่ใช้โดยโปรเซสเซอร์ที่สองในการประมวลผลงานทั้งหมด = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13
ดังนั้น เวลาขั้นต่ำในการประมวลผลงานทั้งหมดจึงเป็น 16

ตัวอย่าง 2:

Input: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
Output: 23
คำอธิบาย:
จัดการให้เหมาะสมที่สุดโดยกำหนดงานที่อินเด็กซ์ 1, 4, 5, 6 ให้กับโปรเซสเซอร์แรกซึ่งพร้อมใช้งานเมื่อเวลา = 10 และงานที่อินเด็กซ์ 0, 2, 3, 7 ให้กับโปรเซสเซอร์ที่สองซึ่งพร้อมใช้งานเมื่อเวลา = 20
เวลาที่ใช้โดยโปรเซสเซอร์แรกในการประมวลผลงานทั้งหมด = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18
เวลาที่ใช้โดยโปรเซสเซอร์ที่สองในการประมวลผลงานทั้งหมด = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23
ดังนั้น เวลาขั้นต่ำในการประมวลผลงานทั้งหมดจึงเป็น 23

ข้อจำกัด:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n

คุณมีโปรเซสเซอร์ n ตัวซึ่งแต่ละตัวมี 4 คอร์และ n * 4 งานที่ต้องดำเนินการเพื่อให้แต่ละคอร์ดำเนินการงานเพียงงานเดียว
เมื่อกำหนดให้มีอาร์เรย์จำนวนเต็มที่มีดัชนี 0 โปรเซสเซอร์เวลาแสดงเวลาที่โปรเซสเซอร์แต่ละตัวพร้อมใช้งานเป็นครั้งแรกและอาร์เรย์จำนวนเต็มที่มีดัชนี 0 แสดงเวลาที่ใช้ในการดำเนินการงานแต่ละงาน ให้ส่งคืนเวลาขั้นต่ำเมื่อโปรเซสเซอร์ดำเนินการงานทั้งหมดแล้ว
หมายเหตุ: คอร์แต่ละตัวจะดำเนินการงานโดยอิสระจากคอร์อื่นๆ
ตัวอย่างที่ 1:

อินพุต: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
เอาต์พุต: 16
คำอธิบาย:
วิธีที่ดีที่สุดคือกำหนดงานที่ดัชนี 4, 5, 6, 7 ให้กับโปรเซสเซอร์ตัวแรกซึ่งจะพร้อมใช้งานในเวลา = 8 และงานที่ดัชนี 0, 1, 2, 3 ให้กับโปรเซสเซอร์ตัวที่สองซึ่งจะพร้อมใช้งานในเวลา = 10
เวลาที่โปรเซสเซอร์ตัวแรกใช้ในการทำงานทั้งหมดจนเสร็จ = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16
เวลาที่โปรเซสเซอร์ตัวที่สองใช้ในการทำงานทั้งหมดจนเสร็จ = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13
ดังนั้น เราจึงสามารถแสดงได้ว่าเวลาขั้นต่ำที่ใช้ในการทำงานทั้งหมดคือ 16
ตัวอย่าง 2:

อินพุต: processorTime = [10,20], tasks = [2,3,1,2,5,8,4,3]
เอาต์พุต: 23
คำอธิบาย:
วิธีที่ดีที่สุดคือกำหนดงานที่ดัชนี 1, 4, 5, 6 ให้กับโปรเซสเซอร์ตัวแรกซึ่งจะพร้อมใช้งานในเวลา = 10 และงานที่ดัชนี 0, 2, 3, 7 ให้กับโปรเซสเซอร์ตัวที่สองซึ่งจะพร้อมใช้งานในเวลา = 20
เวลาที่โปรเซสเซอร์ตัวแรกใช้ในการทำงานทั้งหมดจนเสร็จสิ้น = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18
เวลาที่โปรเซสเซอร์ตัวที่สองใช้ในการทำงานทั้งหมดจนเสร็จสิ้น = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23
ดังนั้น เราจึงสามารถแสดงได้ว่าเวลาขั้นต่ำที่ใช้ในการทำงานทั้งหมดคือ 23.

ข้อจำกัด:

1 <= n == processorTime.length <= 25000
1 <= task.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= task[i] <= 10^9
tasks.length == 4 * n

คุณมีโปรเซสเซอร์ n แต่ละตัวมี 4 คอร์และ n * 4 งานที่ต้องดําเนินการเพื่อให้แต่ละคอร์ควรทํางานเพียงงานเดียว
เมื่อได้รับอาร์เรย์จํานวนเต็มที่มีดัชนี 0 processorTime ซึ่งแสดงถึงเวลาที่โปรเซสเซอร์แต่ละตัวพร้อมใช้งานเป็นครั้งแรก และงานอาร์เรย์จํานวนเต็มที่มีดัชนี 0 ที่แสดงถึงเวลาที่ใช้ในการดําเนินการแต่ละงาน ให้ส่งคืนเวลาขั้นต่ําเมื่อโปรเซสเซอร์ทํางานทั้งหมดแล้ว
หมายเหตุ: แต่ละคอร์ทํางานโดยอิสระจากคอร์อื่นๆ

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

อินพุต: processorTime = [8,10], tasks = [2,2,3,1,8,7,4,5]
เอาท์พุต: 16
การอธิบาย:
เป็นการดีที่สุดที่จะมอบหมายงานที่ดัชนี 4, 5, 6, 7 ให้กับโปรเซสเซอร์ตัวแรกซึ่งพร้อมใช้งานในเวลา = 8 และงานที่ดัชนี 0, 1, 2, 3 ให้กับโปรเซสเซอร์ตัวที่สองซึ่งพร้อมใช้งานในเวลา = 10
เวลาที่ใช้โดยโปรเซสเซอร์ตัวแรกในการดําเนินงานทั้งหมดให้เสร็จสิ้น = max(8 + 8, 8 + 7, 8 + 4, 8 + 5) = 16
เวลาที่ใช้โดยโปรเซสเซอร์ตัวที่สองในการดําเนินงานทั้งหมดให้เสร็จสิ้น = max(10 + 2, 10 + 2, 10 + 3, 10 + 1) = 13
ดังนั้นจึงสามารถแสดงได้ว่าเวลาขั้นต่ําที่ใช้ในการดําเนินการทั้งหมดคือ 16
ตัวอย่างที่ 2:

อินพุต: processorTime = [10,20], tasks= [2,3,1,2,5,8,4,3]
เอาท์พุต: 23
การอธิบาย:
เป็นการดีที่สุดที่จะมอบหมายงานที่ดัชนี 1, 4, 5, 6 ให้กับโปรเซสเซอร์ตัวแรกซึ่งพร้อมใช้งานในเวลา = 10 และงานที่ดัชนี 0, 2, 3, 7 ให้กับโปรเซสเซอร์ตัวที่สองซึ่งพร้อมใช้งานใน time = 20
เวลาที่ใช้โดยโปรเซสเซอร์ตัวแรกในการดําเนินงานทั้งหมดให้เสร็จสิ้น = max(10 + 3, 10 + 5, 10 + 8, 10 + 4) = 18
เวลาที่ใช้โดยโปรเซสเซอร์ตัวที่สองในการดําเนินงานทั้งหมดให้เสร็จสิ้น = max(20 + 2, 20 + 1, 20 + 2, 20 + 3) = 23
ดังนั้นจึงสามารถแสดงได้ว่าเวลาขั้นต่ําที่ใช้ในการดําเนินการทั้งหมดคือ 23

ข้อจํากัด:

1 <= n == processorTime.length <= 25000
1 <= tasks.length <= 10^5
0 <= processorTime[i] <= 10^9
1 <= tasks[i] <= 10^9
tasks.length == 4 * n


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

เลือกดัชนีที่แตกต่างกันสองตัว i และ j และอัปเดตค่าของ nums[i] เป็น (nums[i] AND nums[j]) และ nums[j] เป็น (nums[i] OR nums[j]) พร้อมกัน ที่นี่ OR หมายถึงการดำเนินการ OR แบบบิต และ AND หมายถึงการดำเนินการ AND แบบบิต

คุณต้องเลือกองค์ประกอบ k จากอาร์เรย์สุดท้ายและคำนวณผลรวมของกำลังสอง
ส่งคืนผลรวมสูงสุดของกำลังสองที่คุณสามารถทำได้
เนื่องจากคำตอบอาจมีขนาดใหญ่มากให้ส่งคืนโมดูโล 10^9 + 7

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

อินพุต: nums = [2,6,5,8], k = 2
เอาท์พุท: 261
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้ในอาร์เรย์:
- เลือก i = 0 และ j = 3 จากนั้นเปลี่ยน nums [0] เป็น (2 AND 8) = 0 และ nums [3] เป็น (2 OR 8) = 10. อาร์เรย์ที่ได้คือ nums = [0,6,5 , 10].
- เลือก i = 2 และ j = 3 จากนั้นเปลี่ยน nums [2] เป็น (5 AND10) = 0 และ nums [3] เป็น (5 OR 10) = 15. อาร์เรย์ที่ได้คือ nums = [0,6,0 , 15].
เราสามารถเลือกองค์ประกอบ 15 และ 6 จากอาร์เรย์สุดท้าย ผลรวมของกำลังสองคือ 15^2 + 6^2 = 261
มันสามารถแสดงให้เห็นว่านี่เป็นค่าสูงสุดที่เราจะได้รับ

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

อินพุต: nums = [4,5,4,7], k = 3
เอาท์พุท: 90
คำอธิบาย: เราไม่จำเป็นต้องใช้การดำเนินการใด ๆ
เราสามารถเลือกองค์ประกอบ 7, 5 และ 4 ด้วยผลรวมของกำลังสอง: 7^2 + 5^2 + 4^2 = 90
มันสามารถแสดงให้เห็นว่านี่เป็นค่าสูงสุดที่เราจะได้รับ

ข้อ จำกัด :

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

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

เลือกดัชนีที่แตกต่างกันสองค่าคือ i และ j และอัปเดตค่าของ nums[i] เป็น (nums[i] และ nums[j] พร้อมกัน และ nums[j] เป็น (nums[i] หรือ nums[j]) ที่นี่ OR หมายถึงการดำเนินการ OR ตามบิต และ AND หมายถึงการดำเนินการ AND ตามบิต

คุณต้องเลือกองค์ประกอบ k รายการจากอาร์เรย์สุดท้ายและคำนวณผลรวมของกำลังสองขององค์ประกอบเหล่านั้น
ส่งคืนผลรวมของกำลังสองสูงสุดที่คุณสามารถทำได้ เนื่องจากคำตอบอาจมีค่ามาก ให้คืนค่าโมดูโล 10^9 + 7

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

อินพุต: nums = [2,6,5,8], k = 2
เอาต์พุต: 261
คำอธิบาย: เราสามารถดำเนินการต่อไปนี้กับอาร์เรย์ได้:
- เลือก i = 0 และ j = 3 จากนั้นเปลี่ยน nums[0] เป็น (2 AND 8) = 0 และ nums[3] เป็น (2 OR 8) = 10 อาร์เรย์ที่ได้คือ nums = [0,6,5,10]
- เลือก i = 2 และ j = 3 จากนั้นเปลี่ยน nums[2] เป็น (5 AND 10) = 0 และ nums[3] เป็น (5 OR 10) = 15 อาร์เรย์ที่ได้คือ nums = [0,6,0,15]
เราสามารถเลือกองค์ประกอบ 15 และ 6 จากอาร์เรย์สุดท้ายได้ ผลรวมของกำลังสองคือ 15^2 + 6^2 = 261
สามารถแสดงได้ว่านี่คือค่าสูงสุดที่เราจะหาได้

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

อินพุต: nums = [4,5,4,7], k = 3
เอาต์พุต: 90
คำอธิบาย: เราไม่จำเป็นต้องใช้การดำเนินการใดๆ
เราสามารถเลือกองค์ประกอบ 7, 5 และ 4 ที่มีผลรวมของกำลังสอง: 7^2 + 5^2 + 4^2 = 90
สามารถแสดงได้ว่านี่คือค่าสูงสุดที่เราจะหาได้

ข้อจำกัด:

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


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

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

Input: nums = [12,6,1,2,7]
Output: 77
คำอธิบาย: ค่าของทริเปิล (0, 2, 4) คือ (nums[0] - nums[2]) * nums[4] = 77
สามารถแสดงให้เห็นได้ว่าไม่มีทริเปิลของดัชนีที่เรียงลำดับแล้วที่มีค่ามากกว่า 77

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

Input: nums = [1,10,3,4,19]
Output: 133
คำอธิบาย: ค่าของทริเปิล (1, 2, 4) คือ (nums[1] - nums[2]) * nums[4] = 133
สามารถแสดงให้เห็นได้ว่าไม่มีทริเปิลของดัชนีที่เรียงลำดับที่มีค่ามากกว่า 133

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

Input: nums = [1,2,3]
Output: 0
คำอธิบาย: ชุดเลขสามตัวที่เรียงลำดับเพียงชุดเดียวคือ (0, 1, 2) มีค่าลบของ (nums[0] - nums[1]) * nums[2] = -3 ดังนั้นคำตอบจะเป็น 0.

ข้อจำกัด:

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

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

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

อินพุต: nums = [12,6,1,2,7]
เอาต์พุต: 77
คำอธิบาย: ค่าของไตรเพล็ต (0, 2, 4) คือ (nums[0] - nums[2]) * nums[4] = 77
สามารถแสดงให้เห็นได้ว่าไม่มีไตรเพล็ตแบบเรียงลำดับของดัชนีที่มีค่ามากกว่า 77

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

อินพุต: nums = [1,10,3,4,19]
เอาต์พุต: 133
คำอธิบาย: ค่าของไตรเพล็ต (1, 2, 4) คือ (nums[1] - nums[2]) * nums[4] = 133
สามารถแสดงให้เห็นได้ว่าไม่มีไตรเพล็ตแบบเรียงลำดับของดัชนีที่มีค่ามากกว่า 133

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

อินพุต: nums = [1,2,3]
ผลลัพธ์: 0
คำอธิบาย: ไตรเพล็ตที่เรียงลำดับของดัชนีเพียงตัวเดียว (0, 1, 2) มีค่าลบ (nums[0] - nums[1]) * nums[2] = -3 ดังนั้น คำตอบคือ 0

ข้อจำกัด:

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

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

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

อินพุต: nums = [12,6,1,2,7]
เอาท์พุท: 77
คำอธิบาย: ค่าของชุดดัชนี (0, 2, 4) คือ  (nums[0] - nums[2]) * nums[4] = 77
สามารถแสดงให้เห็นว่าไม่มีชุดดัชนีที่สั่งซื้อที่มีค่ามากกว่า 77

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

อินพุต: nums = [1,10,3,4,19]
เอาท์พุท: 133
คำอธิบาย: ค่าของชุดดัชนี (1, 2, 4) คือ  (nums[1] - nums[2]) * nums[4] = 133
สามารถแสดงให้เห็นว่าไม่มีชุดดัชนีที่สั่งซื้อที่มีค่ามากกว่า 133

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

อินพุต: nums = [1,2,3]
เอาท์พุท: 0
คำอธิบาย: ชุดดัชนีที่สั่งซื้อเพียงชุดเดียวของดัชนี (0, 1, 2) มีค่าลบของ (nums[0] - nums[1]) * nums[2] = -3 ดังนั้นคำตอบจะเป็น 0

ข้อจำกัด:

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


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

ให้ nums[i..j] เป็น ช่วงย่อย ของ nums ที่ประกอบด้วยดัชนีทั้งหมดจาก i ถึง j โดยที่ 0 <= i <= j < nums.length จากนั้นจำนวนของค่าที่แตกต่างกันใน nums [i..j] เรียกว่าจำนวนที่แตกต่างของ nums [i..j]

ส่งคืนผลรวมของกำลังสองของจำนวนที่แตกต่างกันของ ช่วงย่อย ทั้งหมดของ nums
ช่วงย่อย เป็นลำดับที่ไม่ว่างเปล่าขององค์ประกอบภายในอาร์เรย์

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

อินพุต: nums = [1,2,1]
เอาท์พุท: 15
คำอธิบาย: หก ช่วงย่อย ที่เป็นไปได้คือ:
[1]: 1 ค่าที่แตกต่างกัน
[2]: 1 ค่าที่แตกต่างกัน
[1]: 1 ค่าที่แตกต่างกัน
[1,2]: 2 ค่าที่แตกต่างกัน
[2,1]: 2 ค่าที่แตกต่างกัน
[1,2,1]: 2 ค่าที่แตกต่างกัน
ผลรวมของกำลังสองของจำนวนที่แตกต่างกันใน ช่วงย่อย ทั้งหมดเท่ากับ 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15

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

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

ข้อ จำกัด :

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

คุณได้รับอาร์เรย์จำนวนเต็มที่มีดัชนีเริ่มต้นจาก 0 ที่ชื่อ nums
จำนวนdistinct valueของ subarray ของ nums ถูกกำหนดไว้ดังนี้:

ให้ nums[i..j] เป็น subarray ของ nums ที่ประกอบด้วยดัชนีทั้งหมดจาก i ถึง j ซึ่ง 0 <= i <= j < nums.length แล้วจำนวนdistinct valueใน nums[i..j] จะถูกเรียกว่า จำนวนdistinct valueของ nums[i..j]

ให้นำผลรวมของกำลังสองของจำนวนdistinct valueของ subarray ทั้งหมดของ nums มาแสดง
subarray คือลำดับของสมาชิกที่ต่อเนื่องกันในอาร์เรย์

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

Input: nums = [1,2,1]
Output: 15
คำอธิบาย: subarray 6 รูปแบบที่เป็นไปได้คือ:
[1]: 1 distinct value
[2]: 1 distinct value
[1]: 1 distinct value
[1,2]: 2 distinct values
[2,1]: 2 distinct values
[1,2,1]: 2 distinct values
ผลรวมของกำลังสองของจำนวนdistinct valueใน subarray ทั้งหมดเท่ากับ 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15

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

Input: nums = [1,1]
Output: 3
คำอธิบาย: subarray 3 รูปแบบที่เป็นไปได้คือ:
[1]: 1 distinct value
[1]: 1 distinct value
[1,1]: 1 distinct value
ผลรวมของกำลังสองของจำนวนdistinct valueใน subarray ทั้งหมดเท่ากับ 1^2 + 1^2 + 1^2 = 3

ข้อจำกัด:

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

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

ให้ nums[i..j] เป็น ช่วงย่อย ของ nums ที่ประกอบด้วยดัชนีตั้งแต่ i ถึง j โดยที่ 0 <= i <= j < nums.length จากนั้นจำนวนของค่าที่แตกต่างกันใน nums [i..j] เรียกว่าจำนวนที่แตกต่างของ nums [i..j]

ส่งคืนผลรวมของกำลังสองของจำนวนค่าที่แตกต่างกันใน ส่วนย่อย ทั้งหมดของ nums
ช่วงย่อย เป็นลำดับที่ไม่ว่างเปล่าขององค์ประกอบภายในอาร์เรย์

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

อินพุต: nums = [1,2,1]
เอาท์พุท: 15
คำอธิบาย: หก ส่วนย่อย ที่เป็นไปได้คือ:
[1]: 1 ค่าที่แตกต่างกัน
[2]: 1 ค่าที่แตกต่างกัน
[1]: 1 ค่าที่แตกต่างกัน
[1,2]: 2 ค่าที่แตกต่างกัน
[2,1]: 2 ค่าที่แตกต่างกัน
[1,2,1]: 2 ค่าที่แตกต่างกัน
ผลรวมของสี่เหลี่ยมของจำนวนที่แตกต่างกันใน ส่วนย่อย ทั้งหมดเท่ากับ 1^2 + 1^2 + 1^2 + 2^2 + 2^2 + 2^2 = 15

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

อินพุต: nums = [1,1]
เอาท์พุท: 3
คำอธิบาย: สาม ส่วนย่อย ที่เป็นไปได้คือ:
[1]: 1 ค่าที่แตกต่างกัน
[1]: 1 ค่าที่แตกต่างกัน
[1,1]: 1 ค่าที่แตกต่างกัน
ผลรวมของสี่เหลี่ยมของจำนวนที่แตกต่างกันใน ส่วนย่อย ทั้งหมดเท่ากับ 1^2 + 1^2 + 1^2 = 3

ข้อ จำกัด :

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


กำหนดอาร์เรย์ของสตริงคำที่มีดัชนี 0 โดยที่ words[i] จะเป็นจำนวนเต็มบวกที่แสดงเป็นสตริงหรือสตริง "prev"
เริ่มวนซ้ำจากจุดเริ่มต้นของอาร์เรย์ สำหรับสตริง "prev" ทุกสตริงที่เห็นในคำ ให้ค้นหาจำนวนเต็มที่เยี่ยมชมล่าสุดในคำที่กำหนดดังต่อไปนี้:

ให้ k เป็นจำนวนสตริง "prev" ติดต่อกันที่พบจนถึงขณะนี้ (มีสตริงปัจจุบัน) ให้ nums เป็นอาร์เรย์ของจำนวนเต็มที่ดัชนี 0 ที่พบจนถึงขณะนี้ และ nums_reverse เป็นผลย้อนกลับของ nums ดังนั้น จำนวนเต็มที่ดัชนีที่ (k - 1)^th ของ nums_reverse จะเป็นจำนวนเต็มที่เยี่ยมชมล่าสุดสำหรับ "prev" นี้
หาก k มากกว่าจำนวนเต็มที่เยี่ยมชมทั้งหมด จำนวนเต็มที่เยี่ยมชมล่าสุดจะเป็น -1

ส่งคืนอาร์เรย์จำนวนเต็มที่มีจำนวนเต็มที่เยี่ยมชมล่าสุด

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

อินพุต: words = ["1","2","prev","prev","prev"]
เอาต์พุต: [2,1,-1]
คำอธิบาย:
สำหรับ "prev" ที่ index = 2 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 2 เนื่องจากที่นี่ จำนวนสตริง "prev" ติดต่อกันคือ 1 และในอาร์เรย์ reverse_nums 2 จะเป็นองค์ประกอบแรก
สำหรับ "prev" ที่ index = 3 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1 เนื่องจากมีสตริง "prev" ติดต่อกันทั้งหมดสองสตริงซึ่งรวมถึง "prev" นี้ซึ่งได้รับการเยี่ยมชม และ 1 เป็นจำนวนเต็มของการเข้าชมล่าสุดลำดับที่สอง
สำหรับ "prev" ที่ index = 4 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น -1 เนื่องจากมีสตริง "prev" ติดต่อกันทั้งหมดสามสตริงซึ่งรวมถึง "prev" นี้ซึ่งได้รับการเยี่ยมชม แต่จำนวนเต็มทั้งหมดของการเข้าชมคือสอง

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

อินพุต: words = ["1","prev","2","prev","prev"]
เอาต์พุต: [1,2,1]
คำอธิบาย:
สำหรับ "prev" ที่ index = 1 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1
สำหรับ "prev" ที่ index = 3 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 2
สำหรับ "prev" ที่ index = 4 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1 เนื่องจากมีสตริง "prev" ติดต่อกันสองสตริงซึ่งรวมถึง "prev" นี้ซึ่งเข้าชม และ 1 คือจำนวนเต็มของการเข้าชมล่าสุดลำดับที่สอง

ข้อจำกัด:

1 <= words.length <= 100
words[i] == "prev" หรือ 1 <= int(words[i]) <= 100

กำหนดอาร์เรย์ของสตริงคำที่มีดัชนี 0 โดยที่ words[i] จะเป็นจำนวนเต็มบวกที่แสดงเป็นสตริงหรือสตริง "prev"
เริ่มวนซ้ำจากจุดเริ่มต้นของอาร์เรย์ สำหรับสตริง "prev" ทุกสตริงที่เห็นในคำ ให้ค้นหาจำนวนเต็มที่เยี่ยมชมล่าสุดในคำที่กำหนดดังต่อไปนี้:

ให้ k เป็นจำนวนสตริง "prev" ติดต่อกันที่พบจนถึงขณะนี้ (มีสตริงปัจจุบัน) ให้ nums เป็นอาร์เรย์ของจำนวนเต็มที่ดัชนี 0 ที่พบจนถึงขณะนี้ และ nums_reverse เป็นผลย้อนกลับของ nums ดังนั้น จำนวนเต็มที่ดัชนีที่ (k - 1)^ ของ nums_reverse จะเป็นจำนวนเต็มที่เยี่ยมชมล่าสุดสำหรับ "prev" นี้
หาก k มากกว่าจำนวนเต็มที่เยี่ยมชมทั้งหมด จำนวนเต็มที่เยี่ยมชมล่าสุดจะเป็น -1

ส่งคืนอาร์เรย์จำนวนเต็มที่มีจำนวนเต็มที่เยี่ยมชมล่าสุด
ตัวอย่างที่ 1:

อินพุต: คำ = ["1","2","prev","prev","prev"]
เอาต์พุต: [2,1,-1]
คำอธิบาย:
สำหรับ "prev" ที่ index = 2 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 2 เนื่องจากที่นี่ จำนวนสตริง "prev" ติดต่อกันคือ 1 และในอาร์เรย์ reverse_nums 2 จะเป็นองค์ประกอบแรก
สำหรับ "prev" ที่ index = 3 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1 เนื่องจากมีสตริง "prev" ติดต่อกันทั้งหมดสองสตริงซึ่งรวมถึง "prev" นี้ซึ่งได้รับการเยี่ยมชม และ 1 เป็นจำนวนเต็มของการเข้าชมล่าสุดลำดับที่สอง
สำหรับ "prev" ที่ index = 4 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น -1 เนื่องจากมีสตริง "prev" ติดต่อกันทั้งหมดสามสตริงซึ่งรวมถึง "prev" นี้ซึ่งได้รับการเยี่ยมชม แต่จำนวนเต็มทั้งหมดของการเข้าชมคือสอง
ตัวอย่างที่ 2:

อินพุต: คำ = ["1","prev","2","prev","prev"]
เอาต์พุต: [1,2,1]
คำอธิบาย:
สำหรับ "prev" ที่ index = 1 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1
สำหรับ "prev" ที่ index = 3 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 2
สำหรับ "prev" ที่ index = 4 จำนวนเต็มของการเข้าชมล่าสุดจะเป็น 1 เนื่องจากมีสตริง "prev" ติดต่อกันสองสตริงซึ่งรวมถึง "prev" นี้ซึ่งเข้าชม และ 1 คือจำนวนเต็มของการเข้าชมล่าสุดลำดับที่สอง

ข้อจำกัด:

1 <= words.length <= 100
words[i] == "prev" หรือ 1 <= int(words[i]) <= 100

ให้คุณอาร์เรย์ ￼ ซึ่งมีดัชนีเริ่มต้นที่ 0 โดยที่ ￼ เป็นได้ทั้งจำนวนเต็มบวกที่แสดงในรูปแบบสตริง หรือสตริง “prev”
เริ่มต้นวนลูปจากจุดเริ่มต้นของอาร์เรย์ และสำหรับสตริง “prev” แต่ละตัวที่พบใน ￼ ให้หาเลขจำนวนเต็มตัวสุดท้ายที่เคยถูกเยี่ยมชมใน ￼ โดยกำหนดตามเงื่อนไขต่อไปนี้:
	•	ให้ ￼ เป็นจำนวนของสตริง “prev” ที่พบต่อเนื่องกันจนถึงปัจจุบัน (รวมถึงตัว “prev” ปัจจุบันด้วย)
	•	ให้ ￼ เป็นอาร์เรย์ของจำนวนเต็มที่เคยพบมาก่อน และ ￼ เป็นอาร์เรย์ ￼ ที่เรียงลำดับกลับด้าน
	•	เลขจำนวนเต็มที่ตำแหน่ง ￼-th ของ ￼ จะเป็นจำนวนเต็มที่ถูกเยี่ยมชมล่าสุดสำหรับ “prev” ตัวนั้น

หาก ￼ มากกว่าจำนวนของเลขจำนวนเต็มที่เคยเยี่ยมชม จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดจะเป็น ￼

คืนค่าอาร์เรย์จำนวนเต็มที่แสดงจำนวนเต็มที่ถูกเยี่ยมชมล่าสุด

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

Input:

words = ["1","2","prev","prev","prev"]

Output:

[2,1,-1]

Explanation:
	•	สำหรับ “prev” ที่ดัชนี = 2 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ 2 เนื่องจากจำนวนของ “prev” ที่พบต่อเนื่องกันมีค่าเป็น 1 และในอาร์เรย์ ￼ ค่า 2 จะเป็นองค์ประกอบตัวแรก
	•	สำหรับ “prev” ที่ดัชนี = 3 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ 1 เนื่องจากมี “prev” ต่อเนื่องกันทั้งหมด 2 ตัวรวมถึงตัวปัจจุบัน และค่า 1 เป็นจำนวนเต็มที่ถูกเยี่ยมชมรองสุดท้าย
	•	สำหรับ “prev” ที่ดัชนี = 4 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ ￼ เนื่องจากมี “prev” ต่อเนื่องกันทั้งหมด 3 ตัวรวมถึงตัวปัจจุบัน แต่จำนวนเต็มที่เคยถูกเยี่ยมชมทั้งหมดมีเพียง 2 ตัว

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

Input:

words = ["1","prev","2","prev","prev"]

Output:

[1,2,1]

Explanation:
	•	สำหรับ “prev” ที่ดัชนี = 1 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ 1
	•	สำหรับ “prev” ที่ดัชนี = 3 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ 2
	•	สำหรับ “prev” ที่ดัชนี = 4 จำนวนเต็มที่ถูกเยี่ยมชมล่าสุดคือ 1 เนื่องจากมี “prev” ต่อเนื่องกันทั้งหมด 2 ตัวรวมถึงตัวปัจจุบัน และค่า 1 เป็นจำนวนเต็มที่ถูกเยี่ยมชมรองสุดท้าย

ข้อจำกัด:
	1 <= words.length <= 100
words[i] == "prev" or 1 <= int(words[i]) <= 100


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

สำหรับทุกกลุ่ม g ดัชนีทุกตัว i ที่กำหนดให้กลุ่ม g มีค่าเดียวกันใน nums
สำหรับกลุ่มใด ๆ g_1 และ g_2 ความแตกต่างระหว่างจำนวนของดัชนีที่กำหนดให้ g_1 และ g_2 ไม่ควรเกิน 1

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

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

Input: nums = [3,2,3,2,3]
Output: 2
Explanation: วิธีหนึ่งที่ดัชนีสามารถถูกกำหนดไปยัง 2 กลุ่มได้ดังนี้ โดยค่าที่อยู่ในวงเล็บสี่เหลี่ยมคือดัชนี:
group 1 -> [0,2,4]
group 2 -> [1,3]
ดัชนีทั้งหมดถูกกำหนดไปยังหนึ่งกลุ่ม
ในกลุ่ม 1, nums[0] == nums[2] == nums[4] ดังนั้นดัชนีทั้งหมดมีค่าเดียวกัน
ในกลุ่ม 2, nums[1] == nums[3] ดังนั้นดัชนีทั้งหมดมีค่าเดียวกัน
จำนวนดัชนีที่กำหนดให้กลุ่ม 1 คือ 3 และจำนวนดัชนีที่กำหนดให้กลุ่ม 2 คือ 2
ความแตกต่างของพวกเขาไม่เกิน 1
ไม่สามารถใช้กลุ่มน้อยกว่า 2 ได้ เพราะหากต้องการใช้เพียง 1 กลุ่ม ดัชนีทั้งหมดที่กำหนดให้กลุ่มนั้นจะต้องมีค่าเดียวกัน
ดังนั้น คำตอบคือ 2

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

Input: nums = [10,10,10,3,1,1]
Output: 4
Explanation: วิธีหนึ่งที่ดัชนีสามารถถูกกำหนดไปยัง 4 กลุ่มได้ดังนี้ โดยค่าที่อยู่ในวงเล็บสี่เหลี่ยมคือดัชนี:
group 1 -> [0]
group 2 -> [1,2]
group 3 -> [3]
group 4 -> [4,5]
การกำหนดกลุ่มข้างต้นตอบโจทย์ทั้งสองเงื่อนไข
สามารถแสดงได้ว่าไม่สามารถสร้างการกำหนดที่ถูกต้องโดยใช้กลุ่มน้อยกว่า 4 ได้
ดังนั้น คำตอบคือ 4

ข้อจำกัด:

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

คุณจะได้รับจํานวนอาร์เรย์จํานวนเต็มที่มีดัชนี 0 ที่มีความยาว n
เราต้องการจัดกลุ่มดัชนีดังนั้นสําหรับแต่ละดัชนี i ในช่วง [0, n - 1] จะถูกกําหนดให้เป็นกลุ่มเดียว
การมอบหมายกลุ่มจะใช้ได้หากมีเงื่อนไขต่อไปนี้

สําหรับทุกกลุ่ม g ดัชนีทั้งหมดที่ฉันกําหนดให้กับกลุ่ม g มีค่าเท่ากันในหน่วยตัวเลข
สําหรับสองกลุ่มใด ๆ g_1 และ g_2 ความแตกต่างระหว่างจํานวนดัชนีที่กําหนดให้กับ g_1 และ g_2 ไม่ควรเกิน 1

ส่งกลับจํานวนเต็มที่แสดงถึงจํานวนกลุ่มขั้นต่ําที่จําเป็นในการสร้างการกําหนดกลุ่มที่ถูกต้อง

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

อินพุต: nums = [3,2,3,2,3]
เอาท์พุต: 2
คําอธิบาย: วิธีหนึ่งที่สามารถกําหนดดัชนีให้กับ 2 กลุ่มได้มีดังนี้โดยที่ค่าในวงเล็บเหลี่ยมคือดัชนี:
กลุ่มที่ 1 -> [0,2,4]
กลุ่มที่ 2 -> [1,3]
ดัชนีทั้งหมดถูกกําหนดให้กับกลุ่มเดียว
ในกลุ่ม 1 nums[0] == nums[2] == nums[4] ดังนั้นดัชนีทั้งหมดจึงมีค่าเท่ากัน
ในกลุ่ม 2 nums[1] == nums[3] ดังนั้นดัชนีทั้งหมดจึงมีค่าเท่ากัน
จํานวนดัชนีที่กําหนดให้กับกลุ่ม 1 คือ 3 และจํานวนดัชนีที่กําหนดให้กับกลุ่ม 2 คือ 2
ความแตกต่างของพวกเขาไม่เกิน 1
ไม่สามารถใช้กลุ่มน้อยกว่า 2 กลุ่มได้ เนื่องจากในการใช้เพียง 1 กลุ่ม ดัชนีทั้งหมดที่กําหนดให้กับกลุ่มนั้นจะต้องมีค่าเท่ากัน
ดังนั้นคําตอบคือ 2.
ตัวอย่างที่ 2:

อินพุต: nums = [10,10,10,3,1,1]
เอาท์พุต: 4
คําอธิบาย: วิธีหนึ่งที่สามารถกําหนดดัชนีให้กับ 4 กลุ่มได้มีดังนี้โดยที่ค่าในวงเล็บเหลี่ยมคือดัชนี:
กลุ่มที่ 1 -> [0]
กลุ่มที่ 2 -> [1,2]
กลุ่มที่ 3 -> [3]
กลุ่มที่ 4 -> [4,5]
การมอบหมายกลุ่มข้างต้นเป็นไปตามเงื่อนไขทั้งสอง
สามารถแสดงให้เห็นได้ว่าไม่สามารถสร้างงานที่ถูกต้องโดยใช้น้อยกว่า 4 กลุ่ม
ดังนั้นคําตอบคือ 4.

ข้อจํากัด:

1 <= ความยาว <= 10^5
1 <= ตัวเลข[i] <= 10^9

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

สำหรับกลุ่ม g ทุกกลุ่ม ดัชนี i ที่กำหนดให้กับกลุ่ม g จะมีค่าเท่ากันเป็น nums
สำหรับกลุ่ม g_1 และ g_2 สองกลุ่ม ความแตกต่างระหว่างจำนวนดัชนีที่กำหนดให้กับ g_1 และ g_2 ไม่ควรเกิน 1

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

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

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

อินพุต: nums = [10,10,10,3,1,1]
เอาต์พุต: 4
คำอธิบาย: วิธีหนึ่งในการกำหนดดัชนีให้กับ 4 กลุ่มคือดังต่อไปนี้ โดยค่าในวงเล็บเหลี่ยมคือดัชนี:
group 1 -> [0]
group 2 -> [1,2]
group 3 -> [3]
group 4 -> [4,5]
การกำหนดกลุ่มข้างต้นเป็นไปตามเงื่อนไขทั้งสองข้อ
จะเห็นได้ว่าไม่สามารถสร้างการกำหนดที่ถูกต้องโดยใช้กลุ่มน้อยกว่า 4 กลุ่มได้ ดังนั้นคำตอบคือ 4

ข้อจำกัด:

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


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

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

Input: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Output: 12
คำอธิบาย: เราสามารถแทนที่ 0 ได้ดังนี้:
- แทนที่เลข 0 สองตัวใน nums1 ด้วยค่า 2 และ 4 ผลลัพธ์คือ nums1 = [3,2,2,1,4]
- แทนที่เลข 0 ใน nums2 ด้วยค่า 1 ผลลัพธ์คือ nums2 = [6,5,1]
อาร์เรย์ทั้งสองมีผลรวมเท่ากับ 12 ซึ่งเป็นผลรวมน้อยที่สุดที่สามารถทำได้

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

Input: nums1 = [2,0,2,0], nums2 = [1,4]
Output: -1
คำอธิบาย: เป็นไปไม่ได้ที่จะทำให้ผลรวมของอาร์เรย์ทั้งสองเท่ากัน

ข้อจำกัด:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

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

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

อินพุต: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
เอาต์พุต: 12
คำอธิบาย: เราสามารถแทนที่ค่า 0 ได้ดังนี้:
- แทนที่ค่า 0 สองตัวใน nums1 ด้วยค่า 2 และ 4 อาร์เรย์ที่ได้คือ nums1 = [3,2,2,1,4]
- แทนที่ค่า 0 ใน nums2 ด้วยค่า 1 อาร์เรย์ที่ได้คือ nums2 = [6,5,1] ทั้งสองอาร์เรย์มีผลรวมเท่ากันที่ 12 ซึ่งสามารถแสดงได้ว่าเป็นผลรวมขั้นต่ำที่เราหาได้

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

อินพุต: nums1 = [2,0,2,0], nums2 = [1,4]
เอาต์พุต: -1
คำอธิบาย: ไม่สามารถทำให้ผลรวมของทั้งสองอาร์เรย์เท่ากันได้

ข้อจำกัด:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6

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

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

Input: nums1 = [3,2,0,1,0], nums2 = [6,5,0]
Output: 12
คำอธิบาย: เราสามารถแทนที่ 0 ในลักษณะต่อไปนี้:
- แทนที่ 0 สองตัวใน nums1 ด้วยค่า 2 และ 4 อาร์เรย์ที่ได้คือ nums1 = [3,2,2,1,4].
- แทนที่ 0 ใน nums2 ด้วยค่า 1 อาร์เรย์ที่ได้คือ nums2 = [6,5,1].
อาร์เรย์ทั้งสองมีผลรวมเท่ากันที่ 12 ซึ่งสามารถแสดงให้เห็นว่าเป็นผลรวมขั้นต่ำที่เราสามารถทำได้.

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

Input: nums1 = [2,0,2,0], nums2 = [1,4]
Output: -1
คำอธิบาย: ไม่สามารถทำให้ผลรวมของทั้งสองอาเรย์เท่ากันได้

ข้อจำกัด:

1 <= nums1.length, nums2.length <= 10^5
0 <= nums1[i], nums2[i] <= 10^6