题解:洛谷 P1480 AB Problem

【题目来源】

洛谷:P1480 A/B Problem - 洛谷

【题目描述】

输入两个整数 \(a,b\),输出它们的商。

【输入】

两行,第一行是被除数,第二行是除数。

【输出】

一行,商的整数部分。

【输入样例】

10
2

【输出样例】

5

【核心思想】

  1. 问题分析:给定两个整数 \(a\)\(b\),其中 \(a\) 可能非常大(长度可达 \(10^5\) 位),\(b\) 是一个普通整数(可用 intlong long 存储)。需要计算 \(a\) 除以 \(b\) 的商的整数部分。由于 \(a\) 超出基本数据类型范围,必须使用高精度除法模拟手算竖式除法过程。

  2. 算法选择

    • 高精度除以低精度:将被除数 \(a\) 以字符串形式读入,逐位处理。从最高位开始,每次将当前余数乘以 10 加上下一位数字,得到当前被除数,除以 \(b\) 得到当前商位,更新余数。最终所有商位组成结果,去除前导零后输出。
    • 复杂度:时间复杂度 \(O(n)\),空间复杂度 \(O(n)\),其中 \(n\)\(a\) 的位数。
  3. 关键步骤

    • 读入与存储:将 \(a\) 作为字符串读入,按顺序存入数组(高位在前)或直接遍历字符串。
    • 逐位除法:初始化余数 \(r = 0\)。对 \(a\) 的每一位数字 \(d_i\)(从高位到低位):
      • 令当前被除数 \(cur = r \times 10 + d_i\)
      • 当前商位 \(q_i = cur / b\)
      • 更新余数 \(r = cur \% b\)
    • 存储商:将每位商 \(q_i\) 存入结果数组(顺序与输入相同),最后去除前导零(但至少保留一位数字,如商为 0 则输出 0)。
    • 输出:输出处理后的商数组。
  4. 时间/空间复杂度

    • 时间复杂度:\(O(n)\),只需遍历一次被除数。
    • 空间复杂度:\(O(n)\),存储被除数和商的数组。
  5. 高精度除法的核心思想

    • 竖式模拟:从高位到低位,每次将余数扩展一位,再用除数去除,得到当前商位,并保留余数给下一位。这完全符合手算除法的过程。
    • 只求整数部分:本题只要求商的整数部分,因此处理完所有位后,余数可忽略。
    • 前导零处理:结果的高位可能为 0,需在输出前去除,但若商为 0,则需保留一个 0。
    • 适用场景:适用于大整数除以小整数的运算,是算法竞赛中高精度除法的标准模板。

【算法标签】

普及- #高精度

【代码详解】

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;  // 定义数组最大长度
int A[N], C[N];        // A: 存储被除数(逆序), C: 存储商
int b, la, lc;         // b: 除数, la: 被除数长度, lc: 商长度
string a;              // 存储输入的被除数

// 高精度除法函数
void div(int A[], int b, int C[])
{
    long long r = 0;   // 余数初始化为0

    // 从高位到低位进行除法运算
    for (int i = la - 1; i >= 0; i--)
    {
        r = r * 10 + A[i];  // 计算当前被除数
        C[la - 1 - i] = r / b;  // 计算当前位的商
        r %= b;            // 计算余数
    }

    // 将商数组反转(因为之前是逆序存储的)
    reverse(C, C + lc);

    // 去除商的前导零
    while (lc && C[lc] == 0)
        lc--;
}

int main()
{
    // 输入被除数和除数
    cin >> a >> b;

    // 初始化被除数长度和商长度
    lc = la = a.size();

    // 将被除数字符串转换为数字数组(逆序存储)
    for (int i = la - 1; i >= 0; i--)
        A[la - 1 - i] = a[i] - '0';

    // 调用高精度除法函数
    div(A, b, C);

    // 输出商(从高位到低位)
    for (int i = lc; i >= 0; i--)
        cout << C[i];

    return 0;
}
// 使用acwing模板二刷
#include <bits/stdc++.h>
using namespace std;

#define int long long  // 使用长整型
string a;              // 存储输入的大整数
int b;                 // 存储除数

