大整数乘法---分治

分治法：

1 将问题的实例划分成同一个问题的较小的实例，最好拥有同样的规模

2 对这些较小的实例求解（一般使用递归方法，但在问题规模足够小的时候，可能会利用另一个算法）

3 如果必要的话，合并这些较小问题的解，以得到原问题的解。

自己理解看来，首先分治法重点的步骤在于合并，因为小问题求解肯定是很简单的，重点步骤在于合并小问题得到原问题的解。

大整数问题

计算公式：

a = a0a1; b = b0b1

c = a x b = c2*10^2 + c1*10 + c0

其中c1可以转化为c1 = (a1 + a0) * (b1 + b0 ) - (c2 + c0)

但是我就算知道计算公式，知道分治思想，还是写不出代码来，下面是别人的代码，必须承认写这个算法的人是个大牛：

public class BigIntMultiply
{

//规模只要在这个范围内就可以直接计算了
private final static int SIZE = 4;

// 此方法要保证入参len为X、Y的长度最大值
private static String bigIntMultiply(String X, String Y, int len)
{
// 最终返回结果
String str = "";
// 补齐X、Y，使之长度相同
X = formatNumber(X, len);
Y = formatNumber(Y, len);

// 少于4位数，可直接计算
if (len <= SIZE)
{
return "" + (Integer.parseInt(X) * Integer.parseInt(Y));
}

// 将X、Y分别对半分成两部分
int len1 = len / 2;
int len2 = len - len1;
String A = X.substring(0, len1);
String B = X.substring(len1);
String C = Y.substring(0, len1);
String D = Y.substring(len1);

// 乘法法则，分块处理
int lenM = Math.max(len1, len2);
String AC = bigIntMultiply(A, C, len1);
String AD = bigIntMultiply(A, D, lenM);
String BC = bigIntMultiply(B, C, lenM);
String BD = bigIntMultiply(B, D, len2);

// 处理BD，得到原位及进位
String[] sBD = dealString(BD, len2);

// 处理AD+BC的和
String ADBC = addition(AD, BC);
// 加上BD的进位
if (!"0".equals(sBD[1]))
{
ADBC = addition(ADBC, sBD[1]);
}

// 得到ADBC的进位
String[] sADBC = dealString(ADBC, lenM);

// AC加上ADBC的进位
AC = addition(AC, sADBC[1]);

// 最终结果
str = AC + sADBC[0] + sBD[0];

return str;
}

// 两个数字串按位加
private static String addition(String ad, String bc)
{
// 返回的结果
String str = "";

// 两字符串长度要相同
int lenM = Math.max(ad.length(), bc.length());
ad = formatNumber(ad, lenM);
bc = formatNumber(bc, lenM);

// 按位加，进位存储在temp中
int flag = 0;

// 从后往前按位求和
for (int i = lenM - 1; i >= 0; i--)
{
int t =
flag + Integer.parseInt(ad.substring(i, i + 1))
+ Integer.parseInt(bc.substring(i, i + 1));

// 如果结果超过9，则进位当前位只保留个位数
if (t > 9)
{
flag = 1;
t = t - 10;
}
else
{
flag = 0;
}

// 拼接结果字符串
str = "" + t + str;
}
if (flag != 0)
{
str = "" + flag + str;
}
return str;
}

// 处理数字串，分离出进位；
// String数组第一个为原位数字，第二个为进位
private static String[] dealString(String ac, int len1)
{
String[] str = {ac, "0"};
if (len1 < ac.length())
{
int t = ac.length() - len1;
str[0] = ac.substring(t);
str[1] = ac.substring(0, t);
}
else
{
// 要保证结果的length与入参的len一致，少于则高位补0
String result = str[0];
for (int i = result.length(); i < len1; i++)
{
result = "0" + result;
}
str[0] = result;
}
return str;
}

// 乘数、被乘数位数对齐
private static String formatNumber(String x, int len)
{
while (len > x.length())
{
x = "0" + x;
}
return x;
}

//测试桩
public static void main(String[] args)
{
// 正则表达式：不以0开头的数字串
String pat = "^[1-9]\\d*$";
Pattern p = Pattern.compile(pat);

// 获得乘数A
System.out.println("请输入乘数A（不以0开头的正整数）：");
Scanner sc = new Scanner(System.in);
String A = sc.nextLine();
Matcher m = p.matcher(A);
if (!m.matches())
{
System.out.println("数字不合法！");
return;
}

// 获得乘数B
System.out.println("请输入乘数B（不以0开头的正整数）：");
sc = new Scanner(System.in);
String B = sc.nextLine();
m = p.matcher(B);
if (!m.matches())
{
System.out.println("数字不合法！");
return;
}
System.out.println(A + " * " + B + " = "
+ bigIntMultiply(A, B, Math.max(A.length(), B.length())));
}
}

总结来说，当自己动手写大整数相乘时，大概步骤我还是知道怎么写的，但是数位相加和将数位分离这两个函数是我没有想到的。
通过数位分离将树分离成了进位，那么可以将字符串合并。

但是这个算法有一个美中不足的地方，就是使用了4次相乘，最后的时间复杂度为M(n) = 4 ^ log 2 n = n^2

如果使用c1的计算公式，那么算法的4次乘法就可以转化为3次乘法，那么时间复杂度就可以转为为n^1.585，这就是我要完成的任务了~