分治-整数位乘

最新推荐文章于 2024-07-19 15:45:46 发布
最新推荐文章于 2024-07-19 15:45:46 发布
阅读量133 收藏
点赞数
文章标签： 算法 数据结构
原文链接：https://www.jianshu.com/p/4386cff19146
版权

Description
以二进制形式给出两个数，求它们的乘积，也以二进制表示。

Input
每组数据两行，每行一个二进制表示的正整数。01串的长度不大于40000

Output
输出二进制表示的两数乘积。

Sample Input
111
100
Sample Output
11100
Hint
当规模足够小时可直接使用非优化算法以减少常数复杂度运算。

参考代码框架

// 整数位乘
struct BigBinary
{
std::vector<int> x; // 由低位到高位保存二进制位
bool neg; // 标记数的正负
void Init(){x.clear(); neg = false;}
BigBinary(){Init();}
void Print()
{
if(neg && !x.empty()) printf("-");
for(int i = x.size() - 1; i >= 0; i --)
printf("%d", x[i]);
if(x.empty()) printf("0");
printf("\n");
}
};
BigBinary Add(BigBinary &a, BigBinary &b)
{
// TODO: 返回 a + b 的结果，小心两数异号情况
}
BigBinary Minus(BigBinary &a, BigBinary &b)
{
// TODO: 返回 a - b 的结果，注意正负号
}
BigBinary Mul(BigBinary &a, BigBinary &b)
{
// TODO: 模拟竖式计算两数相乘
}
void MulN2(BigBinary &a, int n_2)
{
// TODO: 为 a 添加 n_2 个二进制0，即乘以 2^(n_2)
}
BigBinary FasterMul(BigBinary &a, BigBinary &b)
{
// TODO: 分治优化位乘
// 设 a = A * 2^(n/2) + B， b = C * 2^(n/2) + D
// ab = AC2^n + [(A - B)(D - C) + AC + BD] * 2^(n/2) + BD
// 注意：a 和 b 位数不一定相同，需要额外处理边界。

}

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
struct BigBinary
{
    std::vector<int> x;
    bool neg;
    void Init(){x.clear(); neg = false;}
    unsigned size(){return x.size();}
    BigBinary(){Init();}
    void check0() 
    {
        while(!x.empty() && x.back() == 0) x.pop_back();
        if(x.size() == 0) neg = false;
    }
    void Print()
    {
        if(neg && !x.empty()) printf("-");
        for(int i = x.size() - 1; i >= 0; i --)
            printf("%d", x[i]);
        if(x.empty()) printf("0");
        printf("\n");
    }
};
bool AbsAgB(BigBinary &a, BigBinary &b)
{
    if(a.size() > b.size()) return true;
    if(b.size() > a.size()) return false;
    for(int i = a.size() - 1; i >= 0; i --)
    {
        if(a.x[i] > b.x[i]) return true;
        if(b.x[i] > a.x[i]) return false;
    }
    return true;
}
BigBinary Add(BigBinary &a, BigBinary &b);
BigBinary Minus(BigBinary &a, BigBinary &b);
BigBinary Add(BigBinary &a, BigBinary &b)
{
    BigBinary c;
    if(a.neg != b.neg)
    {
        if(AbsAgB(a, b))
        {
            b.neg ^= 1;
            c = Minus(a, b);
            b.neg ^= 1;
        }
        else
        {
            a.neg ^= 1;
            c = Minus(b, a);
            a.neg ^= 1;
        }
        return c;
    }
    if(a.size() < b.size()) return Add(b, a);
    c.x = a.x;
    for(int i = 0; i < b.size(); i ++) c.x[i] += b.x[i];
    int cur = 0;
    for(int i = 0; i < c.size(); i ++) 
    {
        c.x[i] += cur;
        cur = c.x[i] >> 1;
        c.x[i] &= 1;
    }
    for(; cur; cur >>= 1) c.x.push_back(cur & 1);
    c.neg = a.neg; c.check0();
    return c;
}
BigBinary Minus(BigBinary &a, BigBinary &b)
{
    BigBinary c;
    if(a.neg != b.neg)
    {
        b.neg ^= 1;
        c = Add(a, b);
        b.neg ^= 1;
        return c;
    }
    if(!AbsAgB(a, b))
    {
        a.neg ^= 1;
        b.neg ^= 1;
        c = Minus(b, a);
        a.neg ^= 1;
        b.neg ^= 1;
        return c;
    }
    int i;
    for(i = 0; i < b.size(); i ++)
        c.x.push_back(a.x[i] - b.x[i]);
    for(; i < a.size(); i ++)
        c.x.push_back(a.x[i]);
    for(i = 0; i < c.size(); i ++)
    {
        while(c.x[i] < 0)
        {
            c.x[i] += 2;
            c.x[i + 1] --;
        }
    }
    c.neg = a.neg; c.check0();
    return c;
}
BigBinary Mul(BigBinary &a, BigBinary &b)
{
    BigBinary c;
    for(int i = 0; i < a.size(); i ++)
    {
        for(int j = 0; j < b.size(); j ++)
        {
            while(c.x.size() < i + j + 1)
                c.x.push_back(0);
            c.x[i + j] += a.x[i] & b.x[j];
        }
    }
    int cur = 0;
    for(int i = 0; i < c.size(); i ++) 
    {
        c.x[i] += cur;
        cur = c.x[i] >> 1;
        c.x[i] &= 1;
    }
    for(; cur; cur >>= 1) c.x.push_back(cur & 1);
    c.neg = a.neg ^ b.neg; c.check0();
    return c;
}
void MulN2(BigBinary &a, int n_2)
{
    int isize = a.x.size();
    a.x.resize(isize + n_2);
    for(int i = a.x.size() - 1, j = isize - 1; j >= 0; i --, j--)
        a.x[i] = a.x[j];
    for(int i = n_2 - 1; i >= 0; i --)
        a.x[i] = 0;
}
BigBinary FasterMul(BigBinary &a, BigBinary &b)
{
    if(a.size() < 2 || b.size() < 2)
        return Mul(a, b);
    if(a.size() < 100 && b.size() < 100)
        return Mul(a, b);
    if(a.size() < b.size())
        return FasterMul(b, a);
    BigBinary A, B, C, D;
    int n_2 = a.size() >> 1;
    for(int i = 0; i < n_2; i ++)
        B.x.push_back(a.x[i]);
    B.check0();
    for(int i = n_2; i < a.size(); i ++)
        A.x.push_back(a.x[i]);
    A.check0();
    BigBinary ret;
    if(b.size() < n_2)
    {
        BigBinary tmp_A_b = FasterMul(A, b);
        MulN2(tmp_A_b, n_2);
        BigBinary tmp_B_b = FasterMul(B, b);
        ret = Add(tmp_A_b, tmp_B_b);
    }
    else
    {
        for(int i = 0; i < n_2; i ++)
            D.x.push_back(b.x[i]);
        D.check0();
        for(int i = n_2; i < b.size(); i ++)
            C.x.push_back(b.x[i]);
        C.check0();
        BigBinary tmp_A_C = FasterMul(A, C);
        BigBinary tmp_B_D = FasterMul(B, D);
        BigBinary m_A_B = Minus(A, B);
        BigBinary m_D_C = Minus(D, C);
        BigBinary tmp_ABDC = FasterMul(m_A_B, m_D_C);
        BigBinary ad_ACBD = Add(tmp_A_C, tmp_B_D);
        BigBinary tmp_AD_BC = Add(tmp_ABDC, ad_ACBD);
        MulN2(tmp_A_C, n_2 * 2);
        MulN2(tmp_AD_BC, n_2);
        BigBinary tmpACADBC = Add(tmp_A_C, tmp_AD_BC);
        ret = Add(tmpACADBC, tmp_B_D);
    }
    ret.neg = a.neg ^ b.neg;
    return ret;
}
const int maxn = 1e5 + 10;
char buf[maxn];
BigBinary a, b;
int main()
{
    while(scanf("%s", buf) != EOF)
    {
        a.Init();
        b.Init();
        for(int i = strlen(buf) - 1; i >= 0; i --)
            a.x.push_back(buf[i] == '1');
        scanf("%s", buf);
        for(int i = strlen(buf) - 1; i >= 0; i --)
            b.x.push_back(buf[i] == '1');
        FasterMul(a, b).Print();
    }
    return 0;
}