// 高精度除法函数
vector<int> div(vector<int> &A, int b, int &r)  // 参数:被除数数组,除数,余数(引用传递)
{
    vector<int> C;      // 存储商的数组
    r = 0;              // 初始化余数为0

    // 从高位到低位进行除法运算
    for (int i = A.size() - 1; i >= 0; i--)
    {
        r = r * 10 + A[i];  // 计算当前被除数
        C.push_back(r / b);  // 计算当前位的商
        r %= b;             // 计算余数
    }

    // 反转商数组(因为之前是逆序存储的)
    reverse(C.begin(), C.end());

    // 去除商的前导零(保留至少一位)
    while (C.size() > 1 && C.back() == 0)
        C.pop_back();

    return C;
}

signed main()
{
    // 输入大整数和除数
    cin >> a >> b;

    // 将字符串转换为数字数组(逆序存储)
    vector<int> A;
    for (int i = a.size() - 1; i >= 0; i--)
        A.push_back(a[i] - '0');

    int r;  // 存储余数
    // 调用高精度除法函数
    auto C = div(A, b, r);

    // 输出商(从高位到低位)
    for (int i = C.size() - 1; i >= 0; i--)
        cout << C[i];

    // 如果需要输出余数,可以取消下面注释
    // cout << endl << r << endl;

    return 0;
}
// 使用老师推荐的板子再写一遍
#include <bits/stdc++.h>
using namespace std;

int n, k, a[100005];

// 检查是否可以将所有长度为a[i]的木棍
// 切割成至少k根长度为x的木棍
bool check(int x)
{
    int cnt = 0;  // 记录可以切出多少根长度为x的木棍

    for (int i = 1; i <= n; i++)
    {
        cnt += a[i] / x;  // 每根木棍可以切出a[i]/x根长度为x的木棍
    }

    return cnt >= k;  // 判断总数量是否足够k根
}

// 二分查找最大可能的x
int find()
{
    int l = 0, r = 100000000 + 1;  // 开区间(0, 1e8+1]

    while (l + 1 < r)  // 当区间长度大于1时继续
    {
        int mid = (l + r) / 2;

        if (check(mid))  // 如果mid可行,尝试更大的值
        {
            l = mid;  // 向右收缩
        }
        else
        {
            r = mid;  // 向左收缩
        }
    }

    return l;  // 返回最大的可行值
}

int main()
{
    cin >> n >> k;  // 输入木棍数量n和需要的段数k

    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];  // 输入每根木棍的长度
    }

    int ans = find();  // 查找最大长度
    cout << ans << endl;

    return 0;
}
// 使用acwing的模板二刷
#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
int n, k, a[N];

// 检查函数:判断是否可以将所有长度为a[i]的木棍
// 切割成至少k根长度为x的木棍
bool check(int x)
{
    int cnt = 0;  // 记录可以切出多少根长度为x的木棍

    for (int i = 1; i <= n; i++)
    {
        cnt += a[i] / x;  // 每根木棍可以切出a[i]/x根长度为x的木棍
    }

    return cnt >= k;  // 判断总数量是否足够k根
}

// 二分查找函数:寻找最大的可行长度x
int find()
{
    int l = 0, r = 1000000000;  // 查找范围:[0, 1e9]

    while (l < r)
    {
        // 注意:这里是 l+r+1 >> 1,向上取整
        int mid = l + r + 1 >> 1;  // 等价于 (l+r+1)/2

        if (check(mid))  // 如果mid可行
        {
            l = mid;  // 尝试更大的值
        }
        else
        {
            r = mid - 1;  // 尝试更小的值
        }
    }

    return l;  // 返回最大的可行值
}

int main()
{
    cin >> n >> k;  // 输入木棍数量n和需要的段数k

    for (int i = 1; i <= n; i++)
    {
        cin >> a[i];  // 输入每根木棍的长度
    }

    int ans = find();  // 查找最大长度
    cout << ans << endl;

    return 0;
}

【运行结果】

10
2
5
posted @ 2026-09-02 21:40  团爸讲算法  阅读(19)  评论(0)    收藏  举报