算法1.复数乘积和整数划分问题

设


(1) 算法设计思路

xy=(ac-bd)+(ad+bc)i可以转换成xy=(ac-bd)+((a+b)(c+d)-ac-bd)i，即为一个3次乘法计算。

在对其中的ac，bd,(a+b)(c+d)进行大整数的乘法的分治设计。

把a和c分为2段，每段长为n/2位，分别记为a1，a2和c1，c2，故a=a1*2^(n/2)+a2，c=c1*2(n/2)+c2.则ac=a1c1*2^n+((a1-a2)(c2-c1)+a1c1+a2c2)*2^(n/2)+a2c2。其他bd，和(a+b)(c+d)同理。采用递归的方法将xy划分，递归结束条件为位数剩下1.

(2) 算法实现的伪代码

功能描述：计算a,b的乘积

输入：a,b（均为非负整数）

输出：a*b的结果

fun(stringa,string b){

int n=a.length();

ing m=b.length();

if (n=1||m=1) return a*b;

long a1=(long)substring(0,n/2)//取左半边

long a2=(long)substring(n/2,n)取右半边

long b1=(long)substring(0,m/2)

long b2=(long)substring(m/2,m)

return long x=(long)(fun(a1,b1)*pow(10,a2.length()+b2.length())+fun(a1,b2)*pow(10,a2.length())+fun(a2,b1)*pow(10,b2.length)+fun(a2,b2))

}

(3) 实现代码

import java.util.*;
public class main {
static public long fun(String a,String b){
long sum=0;
long a0=Long.parseLong(a);//将a转换成整数
long b0=Long.parseLong(b);
int n=a.toString().length();//获取a的长度
int m=b.toString().length();
if (n==1||m==1)
return a0*b0;//如果长度为1，则返回，结束递归
String a1=a.toString().substring(0, n/2);//获取a的左半边
String a2=a.toString().substring(n/2, n);//获取a的右半边
String b1=b.toString().substring(0, m/2);//获取b的左半边
String b2=b.toString().substring(m/2, m);//获取b的右半边
//运用公式直接运算，ac=a1c1*2^n+((a1-a2)(c2-c1)+a1c1+a2c2)*2^(n/2)+a2c2
sum=(long)(fun(a1,b1)*Math.pow(10,a2.length()+
b2.length())+fun(a1,b2)*Math.pow(10,a2.length())
+fun(a2,b1)*Math.pow(10,b2.length())+fun(a2,b2));
return sum;
}
public static void main(String []args){
Scanner in=new Scanner(System.in);
while(true){
System.out.println("输入，a,b,c,d");
System.out.println("分别表示x=a+bi 和 y=c+di");
//录入数据
String a=in.next();
String b=in.next();
String c=in.next();
String d=in.next();
long c0=Long.parseLong(c)+Long.parseLong(d);//将数据从字符串转化成long
long b0=Long.parseLong(b)+Long.parseLong(a);
//将long转换成字符串
String ab=String.valueOf(b0);
String cd=String.valueOf(c0);
//调用函数
long num1=fun(a, c);
long num2=fun(ab, cd);
long num3=fun(b, d);
System.out.println("x*y="+(num1-num3)+"+"+(num2-num1-num3)+"i");
System.out.println();
}
}
}

(4) 算法运行结果及计算时间复杂度分析



时间复杂度：该方法主要是运用了大整数乘法的分治运算，

T(n)=O(1), n=1

3T(n/2)+O(n), n>1

T(n)=O(n^log3)

(5) 体会

在考虑问题的时候，根据课本的知识进一步思考，如果两个整数的位数不一样，并且有可能为奇数，所以采用n/2划分的时候有可能会少了一位，所以使用字符串来录入数据。当2个整数的位数不一样的时候，构造的方法和构造位数一样的方法差不多。编写的过程中多次需要将字符串转换成long和将long转换成字符串。



{6}；

{5+1}；

{4+2}，{4+1+1}；

{3+3}，{3+2+1}，{3+1+1+1}；

{2+2+2}，{2+2+1+1}，{2+1+1+1+1}；

{1+1+1+1+1+1}。

(1) 算法设计思路

设q（n，i），表示对n进行i划分

当n=1或者i=1时，q（n，i）=1

当n

import java.util.*;
public class huafen {
public static void main(String []args){
Scanner in=new Scanner(System.in);
while (true){
System.out.println("输入要划分的正整数");
int n=in.nextInt();
int c=huafen(n, n);
System.out.println("正整数 "+n+" 有 "+c+" 种不同的划分方案");
System.out.println();
}
}
static int huafen(int n,int i){
if (n<1||i<1) //当n或者i小于1时，没有划分结果，直接返回0
return 0;
else if (n==1||i==1)//当n或者i=1时，只有一种划分结果
return 1;
else if (n<i)//当n<i最大的划分即为huafen（n,n）=1
return huafen(n,n);
else if (n==i)//当n=i，划分为n1=n和n1=n-1组成
return huafen(n,n-1)+1;
return huafen(n,i-1)+huafen(n-i,i);//划分为n1=i，和n1<=i-1组成
}
}

(3) 算法运行结果及计算时间复杂度分析



时间复杂度O（NlogN）

(4) 体会

递归算法的结构比较清晰，但是运行效率比较低和花费的计算时间长，占用的存储空间多。对于该问题，先分析划分的大小，一般先考虑特殊值，例如i<1，i=1，i=n，i>n，最后再考虑i