📜  使用分而治之算法进行快速乘法的Karatsuba算法

📅  最后修改于: 2021-05-06 20:10:37             🧑  作者: Mango

给定两个表示两个整数值的二进制字符串,找到两个字符串的乘积。例如,如果第一位字符串是“ 1100”,第二位字符串是“ 1010”,则输出应为120。

为简单起见,让两个字符串的长度相同且为n。

天真的方法是遵循我们在学校学习的过程。逐个取第二个数字的所有位,然后将其与第一个数字的所有位相乘。最后添加所有乘法。该算法花费O(n ^ 2)时间。

产品

使用Divide和Conquer ,我们可以将两个整数相乘,从而降低了时间复杂度。我们将给定的数字分为两半。让给定的数字为X和Y。

为简单起见,我们假设n为偶数

X =  Xl*2n/2 + Xr    [Xl and Xr contain leftmost and rightmost n/2 bits of X]
Y =  Yl*2n/2 + Yr    [Yl and Yr contain leftmost and rightmost n/2 bits of Y]

乘积XY可以写成如下形式。

XY = (Xl*2n/2 + Xr)(Yl*2n/2 + Yr)
   = 2n XlYl + 2n/2(XlYr + XrYl) + XrYr

如果我们看上面的公式,有四个大小为n / 2的乘法,所以我们基本上将大小为n / 2的问题分为四个大小为n / 2的子问题。但这无济于事,因为递归T(n)= 4T(n / 2)+ O(n)的解是O(n ^ 2)。该算法的棘手部分是将中间的两个项更改为其他形式,以便仅执行一次额外的乘法就足够了。以下是中间两个术语的棘手表达式。

XlYr + XrYl = (Xl + Xr)(Yl + Yr) - XlYl- XrYr

因此XY的最终值变为

XY = 2n XlYl + 2n/2 * [(Xl + Xr)(Yl + Yr) - XlYl - XrYr] + XrYr

有了以上技巧,递归变为T(n)= 3T(n / 2)+ O(n),并且此递归的解为O(n 1.59 )。

如果输入字符串的长度不同并且不相等怎么办?为了处理不同长度的情况,我们在开头添加0。为了处理奇数长度,我们将floor(n / 2)位放在左半部分,将ceil(n / 2)位放在右半部分。因此,XY的表达式变为以下表达式。

XY = 22ceil(n/2) XlYl + 2ceil(n/2) * [(Xl + Xr)(Yl + Yr) - XlYl - XrYr] + XrYr

上面的算法称为Karatsuba算法,它可以用于任何基础。

以下是上述算法的C++实现。

// C++ implementation of Karatsuba algorithm for bit string multiplication.
#include
#include
  
using namespace std;
  
// FOLLOWING TWO FUNCTIONS ARE COPIED FROM http://goo.gl/q0OhZ
// Helper method: given two unequal sized bit strings, converts them to
// same length by adding leading 0s in the smaller string. Returns the
// the new length
int makeEqualLength(string &str1, string &str2)
{
    int len1 = str1.size();
    int len2 = str2.size();
    if (len1 < len2)
    {
        for (int i = 0 ; i < len2 - len1 ; i++)
            str1 = '0' + str1;
        return len2;
    }
    else if (len1 > len2)
    {
        for (int i = 0 ; i < len1 - len2 ; i++)
            str2 = '0' + str2;
    }
    return len1; // If len1 >= len2
}
  
// The main function that adds two bit sequences and returns the addition
string addBitStrings( string first, string second )
{
    string result;  // To store the sum bits
  
    // make the lengths same before adding
    int length = makeEqualLength(first, second);
    int carry = 0;  // Initialize carry
  
    // Add all bits one by one
    for (int i = length-1 ; i >= 0 ; i--)
    {
        int firstBit = first.at(i) - '0';
        int secondBit = second.at(i) - '0';
  
        // boolean expression for sum of 3 bits
        int sum = (firstBit ^ secondBit ^ carry)+'0';
  
        result = (char)sum + result;
  
        // boolean expression for 3-bit addition
        carry = (firstBit&secondBit) | (secondBit&carry) | (firstBit&carry);
    }
  
    // if overflow, then add a leading 1
    if (carry)  result = '1' + result;
  
    return result;
}
  
// A utility function to multiply single bits of strings a and b
int multiplyiSingleBit(string a, string b)
{  return (a[0] - '0')*(b[0] - '0');  }
  
