C++祖传代码（各种排序、高精度、因数与倍数、质数、闰年等等。所有代码都是函数类型，即套即用，附有超详细的参数说明）

分享一些祖传代码

模板

#include<bits/stdc++.h>
using namespace std;
int main (){
	
	return 0;
}

判断质数

bool isprime(long long int num){
	num = abs(num);//求绝对值
	if(num == 2){//2特判
		return true;
	}
	if(num%2 == 0 || num < 2){//是偶数或者小于2
		return false;
	}else{
		for(long long int i = 3; i*i <= num; i +=2){
			if(num%i == 0){
				return false;
			}
		}
		return true;
	}
}

参数类型：long long int
返回值：bool

关于因数

返回一个数的因数和

long long int factor_sum(long long int a){//为了防爆我开了long long int
	long long int s = 0;
	for(int i = 1; i <= sqrt(a); i++){
		if(a%i == 0){
			s += i;
			if(a/i == i){
				continue;
			}else{
				s += (a/i);
			}
		}
	}
	return s;
}

参数类型：long long int
返回格式：long long int

返回一个数的因数个数

long long int factor_num(long long int a){//同上
	long long int num = 0;
	for(int i = 1; i <= sqrt(a); i++){
		if(a%i == 0){
			num++;
			if(a/i == i){//是不是平方根
				continue;
			}else{
				num++;
			}
		}
	}
	return num;
}

参数类型：long long int
返回格式：long long int

最大公因数

long long int mcf(long long int a, long long int b){
    long long int temp = a;
    while(a%b != 0){
        a = b;
        b = temp%b;
        temp = a;
    }
    return b;
}

参数类型：long long int、long long int
返回格式：long long int

不考虑两个参数的相对大小。

函数名mcf是Maximum common factor的缩写。

最小公倍数

long long int lcm(long long int a,long long int b){
	long long int ans;
	for(long long int i = 1; ; i++){
		if(a*i % b == 0){
			ans = a*i;
			return ans;
		}
	}
}

参数类型：long long int、long long int
返回格式：long long int

不考虑两个参数的相对大小。

函数名lcm是Least common multiple的缩写。

判断闰年

bool isleapyear(int n){
	if(n%4 == 0){
		if(n%400 == 0){
			return true;
		}else{
			if(n % 100 == 0){
				return false;
			}else{
				return true;
			}
		}
	}else{
		return false;
	}
}

参数类型：int
返回格式：bool

斐波那契数列

long long int Fibonacci(int di){
	long long int a = 1,b = 1,ans = 0;
	if(di == 1|| di == 2){
	    return 1;
	}
    for(int i = 2; i < di; i++){
        ans = a+b;
        a = b;
        b = ans;
    }
    return ans;
}

参数类型：int
表示斐波那契数列的第几项。

返回格式：long long int

排序

sort排序

不会吧不会吧，都3202年了，还有人不会用sort吗？
例：现在要对数组int a[100]中的第 0~99 项排序

从小到大排

sort(a,a+99);
//or
sort(a,a+99,less<int>);

从大到小排

sort(a,a+99,greater<int>);

特殊排序

这就需要自己定义比较函数cmp了。
就不给示例了。

选择排序

void select_sort(long long int* arr,long long int len)
{
	long long int k;
    for(long long int i = 0; i < len-1; i++){
    	k = i;
        for(long long int j = i+1; j < len; j++){
            if(arr[j] < arr[k]){
            	k = j;
			}
        }
        swap(arr[i],arr[k]);
    }
}

参数类型：long long int类型数组、long long int

第一个参数是将要被排序的数组；
第二个参数是数组的长度。

排序操作将在传入的数组上直接进行；

冒泡排序

标准冒泡排序

void bubble_sort(long long int* arr,long long int len)
{
    bool ok = 0;
    for(long long int i = 0; i < len-1; i++){
    	ok = 1;
        for(long long int j = 0; j < len-1-i; j++){
            if(arr[j] > arr[j+1]){
            	ok = 0;
                swap(arr[j],arr[j+1]);
            }
        }
        if(ok){
    		break;
		}
    }
}

参数类型：long long int类型数组、long long int

第一个参数是将要被排序的数组；
第二个参数是数组的长度。

排序操作将在传入的数组上直接进行；

使用冒泡排序统计逆序对

long long int bubble_sort(long long int* arr,long long int len)
{
	long long int ans = 0;
    bool ok = 0;
    for(long long int i = 0; i < len-1; i++){
    	ok = 1;
        for(long long int j = 0; j < len-1-i; j++){
            if(arr[j] > arr[j+1]){
            	ok = 0;
            	ans++;
                swap(arr[j],arr[j+1]);
            }
        }
        if(ok){
    		break;
		}
    }
    return ans;
}

参数类型：long long int类型数组、long long int

第一个参数是将要被排序的数组；
第二个参数是数组的长度。

排序操作将在传入的数组上直接进行；

返回值：long long int，表示逆序对个数。

插入排序