一个更容易写的方法：

事先对齐两数，前导0不影响计算结果
优化AD+BC的表示为(A+B)*(C+D)-AC-BD，代替(A-B)(D-C)+AC+BD，避免了减法出现负数

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
typedef std::vector<int> BigBinary;
void check(BigBinary &x)
{
    while(!x.empty() && x.back() == 0) x.pop_back();
    int cur = 0;
    for(int i = 0; i < x.size(); i ++) 
    {
        x[i] += cur;
        // if(x[i] < 0) x[i + 1] += (x[i] - 1) / 2 - 1, x[i] = x[i] % 2 + 2;
        cur = x[i] >> 1; x[i] &= 1;
    }
    for(; cur; cur >>= 1) x.push_back(cur & 1);
}
void Print(BigBinary &x)
{
    check(x);
    for(int i = x.size() - 1; i >= 0; i --) printf("%d", x[i]);
    if(x.empty()) printf("0");
    printf("\n");
}
BigBinary Add(const BigBinary &a, const BigBinary &b, int negFlag=1)
{
    BigBinary c(a);
    for(int i = 0; i < b.size(); i ++) c[i] += b[i] * negFlag;
    return c;
}
BigBinary Minus(const BigBinary &a, const BigBinary &b)
{
    return Add(a, b, -1); // 本算法保证了减法结果不小于0
}
BigBinary Mul(const BigBinary &a, const BigBinary &b)
{
    BigBinary c;
    c.resize(a.size() * b.size() + 1);
    for(int i = 0; i < a.size(); i ++)
        for(int j = 0; j < b.size(); j ++)
            c[i + j] += a[i] * b[j];
    return c;
}
void MulN2(BigBinary &a, int n_2)
{
    int isize = a.size();
    a.resize(isize + n_2);
    for(int i = a.size() - 1, j = isize - 1; j >= 0; i --, j--)
        a[i] = a[j];
    for(int i = n_2 - 1; i >= 0; i --) a[i] = 0;
}
BigBinary FasterMul(const BigBinary &a, const BigBinary &b)
{
    if(a.size() < 32) return Mul(a, b);
    int n_2 = a.size() >> 1;
    BigBinary A(a.begin() + n_2, a.end());
    BigBinary B(a.begin(), a.begin() + n_2);
    BigBinary C(b.begin() + n_2, b.end());
    BigBinary D(b.begin(), b.begin() + n_2);
    BigBinary A_C = FasterMul(A, C);
    BigBinary B_D = FasterMul(B, D);
    // AD+BC = (A+B)*(C+D)-AC-BD，该方式与课本不同，避免了减法出现负数
    BigBinary ADpBC = Minus(Minus(FasterMul(Add(A, B), Add(C, D)), A_C), B_D);
    MulN2(A_C, n_2 << 1); MulN2(ADpBC, n_2);
    return Add(Add(A_C, ADpBC), B_D);
}
const int maxn = 1e5 + 10;
char buf[maxn];
BigBinary a, b;
#ifdef CPC
#include<time.h>
#endif
int main()
{
    while(scanf("%s", buf) != EOF)
    {
        a.clear();
        b.clear();
        for(int i = strlen(buf) - 1; i >= 0; i --)
            a.push_back(buf[i] == '1');
        scanf("%s", buf);
        for(int i = strlen(buf) - 1; i >= 0; i --)
            b.push_back(buf[i] == '1');
        if(a.size() < b.size()) a.resize(b.size(), 0);
        else b.resize(a.size(), 0);
        BigBinary res = FasterMul(a, b);
        Print(res);
    }
    return 0;
}

