LeetCode //C - 441. Arranging Coins

最新推荐文章于 2025-05-09 14:48:06 发布

Navigator_Z

最新推荐文章于 2025-05-09 14:48:06 发布

阅读量971

点赞数 7

分类专栏： LeetCode 文章标签： leetcode c语言算法

本文链接：https://blog.csdn.net/navicheung/article/details/137489679

版权

LeetCode 专栏收录该内容

663 篇文章

订阅专栏

该篇文章是关于使用编程解决LeetCode问题441，计算在有限数量的硬币下可以构建多少个完整的楼梯级数。通过二分搜索法找到满足条件的最小完整楼梯层数，利用自然数和公式来确定所需的硬币数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

441. Arranging Coins

You have n coins and you want to build a staircase with these coins. The staircase consists of k rows where the $i^{th}$ row has exactly i coins. The last row of the staircase may be incomplete.

Given the integer n, return the number of complete rows of the staircase you will build.

Example 1:

在这里插入图片描述

Input: n = 5
Output: 2
Explanation: Because the $3^{rd}$ row is incomplete, we return 2.

Example 2:

在这里插入图片描述

Input: n = 8
Output: 3
Explanation: Because the $4^{th}$ row is incomplete, we return 3.

Constraints:

$1 <= n <= 2^{31} - 1$

From: LeetCode
Link: 441. Arranging Coins

Solution:

Ideas:

1. Binary Search: This is an efficient algorithm used to find an item in a sorted list. The algorithm repeatedly divides the range of possible solutions in half, choosing the half where the item must be, until it narrows down to the exact location.

2. Using the Formula for the Sum of Natural Numbers: To find how many coins are needed to completely fill k rows, the formula k * (k + 1) / 2 is used. This is the sum of the first k natural numbers, and in the context of this problem, it represents the total number of coins needed to fill k rows of the staircase.

3. Finding the Maximum k: The goal is to find the largest k such that k * (k + 1) / 2 is less than or equal to n. This k represents the number of complete rows you can build with n coins.

4. Binary Search Implementation:

The search starts with the full range of possible row counts (left at 0 and right at n).
It repeatedly calculates the middle point (mid) and the number of coins needed to fill that many rows (curr).
If curr equals n, we’ve found the exact number of rows we can fill and return mid.
If curr is greater than n, we have too many rows, so we reduce the search range to the left half.
If curr is less than n, we have too few rows, so we increase the search range to the right half.
The search stops when left exceeds right, meaning we’ve narrowed down the range as much as possible. At this point, right will be the greatest number of complete rows that can be built with n coins.

Code:

int arrangeCoins(int n) {
    long left = 0, right = n;
    long mid, curr;
    
    while (left <= right) {
        mid = left + (right - left) / 2;
        curr = mid * (mid + 1) / 2;
        
        if (curr == n) return (int)mid;
        
        if (n < curr) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    
    return (int)right;
}