常用算法详解

前缀和与差分：

nums[101] //存放原数据
sum[101] //存放前缀和
b[101] //存放差分标记
bsum[101] //存放差分标记的前缀和

一维前缀和：核心算法：sum[i] = sum[i-1] + nums[i]。
二维前缀和：核心算法：sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + nums[i][j]。

 容斥原理基本思想：先不考虑重叠的情况，把包含于某内容中的所有对象的数目先计算出来，然后再把计数时重复计算的数目排斥出去，使得计算的结果既无遗漏又无重复，这种计数的方法称为容斥原理。

差分和与前缀和是逆运算：
一维差分：核心算法：nums[i]=sum[i]-sum[i-1]
二维差分：核心算法：nums[i][j]=sum[i][j]-sum[i-1][j]-sum[i][j-1]+sum[i-1][j-1]

差分标记数组，解决元素变化的问题。
一维：
如下m个操作
l r q:把[l,r]内的所有元素都增加q
把b[l]+q,把b[r+1]-q
然后对b数组求前缀和，b数组的前缀和就是原数组元素变化的累计量。
二维：
如下m个操作
x1 y1 x2 y2 q:把[x1,y1]到[x2,y2]内的所有元素都增加q
把b[x1][y1]+q,把b[x1][y2+1]-q,把b[x2+1][y1]-q,把b[x2+1][y2+1]+q
然后对b数组求二维前缀和，b数组的前缀和就是原数组元素变化的累计量。

---

尺取法/滑动窗口：

一种利用双指针遍历获取满足条件区间的算法。
尺取法需要满足的条件：区间和大小满足随区间长度单调变化，递增或者递减。
尺取法的优点：

1. 区间和大小满足随区间长度单调变化，可以利用前缀和与差分优化。
2. 不会去枚举不满足条件的空间

一般用于求取有一定限制的区间个数或者最短区间

---

质数筛法

质数概念：质数，又称素数，即约数只有1以及它本身的数。
筛质数：将0—n之间的质数筛选出来，并保存到一个数组中或者直接输出。
方法：

1. 朴素方法
2. 埃氏筛法
3. 欧拉筛法

朴素方法

验证一个数是否为质数
根据定义，因为质数除了1和本身之外没有其他约数，所以判断n是否为质数，根据定义直接判断从2到n-1是否存在n的约数即可。

bool isPrimer(int n)
{
	for (int i = 2; i < n - 1; i++)
	{
		if (n % i == 0)return 0;//不是质数
	}
	return 1;	//是质数
}

优化1：一个数去除以比它的一半还要大的数，一定除不尽的，因此，只需要除到𝑛/2。

bool isPrimer(int n)
{
	for (int i = 2; i < n/2; i++)
	{
		if (n % i == 0)return 0;//不是质数
	}
	return 1;	//是质数
}

优化2一个数若可以进行因数分解，那么分解时得到的两个数一定是一个小于等于sqrt(n)，一个大于等于sqrt(n)，所以若sqrt(n)左侧找不到约数，那么右侧也一定找不到约数。因此只要从2枚举到 √𝑛即可。

bool isPrimer(int n)
{
	for (int i = 2; i < sqrt(n); i++)
	{
		if (n % i == 0)return 0;//不是质数
	}
	return 1;	//是质数
}

埃氏筛法

查找出一个范围内所有的质数
基本原理：一个合数总是可以分解成若干个质数的乘积，那么把质数的倍数都去掉那么剩下的都是质数了。
步骤：

1. 先把1删除（1不是质数也不是合数）
2. 读取数组中当前最小的数2，然后把2的倍数删去
3. 读取数组中当前最小的数3，然后把3的倍数删去
4. 读取数组中当前最小的数5，然后把5的倍数删去
5. …
6. 读取数组中当前最小的数n，然后把n的倍数删去

代码思路：

1. 状态初始化
2. 从2开始判断是否为质数，保存2，遍历比n小的所有2的倍数，状态置位false。
3. 判断是否为质数，保存3，遍历比n小的所有3的倍数，状态置位false。
4. …

#include<iostream>

using namespace std;

int prime[10005],k=0;
bool isPrime[10005];

int main()
{
	int n;
	cin >> n;
	for (int i = 2; i <= n; i++)//初始化,所有数为质数 
	{
		isPrime[i] = true;
	}
	for (int i = 2; i < n; i++)//遍历2~n之间的所有数 
	{
		if (isPrime[i] == true)//从当前质数开始，筛去它的倍数 
		{
			k++;
			prime[k] = i;
			for (int j = i * 2; j <= n; j += i)//从当前质数2倍，3倍..直到j>n 
			{
				isPrime[j] = false;;//将状态置为false 

			}
			cout << i << endl;
		}
	}
	int a;						//判断范围内的一个数是否为质数
	cin >> a;
	cout << isPrime[a] << endl;
}

欧拉筛法

