基础算法（二）

一 高精度计算

  int能表示范围为2^32，这看起来很大，但在大数据时代的如今，不说是int 哪怕是long long也是不够的，那么为了使用或计算这些超出或远超整形大小的数，我们这些数的计算方法称为高精度计算。

（1)高精度加法（A+B，A和B均为高精度）

  我们采用的方法是开两个数组A，B，然后用这两个数组来模拟两个大数之间的加法运算。代码实现要注意两个细节：
  ①实现过程中一定要保证A的长度大于B
  ②实现过程中注意数的存储顺序是从低位向高位，具体过程如下所示：

  代码如下所示：

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

    vector<int> C;
    int t = 0;//t用于表示进位
    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!=0) C.push_back(t);//用于保存进位
    return C;
}

（2）高精度减法（满足A>B)

  思路和高精度加法基本一致，只是模拟的过程是减法而不是加法

vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();
    //去掉首位的所有0
    return C;
}

二 前缀和与差分

  这两种方法都是预处理方式，可以降低达到某种操作的时间复杂度。
  前缀和降低时间复杂度的代表操作为求某一个区间的和。
  差分时间复杂度的代表操作为给区间内每一个数加上一个固定常数。

（1）前缀和

  前缀和是一种重要的预处理，能大大降低查询的时间复杂度。通常用于处理获取某一部分连续区间的问题。前缀和是以求和的方式灵活地面对区间询问。例如以下问题：
  给你一串长度为 n 的数列 a1, a2, a3, …, an，再给出 m 个询问，每次询问给出 L, R 两个数，要求给出区间 [L, R] 里的数的和。如果使用前缀和处理以后很容易可以得到
$$则上述题目的结果为S[L]-S[R-1]$$
  时间复杂度显然降低

  ①一维前缀和（用于处理一维数组）

$$\begin{gathered} 表达式为S[n]=a_1+a_2+a_3+....a_n \\ 预处理递推公式为：S[n]=S[n-1]+a_n \end{gathered}$$
  ②二维前缀和（用于处理二维数组）
  二维前缀和的公式如下
$$\begin{gathered} 二维前缀和表达式为：S[x,y]=\sum _{i=1}^x\sum _{i=0}^y{a}_{ij} \\ 预处理递推公式为： \\ S[x,y]=S[x-1,y]+S[x,y-1]-S[x-1,y-1]+a_{xy} \end{gathered}$$
  这个公式可以根据以下方法记忆：

  代码实现思路如下：
  （1）初始化所有的S[n][0],S[0][m]（第一行与第一列）
  （2）根据递推公式推出所有的S[x][y]

（2）差分思想（也存在二维差分）

  差分：一个数列，如果知道第一个数，以及每一个数与前一个数的差值，那么我们就可以推出整个数列。前缀和与差分运算为互逆运算。差分数组d[n]的公式如下：
$$d[i]=\{\begin{array}{r}a[i],i=1\\ a[i]-a[i-1],i>1\end{array}$$
  所以可以推出公式：
$$a[n]=\sum _{i=1}^{n}d[i]$$
  下面介绍一个差分算法很重要的应用：给定区间[l ,r ]，让我们把a数组中的[ l, r]区间中的每一个数都加上c,即 a[l] + c , a[l+1] + c , a[l+2] + c , a[r] + c;
  暴力做法是for循环l到r区间，时间复杂度O(n)，这个时候使用差分数组时间效率就大大提高了。根据差分的公式，可知道：
$$\begin{gathered} b[n]+=c,a[i]全部都加c \\ b[n]-=c,a[i]全部减去c \\ 以上两个式子都是在i>=n的时候成立 \end{gathered}$$
  所以具体方法是：这样就不用暴力循环每个数都加上c，只需要构造根据数组a构造差分数组b，而后对差分数组b做 b[l] + = c, b[r+1] - = c。要哪个数就进行b[n]数组的求和就行，从效果上看也达到了暴力做法的效果，但是只改了两个地方。

三 双指针算法

  双指针只能说是是算法中的一种技巧。双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。
  双指针算法的核心思想就是运用某个性质，使用两个指针把时间复杂度优化。代码模板如下：

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;
}

四 离散化

  离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。例如：

可以使用以下代码实现：思路就是使用二分查找找到对应下标。

vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素

// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于x的位置
{
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
}

五 位运算

  （1）判断正整数N的二进制表示的第k位数步骤：将N右移k-1位以后与1进行与运算，如下列公式所示：

                           N>>(k-1)&1

  (2)lowbit操作：返回N的最小的2的次方数。
$$6=(110{)}_2=2^2+2^1,则6的最后一位1就是（10）也就是2$$
  代码如下

                                N&-N

  用这个代码可以判断N中1的个数，具体方法就是每执行一次lowbit操作得到N的最小的2的次方数，然后减去lowbit操作的返回值。而后再执行lowbit操作直到N等于0位置，N执行了多少次lowbit操作就有几个1。
  原理如下：
$$\begin{gathered} 我们知道计算机这种负数就是取反再加1， \\ 设N=（\mathrm{10110......10.....0}{)}_2, \\ 则-N=（\mathrm{01001......01.....1}{)}_2+1=（\mathrm{01001......10....0}{)}_2 \\ 则上述代码的结果为\mathrm{10.....0},就是N的最后一位1 \end{gathered}$$

六 区间合并

  区间合并问题也是一个贪心问题，由于比较常用所以单独拿出来。区间合并的解决方法是：把所有区间按照左端点从小到大排序，如果遍历到区间和维护的区间有交集，就合并（能合则合），没有交集的时候，当前维护的区间就变成这个遍历到的区间。