在李志的贴子里已经回复了。高手谈不上，不过我也很喜欢你和李志兄弟。有时间我们多交流吧!

老杨你好。

我觉的这个主要是精度的问题，之前有做过类似的求大数的题，思路是把用数组存放结果，化成十进制的每一位都存放在数组中，这种情况可能会使用内存超限，可以试试，不行的话再讨论。

Devil_Wang    姝ｇ‘    619ms    84KB    g++    11-01 23:01

#include <deque>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

class DividedByZeroException{};

class BigInteger
{
private:
     vector<char> digits; 
     bool sign;          //  true for positive, false for negitive
     void trim();        //  remove zeros in tail, but if the value is 0, keep only one:)
public:
     BigInteger(int);    // construct with a int integer
     BigInteger(string&) ;
     BigInteger();
     BigInteger (const BigInteger&);
     BigInteger operator=(const BigInteger& op2);

     BigInteger      abs() const;
     BigInteger    pow(int a);

     //binary operators
        
     friend BigInteger operator+=(BigInteger&,const BigInteger&);
     friend BigInteger operator-=(BigInteger&,const BigInteger&);
     friend BigInteger operator*=(BigInteger&,const BigInteger&);
     friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
     friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException);       

     friend BigInteger operator+(const BigInteger&,const BigInteger&);
     friend BigInteger operator-(const BigInteger&,const BigInteger&);
     friend BigInteger operator*(const BigInteger&,const BigInteger&);
     friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
     friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
   

     //uniary operators
     friend BigInteger operator-(const BigInteger&);   //negative

     friend BigInteger operator++(BigInteger&);        //++v
     friend BigInteger operator++(BigInteger&,int);    //v++
     friend BigInteger operator--(BigInteger&);        //--v
     friend BigInteger operator--(BigInteger&,int);    //v--

     friend bool operator>(const BigInteger&,const BigInteger&);
     friend bool operator<(const BigInteger&,const BigInteger&);
     friend bool operator==(const BigInteger&,const BigInteger&);
     friend bool operator!=(const BigInteger&,const BigInteger&);
     friend bool operator>=(const BigInteger&,const BigInteger&);
     friend bool operator<=(const BigInteger&,const BigInteger&);

     friend ostream& operator<<(ostream&,const BigInteger&);    //print the BigInteger
     friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger

public:
     static const BigInteger ZERO;
     static const BigInteger ONE;
     static const BigInteger TEN;
};

const BigInteger BigInteger::ZERO=BigInteger(0);
const BigInteger BigInteger::ONE =BigInteger(1);
const BigInteger BigInteger::TEN =BigInteger(10);


BigInteger::BigInteger()
{
    sign=true; 
}


BigInteger::BigInteger(int val){// construct with a int integer
    if (val >= 0)
        sign = true;
    else{
        sign = false;
        val *= (-1);
    }
    do{
        digits.push_back( (char)(val%10) );
        val /= 10;
    } while ( val != 0 );
}


BigInteger::BigInteger(string& def){
    sign=true;
    for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++){
        char ch = (*iter);
        if (iter == def.rend()-1){
            if ( ch == '+' )
                break;
            if(ch == '-' ){
                sign = false;
                break;
            }
        }
        digits.push_back( (char)((*iter) - '0' ) );
    }
    trim();
}

void BigInteger::trim(){
    vector<char>::reverse_iterator iter = digits.rbegin();
    while(!digits.empty() && (*iter) == 0){
        digits.pop_back();
        iter=digits.rbegin();
    }
    if( digits.size()==0 ){
        sign = true;
        digits.push_back(0);
    }
}


BigInteger::BigInteger(const BigInteger& op2){
    sign = op2.sign;
    digits=op2.digits;
}


BigInteger BigInteger::operator=(const BigInteger& op2){
    digits = op2.digits;
    sign = op2.sign;
    return (*this);
}


BigInteger BigInteger::abs() const {
    if(sign)  return *this;
    else      return -(*this);
}


BigInteger BigInteger::pow(int a) 
{
    BigInteger res(1);
    for(int i=0; i<a; i++)
        res*=(*this);
    return res;
}


