最 小 公 倍 数 算 法 分 析

算法设计与分析：第一章算法分析介绍 1.1求任意三个已知数的最小公倍数
求任意三个已知数的最小公倍数：
自己分析:
分治，看看先求出两个数的最小公倍数，例如8和12最小公倍数为24，再求24与28最小公倍数:
这是可行的。

另一种方法:
12= 2^2 * 3
28 = 2^2 * 7
最小公倍数 = 2^3 * 3 * 7 = 8 * 21 = 168
所以应该先分解质因数，然后用一个数组保存质因子的指数，分解的时候覆盖分解；
如果当前质因子的指数比原来存储的指数要大，则更新
n个数，每个数分解O(n),
12 = 2^2 * 3
最大公约数 = 2^2找到最大的公共指数部分
可以用素数筛选法，选择出10000个素数，来做
iPrimeArr[iNum]中存放的是{2,3,5,7}这种
大牛分析:
为了避免因数重复计算，每次都需要除掉3个整数中已经找到的因数
（即用因数法）
去除含有它的整数。

因此需要记录i具体是哪个数的个数，要对哪个数进行整数。

例如:2是2,5,6中2，6两个数的因数，因此要用2,6去除以2得到新的一组数
例如:8 12 28，
1）找到8与12的公因数4，除掉得2,3，28；记录4
2）找2与28的公因数2，除掉得1,14，3；记录2
3）找到3与14的公因数1，除掉得3,14,1，记录1
判断3个公因数是否存在包含，关系，
最后用剩余的三个数的乘积乘以3次公因数=1*3*14*4*2*1=42*8=336 #include stdio.h
#include string.h
#include math.h
const int MAXSIZE = 10000;
int isPrime(int* pArr,int iLen,int* pPrimeArr)
--memset(pArr,0,sizeof(pArr));--默认全部是不是素数【用0表示】，然后将是合数的翻过来
int m = sqrt(0.5 + iLen);
int iCnt = 0 ;
for(int i = 2 ; i = iLen ; i++)--素数筛选法
if(pArr[i] == 0)--如果当前数是素数,置其倍数为合数；如果当前数
是合数，则不需要重新设置
pPrimeArr[iCnt++] = i;--存储素数
for(int k = i*i ; k = iLen ; k += i)--从平方开始而不从2i开始的原因是，避免重复运算,2*2=4,
pArr[k] = 1;--将素数的倍数置为合数的标记
return iCnt;
int divide(int iNum,int* pTimeArr,int* pPrimeArr,int iPrimeLen) for(int i = 0 ;i iPrimeLen ; i++)
int iCnt = 0;
while( iNum % pPrimeArr[i] == 0)
iNum -= pPrimeArr[i];
if(iCnt pTimeArr[i])
pTimeArr[j] = iCnt;--相同的质因子保留最大的，记录质因数的个数return j;
long long power(int iNum,int iIndex)
if(iIndex == 1)--递归出口
return iNum;
if(iIndex == 0)
return 1;
long long iRet = power(iNum,iIndex-2);
iRet *= iRet;
if(iIndex % 2 == 1)
iRet *= iNum;
return iRet;
long long result(int* pTimeArr,int* pPrimeArr,int iLen) long long lRet = 1;
for(int i = 0 ; i iLen ; i++)
lRet *= power(pPrimeArr[i],pTimeArr[i]);
return lRet;
int max(int a,int b)
return a b ? a : b;
int gcd(int maxNum,int minNum)
return minNum == 0 ? maxNum : gcd(minNum,maxNum%minNum); void swap(int* pNum1,int* pNum2)
int iTemp = *pNum1;
*pNum1 = *pNum2;
*pNum2 = iTemp;
int result2(int a,int b,int c)
swap(a,b);
int lcm = a*b-gcd(a,b);--求取a,b最小公倍数
if(lcm c)
swap(lcm,c);
return lcm*c-gcd(lcm,c);
void process()
int a,b,c;
int iTimeArr[MAXSIZE];
int iNumArr[MAXSIZE];
int iLen = 0;
int iArr[MAXSIZE];
int iPrimeArr[MAXSIZE];
memset(iArr,0,sizeof(iArr));
int iPrimeLen = isPrime(iArr,MAXSIZE,iPrimeArr);
while(EOF != scanf("%d %d %d",a,b,c))
memset(iTimeArr,0,sizeof(iTimeArr));--分解的质因子范围为当前数分解到1为止
iLen = max(iLen, divide(a,iTimeArr,iPrimeArr,iPrimeLen));
iLen = max(iLen, divide(b,iTimeArr,iPrimeArr,iPrimeLen));
iLen = max(iLen, divide(c,iTimeArr,iPrimeArr,iPrimeLen));
printf("%lld",result(iTimeArr,iPrimeArr,iLen));
printf("%d",result2(a,b,c));
int main(int argc,char* argv[])
process();
getchar();
return 0;
lcm = min * (min + 1) - fun_gcd(min + 1, min);
例如:2是2,5,6中2，6两个数的因数，因此要用2,6去除以2得到新
的一组数
27－15＝12( 1512 ) 15－12＝3( 123 )
System.out.println("更相减损法-----递归方式---最大公约数是:" + subDivisor(m, n));
printf("Inputtwointegernumbers:");
14 if ( a%t == 0 b%t ==0 ) break;
printf("Theleastcommonmultiple:%d",m*n-t);
b = new maxDivisor(marr,false)。