7.高精度加法

1.题目

给定两个正整数，计算它们的和。

输入格式
共两行，每行包含一个整数。

输出格式
共一行，包含所求的和。

数据范围

1≤整数长度≤100000

输入样例：

12

23

输出样例：

35

2.解题

两个大数相加，会造成越界的问题，所以需要将两个大数存放至数组，然后相加

（1）存放大数到数组

从前往后倒序存储，便于进位的计算

（2）计算进位

java:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String x = in.readLine();
        String y = in.readLine();

        int[] x_arr = new int[x.length()];
        int[] y_arr = new int[y.length()];
        int[] res = new int[Math.max(x.length(), y.length()) + 1];

        for (int i = x.length() - 1, j = 0; i >= 0; i--, j++) {
            // x_arr[j] = Integer.parseInt(Character.toString(x.charAt(i)));
            x_arr[j] = x.charAt(i) - '0';
        }

        for (int i = y.length() - 1, j = 0; i >= 0; i--, j++) {
            // y_arr[j] = Integer.parseInt(Character.toString(y.charAt(i)));
            y_arr[j] = y.charAt(i) - '0';
        }

        // System.out.print(Arrays.toString(x_arr));
        // System.out.print(Arrays.toString(y_arr));

        int c = 0;//进位
        int j = 0;
        for (int i = 0; i < x_arr.length || i < y_arr.length; i++) {
            if (i < x_arr.length)
                c += x_arr[i];
            if (i < y_arr.length)
                c += y_arr[i];
            res[j++] = c % 10;
            c /= 10;
        }
        if (c != 0)
            res[j] = 1;

        // System.out.print(Arrays.toString(res));

        String r = "";
        for (int k = res.length - 1; k >= 0; k--) {
            r += res[k];
        }
        if (r.charAt(0) == '0')
            System.out.print(r.substring(1));
        else
            System.out.print(r);

        in.close();
    }
}

c++:

#include <iostream>
#include <vector>

using namespace std;

vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);

    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];
        if (i < B.size()) t += B[i];
        C.push_back(t % 10);
        t /= 10;
    }

    if (t) C.push_back(t);
    return C;
}

int main()
{
    string a, b;
    vector<int> A, B;
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i -- ) A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i -- ) B.push_back(b[i] - '0');

    auto C = add(A, B);

    for (int i = C.size() - 1; i >= 0; i -- ) cout << C[i];
    cout << endl;

    return 0;
}

3.相关知识

3.1 C++ vector

3.1.1 什么是vector？

向量（Vector）是一个封装了动态大小数组的顺序容器（Sequence Container）。跟任意其它类型容器一样，它能够存放各种类型的对象。可以简单的认为，向量是一个能够存放任意类型的动态数组。

3.1.2 容器特性

3.1.2.1 顺序序列

顺序容器中的元素按照严格的线性顺序排序。可以通过元素在序列中的位置访问对应的元素。

3.1.2.2 动态数组

支持对序列中的任意元素进行快速直接访问，甚至可以通过指针算述进行该操作。操供了在序列末尾相对快速地添加/删除元素的操作。

3.1.2.3 能够感知内存分配器的（Allocator-aware）

容器使用一个内存分配器对象来动态地处理它的存储需求。

3.1.3 基本函数实现

3.1.3.1 构造函数

vector():创建一个空vector

vector(int nSize):创建一个vector,元素个数为nSize

vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t

vector(const vector&):复制构造函数

vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

3.1.3.2 增加函数

void push_back(const T& x):向量尾部增加一个元素X

iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x

iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x

iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

3.1.3.3 删除函数

iterator erase(iterator it):删除向量中迭代器指向元素

iterator erase(iterator first,iterator last):删除向量中[first,last)中元素

void pop_back():删除向量中最后一个元素

void clear():清空向量中所有元素

3.1.3.4 遍历函数

reference at(int pos):返回pos位置元素的引用

reference front():返回首元素的引用

reference back():返回尾元素的引用

iterator begin():返回向量头指针，指向第一个元素

iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置

reverse_iterator rbegin():反向迭代器，指向最后一个元素

reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

3.1.3.5 判断函数

bool empty() const:判断向量是否为空，若为空，则向量中无元素

3.1.3.6 大小函数

int size() const:返回向量中元素的个数

int capacity() const:返回当前向量所能容纳的最大元素值

int max_size() const:返回最大可允许的vector元素数量值

3.1.3.7 其他函数

void swap(vector&):交换两个同类型向量的数据

void assign(int n,const T& x):设置向量中前n个元素的值为x

void assign(const_iterator first,const_iterator last):向量中[first,last)中元素设置成当前向量元素

3.1.3.8 看着清楚

1. push_back 在数组的最后添加一个数据

2. pop_back 去掉数组的最后一个数据

3. at 得到编号位置的数据

4. begin 得到数组头的指针

5. end 得到数组的最后一个单元+1的指针

6. front 得到数组头的引用

7. back 得到数组的最后一个单元的引用

8. max_size 得到vector最大可以是多大

9. capacity 当前vector分配的大小

10. size 当前使用数据的大小

11. resize 改变当前使用数据的大小，如果它比当前使用的大，者填充默认值

12. reserve 改变当前vecotr所分配空间的大小

13. erase 删除指针指向的数据项

14. clear 清空当前的vector

15. rbegin 将vector反转后的开始指针返回(其实就是原来的end-1)

16. rend 将vector反转构的结束指针返回(其实就是原来的begin-1)

17. empty 判断vector是否为空

18. swap 与另一个vector交换数据

3.1.4 基本用法

#include < vector> 

using namespace std;

3.1.5 简单介绍

Vector<类型>标识符

Vector<类型>标识符(最大容量)

Vector<类型>标识符(最大容量,初始所有值)

Int i[5]={1,2,3,4,5}

Vector<类型>vi(I,i+2);//得到i索引值为3以后的值

Vector< vector< int> >v; 二维向量//这里最外的<>要有空格。否则在比较旧的编译器下无法通过