基本定理：任何合数都能表示为若干质数的乘积，且该分解因式是唯一的
原理：规定每个合数只能被他的最小的质因数筛去，后面的质因数直接跳过。

#include<iostream>

using namespace std;

int prime[10005],k=0;
bool isPrime[10005];
int main()
{
	int n;
	cin >> n;
	for (int i = 2; i <= n; i++)//初始化,所有数为质数 
	{
		isPrime[i] = true;
	}
	//欧拉算法
	for (int i = 2; i <= n; i++)//枚举需要判断的每个数
	{
		if (isPrime[i] == true)//i是质数
		{
			k++;
			prime[k] = i;
		}
		//枚举质数表
		for (int j = 1; j <= k; j++)
		{
			int x = i * prime[j];
			if (x > n)//超过范围跳出
			{
				break;
			}
			isPrime[x] = 0;//把x标记成合数
			if (i % prime[j] == 0)//保证只筛选到了以prime[j]为最小质因数的数，精髓所在（我没太搞懂啊啊啊啊）
			{
				break;
			}
		}
	}
}

---

快速幂

例如计算2¹⁰,安装平常理解就是使用一个循环对2累乘10次，但是仔细看的话，其实都是重复过程，可以把这个过程缩减为（2 * 2）累乘5次，进一步可以缩减为（2 * 2 * 2 * 2） * （2 * 2 * 2 * 2 ） * （ 2 * 2 ），我们在应用一下小学数学知识（2 * 2 * 2 * 2）可以写为2⁴,所以任何一个幂都可以用这种方法表示：.,n=n1+n2+n3+…,aⁿ=a^n1+n1+n3+…,aⁿ=aⁿ¹ * aⁿ² * aⁿ³ * …。然后任何一个数都可以用二进制表示，写成2ⁿ 的形式，所以幂函数的计算可以写成aⁿ =a^{n的二进制形式},这么说有点不太准确，看例子吧

先看10的二进制为：1010=2³ +2¹ =8+2
2¹⁰ =2⁽⁸⁺²⁾ =2⁸ * 2²

使用快速幂的要点

步骤1：有一个变量始终保存当前是2的几次方
步骤2：如果对应进制位为1，就需要一个累乘变量乘上步骤1的变量

核心算法

int q_mul(int n,int x)
{
	int res=1;//累乘变量
	while(x!=0)//只要x!=0就一直循环下去
	{
		if(x%2==1)res*=n;//当前的二进制为1，乘上当前位置的n，步骤二
		x/=2;//短除法，x除以2
		n*=n;//n每次都乘以自身，步骤1
	}
	return res;
}

---

高精度运算（大数运算）

大数：指的是计算的数值非常大或者对运算的精度要求非常高，无法用现有的数据类型表示的数值。

例如：计算圆周率小数点后200位

解决办法：

1. 用数组模拟大数运算
2. 开一个较大的整型数组
3. 数组的元素代表大数的某一位
4. 通过数组元素运算模拟大数的运算
5. 最后将代表大数的数组输出

模拟中需要解决的问题：

1. 数据的输入方法和存储方法：输入用字符串、存储用数组
2. 大整数位数确定：计算字符串长度
3. 模拟过程：进位、借位处理

加法

//输入和存储方法
int init(int x[]，string s)
{
    int l = s.size();
    for (int i = 0; i < l; i++)
    {
        x[i] = s[l - i - 1] - '0';//把字符串倒着存到x数组中
    }
    return l;
}
int main() {
    string s;
    cin >> s;
    int la = init(a,s);
    int lb = init(b,s);
    int lc = max(la, lb);
    for (int i = 0; i < lc; i++)
    {
    	//核心算法
        c[i] += a[i] + b[i];
        if (c[i] >= 10)//大于等于10,则进位
        {
            c[i + 1]++;
            c[i] -= 10;
        }
    }
    if (c[lc] != 0)
    {
        cout << c[lc];
    }
    for (int i = lc - 1; i >= 0; i--)
    {
        cout << c[i];
    }
    return 0;
}

减法

int init(int x[],string s)
{
    int l = s.size();
    for (int i = 0; i < l; i++)
    {
        x[i] = s[l - i - 1] - '0';//把字符串倒着存到x数组中
    }
    return l;
}


int main() {
    string s1,s2;
    cin >> s1>>s2;
    int la = init(a,s1);
    int lb = init(b,s2);
    int lc = max(la, lb);
    //判断是否为负数,是的话输出负号，交换数字，以大数减小数
    if (la < lb || (la == lb && s1 < s2))
    {
        cout << "-";
        swap(a, b);
    }
    for (int i = 0; i < lc; i++)
    {
        if (a[i] < b[i])
        {
            a[i] += 10;
            a[i + 1]--;
        }
        c[i] = a[i] - b[i];
    }
    lc--;
    while (c[lc] == 0 && lc > 0)lc--;//去掉前导0
    for (int i = lc; i >= 0; i--)
    {
        cout << c[i];
    }
    return 0;
}