//binary operators
BigInteger operator+=(BigInteger& op1,const BigInteger& op2){
    if( op1.sign == op2.sign ){     //鍙??鐞嗙浉鍚岀殑绗﹀彿鐨勬儏鍐碉紝寮傚彿鐨勬儏鍐电粰-澶勭悊
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
        char to_add = 0;        //杩涗綅
        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
            (*iter1) = (*iter1) + (*iter2) + to_add;
            to_add = ((*iter1) > 9);    // 澶т簬9杩涗竴浣?            (*iter1) = (*iter1) % 10;
            iter1++; iter2++;
        }
        while ( iter1 != op1.digits.end() ){   // 
            (*iter1) = (*iter1) + to_add;
            to_add = ( (*iter1) > 9 );
            (*iter1) %= 10;
            iter1++;
        }
        while ( iter2 != op2.digits.end() ){
            char val = (*iter2) + to_add;
            to_add = (val > 9) ;
            val %= 10;
            op1.digits.push_back(val);
            iter2++;
        }
        if( to_add != 0 )
            op1.digits.push_back(to_add);
        return op1;
    }
    else{
        if (op1.sign)
            return op1 -= (-op2);
        else
            return op1= op2 - (-op1);
    }

}

BigInteger operator-=(BigInteger& op1,const BigInteger& op2){
    if( op1.sign == op2.sign ){
        if(op1.sign) { 
            if(op1 < op2)
                return  op1=-(op2 - op1);
        } 
        else {
            if(-op1 > -op2) 
                return op1=-((-op1)-(-op2));
            else            
                return op1= (-op2) - (-op1);
        }
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();

        char to_substract = 0;  

        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end()){
            (*iter1) = (*iter1) - (*iter2) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 ){
                to_substract=1;
                (*iter1) += 10;
            }
            iter1++;
            iter2++;
        }
        while ( iter1 != op1.digits.end() ){
            (*iter1) = (*iter1) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 ){
                to_substract=1;
                (*iter1) += 10;
            }
            else break;
            iter1++;
        }
        op1.trim();
        return op1;
    }
    else{
        if (op1 > BigInteger::ZERO)
            return op1 += (-op2);
        else
            return op1 = -(op2 + (-op1));
    }
}
BigInteger operator*=(BigInteger& op1,const BigInteger& op2){
    BigInteger result(0);
    if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
        result = BigInteger::ZERO;
    else{
        vector<char>::const_iterator iter2 = op2.digits.begin();
        while( iter2 != op2.digits.end() ){
            if(*iter2 != 0){
                deque<char> temp(op1.digits.begin() , op1.digits.end());
                char to_add = 0;
                deque<char>::iterator iter1 = temp.begin();
                while( iter1 != temp.end() ){
                    (*iter1) *= (*iter2);
                    (*iter1) += to_add;
                    to_add = (*iter1) / 10;
                    (*iter1) %= 10;
                    iter1++;
                }
                if( to_add != 0)
                    temp.push_back( to_add );
                int num_of_zeros = iter2 - op2.digits.begin();
                while(  num_of_zeros--)
                    temp.push_front(0);
                BigInteger temp2;
                temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );
                temp2.trim();
                result = result + temp2;
            }
            iter2++;
        }
        result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    }
    op1 = result;
    return op1;
}

BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException) {
    if( op2 == BigInteger::ZERO )
        throw DividedByZeroException();
    BigInteger t1 = op1.abs(), t2 = op2.abs();
    if ( t1 < t2 ){
        op1 = BigInteger::ZERO;
        return op1;
    }
  
  
    deque<char> temp;
    vector<char>::reverse_iterator iter = t1.digits.rbegin();

    BigInteger temp2(0);
    while( iter != t1.digits.rend() ){
        temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );
        char s = 0;
        while( temp2 >= t2 ){
            temp2 = temp2 - t2;
            s = s + 1;
        }
        temp.push_front( s );
        iter++;
    }
    op1.digits.clear();
    op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );
    op1.trim();
    op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    return op1;
}

BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    return op1 -= ((op1 / op2)*op2);
}

BigInteger operator+(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp += op2;
    return temp;
}
BigInteger operator-(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp -= op2;
    return temp;
}

BigInteger operator*(const BigInteger& op1,const BigInteger& op2){
    BigInteger temp(op1);
    temp *= op2;
    return temp;

}

BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp /= op2;
    return temp;
}

BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException) {
    BigInteger temp(op1);
    temp %= op2;
    return temp;
}


BigInteger operator-(const BigInteger& op){ 
    BigInteger temp = BigInteger(op);
    temp.sign = !temp.sign;
    return temp;
}

BigInteger operator++(BigInteger& op){   
    op += BigInteger::ONE;
    return op;
}

BigInteger operator++(BigInteger& op,int x){
    BigInteger temp(op);
    ++op;
    return temp;
}

BigInteger operator--(BigInteger& op){   
    op -=  BigInteger::ONE;
    return op;
}

BigInteger operator--(BigInteger& op,int x){
    BigInteger temp(op);
    --op;
    return temp;
}

