高精度算法总结

一句话：只需将两个大数按照竖式模拟计算即可！

高精度加法：

题解报告：hdu 1002 A + B Problem II

Problem Description

I have a very simple problem for you. Given two integers A and B, your job is to calculate the Sum of A + B.

Input

The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line consists of two positive integers, A and B. Notice that the integers are very large, that means you should not process them by using 32-bit integer. You may assume the length of each integer will not exceed 1000.

Output

For each test case, you should output two lines. The first line is "Case #:", # means the number of the test case. The second line is the an equation "A + B = Sum", Sum means the result of A + B. Note there are some spaces int the equation. Output a blank line between two test cases.

Sample Input

2

1 2

112233445566778899 998877665544332211

Sample Output

Case 1:

1 + 2 = 3

 

Case 2:

112233445566778899 + 998877665544332211 = 1111111111111111110

解题思路：大数加法，简单模拟竖式运算或者直接调用java中BigInteger大数类的add()方法即可。

AC之C++代码：时间复杂度为O(n)。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e5+5;
const int inf = 0x3f3f3f3f;

int t, now, tmp;
string a, b, r;
bool flag;

int main(){
    while(cin >> t){
        flag = true;
        for(int i = 1; i <= t; ++i){
            cin >> a >> b;
            tmp = 0, r = "";
            if(!flag) puts("");
            cout << "Case " << i << ":
" << a << " + " << b << " = ";
            if(a.size() > b.size()) swap(a, b);
            for(int i = a.size() - 1, j = b.size() - 1; ~j; --i, --j){
                now = (i >= 0 ? a[i] - '0' : 0) + b[j] - '0' + tmp;
                tmp = now > 9 ? 1 : 0;
                now = now > 9 ? now - 10 : now;
                r += '0' + now;
            }
            if(tmp) r += '1'; //如果还有进位，则高位补1
            for(int i = r.size() - 1; ~i; --i) cout << r[i];
            puts(""); flag = false;
        }
    }
    return 0;
}

AC之java代码：

import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        BigInteger a, b;
        for(int i = 1; i <= t; ++i){
            a = scan.nextBigInteger();
            b = scan.nextBigInteger();
            System.out.println("Case " + i + ":");
            System.out.println(a + " + " + b + " = " + a.add(b));
            if(i != t) System.out.println();
        }    
    }
}

高精度乘法：

蓝桥杯 算法提高 P1001  

时间限制：1.0s   内存限制：256.0MB

当两个比较大的整数相乘时，可能会出现数据溢出的情形。为避免溢出，可以采用字符串的方法来实现两个大数之间的乘法。具体来说，首先以字符串的形式输入两个整数，每个整数的长度不会超过8位，然后把它们相乘的结果存储在另一个字符串当中（长度不会超过16位），最后把这个字符串打印出来。例如，假设用户输入为：62773417和12345678，则输出结果为：774980393241726.
输入：
62773417 12345678
输出：
774980393241726

注意：特判输入有0的情况！

AC之C++代码：时间复杂度为O(n^2)。此方法适用于两个位数不大的大数做乘法运算。（没有做压位运算）

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 10;
const int inf = 0x3f3f3f3f;

char s1[maxn], s2[maxn];
int m1, m2, a[maxn], b[maxn], carry, ans[maxn << 1]; //2倍
bool flag;

int main() {
    while(cin >> s1 >> s2) {
        memset(ans, 0, sizeof(ans));
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        m1 = strlen(s1), m2 = strlen(s2), carry = 0;
        if((m1 == 1 && s1[0] == '0') || (m2 == 1 && s2[0] == '0')) {puts("0"); continue;} //特判0
        for(int i = m1 - 1; ~i; --i) a[m1 - 1 - i] = s1[i] - '0';
        for(int i = m2 - 1; ~i; --i) b[m2 - 1 - i] = s2[i] - '0';
        for(int i = 0; i < m2; ++i) {
            for(int j = 0; j < m1; ++j) {
                ans[j + i] += a[j] * b[i] + carry;
                if(ans[j + i] > 9) carry = ans[j + i] / 10, ans[j + i] %= 10;
                else carry = 0;
            }
            if(carry) ans[i + m1] += carry, carry = 0;
        }
        flag = false;
        for(int i = m1 + m2 - 1; ~i; --i) { //最多有m1 + m2位数
            if(!flag && !ans[i]) continue;
            flag = true;
            cout << ans[i];
        }
        puts("");
    }
    return 0;
}

AC之java代码：

