java大数乘法分治_分治法的经典问题——大整数相乘

最新推荐文章于 2021-03-11 19:23:57 发布
最新推荐文章于 2021-03-11 19:23:57 发布
阅读量1.5k 收藏 14
点赞数 3
文章标签： java大数乘法分治
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_31088605/article/details/114667450
版权

分治法的经典问题——大整数相乘

分治法的原理

分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。即一种分目标完成程序算法，简单问题可用二分法完成。(来自度娘的搬运工)

简单的说，分治就是分而治之，把一个问题拆分成几个小问题，最后再汇总解决的办法。

有两点需要记住：

(1) 分治法基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。

(2)递归的解这些子问题，然后将各子问题的解合并得到原问题的解。

分治法的重点是分析问题是否可以划分为规模较小的子问题，难点是如何划分以及划分之后如何将各个子问题的解合并成最终的解。这一般需要用到数学知识或者其他理论。

下面我们用图来说明：

ec3e2b6a1bbec0f874ea5abcc8944db2.png

通过大整数相乘问题来了解分治法(理想状态下)

这里我们假设有两个大整数X、Y，分别设X=1234、Y=5678。现在要求X*Y的乘积，小学的算法就是把X与Y中的每一项去乘，但是这样的乘法所需的时间复杂度为，效率比较低下。那我们可以采用分治的算法，将X、Y分别拆分为A与B、C与D，如下图:

ecb1843d78510e05e6c321cd31d08562.png

31f867493bed3966a413b0b32d41a7ac.png

注：我们这里取的大整数X、Y是在理想状态下，即X与Y的位数一致，且

f68dc82c8a2c000eccdf2c03bcfe3d49.png。

算法分析

首先将X和Y分成A，B，C，D

此时将X和Y的乘积转化为(1)式，把问题转化为求解因式分解的值

在(1)式中，我们一共需要进行4次n/2的乘法(AC2次，AD、BC各一次)和3次加法，因而该算法的时间复杂度为：

d433680cc89c4e8ecae09fe522e90fc4.png

通过master定理可以求得

7397857dc03e9b9b4d92f4d8b7179c52.png，跟小学算法的时间复杂度没有区别。

但是我们再来看看，我们是否可以用加法来换取乘法？因为多一个加法操作，也是常数项，对时间复杂度没有影响，如果减少一个乘法则不同。

(1)式化为：

f6b2b5ebe829e2ca00df763ffdc60b8c.png (2)

现在的时间复杂度为：

cc8e41c655feeb54ac1d9913e9a25d48.png，通过master定理求得，

149dc8b6e6dee4762422c532dac2acf9.png。

理想状态下代码实现(部分)：

c#:

static void Main(string[] args)

{

//SameNumber();

//UnSameNumber();

UnSameNumber2();

}

static int SIGN(long A)

{

return A > 0 ? 1 : -1;

}

#region 两整数位数相同

private static void SameNumber()

{

Console.Write("请输入两个大整数：\nX=");

long X = Convert.ToInt64(Console.ReadLine());

Console.Write("Y=");

long Y = Convert.ToInt64(Console.ReadLine());

Console.Write("请输入两个大整数的长度：n=");

int n = Convert.ToInt32(Console.ReadLine());

long sum = CalculateSame(X, Y, n);

Console.WriteLine("普通乘法 X*Y={0}*{1}={2}\n", X, Y, X * Y);

Console.WriteLine("分治乘法 X*Y={0}*{1}={2}\n", X, Y, sum);

}

static long CalculateSame(long X, long Y, int n)

{

int sign = SIGN(X) * SIGN(Y);

X = Math.Abs(X);

Y = Math.Abs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

long A = (long)(X / Math.Pow(10, n / 2));

long B = (long)(X % Math.Pow(10, n / 2));

long C = (long)(Y / Math.Pow(10, n / 2));

long D = (long)(Y % Math.Pow(10, n / 2));

long AC = CalculateSame(A, C, n / 2);

long BD = CalculateSame(B, D, n / 2);

long ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

//Console.WriteLine("A={0} B={1} C={2} D={3}\n", A, B, C, D);

return (long)(sign * (AC * Math.Pow(10, n) + ABCD * Math.Pow(10, n / 2) + BD));

}

}

#endregion