bool operator<(const BigInteger& op1,const BigInteger& op2){
    if( op1.sign != op2.sign )
        return !op1.sign;
    else{
        if(op1.digits.size() != op2.digits.size())
            return (op1.sign && op1.digits.size()<op2.digits.size())
        || (!op1.sign && op1.digits.size()>op2.digits.size());
        vector<char>::const_reverse_iterator iter1,iter2;
        iter1 = op1.digits.rbegin();iter2 = op2.digits.rbegin();
        while( iter1 != op1.digits.rend() ){
            if(  op1.sign &&  *iter1 < *iter2 ) return true;
            if(  op1.sign &&  *iter1 > *iter2 ) return false;
            if( !op1.sign &&  *iter1 > *iter2 ) return true;
            if( !op1.sign &&  *iter1 < *iter2 ) return false;
            iter1++;
            iter2++;
        }
        return false;
    }
}
bool operator==(const BigInteger& op1,const BigInteger& op2){
    if( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )
        return false;
    vector<char>::const_iterator iter1,iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    while( iter1!= op1.digits.end() ){
        if( *iter1 != *iter2 )  return false;
        iter1++;
        iter2++;
    }
    return true;
}

bool operator!=(const BigInteger& op1,const BigInteger& op2){
    return !(op1==op2);
}

bool operator>=(const BigInteger& op1,const BigInteger& op2){
    return (op1>op2) || (op1==op2);
}

bool operator<=(const BigInteger& op1,const BigInteger& op2){
    return (op1<op2) || (op1==op2);
}

bool operator>(const BigInteger& op1,const BigInteger& op2){
    return !(op1<=op2);
}

ostream& operator<<(ostream& stream,const BigInteger& val){    //print the BigInteger
    if (!val.sign)
        stream << "-";
    for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend() ; iter++)
        stream << (char)((*iter) + '0');
    return stream;
}

istream& operator>>(istream& stream, BigInteger& val){    //Input the BigInteger
    string str;
    stream >> str;
    val=BigInteger(str);
    return stream;
}

BigInteger gcd (BigInteger m, BigInteger n)
{
        if( m < n )
                std::swap(m,n);
        if ( n == BigInteger(0))
                return m;
        return gcd(n,m%n);
}

BigInteger lcm(BigInteger m, BigInteger n)
{
        return m * n /gcd(m,n);
}

int main()
{
        std::string b1,b2;
        do
        {
                std::cin>>b1>>b2;
                if ( b1 == b2 && b1 == "0" )
                        break;
                BigInteger ret = lcm(BigInteger(b1), BigInteger(b2));
                std::cout<<ret<<std::endl;
        }while(1);
}

搞定了。秀一下成绩吧算法就是针对题目构造了自己的大数乘、除、求模运算法则。其中除法和求模运算用循环减法实现，效率还不错。
代码先看看，有问题的地方咱们再交流。

#include<stdio.h>
#include<string.h>
void output(char * a, int an)
{
    int i;
    for(i = an - 1; i >= 0; i--) putchar(a[i] + '0');
    putchar('\n');
}
void format(char * a, int an)
{
    int i, j;
    char t;
    for(i = 0, j = an - 1; i < j; i++, j--)
    {
        a[i] -= '0';
        a[j] -= '0';
        t = a[i];
        a[i] = a[j];
        a[j] = t;
    }
    if(i == j) a[i] -= '0';
}
void mul(char * a, int * an, char * b, int bn)
{
    char t[256], s[256] = {0};
    int i, j, k, f;
    for(i = 0; i < bn; i++)
    {
        if(b[i] == 0) continue;
        for(j = 0; j < i; t[j++] = 0);
        for(f = 0, k = 0; k < *an; k++)
        {
            t[j] = b[i] * a[k] + f;
            f = t[j] / 10;
            t[j++] %= 10;
        }
        if(f) t[j++] = f;
        for(f = 0, k = 0; k < j; k++)
        {
            s[k] += t[k] + f;
            if(s[k] >= 10){ s[k] -= 10; f = 1;} else f = 0;
        }
        if(f)s[j++] = 1;
    }
    for(i = 0; i < j; a[i] = s[i++]);
    *an = j;
}
void div(char * a, int * an, char * b, int bn)
{
    char t[256], r[256] = {0};
    int f, i, j;
    if(*an < bn)
    {
        a[0] = 0;
        a[1] = 0;
        *an = 1;
        return;
    }
    for(i = *an - bn; i >= 0; i--)
    {
        for(f = 0, j = 0; j < bn; j++)
        {
            t[j] = a[i + j] - b[j] - f;
            if(t[j] < 0){ t[j] += 10; f = 1;} else f = 0;
        }
        if(a[bn + i] - f >= 0)
        {
            a[bn + i] -= f;
            for(j = 0; j < bn; a[i + j] = t[j++]);
            r[i]++;
            i++;
        }
    }
    for(i = *an - bn; i && !r[i]; i--);
    for(j = i; j >= 0; a[j] = r[j--]);
    *an = i + 1;
    a[*an] = 0;
}
void mod(char * a, int * an, char * b, int bn)
{
    char t[256];
    int f, i, j;
    if(*an < bn) return;
    for(i = *an - bn; i >= 0; i--)
    {
        for(f = 0, j = 0; j < bn; j++)
        {
            t[j] = a[i + j] - b[j] - f;
            if(t[j] < 0){ t[j] += 10; f = 1;} else f = 0;
        }
        if(a[bn + i] - f >= 0)
        {
            a[bn + i] -= f;
            for(j = 0; j < bn; a[i + j] = t[j++]);
            i++;
        }
    }
    for(i = bn - 1; i && !a[i]; i--);
    *an = i + 1;
}
void lcm(char *a, int * an, char *b, int bn)
{
    char ta[256], tb[256], *pa, *pb, *pt;
    int pan, pbn, ptn, i;
    for(i = 0; i <= *an; ta[i] = a[i++]);
    for(i = 0; i <= bn; tb[i] = b[i++]);
    pa = ta;
    pb = tb;
    pan = *an;
    pbn = bn;
    mod(pa, &pan, pb, pbn);
    while(pan > 1 || pa[0])
    {
        pt = pa;
        pa = pb;
        pb = pt;
        ptn = pan;
        pan = pbn;
        pbn = ptn;
        mod(pa, &pan, pb, pbn);
    }
    div(a, an, pb, pbn);
    mul(a, an, b, bn);
}
int main()
{
    char a[256], b[256];
    int an, bn;
    while(scanf("%s %s", a, b), a[0] > '0')
    {
        an = strlen(a);
        bn = strlen(b);
        format(a, an);
        format(b, bn);
        lcm(a, &an, b, bn);
        output(a, an);
    }
    return 0;
}