void insert_sort(long long int* arr,long long int len)
{
    for(long long int i = 1; i < len; i++){
    	long long int temp = arr[i],j = i-1;
        for(; j >= 0; j--){
            if(temp < arr[j]){
            	arr[j+1] = arr[j];
			}else{
				break;
			}
        }
        arr[j+1] = temp;
    }
}

参数类型：long long int类型数组、long long int

第一个参数是将要被排序的数组；
第二个参数是数组的长度。

排序操作将在传入的数组上直接进行；

归并排序

标准归并排序

void merger(long long int* a,long long int* r,long long int L,long long int Mid,long long int R){
	long long int i,j,k;
	i = L;
	j = Mid + 1;
	k = L;
	while(i <= Mid && j <= R){
		if(a[i] <= a[j]){
			r[k] = a[i];
			k++;
			i++;
		}else{
			r[k] = a[j];
			k++;
			j++;
		}
	}
	while(i <= Mid){
		r[k] = a[i];
		k++;
		i++;
	}
	while(j <= R){
		r[k] = a[j];
		k++;
		j++;
	}
	for(long long int m = L; m <= R; m++){
		a[m] = r[m];
	}
}
void merge_sort(long long int* a,long long int* r,long long int L,long long int R){
	if(L < R){
		long long int mid  = (L+R)/2;
		merge_sort(a,r,L,mid);
		merge_sort(a,r,mid+1,R);
		merger(a,r,L,mid,R);
	}
}

参数类型：long long int类型数组、long long int类型数组、long long int、long long int

第一个参数是原数组；
第二个参数是排序好后返回的数组；
第三个参数是数组的起始项、第四个参数是数组的结束项;

排序操作将在第二个数组上进行、原数组不变；
使用时只需调用merge_sort()函数即可

使用归并排序统计逆序对

long long int ans = 0;
void merger(long long int* a,long long int* r,long long int L,long long int Mid,long long int R){
	long long int i,j,k;
	i = L;
	j = Mid + 1;
	k = L;
	while(i <= Mid && j <= R){
		if(a[i] <= a[j]){
			r[k] = a[i];
			k++;
			i++;
		}else{
			r[k] = a[j];
			k++;
			j++;
			ans += Mid-i+1;
		}
	}
	while(i <= Mid){
		r[k] = a[i];
		k++;
		i++;
	}
	while(j <= R){
		r[k] = a[j];
		k++;
		j++;
	}
	for(int m = L; m <= R; m++){
		a[m] = r[m];
	}
}
void merge_sort(long long int* a,long long int* r,long long int L,long long int R){
	if(L < R){
		long long int mid  = (L+R)/2;
		merge_sort(a,r,L,mid);
		merge_sort(a,r,mid+1,R);
		merger(a,r,L,mid,R);
	}
}

参数类型：long long int类型数组、long long int类型数组、long long int、long long int

第一个参数是原数组；
第二个参数是排序好后返回的数组；
第三个参数是数组的起始项、第四个参数是数组的结束项;

排序操作将在第二个数组上进行、原数组不变；
使用时只需调用merge_sort()函数即可

ans为全局变量，表示逆序对个数，使用时注意避免变量名重复。

快速排序

void quick_sort(long long int* a,long long int l,long long int r){
	long long int x,y,mid;
	x = l;
	y = r;
	mid = a[(l+r)/2];
	while(x <= y){
		while(a[x] < mid){
			x++;
		}
		while(a[y] > mid){
			y--;
		}
		if(x <= y){
			swap(a[x],a[y]);
			x++;
			y--;
		}
	}
	if(l < y){
		quick_sort(a,l,y);
	}
	if(x < r){
		quick_sort(a,x,r);
	}
}

参数类型：long long int类型数组、long long int、long long int

第一个参数是将要被排序的数组；
第二个参数是要排序数组的起始项序号；
第三个参数是要排序数组的结束项序号。

排序操作将在传入的数组上直接进行；

二分快速幂

取模

long long int Pow(long long int a,long long int c,long long int n){
	long long int ans = 1;
	while(c){
		if(c & 1){
			ans = (ans*a)%n;
		}
		a = (a*a)%n;
		c /= 2;
	}
	return ans;
}

参数类型：long long int、long long int、long long int

第一个参数是底数；
第二个参数是指数；
第三个参数是结果对其取模的数。

返回值：long long int，表示$a^c\mathrm{mod}n$。

不取模

long long int Pow(long long int a,long long int c){
	long long int ans = 1;
	while(c){
		if(c & 1){
			ans = ans*a;
		}
		a = a*a;
		c /= 2;
	}
	return ans;
}

参数类型：long long int、long long int

第一个参数是底数；
第二个参数是指数；

返回值：long long int，表示$a^c$。

高精度

加法

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;
}

参数类型：vector<int>、vector<int>

返回值：vector<int>

减法

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();
	}
    return C;
}

参数类型：vector<int>、vector<int>

返回值：vector<int>

暂时先写这么多吧！以后再补充。
再见！