75cf1238d6adf8b9a8c99834ec629573.png

大整数相乘算法非理想状态下

这里我们还是假设有两个大整数X、Y，分别设X=123、Y=45678。现在要求X*Y的乘积，乘法所需的时间复杂度为。我们采用分治的算法，将X、Y分别拆分为A与B、C与D，如下图:

dac84a15d0919b169250be4e80e81ce1.png

aa2b783c8a41ddf4da369899fc64c11f.png   (3)

在(3)式中，我们一共需要进行2次xn0的乘法(AC、AD各一次)、2次yn0的乘法(AC、BC各一次)和3次加法，因而该算法的时间复杂度为：

e16134fd4e64689f655df766217c015e.png

现在我们用加法来换取乘法并计算其时间复杂度。

(3)式化为：

d4ee497bf75a0fff61a6350dc2bde9d2.png(4)

现在的时间复杂度为：

8fb844e4098cd112aed2a20fd70adb2b.png

由于

27496840210e038aba71368790265787.png，所以(4)式的时间复杂度小于(3)式的时间复杂度。

非理想状态下代码实现(部分)：

c#:

#region 两整数位数不相同

private static void UnSameNumber2()

{

Console.Write("请输入两个大整数：\nX=");

long X = Convert.ToInt64(Console.ReadLine());

Console.Write("Y=");

long Y = Convert.ToInt64(Console.ReadLine());

Console.Write("请输入X的长度：xn=");

int xn = Convert.ToInt32(Console.ReadLine());

Console.Write("请输入Y的长度：yn=");

int yn = Convert.ToInt32(Console.ReadLine());

long sum = CalculateUnSame2(X, Y, xn, yn);

Console.WriteLine("\n普通乘法 X*Y={0}*{1}={2}", X, Y, X * Y);

Console.WriteLine("分治乘法 X*Y={0}*{1}={2}\n", X, Y, sum);

}