// The main function that multiplies two bit strings X and Y and returns
// result as long integer
long int multiply(string X, string Y)
{
    // Find the maximum of lengths of x and Y and make length
    // of smaller string same as that of larger string
    int n = makeEqualLength(X, Y);
  
    // Base cases
    if (n == 0) return 0;
    if (n == 1) return multiplyiSingleBit(X, Y);
  
    int fh = n/2;   // First half of string, floor(n/2)
    int sh = (n-fh); // Second half of string, ceil(n/2)
  
    // Find the first half and second half of first string.
    // Refer http://goo.gl/lLmgn for substr method
    string Xl = X.substr(0, fh);
    string Xr = X.substr(fh, sh);
  
    // Find the first half and second half of second string
    string Yl = Y.substr(0, fh);
    string Yr = Y.substr(fh, sh);
  
    // Recursively calculate the three products of inputs of size n/2
    long int P1 = multiply(Xl, Yl);
    long int P2 = multiply(Xr, Yr);
    long int P3 = multiply(addBitStrings(Xl, Xr), addBitStrings(Yl, Yr));
  
    // Combine the three products to get the final result.
    return P1*(1<<(2*sh)) + (P3 - P1 - P2)*(1<

输出:

120
60
30
10
0
49
9

时间复杂度:上述解决方案的时间复杂度为O(n log 2 3 )= O(n 1.59 )。

使用另一种分而治之算法,快速傅里叶变换,可以进一步提高乘法的时间复杂度。我们很快将在单独的文章中讨论快速傅立叶变换。

锻炼
上面的程序返回一个long int值,不适用于大字符串。扩展上述程序以返回字符串而不是long int值。

解决方案

大量的乘法过程是计算机科学中的一个重要问题。给定的方法使用分而治之方法。

运行代码以查看常规二进制乘法和Karatsuba算法的时间复杂度比较。
您可以在此存储库中看到完整的代码

例子:

Fist Binary Input : 101001010101010010101001010100101010010101010010101 
Second Binary Input : 101001010101010010101001010100101010010101010010101
Decimal Output : Not Representable 
Output : 2.1148846e+30
Fist Binary Input : 1011 
Second Binary Input : 1000
Decimal Output : 88
Output : 5e-05
#include 
#include 
#include 
#include 
#include 
#include 
  
using namespace std;
  
// classical method class
class BinaryMultiplier
{
public:
    string MakeMultiplication(string,string);      
    string MakeShifting(string,int);               
    string addBinary(string,string);
    void BinaryStringToDecimal(string);
};
  
// karatsuba method class
class Karatsuba
{
public:
    int lengthController(string &,string &);
    string addStrings(string,string);
    string multiply(string,string);
    string DecimalToBinary(long long int);
    string Subtraction(string,string);
    string MakeShifting(string,int);
};
  
// this function get strings and go over str2 bit bit 
// if it sees 1  it calculates the shifted version according to position bit
// Makes add operation for binary strings
// returns result string
string BinaryMultiplier::MakeMultiplication(string str1, string str2)
{
    string allSum = "";
    for (int j = 0 ; j= 0 || j >= 0 || s == 1)
    {
        s += ((i >= 0)? a[i] - '0': 0);
        s += ((j >= 0)? b[j] - '0': 0);
          
        result = char(s % 2 + '0') + result;
          
        s /= 2;
      
        i--;
        j--;
    }
    return result;
}
  
// this function shifts the given string according to given number
// returns shifted version 
string BinaryMultiplier::MakeShifting(string str, int stepnum)
{
    string shifted = str;
    for (int i = 0 ; i < stepnum ; i++)
        shifted = shifted + '0';
    return shifted;
}
  
// this function converts Binary String Number to Decimal Number
// After 32 bits it gives 0 because it overflows the size of int
void BinaryMultiplier::BinaryStringToDecimal(string result)
{
    cout<<"Binary Result : "<= 0; i--)
    {
        if (result[i] == '1')
        {
            val += pow(2,(result.length()-1)-i);
        }
    }
    cout<<"Decimal Result (Not proper for Large Binary Numbers):" < len2)
    {
        for (int i = 0 ; i < len1 - len2 ; i++)
            str2 = '0' + str2;
    }
    return len1;
}
  