佳楠也搞定了，还在做优化？
比赛时允许带样例代码吗？这些代码很有复用价值。

杨大哥，你的代码没研究懂，能解释下么？

更相减损术，配合高精度

这下明白了，我说怎么各种数乱减能得出结果吗，原来是这么回事，谢谢了

更相减损术，呵呵，好炫的名字，头一回听说。

于是查了一下相关资料，原来出自《九章算术》，不过看完之后我失望，不是我用的算法。

奇怪的是，我用的不是更相减损术，但蔡兄弟怎么就明白了呢？

就计算最大公约数的部分，我用的依然是辗转相除法。只不过我构造了需要在大数乘法、除法和求模的方法。

大数乘法就不说了，是很初级的方法，我称之为小学生算法。

大数除法是用循环减法实现的。首先使被除数与除数在最高位（十进制）对齐，然后用被除数的对应位减去除数。循环执行这一步，直至被除数的对应位以小于除数。这时做减法的次数为商在该位的值。将除数相后移一位，重复上述过程，计算商的下一位。

求模的过程和除法几乎是一样的，只不过不记录相减的次数。

在准备应用这一算法前我做过它的复杂度评估。

先是大数减法，我需要按位做减法，其复杂度为O(n)。对于100位的数，一次大数减法我需要做最多100次计算机整数减法运算。

然后是除法，每求1位最多需要做10次大数减法运算（我将数的比较与减法柔和在了一起），对于两个位长相同的大数其相除结果肯定<=9，也就是说我只需求1位。对于被除数小于除数的两个大数，其商为0，判断这一点也只需要做1次大数减法运算。

对于被除数位长大于除数位长的情况，设被除数位长为y，除数位长为x，（y > x)，则需要求y-x+1位，略去常数项为y-x

而每位最多10次大数减法，每次大数减法需要做x次计算机整数减法。综合后就是10x*(y-x)次整数减法运算。

对于本题的定义域，x,y <= 100。对上面的二元函数求偏导后可知极限值出现在x = 50, y = 100时，这时10x * (y-x) = 10 * 50 * 50 = 25000。

也就是说为完成一次除法运算，我最多需要做25000次正常的减法运算。

这个运算量够大吗？还好，在我能接受的范围内，毕竟你我的计算机现在每秒钟都能做上亿次这样的运算。

而辗转相除法对除法运算的需要量约为除数的位数（不超过5倍）。

之后，再做一次除法、一次乘法即可得出最小公倍数。

综上估算25000 * 50 * 5 / 100000000 = 0.0625

也就是说应该可以在60毫秒以内完成。

据此，我实施了这一算法，提交结果证明，它在我预计的最长时间内完成了任务。

也证明，题目的样本中，没有我预想的极限数据。

好吧，我没仔细看你的代码，看你前面说的话猜的，我看他8s的时限用更相减损术貌似可以ac，我错了