static long CalculateUnSame2(long X, long Y, int xn, int yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

int xn0 = xn / 2, yn0 = yn / 2;

int xn1 = xn - xn0, yn1 = yn - yn0;

long A = (long)(X / Math.Pow(10, xn0));

long B = (long)(X % Math.Pow(10, xn0));

long C = (long)(Y / Math.Pow(10, yn0));

long D = (long)(Y % Math.Pow(10, yn0));

//Console.WriteLine("A={0}*10^{1} B={2}*10^{3} C={4}*10^{5} D={6}*10^{7}\n", A, xn1, B, xn0, C, yn1, D, yn0);

long AC = CalculateUnSame2(A, C, xn1, yn1);

long BD = CalculateUnSame2(B, D, xn0, yn0);

long ABCD = CalculateUnSame2((long)(A * Math.Pow(10, xn0) - B), (long)(D - C * Math.Pow(10, yn0)), xn1, yn1);

return (long)(2 * AC * Math.Pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

#endregion

36a61e1ac36cc8f7b1e17fcc0195fe98.png

理想状态下与非理想状态下代码实现(完整)：

c语言：

#include

#include

#include

void SameNumber();

void UnSameNumber();

int SIGN(long A);

long CalculateSame(long X, long Y, int n);

long CalculateUnSame(long X, long Y, int xn, int yn);

int main()

{

SameNumber();

UnSameNumber();

return (0);

}

int SIGN(long A)

{

return A > 0 ? 1 : -1;

}

void SameNumber()

{

long X=0,Y = 0;

int n=0;

printf("理想状态下用法！");

printf("请输入两个大整数：\nX=");

scanf("%d",&X);

printf("Y=");

scanf("%d",&Y);

printf("请输入两个大整数的长度：n=");

scanf("%d",&n);

long sum = CalculateSame(X, Y, n);

printf("普通乘法 X*Y=%d*%d=%d\n",X,Y,X*Y);

printf("分治乘法 X*Y=%d*%d=%d\n",X,Y,sum);

}

long CalculateSame(long X, long Y, int n)

{

int sign = SIGN(X) * SIGN(Y);

X = labs(X);

Y = labs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

long A = (long)(X / pow(10, n / 2));

long B = (X % (long)pow(10, n / 2));

long C = (long)(Y / pow(10, n / 2));

long D = (Y % (long)pow(10, n / 2));

long AC = CalculateSame(A, C, n / 2);

long BD = CalculateSame(B, D, n / 2);

long ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

//cout<

return (long)(sign * (AC * pow(10, n) + ABCD * pow(10, n / 2) + BD));

}

}

void UnSameNumber()

{

long X=0,Y = 0;

int xn=0,yn=0;

printf("非理想状态下用法！");

printf("请输入两个大整数：\nX=");

scanf("%d",&X);

printf("Y=");

scanf("%d",&Y);

printf("请输入X的长度：xn=");

scanf("%d",&xn);

printf("请输入Y的长度：xn=");

scanf("%d",&yn);

long sum = CalculateUnSame(X, Y, xn,yn);

printf("普通乘法 X*Y=%d*%d=%d\n",X,Y,X*Y);

printf("分治乘法 X*Y=%d*%d=%d\n",X,Y,sum);

}

long CalculateUnSame(long X, long Y, int xn, int yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

int xn0 = xn / 2, yn0 = yn / 2;

int xn1 = xn - xn0, yn1 = yn - yn0;

long A = (long)(X / pow(10, xn0));

long B = (long)(X % (long)pow(10, xn0));

long C = (long)(Y / pow(10, yn0));

long D = (long)(Y % (long)pow(10, yn0));

long AC = CalculateUnSame(A, C, xn1, yn1);

long BD = CalculateUnSame(B, D, xn0, yn0);

long ABCD = CalculateUnSame((long)(A * pow(10, xn0) - B), (long)(D - C * pow(10, yn0)), xn1, yn1);

return (long)(2 * AC * pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

c++语言：

#include

#include

#include

int count=0;

using namespace std;

void SameNumber();

void UnSameNumber();

int SIGN(long A);

long CalculateSame(long X, long Y, int n);

long CalculateUnSame(long X, long Y, int xn, int yn);

int main()

{

SameNumber();

UnSameNumber();

return (0);

}

int SIGN(long A)

{

return A > 0 ? 1 : -1;

}

void SameNumber()

{

cout<

cout<

long X = 0;

cin>>X;

cout<

long Y = 0;

cin>>Y;

cout<

int n = 0;

cin>>n;

long sum = CalculateSame(X, Y, n);

cout<

cout<

}

long CalculateSame(long X, long Y, int n)

{

int sign = SIGN(X) * SIGN(Y);

X = abs(X);

Y = abs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

long A = (long)(X / pow(10, n / 2));

long B = (X % (long)pow(10, n / 2));

long C = (long)(Y / pow(10, n / 2));

long D = (Y % (long)pow(10, n / 2));

long AC = CalculateSame(A, C, n / 2);

long BD = CalculateSame(B, D, n / 2);

long ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

cout<

return (long)(sign * (AC * pow(10, n) + ABCD * pow(10, n / 2) + BD));

}

}

void UnSameNumber()

{

cout<

cout<

long X = 0;

cin>>X;

cout<

long Y = 0;

cin>>Y;

cout<

int xn = 0;

cin>>xn;

cout<

int yn = 0;

cin>>yn;

long sum = CalculateUnSame(X, Y, xn,yn);

cout<

cout<

}

long CalculateUnSame(long X, long Y, int xn, int yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

int xn0 = xn / 2, yn0 = yn / 2;

int xn1 = xn - xn0, yn1 = yn - yn0;

long A = (long)(X / pow(10, xn0));

long B = (long)(X % (long)pow(10, xn0));

long C = (long)(Y / pow(10, yn0));

long D = (long)(Y % (long)pow(10, yn0));

long AC = CalculateUnSame(A, C, xn1, yn1);

long BD = CalculateUnSame(B, D, xn0, yn0);

long ABCD = CalculateUnSame((long)(A * pow(10, xn0) - B), (long)(D - C * pow(10, yn0)), xn1, yn1);

return (long)(2 * AC * pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

c#语言：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace BigInteger

{

class Program

{

static void Main(string[] args)

{

SameNumber();

UnSameNumber();

}

static int SIGN(long A)

{

return A > 0 ? 1 : -1;

}

#region 两整数位数相同

private static void SameNumber()

{

Console.Write("请输入两个大整数：\nX=");

long X = Convert.ToInt64(Console.ReadLine());

Console.Write("Y=");

long Y = Convert.ToInt64(Console.ReadLine());

Console.Write("请输入两个大整数的长度：n=");

int n = Convert.ToInt32(Console.ReadLine());

long sum = CalculateSame(X, Y, n);

Console.WriteLine("普通乘法 X*Y={0}*{1}={2}\n", X, Y, X * Y);

Console.WriteLine("分治乘法 X*Y={0}*{1}={2}\n", X, Y, sum);

}

static long CalculateSame(long X, long Y, int n)

{

int sign = SIGN(X) * SIGN(Y);

X = Math.Abs(X);

Y = Math.Abs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

long A = (long)(X / Math.Pow(10, n / 2));

long B = (long)(X % Math.Pow(10, n / 2));

long C = (long)(Y / Math.Pow(10, n / 2));

long D = (long)(Y % Math.Pow(10, n / 2));

long AC = CalculateSame(A, C, n / 2);

long BD = CalculateSame(B, D, n / 2);

long ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

return (long)(sign * (AC * Math.Pow(10, n) + ABCD * Math.Pow(10, n / 2) + BD));

}

}

#endregion

#region 两整数位数不相同

private static void UnSameNumber()

{

Console.Write("请输入两个大整数：\nX=");

long X = Convert.ToInt64(Console.ReadLine());

Console.Write("Y=");

long Y = Convert.ToInt64(Console.ReadLine());

Console.Write("请输入X的长度：xn=");

int xn = Convert.ToInt32(Console.ReadLine());

Console.Write("请输入Y的长度：yn=");

int yn = Convert.ToInt32(Console.ReadLine());

long sum = CalculateUnSame(X, Y, xn, yn);

Console.WriteLine("\n普通乘法 X*Y={0}*{1}={2}", X, Y, X * Y);

Console.WriteLine("分治乘法 X*Y={0}*{1}={2}\n", X, Y, sum);

}

static long CalculateUnSame(long X, long Y, int xn, int yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

int xn0 = xn / 2, yn0 = yn / 2;

int xn1 = xn - xn0, yn1 = yn - yn0;

long A = (long)(X / Math.Pow(10, xn0));

long B = (long)(X % Math.Pow(10, xn0));

long C = (long)(Y / Math.Pow(10, yn0));

long D = (long)(Y % Math.Pow(10, yn0));

long AC = CalculateUnSame(A, C, xn1, yn1);

long BD = CalculateUnSame(B, D, xn0, yn0);

long ABCD = CalculateUnSame((long)(A * Math.Pow(10, xn0) - B), (long)(D - C * Math.Pow(10, yn0)), xn1, yn1);

return (long)(2 * AC * Math.Pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

#endregion

}

}

Java语言：

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.io.*;

import java.util.Scanner;

import java.util.Collections;

import java.util.Comparator;

import java.util.Random;

public class Program

{

public static Scanner sc = new Scanner(System.in);

public static int count=0;

public static void main(String[] args)

{

SameNumber();

UnSameNumber();

}

public static int SIGN(long A)

{

return A > 0 ? 1 : -1;

}

//两整数位数相同

private static void SameNumber()

{

System.out.print("请输入两个大整数：\nX=");

long X = sc.nextLong();

System.out.print("Y=");

long Y = sc.nextLong();

System.out.print("请输入两个大整数的长度：n=");

int n = sc.nextInt();

long sum = CalculateSame(X, Y, n);

System.out.println("普通乘法 X*Y="+X+"*"+Y+"="+X*Y+"\n");

System.out.println("分治乘法 X*Y="+X+"*"+Y+"="+sum+"\n");

}

public static long CalculateSame(long X, long Y, int n)

{

int sign = SIGN(X) * SIGN(Y);

X = Math.abs(X);

Y = Math.abs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

long A = (long)(X / Math.pow(10, n / 2));

long B = (long)(X % Math.pow(10, n / 2));

long C = (long)(Y / Math.pow(10, n / 2));

long D = (long)(Y % Math.pow(10, n / 2));

long AC = CalculateSame(A, C, n / 2);

long BD = CalculateSame(B, D, n / 2);

long ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

return (long)(sign * (AC * Math.pow(10, n) + ABCD * Math.pow(10, n / 2) + BD));

}

}

//两整数位数不同

private static void UnSameNumber()

{

System.out.print("请输入两个大整数：\nX=");

long X = sc.nextLong();

System.out.print("Y=");

long Y = sc.nextLong();

System.out.print("请输入X的长度：xn=");

int xn = sc.nextInt();

System.out.print("请输入Y的长度：yn=");

int yn = sc.nextInt();

long sum = CalculateUnSame(X, Y, xn, yn);

System.out.println("普通乘法 X*Y="+X+"*"+Y+"="+X*Y+"\n");

System.out.println("分治乘法 X*Y="+X+"*"+Y+"="+sum+"\n");

}

public static long CalculateUnSame(long X, long Y, int xn, int yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

int xn0 = xn / 2, yn0 = yn / 2;

int xn1 = xn - xn0, yn1 = yn - yn0;

long A = (long)(X / Math.pow(10, xn0));

long B = (long)(X % Math.pow(10, xn0));

long C = (long)(Y / Math.pow(10, yn0));

long D = (long)(Y % Math.pow(10, yn0));

long AC = CalculateUnSame(A, C, xn1, yn1);

long BD = CalculateUnSame(B, D, xn0, yn0);

long ABCD = CalculateUnSame((long)(A * Math.pow(10, xn0) - B), (long)(D - C * Math.pow(10, yn0)), xn1, yn1);

return (long)(2 * AC * Math.pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

}

JavaScript语言：

function SIGN(A)

{

return A > 0 ? 1 : -1;

}

function SameNumber()

{

var str = "";

var X = document.getElementById('SX').value;

var Y = document.getElementById('SY').value;

var n = document.getElementById('Sn').value;

var sum = CalculateSame(X, Y, n);

str += "普通乘法 X*Y="+X+"*"+Y+"="+X * Y+"
";

str += "分治乘法 X*Y="+X+"*"+Y+"="+sum;

document.getElementById('oldcontent').innerHTML = str;

}

function CalculateSame(X, Y, n)

{

var sign = SIGN(X) * SIGN(Y);

X = Math.abs(X);

Y = Math.abs(Y);

if (X == 0 || Y == 0)

return 0;

else if (n == 1)

return sign * X * Y;

else

{

var A = parseInt(X / Math.pow(10, n / 2));

var B = parseInt(X % Math.pow(10, n / 2));

var C = parseInt(Y / Math.pow(10, n / 2));

var D = parseInt(Y % Math.pow(10, n / 2));

var AC = CalculateSame(A, C, n / 2);

var BD = CalculateSame(B, D, n / 2);

var ABCD = CalculateSame((A - B), (D - C), n / 2) + AC + BD;

return (sign * (AC * Math.pow(10, n) + ABCD * Math.pow(10, n / 2) + BD));

}

}

function UnSameNumber()

{

var str = "";

var X = document.getElementById('KX').value;

var Y = document.getElementById('KY').value;

var xn = document.getElementById('xn').value;

var yn = document.getElementById('yn').value;

var sum = CalculateUnSame(X, Y, xn, yn);

str += "普通乘法 X*Y="+X+"*"+Y+"="+X * Y+"
";

str += "分治乘法 X*Y="+X+"*"+Y+"="+sum;

document.getElementById('newcontent').innerHTML = str;

}

function CalculateUnSame(X,Y,xn,yn)

{

if (X == 0 || Y == 0)

return 0;

else if ((xn == 1 && yn == 1) || xn == 1 || yn == 1)

return X * Y;

else

{

var xn0 = parseInt(xn / 2), yn0 = parseInt(yn / 2);

var xn1 = xn - xn0, yn1 = yn - yn0;

var A = parseInt(X / Math.pow(10, xn0));

var B = parseInt(X % Math.pow(10, xn0));

var C = parseInt(Y / Math.pow(10, yn0));

var D = parseInt(Y % Math.pow(10, yn0));

var AC = CalculateUnSame(A, C, xn1, yn1);

var BD = CalculateUnSame(B, D, xn0, yn0);

var ABCD = CalculateUnSame((A * Math.pow(10, xn0) - B), (D - C * Math.pow(10, yn0)), xn1, yn1);

return (2 * AC * Math.pow(10, (xn0 + yn0)) + ABCD + 2 * BD);

}

}

请输入两个大整数：X= Y= 请输入两个大整数的长度：n=
请输入两个大整数：X= Y= 请输入X的长度：xn=请输入Y的长度：yn=

PHP语言：

error_reporting(E_ALL ^ E_NOTICE);

SameNumber();

UnSameNumber();

function SameNumber()

{

fwrite(STDOUT, "理想状态算法！\n请输入两个大整数：\nX=");

$X = trim(fgets(STDIN));

fwrite(STDOUT, "Y=");

$Y = trim(fgets(STDIN));

fwrite(STDOUT, "请输入两个大整数的长度：n=");

$n = trim(fgets(STDIN));

$sum = CalculateSame($X, $Y, $n);

echo "普通乘法 X*Y=".$X."*".$Y."=".$X*$Y."\n";

echo "分治乘法 X*Y=".$X."*".$Y."=".$sum."\n";

}

function SIGN($A)

{

return $A > 0 ? 1 : -1;

}

function CalculateSame($X,$Y,$n)

{

$sign = SIGN($X) * SIGN($Y);

$X = abs($X);

$Y = abs($Y);

if ($X == 0 || $Y == 0)

return 0;

else if ($n == 1)

return $sign * $X * $Y;

else

{

$A = intval($X / pow(10, $n / 2));

$B = intval($X % pow(10, $n / 2));

$C = intval($Y / pow(10, $n / 2));

$D = intval($Y % pow(10, $n / 2));

//echo"sign=".$sign." pow=".pow(10, $n / 2)." X=".$X." Y=".$Y." A=".$A." B=".$B." C=".$C." D=".$D."\n";

$AC = CalculateSame($A, $C, $n / 2);

$BD = CalculateSame($B, $D, $n / 2);

$ABCD = CalculateSame(($A - $B), ($D - $C), $n / 2) + $AC + $BD;

//echo "sum=".( $AC * pow(10, $n) )." AC=".$AC." BD=".$BD." ABCD=".$ABCD."\n";

return ($sign * ($AC * pow(10, $n) + $ABCD * pow(10, $n / 2) + $BD));

}

}

function UnSameNumber()

{

fwrite(STDOUT, "\n非理想状态！\n请输入两个大整数：\nX=");

$X = trim(fgets(STDIN));

fwrite(STDOUT, "Y=");

$Y = trim(fgets(STDIN));

fwrite(STDOUT, "请输入X的长度：xn=");

$xn = trim(fgets(STDIN));

fwrite(STDOUT, "请输入Y的长度：yn=");

$yn = trim(fgets(STDIN));

$sum = CalculateUnSame($X, $Y, $xn,$yn);

echo "普通乘法 X*Y=".$X."*".$Y."=".$X*$Y."\n";

echo "分治乘法 X*Y=".$X."*".$Y."=".$sum."\n";

}

function CalculateUnSame($X,$Y,$xn,$yn)

{

if ($X == 0 || $Y == 0)

return 0;

else if (($xn == 1 && $yn == 1) || $xn == 1 || $yn == 1)

return $X * $Y;

else

{

$xn0 = intval($xn / 2);

$yn0 = intval($yn / 2);

$xn1 = $xn - $xn0;

$yn1 = $yn - $yn0;

$A = intval($X / pow(10, $xn0));

$B = intval($X % pow(10, $xn0));

$C = intval($Y / pow(10, $yn0));

$D = intval($Y % pow(10, $yn0));

echo"X=".$X." Y=".$Y." A=".$A." B=".$B." C=".$C." D=".$D."\n";

$AC = CalculateUnSame($A, $C, $xn1, $yn1);

$BD = CalculateUnSame($B, $D, $xn0, $yn0);

$ABCD = CalculateUnSame(($A * pow(10, $xn0) - $B), ($D - $C * pow(10, $yn0)), $xn1, $yn1);

//echo "sum=".( $AC * pow(10, $n) )." AC=".$AC." BD=".$BD." ABCD=".$ABCD."\n";

return (2 * $AC * pow(10, ($xn0 + $yn0)) + $ABCD + 2 * $BD);

}

}

?>

酱小匠
关注
java大整数乘法分治法,大数相乘（分治法， C/C++）
weixin_34882814的博客
03-21 507
1、分治法有两点需要理解：(1)分治法基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同。(2)递归的解这些子问题，然后将各子问题的解合并得到原问题的解。分治法的重点是分析问题是否可以划分为规模较小的子问题，难点是如何划分以及划分之后如何将各个子问题的解合并成最终的解。这一般需要用到数学知识或者其他理论。以大数相乘为例，有A,B两个大数，都为n位，要计算A*...
java大数乘法分治_分治算法解大整数相乘问题
weixin_33210666的博客
02-25 461
1 问题有两个n位大整数，，它们数值之分大，如。现在要计算它们的乘积。2 分析2.1 传统方法逐位相乘、错位相加，时间复杂度。效率太低。2.2 分治方法将n位的二进制整数X和Y各分为2段，每段的长为n/2位(为简单起见，假设n是2的幂)。此处整数用2进制表示。分治1复杂度分析：X乘Y，一共有4次位大整数相乘，3次加法，2次移位。这种分治的复杂度与传统计算方法相比并没有改进。分治2复杂度分析：X乘Y...
Java实现大整数乘法
热门推荐
南 墙
07-21 1万+
1 问题描述 计算两个大整数相乘的结果。 2 解决方案 2.1 蛮力法 package com.liuzhen.chapter5; import java.math.BigInteger; public class BigNumber { /* * 参数A:进行乘法运算的大整数A，用字符串形式表示 * 参数B：进行乘法运算的另一个大整数B，用字符串形式表示 ...
java大数乘法分治_实现利用分治方法实现一种高效的大整数乘法
weixin_29477915的博客
02-25 562
我们可以用小学所学的方法来设计一个计算乘积XY的算法，但是这样做计算步骤太多，显得效率较低。如果将每2个1位数的乘法或加法看作一步运算，那么这种方法要作O(n2)步运算才能求出乘积XY。下面我们用分治法来设计一个更有效的大整数乘积算法。将n位的二进制整数X和Y各分为2段，每段的长为n/2位(为简单起见，假设n是2的幂.由此，X=A*10^(n/2)+B ，Y=C*10^(n/2)+D。这样，X和Y...
用分治法实现大整数乘法java_分治法实现大整数乘法【C++语言】
weixin_28882149的博客
02-27 856
若是实现传统算法中两个n位整数相乘，第一个整数中的n个数字都要分别乘以第二个整数的n个数字，这样就一共要作n*n次乘法。看上去设计一个乘法次数少于n*n的算法是不可能的，但事实证实并不是如此，能够使用分治的思想计算两个大整数的相乘。c++首先从仅有两位数字的两个数12和34考虑，12 = 1 * 10 + 2，34 = 3 * 10 + 4算法把它们相乘：408 = 12 * 34 = (1 * ...
分治法求两个大整数相乘
03-12
### 分治法求两个大整数相乘 #### 一、问题背景及描述 在计算机科学领域，处理大整数的运算是一项常见的需求，尤其是在密码学、数据加密以及某些科学计算场景中。对于传统整数类型（如 `int`, `long` 等）无法表示...
分治法-大整数相乘.docx
最新发布
06-28
【分治法大数相乘】是解决大整数乘法问题的一种高效算法，它将一个大问题分解为若干个小问题来求解。在大整数相乘的问题中，两个整数A和B分别有n位和m位，常规方法是逐位相乘并累加，但这种方法的时间复杂度过高。...
用分治法实现两个二进制数的大整数乘法（带界面）
10-31
大整数分解问题：给定两个n位长二进制数x和y，求这两个数的乘积。时间复杂性控制在Θ(n1.6)
分治法大整数乘法java_分治法解决大整数乘法问题 | 学步园
weixin_42441929的博客
02-26 492
通常，在分析将n位二进制数X和Y都分为两段，每段长n/2位(为简单起见，假设n是2的幂)。则有：其中X1、Xo分别为X的高位和低位，Y1、Yo分别为Y的高位和低位。C2是它们的前半部分的积；Co是它们后半部分的积；C1是X、Y两部分的和的积减去C2与C0的积。如果n/2也是偶数，我们可以利用相同的方法来计算C2、Co的和C1。因此我们就得到了一个计算n位数积的递归算法：在这种完美的形式下,当n变成...
java大整数乘法_java大整数的乘法 | 学步园
weixin_35971787的博客
02-15 653
思路：对于特别大的整数，无法使用long型变量来处理大整数的运算。一种简单的处理方法是使用数组。可以将一个大整数的各个位上的数字存放到一个数组中。对存放结果的数组进行整理，使得数组中的每个元素都不超过10，对于超过10的向前进位最后相乘的结果为989901代码：public class LargeNumberMul {/*** @Title: main* @Description: 两个大整数的乘...
JAVA版大整数相乘
08-02
java写的大整数乘法 可以计算很大的整数
大整数乘法分治法 java,大整数的乘法（分治法）
weixin_34013327的博客
03-11 775
function MULT(X，Y，n); {X和Y为2个小于2n的整数，返回结果为X和Y的乘积XY}beginS:=SIGN(X)*SIGN(Y); {S为X和Y的符号乘积}X:=ABS(X);Y:=ABS(Y); {X和Y分别取绝对值}if n=1 thenif (X=1)and(Y=1) then return(S)else return(0)else beginA:=X的左边n/2位;B:...
分治法大整数乘法java_大整数相乘 + 分治法（JS）
weixin_34343610的博客
02-26 891
使用分治法来实现大整数相乘相乘的基本原理如： 1234 * 567第一步：分解234 -> 12 和 34;567 -> 5 和 67;第二步：分别计算首部: 12*5=60中部：12*67+34*5=974尾部：34*67=2278第三步：进位(因为是以两位数字分割的，所以进位是满100进一位)尾部：留78，进22，即78中部：974+22=996，留96，进9，即96首部：60+9...
用分治法实现大数乘法，加法，减法（java实现）
11-07 190
　　大数乘法即多项式乘法问题，求A(x)与B(x)的乘积C(x)，朴素解法的复杂度O(n^2)，基本思想是把多项式A(x)与B(x)写成 A(x)=a*x^m+b B(x)=c*x^m+d 其中a,b,c,d为x的多项式。 则A(x)*B(x)=(ac)*x^2m+(ad+bc)*x^m+bd 由ad+bc=(a+b)(c+d)-ac-bd 原来的4次乘法和1次加法由3...
分治法求大整数乘法java_大整数乘法(分治法)
weixin_39983912的博客
02-28 295
#include#includeusing namespace std;int num(int u) //计算乘数的位数{int i,num;i=1;num=u/10;while(num!=0){u=num;num=u/10;i=i+1;}//cout<return i;}void MUL(int u,int i,int &w,int &x)//将乘数分治{w=u/(pow...
java大数乘法分治_用分治法实现大数乘法，加法，减法（java实现）
weixin_33628144的博客
02-25 177
packagecom.kyy.sf;public classBigInteger {publicBigInteger() {}//基本思想是把多项式A(x)与B(x)写成//A(x)=a*x^m+b//B(x)=c*x^m+d//其中a,b,c,d为x的多项式。//则A(x)*B(x)=(ac)*x^2m+(ad+bc)*x^m+bd//由ad+bc=(a+b)(c+d)-ac-bd//字符串模拟...
python数值相乘_python里大整数相乘相关技巧指南
weixin_39553757的博客
11-28 807
问题大整数相乘思路说明对于大整数计算，一般都要用某种方法转化，否则会溢出。但是python无此担忧了。Python支持“无限精度”的整数，一般情况下不用考虑整数溢出的问题，而且Python Int类型与任意精度的Long整数类可以无缝转换，超过Int 范围的情况都将转换成Long类型。例如：>>> 2899887676637907866*178877899278834827738994351872...
java---自己实现超大整数的乘法
a823837282的博客
01-23 1168
今天看了一篇博客，它是先把每个位置加起来，最后再进行进位操作，数字够大后，存在溢出可能性。 链接如下：https://blog.csdn.net/baokx/article/details/39005159   注意： 计算较大的阶乘时，eclipse运行的话，前面的结果可以正常输出，后面较大的结果只会输出空白。我在命令行用javac编译运行，得到结果是正常的。   我在他的基础上改了...
分治法详解：大整数乘法的C++实现策略
在本文中，我们将深入探讨如何...总结来说，利用分治法求两个大整数相乘的C++实现，通过字符串处理和递归算法设计，有效地解决了大数乘法问题。这种方法虽然增加了代码复杂性，但确保了在处理大数值时的正确性和效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值