最 小 公 倍 数 算 法 分 析

算法设计与分析：第一章算法分析介绍 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得到新