转载自作者：坪河夜雨
链接：https://www.jianshu.com/p/4386cff19146
来源：简书
 

拉玛干
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
递归分治-大整数乘法
毛毛虫的专栏
05-19 1万+
最近在学算法，想着不能只是学，要深刻领悟，需要记录，需要写代码，需要分析……所以就诞生了这篇博客。问题描述：设X和Y都是n位整数，计算它们的乘积XY。可以使用传统的数学计算方法，但是这样做计算步骤太多，效率较低。如果将每个一位数的乘法或加法看做一步运算，则这种方法需要进行O（n^2）步运算才能求出乘积XY。方法一基本计算步骤如下，如：56*78 第一步：6*8； 第二步：5*8； 第三步：6*
分治法-大整数乘法
热门推荐
HeinSven的博客
01-07 3万+
问题分析： 在计算机上处理一些大数据相乘时，由于计算机硬件的限制，不能直接进行相乘得到想要的结果。可以将一个大的整数乘法分而治之，将大问题变成小问题，变成简单的小数乘法再进行合并，从而解决上述问题。 当分解到只有一位数时，乘法就很简单了。 算法设计： 分解： 首先将2个大整数a(n位）、b(m位)分解为两部分：ah和al、bh和bl ah表示大整数a的高位，al表示大整数a的...
分治-幂乘算法及应用
qq_63525443的博客
09-25 213
简化：只用算出来一个n/2个a相乘，后面那一个n/2个a就不用算了。Fibonacci数列：1, 1, 2, 3, …a为给定实数，n为自然数。
分治算法经典问题---大整数乘法（1～32位大整数乘法）C++
Cathy___Sun的博客
07-17 2831
大整数乘法（1~16位大整数乘法） 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择
分治算法--大整数乘法
走别人的路，让别人无路可走！！！
11-15 7474
大整数乘法：就是乘法的两个乘数比较大，最后结果超过了整型甚至长整型的最大范围，此时如果需要得到精确结果，就不能常规的使用乘号直接计算了。没错，就需要采用分治的思想，将乘数“分割”，将大整数计算转换为小整数计算。 可以通过列表的形式来进行大整数的乘法，通过数组来保存列表中的数据。结合http://blog.csdn.net/tjsinor2008/article/details/5625849计算87
分治 - Karatsuba算法 (大数位乘运算)（大数相乘）
while_black的博客
04-01 2577
https://blog.csdn.net/u010983881/article/details/77503519 这个Karatsuba算法，时间复杂度仅有 O(nlog23)O(nlog2⁡3) 。下面，我就来介绍一下这个算法。 Karatsuba于1960年发明在 O(nlog23)O(nlog2⁡3) 步骤内将两个n位数相乘的Karatsuba算法。它反证了安德雷·柯尔莫哥洛夫于195...
分治算法实践3-整数的幂次方表示 C++
m0_51230983的博客
12-18 1691
题目描述 任何一个正整数都可以用2的幂次方表示。例如137=27+23+20。 同时约定方次用括号来表示，即ab可以表示为a(b). 由此可知，137可表示为2(7)+2(3)+2(0) 进一步： 7=22+2+20(21用2表示),并且3=2+20。 所以最后137可表示为2(2(2)+2+2(0))+2(2+2(0))+2(0)。 又如1315=210+28+25+2+1, 所以1315最后可表示为2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0)。 输入
分治算法解大整数相乘问题
qq_39545674的博客
11-15 2133
1 问题 有两个n位大整数XXX，YYY，它们数值之分大，如1e10001e10001e1000。现在要计算它们的乘积XYXYXY。 2 分析 2.1 传统方法 逐位相乘、错位相加，时间复杂度O(n2)O(n^2)O(n2)。效率太低。 2.2 分治方法 将n位的二进制整数X和Y各分为2段，每段的长为n/2位（为简单起见，假设n是2的幂）。此处整数用2进制表示。 X=a2n2+bY=c2n2+d X=a2^{\frac{n}{2}}+b\\ Y=c2^{\frac{n}{2}}+d X=a22n​+bY=
用分治法实现两个二进制数的大整数乘法（带界面）
10-31
大整数分解问题：给定两个n位长二进制数x和y，求这两个数的乘积。时间复杂性控制在Θ(n1.6)
算法分析PPT（分治法-大整数、矩阵相乘).ppt）
10-20
算法分析PPT（分治法-大整数、矩阵相乘).ppt）
大整数乘法源代码_大整数_
10-03
本主题主要探讨大整数乘法的算法实现，特别是通过阅读提供的"大整数乘法源代码.txt"文件，我们可以学习如何编写程序来高效地处理这些大数的乘法操作。 一、大整数表示 在编程中，大整数通常以数组形式存储，每个...
50位整数与50位整数相乘
07-01
标题 "50位整数与50位整数相乘" 涉及的是大整数运算中的一个挑战，这通常在计算机编程中遇到，特别是在处理金融、密码学或科学计算等领域。在这种情况下，我们讨论的是两个具有50位长度的整数进行相乘的操作，这超出...
大二数据结构作业--大整数
11-15
1. **数组表示法**：由于常规的整型变量无法存储大整数，我们可以用数组来存储每一位数字。例如，一个数组`[9, 8, 7, 6, 5]`可以代表大整数`98765`。这种表示法允许我们轻松地进行加、减、乘、除等基本运算。 2. **...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1137
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 216
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
最新发布
Atticus的博客
07-19 279
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
排序思想-快排
m0_58257626的博客
07-17 338
快速排序核心思想就是每次在当前区间 [left, right] 中选择出一个元素 nums[p]，然后将区间内所有大于它的元素和所有小于它的元素都放到其两侧【具体放在哪一侧取决于是升序还是降序】，然后再递归去处理两侧区间。将大于切分值的元素都放到左侧，小于切分值得元素都放到右侧。因此我们可以使用双指针分别从两端往中间搜索，分别找到左侧小于切分值的元素和右侧大于切分值的元素，交换之，直到两个指针相遇。
完全二叉树的节点个数-递归
qq_45031559的博客
07-19 250
完全二叉树的节点个数-递归
使用分治法求解二进制位乘问题c++代码
07-08
当我们需要使用分治法来解决二进制位乘的问题时，可以将乘法运算转化为位运算。下面是使用分治法求解二进制位乘问题的C++代码： ```cpp #include // 使用分治法求解二进制位乘 int binaryMultiply(int a, int b) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值