กลับไปยังโจทย์
ง่าย 0 ข้อที่แก้แล้ว อัตราผ่าน 0%

ทำให้อาเรย์ไม่ลดลง

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

สิ่งที่คุณจะได้เรียนรู้

  • แก้แต่ละค่าเทียบกับค่าก่อนหน้า
  • นับจำนวนการเพิ่มทั้งหมดที่ต้องใช้
  • เข้าใจว่าทำไมการเลือกแบบละโมบจึงดีที่สุด

โจทย์

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

ให้เขียนฟังก์ชัน increasing_array(numbers)

อินพุต

numbers: ค่าต่าง ๆ ตามลำดับเดิม

เอาต์พุต

ให้คืนค่าจำนวนครั้งรวมขั้นต่ำที่ต้องเพิ่มทีละ 1

เงื่อนไข

1 ≤ ความยาว ≤ 200,000 แต่ละค่าระหว่าง 1 ถึง 1,000,000,000 ใช้ผลลัพธ์เป็นจำนวนเต็ม signed 64-bit

ตัวอย่าง

ตัวอย่างที่ 1
อินพุต:
numbers = [4, 1, 3]

ผลลัพธ์ที่คาดหวัง:
expected = 4
อินพุต:
std::vector<long long> numbers = {4, 1, 3};

ผลลัพธ์ที่คาดหวัง:
long long expected = 4;
อินพุต:
long[] numbers = new long[] {4, 1, 3};

ผลลัพธ์ที่คาดหวัง:
long expected = 4;

คำอธิบาย

เพิ่ม 1 เป็น 4 ด้วยสามครั้ง และเพิ่ม 3 เป็น 4 อีกหนึ่งครั้ง ผลลัพธ์ [4, 4, 4] ใช้ทั้งหมดสี่ครั้ง

ตัวอย่างที่ 2
อินพุต:
numbers = [1, 2, 2, 5]

ผลลัพธ์ที่คาดหวัง:
expected = 0
อินพุต:
std::vector<long long> numbers = {1, 2, 2, 5};

ผลลัพธ์ที่คาดหวัง:
long long expected = 0;
อินพุต:
long[] numbers = new long[] {1, 2, 2, 5};

ผลลัพธ์ที่คาดหวัง:
long expected = 0;

คำอธิบาย

ทุกค่ามีค่ามากกว่าหรือเท่ากับค่าก่อนหน้าอยู่แล้ว; ค่าที่เท่ากันติดกันก็อนุญาต

แนวทางการแก้

ลองทำเองก่อน แล้วค่อยเปิดคำใบ้ทีละข้อ

คำใบ้ 1

ไล่จากซ้ายไปขวา เพราะแต่ละค่าขึ้นกับค่าก่อนหน้าเท่านั้น

คำใบ้ 2

ถ้าค่าไหนน้อยเกินไป ให้เพิ่มแค่พอให้เท่าค่าต่ำสุดที่อนุญาต ณ ตอนนั้น

คำใบ้ 3

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

ความซับซ้อนที่คาดหวัง

เวลา O(n), หน่วยความจำเพิ่ม O(1)

แหล่งอ้างอิง

โจทย์นี้ปรับให้เหมาะกับ CodeUtility กรุณาทำตามคำชี้แจงและข้อจำกัดด้านบน

เรียนรู้จากคนอื่น

แนวทางจากชุมชน

ยังไม่มีวิธีทำที่เผยแพร่ ลองแก้โจทย์นี้เพื่อแชร์วิธีแรก