import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        BigInteger a, b;
        while(scan.hasNext()) {
            a = scan.nextBigInteger();
            b = scan.nextBigInteger();
            System.out.println(a.multiply(b));
        }
    }
}

题解报告：hdu 1042 N!

Problem Description

Given an integer N(0 ≤ N ≤ 10000), your task is to calculate N!

Input

One N in one line, process to the end of file.

Output

For each N, output N! in one line.

Sample Input

1 2 3

Sample Output

1 2 6

AC之C++代码：高精度乘法压5位。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 7200; // log_10^(10000!) ≈ 35560，压5位，则最多存35560 / 5 约等于7200
const int inf = 0x3f3f3f3f;

int n, cnt, carry, ans[maxn];

int main() {
    while(cin >> n) {
        memset(ans, 0, sizeof(ans));
        cnt = carry = 0;
        ans[cnt++] = 1;
        for(int i = 2; i <= n; ++i) {
            for(int j = 0; j < cnt; ++j) {
                ans[j] = ans[j] * i + carry; // 先乘再累加进位
                if(ans[j] > 99999) carry = ans[j] / 100000, ans[j] %= 100000;
                else carry = 0;
            }
            if(carry) ans[cnt++] = carry, carry = 0; //放到下一位，同时进位置0
        }
        printf("%d", ans[cnt - 1]); //先输出最高位，余下五位五位输出
        for(int j = cnt - 2; j >= 0; --j)
            printf("%05d", ans[j]); // 不足补0
        puts("");
    }
    return 0;
}

高精度减法：

luogu P2142 高精度减法

题目描述

高精度减法

输入格式：
两个整数a,b（第二个可能比第一个大）

输出格式：
结果（是负数要输出负号）

输入输出样例
输入样例#1：
2
1
输出样例#1：
1
说明
20%数据a,b在long long范围内
100%数据0<a,b<=10的10000次方

AC之C++代码：时间复杂度是O(n)。注意：做减法时，被减数要大于减数！！！

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <deque>
#include <queue>
#include <stack>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e4+5;
const int inf = 0x3f3f3f3f;

char s1[maxn], s2[maxn];
int m1, m2, maxL, a[maxn], b[maxn], ans[maxn];
bool op1, op2, flag;

int main() {
    while(cin >> s1 >> s2) {
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        memset(ans, 0, sizeof(ans));
        if(!strcmp(s1, s2)) {puts("0"); continue;}
        op1 = (s1[0] == '-') ? true : false;
        op2 = (s2[0] == '-') ? true : false;
        m1 = strlen(s1), m2 = strlen(s2);
        for(int i = op1 ? 1 : 0, k = op1 ? 0 : 1; i < m1; ++i) a[i - !k] = (s1[m1 - k - i] - '0');
        for(int i = op2 ? 1 : 0, k = op2 ? 0 : 1; i < m2; ++i) b[i - !k] = (s2[m2 - k - i] - '0');
        maxL = max(m1, m2);
        if((op1 && !op2) || (!op1 && op2)) { // 负、正 --> 负；正、负 --> 正
            if(op1 && !op2) cout << '-';
            for(int j = 0; j < maxL; ++j) { //加法运算
                ans[j] += a[j] + b[j];
                ans[j + 1] += ans[j] > 9 ? 1 : 0; //进位
                ans[j] = ans[j] > 9 ? ans[j] - 10 : ans[j];
            }
        }
        else {
            if(!op1) {
                if(m1 < m2 || (m1 == m2 && strcmp(s1, s2) < 0)) cout << '-', swap(a, b); //正、正 --> 正，交换
            }
            else if(op2) {
                if(m1 > m2 || (m1 == m2 && strcmp(s1, s2) > 0)) cout << '-'; //负、负 --> s1 > s2 -- > 负数，不交换
                else swap(a, b);
            }
            for(int j = 0; j < maxL; ++j) { //减法运算
                if(a[j] < b[j]) a[j + 1]--, a[j] += 10; //借位
                ans[j] = a[j] - b[j];
            }
        }
        flag = false;
        for(int j = maxL; ~j; --j) { //多处理一个进位项的系数
            if(!flag && !ans[j]) continue; //去掉前导0
            flag = true;
            cout << ans[j];
        }
        puts("");
    }
    return 0;
}

AC之java代码：

import java.util.Scanner;
import java.math.BigInteger;
public class Main {
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        BigInteger a, b;
        while(scan.hasNext()) {
            a = scan.nextBigInteger();
            b = scan.nextBigInteger();
            System.out.println(a.subtract(b));
        }
    }
}