// this function add strings with carry 
// uses one by one bit addition methodology
// returns result string
string Karatsuba::addStrings(string first, string second)
{
    string result;  // To store the sum bits
      
    // make the lengths same before adding
    int length = lengthController(first, second);
    int carry = 0;  // Initialize carry
      
    // Add all bits one by one
    for (int i = length-1 ; i >= 0 ; i--)
    {
        int firstBit = first.at(i) - '0';
        int secondBit = second.at(i) - '0';
          
        // boolean expression for sum of 3 bits
        int sum = (firstBit ^ secondBit ^ carry)+'0';
          
        result = (char)sum + result;
          
        // Boolean expression for 3-bit addition
        carry = (firstBit&secondBit) | (secondBit&carry) | (firstBit&carry);
    }
      
    // if overflow, then add a leading 1
    if (carry)
    {
        result = '1' + result;
    }
      
    return result;
}
  
// this function converts decimal number to binary string
string Karatsuba::DecimalToBinary(long long int number)
{
    string result = "";
    if (number <= 0)
    {
        return "0";
    }
    else
    {
        int i = 0;
        while (number > 0)
        {
              
            long long int num= number % 2;
            stringstream ss;
            ss<= 0; i--)
    {
        diff = (lhs[i]-'0') - (rhs[i]-'0');
        if (diff >= 0)
        {
            result = DecimalToBinary(diff) + result;
        }
        else
        {
            for (int j = i-1; j>=0; j--)
            {
                lhs[j] = ((lhs[j]-'0') - 1) % 10 + '0';
                if (lhs[j] != '1')
                {
                    break;
                }
            }
            result = DecimalToBinary(diff+2) + result;
        }
    }
    return result;
}
  
// this function makes shifting
string Karatsuba::MakeShifting(string str, int stepnum)
{
    string shifted = str;
    for (int i = 0 ; i < stepnum ; i++)
        shifted = shifted + '0';
    return shifted;
}
  
// this function is the core of the Karatsuba 
// divides problem into 4 subproblems
// recursively multiplies them
// returns the result string
string Karatsuba::multiply(string X,  string Y)
{
    int n = lengthController(X, Y);
      
    if (n == 1) return ((Y[0]-'0' == 1) && (X[0]-'0' == 1)) ? "1" : "0";
      
    int fh = n/2;   // First half of string, floor(n/2)
    int sh = (n-fh); // Second half of string, ceil(n/2)
      
    // Find the first half and second half of first string.
    string Xl = X.substr(0, fh);
    string Xr = X.substr(fh, sh);
      
    // Find the first half and second half of second string
    string Yl = Y.substr(0, fh);
    string Yr = Y.substr(fh, sh);
      
    // Recursively calculate the three products of inputs of size n/2
    string P1 = multiply(Xl, Yl);
    string P2 = multiply(Xr, Yr);
    string P3 = multiply(addStrings(Xl, Xr), addStrings(Yl, Yr));
      
    // return added string version
    return addStrings(addStrings(MakeShifting(P1, 2*(n-n/2)),P2),MakeShifting(Subtraction(P3,addStrings(P1,P2)), n-(n/2)));
}
  
  
int main(int argc, const char * argv[])
{
    // get the binary numbers as strings
    string firstNumber,secondNumber;
    
    cout<<"Please give the First Binary number : ";
    cin>>firstNumber;
    cout<>secondNumber;
    cout << endl;
      
  
    // make the initial lengths equal by adding zeros
    int len1 = firstNumber.size();
    int len2 = secondNumber.size();
    int general_len = firstNumber.size();
      
    if (len1 < len2)
    {
        for (int i = 0 ; i < len2 - len1 ; i++)
            firstNumber = '0' + firstNumber;
        general_len = firstNumber.size();
    }
    else if (len1 > len2)
    {
        for (int i = 0 ; i < len1 - len2 ; i++)
            secondNumber = '0' + secondNumber;
        general_len = secondNumber.size();
    }
      
    // In classical methodology Binary String Multiplication
    cout<<"Classical Algorithm : "<

相关文章:
大数表示为字符串

参考:
Karatsuba算法的维基百科页面
算法第一版,作者:Sanjoy Dasgupta,Christos Papadimitriou和Umesh Vazirani
http://courses.csail.mit.edu/6.006/spring11/exams/notes3-karatsuba
http://www.cc.gatech.edu/~ninamf/Algos11/lectures/lect0131.pdf