I am the dog God of math!

东山再起!!!

初一的小朋友来感受一下C++的威力吧

我是数学的狗 我爱数学 我爱物理 我爱化学 我爱生物 我爱语文 我爱英语

2026.2.3 去初一班转了一圈 一片惊叫

一些函数

数论篇

最大公约数

long long gcd(long long x, long long y) {
	if (!y) return x;
	return gcd(y, x % y);
}

最小公倍数

int gcd(int x, int y) {
	if (!y) return x;
	return gcd(y, x % y);
}
int lcm(int x, int y){
	return x*y/gcd(x, y);
}

判断素数--旧版

注：最经典,最常用的版本

bool is_prime(int o){
	if(o==2)return true;
    if(o<2)return false;
    int q=1;
	while(q*q<=o){
        q++;if(o%q==0)return false;
    }
    return true;
}

判断素数--记忆化改良

注：在一定条件下比质数筛好用

#define MAXN 10010
short dp[MAXN] = {-1, -1, 1};
bool is_prime(int m) {
	if (dp[m] == 1) return true;
	if (dp[m] == -1) return false;
	for (int i = 2; i * i <= m; i++)
		if (m % i == 0) {
			dp[m] = -1;
			return false;
		}
	dp[m] = 1;
	return true;
}

Tips:取消已经定义的宏"MAXN"

#ifdef MAXN
#undef MAXN
#endif

线性质数筛(含注释)

注:需要头文件"cstring"

#define MAXN 100000010
#define Primenum 6000010
bool isprime[MAXN];//isprime[i] == 1表示:i是素数
int prime[Primenum], cnt = 0;//数组prime存质数
void find_prime(int n){//筛到n
	memset(isprime, 1, sizeof(isprime));//初始状态为"所有数均为素数",需逐个筛去
	//特殊说明:memset需要头文件"cstring"
	isprime[1] = 0;//特判:1不是素数
	for(int i = 2; i <= n; i++){
		if(isprime[i]) 
			prime[++cnt] = i; //如果i没筛掉,则i是素数
		for(int j = 1; j <= cnt && i*prime[j] <= n/*不超上限*/; j++) {
			isprime[i*prime[j]] = 0;
			if(i % prime[j] == 0) break; //魔法!
		}
	}
}

无注释版

#define MAXN 100000010
#define Primenum 6000010
bool isprime[MAXN];
int prime[Primenum], cnt = 0;
void find_prime(int n){
	memset(isprime, 1, sizeof(isprime));
	isprime[1] = 0;
	for(int i = 2; i <= n; i++){
		if(isprime[i]) 
			prime[++cnt] = i; 
		for(int j = 1; j <= cnt && i*prime[j] <= n; j++) {
			isprime[i*prime[j]] = 0;
			if(i % prime[j] == 0) break;
		}
	}
}

Phi(欧拉函数)

#define MAXN 100000
int phi[MAXN] = {0, 1, 1, 2, 2, 4, 2};
bool is_prime(int o) {
	if (o == 2)return true;
	if (o < 2)return false;
	int q = 1;
	while (q * q <= o) {
		q++;
		if (o % q == 0)return false;
	}
	return true;
}
int Phi(int q) {
	if (q <= 0) return 0;
	if (phi[q]) return phi[q];
	if (is_prime(q)) return phi[q] = q - 1;
	int i = 1, ans = q, p = q;
	while (i <= p) {
		i++;
		if (p % i == 0) {
			while (p % i == 0) p /= i;
			ans -= ans / i;
		}
	}
	return ans;
}

因子和(不包含1和它本身)

int total(int t) {
	int b = 0;
	for (int i = 2; i * i <= t; i++) {
		if (t % i == 0)b += i + t / i;
		if(i*i==t)b-=i;
	}
	return b;
}

质因子和

int total_prime(int t){
    int b=0,a=2;
    while(t!=1){
        while(t%a==0){
            b+=a;
            t/=a;
        }
	a++;
	}
    return b;
}

C

#define MAXN 1000010
ull fac[MAXN] = {1};
void FAC(int n, int mod = 100000000) {
	for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
}
ull pow(int a, int b, ull mod = 1e9) {
	ull ans = 1, base = a;
	while (b > 0) {
		if (b & 1) ans = ans * base % mod;
		base = base * base % mod;
		b >>= 1;
	}
	return ans;
}
ull C(ull n, ull m, ull mod) {
	if (m > n) return 0;
	return (fac[n] * pow(fac[m], mod - 2, mod)) % mod * pow(fac[n - m], mod - 2, mod) % mod;
}
ull Cpp(ull n, ull m, ull mod) {
	if (!m) return 1;
	return C(n % mod, m % mod, mod) * Cpp(n / mod, m / mod, mod) % mod;
}

操作型

交换两个整数的值

void swap(int &a, int &b) {
	a ^= b ^= a ^= b;
}

快读快写

template <class T> inline T read() {
	T f = 1, x = 0;
	char c = getchar();
	while (!isdigit(c)) {
		if (c == '-')f = -1;
		c = getchar();
	}
	while (isdigit(c)) {
		x = x * 10 + c - '0';
		c = getchar();
	}
	return x * f;
}
void write(int x) {
	if (x < 0)
		putchar('-'), x = -x;
	if (x > 9)
		write(x / 10);
	putchar(x % 10 + '0');
	return;
}

常用函数

数的长度（数的位数）

int its_length(int t){
	int s=0;
	while(t){
        s++,t/=10;
    }
    return s;
}

各数位和

int total_num(int t){
	int s=0;
	while(t!=0){
        s+=t%10,t/=10;
    }
    return s;
}

统计数码

int a[10];
void add_num(int t){
	while(t){
        a[t%10]++,t/=10;
    }
}

回文数

int month[13] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool is_palindrome(int a) {
	int o[10], len = 0;
	while (a) o[len++] = a % 10, a /= 10;

	for (int i = 0;  i <= len / 2; i++)
		if (o[i] != o[len - i - 1]) return false;
	return true;
}
bool check_date(int a) {
	int y, m, d;
	d = a % 100, a /= 100;
	m = a % 100, a /= 100;
	if (m > 12) return false;
	if (d > month[m]) return false;
	y = a;
	if (y % 4 && (y % 100 == 0 && y % 400)) if (m == 2 && d > 28) return false;
	return true;
}

回文数----string型

#define MAXN 10010
int len;char arr[MAXN];
bool is_palindrome_string_plus_pro_max() {
	for (int i = 0;  i <= len / 2; i++)
		if (arr[i] != arr[len - i - 1]) return false;
	return true;
}

模板函数

二分查找

#define SIZE 1000010
int a[SIZE],n;
int find(int x) {
	int l = 1, r = n + 1, mid;
	while (l < r) {
		mid = l + (r - l >> 1);
//		printf("%d\n",mid);
		if (a[mid] == x) return mid;
		if (a[mid] > x) r = mid;
		else l = mid + 1;
	}
	if (a[mid] == x) return mid;
	return -1;
}

二分----找左边界

#define SIZE 1000010
int a[SIZE],n;
int front_find(int x) {
	int l = 1, r = n + 1, mid;
	while (l < r) {
		mid = l + (r - l >> 1);
//		printf("%d\n",mid);
		if (a[mid] == x) break;
		if (a[mid] > x) r = mid;
		else l = mid + 1;
	}
	if (a[mid] == x) for (int i = mid; i >= 1; i--) if (a[i - 1] != x) return i;
	return -1;
}

二分----找右边界

#define SIZE 1000010
int a[SIZE],n;
int back_find(int x) {
	int l = 1, r = n + 1, mid;
	while (l < r) {
		mid = l + (r - l >> 1);
//		printf("%d\n",mid);
		if (a[mid] == x) break;
		if (a[mid] > x) r = mid;
		else l = mid + 1;
	}
	if (a[mid] == x) for (int i = mid; i <= n; i++) if (a[i + 1] != x) return i;
			
		
	return -1;
}

计算型函数

阶乘

long long fac(int a){
	long long q=1;
	for(int w=1;w<=a;w++){
	    q*=w;	
	}
	return q;
}

阶乘(递归版)

long long Fac(int a){
	if(a<=0) return 1;
	return Fac(a-1)*a;
}

绝对值

int abs(int a) {
	return (a + (a >> 31)) ^ (a >> 31);
}

快速整数幂

普通版

typedef unsigned long long ull;
ull super_pow(int a, int b) {
	ull ans = 1, base = a;
	while (b > 0) {
		if (b & 1) ans *= base;
		base *= base;
		b >>= 1;
	}
	return ans;
}

取模版

typedef unsigned long long ull;
ull mod_pow(int a, int b, ull mod = 1e9) {
	ull ans = 1, base = a;
	while (b > 0) {
		if (b & 1) ans = ans * base % mod;
		base = base * base % mod;
		b >>= 1;
	}
	return ans;
}

四则运算

加法

int add(int a, int b) {
	if (!b) return a;
	int xorr = a ^ b;
	int andd = a & b;
	return add(xorr, andd<<1);
}

减法

int sub(int a, int b) {
    b = add(~b, 1); 
    return add(a, b);
}

乘法

int multiply(int a, int b) {
    bool sign = ((a < 0) ^ (b < 0)) ? 1 : 0;
    a = abs(a),b = abs(b);
    int res = 0;
    while (b > 0) {
        if (b & 1) res = add(res, a);  // 检查最低位
        a <<= 1;  // a左移（乘2）
        b >>= 1;  // b右移（除2）
    }
    if(sign) res=add(~res,1);
    return res;
}

除法

int divide(int a, int b) {
    bool sign = ((a < 0) ^ (b < 0)) ? 1 : 0;
    a = abs(a),b = abs(b);
    int res = 0;
    while (a >= b) {
        a = sub(a, b);
        res = add(res, 1);
    }
    if(sign) res=add(~res,1);
    return res;
}

特殊函数

高精度2的幂

应用函数

读入字符串中的整数(回车结尾)

#define INF 1 << 31
int get() {
	int ans = 0;
	char in;
	while ((in = getchar()) != ' ') {
		if (in == '\n') return INF;
		ans = ans * 10 + in - '0';
	}
	return ans;
}

搜索模板

dfs

#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <stdio.h>
#define PI 3.14159265358979323846
#define MAXN 510
#define bigst 2e9
using namespace std;
bool is_prime(int o) {
	if (o == 2)return true;
	if (o < 2)return false;
	int q = 1;
	while (q * q <= o) {
		q++;
		if (o % q == 0)return false;
	}
	return true;
}
int ans, n, in[MAXN];
bool yet[MAXN];
void dfs(int k) {
	if (k > n ) {
		ans++;
		printf("%d:", ans);
		for (int i = 1; i <= n; i++)printf("%d ", in[i]);
		printf("\n");
		return;
	}
	if (k == 1) {
		for (int i = 1; i <= n; i++) {
			in[k] = i, yet[i] = 1;
			dfs(2);
			in[k] = 0, yet[i] = 0;
		}
		return;
	}
	for (int i = 1; i <= n; i++) {
		if (k < n || (is_prime(i + in[1]) && !yet[i]))
			if (is_prime(i + in[k - 1]) && !yet[i]) {
				in[k] = i, yet[i] = 1;
				dfs(k + 1);
				in[k] = 0, yet[i] = 0;
			}
	}
}
int main() {
	cin >> n;
	dfs(1);
	printf("total:%d", ans);
	return 0;
}

bfs

//暂无

数据结构

前置宏定义

#define SIZE 1010

栈

template <class T> struct stack {
	T a[SIZE];
	int len = 0, INF = 1 << 31;
	T top() {
		if (len)
			return a[len - 1];
	}
	int size() {
		return len;
	}
	bool empty() {
		return !len;
	}
	void push(T p) {
		a[len++] = p;
	}
	void pop() {
		len--;
	}
};

plus

template <class T, int N = 1010> class stack {
private:
	T a[N];
	int len = 0;
public:
	bool empty() {
		return !len;
	}
	T top() {
		if (len)
			return a[len - 1];
		else {
			puts("Error");
			return a[0];
		}
	}
	int size() {
		return len;
	}
	void push(T p) {
		a[len++] = p;
	}
	void pop() {
		len--;
	}
};

队列

struct queue {
	int a[SIZE] = {0}, lef = 0, righ = 0, INF = 1 << 31;
	int top() {
		if (righ != lef)
			return a[lef];
		return INF;
	}
	int size() {
		return righ - lef;
	}
	bool empty() {
		return lef == righ;
	}
	void push(int p) {
		a[righ++] = p;
	}
	void pop() {
		if (lef != righ)
			lef++;
	}
};

plus

template <class T, int N = 1010> class queue {
	private:
	protected:
		T a[N];
		int lef = 0, righ = 0;
	public:
		bool empty() {
			return lef == righ;
		}
		T top() {
			if (righ != lef)
				return a[lef];
		}
		int size() {
			return righ - lef;
		}
		void push(T p) {
			a[righ++] = p;
		}
		void pop() {
			if (lef != righ)
				lef++;
		}
};

链表

struct list {
	struct node {
		int num = 0;
		int next = 0, front = 0;
		int id = 0;
		void del(bool p = false) {
			if (p) num = 0, next = 0, front = 0, id = 0;
		}
	} a[SIZE];
	int head = 1;
	int tail = 1;
	int len = 0;
	int INF = 1 << 31;
	node &operator[](int i) {
		return a[i];
	}
	void swap(node &p, node &q) {
		node w;
		w = q, q = p, p = w;
	}
	void sinp(int &a, int &b) {
		a ^= b ^= a ^= b;
	}
	void set(int i) {
		a[++len].num = i;
		a[len].id = len;
	}
	void push(int i) {
		set(i);
		a[tail].next = len;
		a[len].front = tail;
		tail = len;
	}
	int top() {
		return a[head].num;
	}
	int back() {
		return a[tail].num;
	}
	void pop() {
		int h = head;
		a[a[h].next].front = 0, h = a[head].next;
		swap(a[head], a[len]);
		a[a[head].front].next = head;
		a[len].del(true);
		len--, head = h;
	}
	void push_front(int x, int i) {//第x号元素
		set(i);
		a[len].next = x;
		a[len].front = a[x].front;
		a[a[x].front].next = len;
		a[x].front = len;
		if (x == head) head = len;
	}
	void push_back(int x, int i) {//第x号元素
		set(i);
		a[len].front = x;
		a[len].next = a[x].next;
		a[a[x].next].front = len;
		a[x].next = len;
		if (x == tail) tail = len;
	}
	void del(int x) { //第x号元素
		if (x > len) return;
		a[a[x].front].next = a[x].next;
		a[a[x].next].front = a[x].front;
		if (x == head) head = a[x].next;
		else if (len == head) head = x;
		if (x == tail) tail = a[x].front;
		else if (len == tail) tail = x;
		swap(a[x], a[len]);
		a[a[x].front].next = x;
		a[a[x].next].front = x;
		a[len].del(true);
		len--;
	}
	void del_front(int x) { //第x号元素
		if (x == head) return;
		if (x > len) return;

		a[x].front = a[a[x].front].front;
		a[a[a[x].front].front].next = x;

		if (a[x].front == head) head = x;
		else if (len == head) head = a[x].front;
		if (len == tail) tail = a[x].front;

		swap(a[a[x].front], a[len]);
		a[a[x].front].next = a[x].front;
		a[a[x].next].front = a[x].front;
		a[len].del(true);
		len--;
	}
	void del_back(int x) { //第x号元素
		if (x == tail) return;
		if (x > len) return;

		a[x].next = a[a[x].next].next;
		a[a[a[x].next].next].front = x;

		if (a[x].next == tail) tail = x;
		else if (len == tail) tail = a[x].front;
		if (len == head) head = a[x].front;

		swap(a[a[x].next], a[len]);
		a[a[x].front].next = a[x].front;
		a[a[x].next].front = a[x].front;
		a[len].del(true);
		len--;
	}

};

fixed-plus

#include <iostream>
#define SIZE 10010
using namespace std;
struct list {
	public:
		struct node {
			int num = 0;
			int next = 0, front = 0;
			int id = 0;
			void del(bool p = false) {
				if (p) num = 0, next = 0, front = 0, id = 0;
			}
		} a[SIZE];
	protected:
		int head = 0;    // 修改：0表示空
		int tail = 0;
		int len = 0;
		int free_pos = 1;  // 空闲位置指针
	public:
		node &operator[](int i) {
			return a[i];
		}

		void swap(node &p, node &q) {
			node w = p;
			p = q;
			q = w;
		}

		int new_node(int value) {
			int pos = free_pos++;
			a[pos].num = value;
			a[pos].id = pos;
			a[pos].next = 0;
			a[pos].front = 0;
			return pos;
		}

		void push(int i) {
			int pos = new_node(i);

			if (len == 0) {  // 空链表
				head = tail = pos;
			} else {
				a[tail].next = pos;
				a[pos].front = tail;
				tail = pos;
			}
			len++;
		}

		int top() {
			if (len == 0) return -1;  // 链表为空
			return a[head].num;
		}

		int back() {
			if (len == 0) return -1;  // 链表为空
			return a[tail].num;
		}

		void pop() {
			if (len == 0) return;  // 空链表

			int old_head = head;
			head = a[head].next;

			if (head != 0) {
				a[head].front = 0;
			} else {
				tail = 0;  // 链表变空
			}

			// 清理被删除的节点
			a[old_head].del(true);
			len--;
		}

		void insert_after(int x, int value) {
			if (x <= 0 || x > free_pos) return;

			int pos = new_node(value);
			int next_node = a[x].next;

			a[x].next = pos;
			a[pos].front = x;
			a[pos].next = next_node;

			if (next_node != 0) {
				a[next_node].front = pos;
			}

			if (x == tail) {
				tail = pos;
			}
			len++;
		}

		void insert_before(int x, int value) {
			if (x <= 0 || x > free_pos) return;

			int pos = new_node(value);
			int prev_node = a[x].front;

			a[x].front = pos;
			a[pos].next = x;
			a[pos].front = prev_node;

			if (prev_node != 0) {
				a[prev_node].next = pos;
			}

			if (x == head) {
				head = pos;
			}
			len++;
		}

		void remove(int x) {
			if (x <= 0 || x > free_pos || a[x].id == 0) return;

			int prev_node = a[x].front;
			int next_node = a[x].next;

			if (prev_node != 0) {
				a[prev_node].next = next_node;
			} else {
				head = next_node;  // 删除的是头节点
			}

			if (next_node != 0) {
				a[next_node].front = prev_node;
			} else {
				tail = prev_node;  // 删除的是尾节点
			}

			a[x].del(true);
			len--;
		}

		// 遍历打印
		void print() {
			int cur = head;
			while (cur != 0) {
				cout << a[cur].num << " ";
				cur = a[cur].next;
			}
			cout << endl;
		}
		
		//稠密性检验
		void print(bool p){
			if(!p) return;
			for(int i=1;i<=len;i++){
				printf("%d ",a[i].num);
			}
			putchar('\n');
		}
};

int main() {
	list lst;

	// 测试
	for (int i = 1; i <= 5; i++) {
		lst.push(i);
	}

	cout << "原始链表: ";
	lst.print();

	cout << "头部: " << lst.top() << endl;
	cout << "尾部: " << lst.back() << endl;

	lst.insert_after(2, 99);
	cout << "在节点2后插入99: ";
	lst.print();

	lst.insert_before(4, 88);
	cout << "在节点4前插入88: ";
	lst.print();

	lst.remove(3);
	cout << "删除节点3: ";
	lst.print();

	lst.pop();
	cout << "删除头部: ";
	lst.print();

//	cout<<"稠密性测试：";
//	lst.print(true);
//  不满足稠密性，需修改
	return 0;
}

大根堆

struct sort_queue {
	int a[SIZE] = {0}, len = 0, INF = 1 << 31;
	void swap(int &a, int &b) {
		a ^= b ^= a ^= b;
	}
	int size() {
		return len;
	}
	bool empty() {
		return !len;
	}
	int top() {
		if (len)
			return a[1];
		return INF;
	}
	void modify(int x) {
		if (x == 1 || a[x] < a[x / 2]) return;
		swap(a[x], a[x / 2]);
		modify(x / 2);
	}
	void push(int x) {
		a[++len] = x;
		modify(len);
	}
	void repair(int x) {
		if (x * 2 > len) return;
		int tar = x * 2;
		if (x * 2 + 1 <= len)
			tar = a[x * 2] > a[x * 2 + 1] ? x * 2 : x * 2 + 1;
		if (a[x] < a[tar]) {
			swap(a[x], a[tar]);
			repair(tar);
		}
	}
	void pop() {
		if (!len) return;
		swap(a[1], a[len--]);
		repair(1);
	}
};

小根堆

struct s_sort_queue {
	int a[SIZE] = {0}, len = 0;
	const int INF = 1 << 31;
	void swap(int &a, int &b) {
		a ^= b ^= a ^= b;
	}
	int size() {
		return len;
	}
	bool empty() {
		return !len;
	}
	int top() {
		if (len)
			return a[1];
		return INF;
	}
	void modify(int x) {
		if (x == 1 || a[x] > a[x / 2]) return;
		swap(a[x], a[x / 2]);
		modify(x / 2);
	}
	void push(int x) {
		a[++len] = x;
		modify(len);
	}
	void repair(int x) {
		if (x * 2 > len) return;
		int tar = x * 2;
		if (x * 2 + 1 <= len)
			tar = a[x * 2] < a[x * 2 + 1] ? x * 2 : x * 2 + 1;
		if (a[x] > a[tar]) {
			swap(a[x], a[tar]);
			repair(tar);
		}
	}
	void pop() {
		if (!len) return;
		swap(a[1], a[len--]);
		repair(1);
	}
};

树状数组

#define SIZE 1010
int arr[SIZE], s[SIZE], tree[SIZE], N;
inline lowbit(int x) {
	return x & -x;
}
void init() {
	for (int i = 1; i <= N; i++) {
		s[i] = s[i - 1] + arr[i];
		tree[i] = s[i] - s[i - lowbit(i)];
	}
}
void add(int id, int plus) { /*arr[id] += plus*/
	for (int i = id; i <= N; i += lowbit(i)) tree[i] += plus;
}
int sum(int x) {
	int res = 0;
	for (int i = x; i; i &= i - 1) res += tree[i]; /*i&=i-1<=>i-=lowbit(i)*/
	return res;
}

线段树

#define N 100010
int arr[N];
long long tr[N<<2],laz[N<<2];
//■更新函数 
void pushup(int u){tr[u]=tr[u<<1]+tr[u<<1|1];}//这点的值为左右子树和
//■下放laz标记函数 
void addlaz(int u,int l,int r,int m){//当前节点，当前左、右边界，当前区间中点 
    tr[u<<1]+=(m-l+1)*laz[u];//左子树总值更新 
    tr[u<<1|1]+=(r-m)*laz[u];//右子树总值更新
    laz[u<<1]+=laz[u];//左子树laz标记加上其父亲的标记以便后续下放标记 
    laz[u<<1|1]+=laz[u];//右子树laz标记加上其父亲的标记以便后续下方标记 
    laz[u]=0;//你现在已经没有价值了！以后再来吧（下放后清除标记） 
}//函数结尾你懂的 
//■建树函数 
void build(int u,int l,int r){//当前节点，当前左、右边界 
    if(l==r){tr[u]=arr[l];return;}//边界为同一点时输入此点的值（递归终点） 
    int m=l+(r-l>>1);//二分取中点，这种写法防止爆int范围 
    build(u<<1,l,m);//建左子树 
    build(u<<1|1,m+1,r);//建右子树 
    pushup(u);//左右建完后更新此点 
}//函数结尾
//■修改函数 
void update(int u,int l,int r,int L,int R,long long v){//当前节点，当前左、右边界，目标区间左、右边界，修改参数 
    if(L<=l&&r<=R){//如果当前区间已被包含于目标区间 
        tr[u]+=(r-l+1)*v;//修改这个点的值 = 区间大小 * 修改参数 
        laz[u]+=v;return;}//存储laz值表示他所有后代都要这样修改 
    int m=l+(r-l>>1);//你说呢 
    if(laz[u]&&l!=r)addlaz(u,l,r,m);//如果这点有laz值，下放laz标记以便后续修改 
    if(L<=m)update(u<<1,l,m,L,R,v);//如果目标左边界在中心左边就修改左子树 
    if(m<R)update(u<<1|1,m+1,r,L,R,v);//果如目标右边界在中心右边就修改右子树 
    pushup(u);//左右子树修改完后更新次节点值 
}//不用我说了吧 
//■查询函数 
long long qry(int u,int l,int r,int L,int R){//当前节点，当前左、右边界，目标区间左、右边界
    if(L<=l&&r<=R)//如果当前区间已被包含于目标区间
        return tr[u];//返回这一区间的和 
    int m=l+(r-l>>1);long long sum=0;//中点，这一区间和（答案） 
    if(laz[u]&&l!=r)addlaz(u,l,r,m);//下放laz标记更新即将查询的区间或点 
    if(L<=m)sum+=qry(u<<1,l,m,L,R);//如果目标左边界在中心左边就查询左子树 
    if(m<R)sum+=qry(u<<1|1,m+1,r,L,R);//如果目标右边界在中心右边就查询右子树 
    return sum;//返回答案（区间和） 
}//为了每行注释

-------------------分界线-------------------------

高精度系列

除法研发中

1000位高精度结构体(仅支持加法和乘法)

使用须知见末尾

struct Bigint{
	int len,a[1000];
	Bigint(long long x=0){
		memset(a,0,sizeof(a));
		for(len=1;x;len++)a[len]=x%10,x/=10;
		len--;
	}
	int &operator[](int i){
		return a[i];
	}
	void jin(int l){
		len=l;
		for(int i=1;i<=len;i++)a[i+1]+=a[i]/10,a[i]%=10;
		while(!a[len])len--;
	}
	void print(){
		for(int i=max(len,1);i>=1;i--)printf("%d",a[i]);
	}
};
Bigint operator+(Bigint m,Bigint n){
	Bigint k;
	int len=max(m.len,n.len);
	for(int i=1;i<=len;i++)
	k[i]+=m[i]+n[i];
	k.jin(len+1);
	return k;
}
Bigint operator*(Bigint m,int n){
	Bigint k;
	int len=m.len;
	for(int i=1;i<=len;i++)
	k[i]=m[i]*n;
	k.jin(len+11);
	return k;
}

使用须知:

(1)定义赋值时格式如下:

Bigint a(1),b(0);

(2)若需输出一个高精度数,格式如下:

a.print();

(3)加法乘法格式相同,即:

a=a+b,b=a*2;

注意:1.不可使用如"+=""*="之类的符号

2.高精度数不能与高精度数相乘

3.高精度数不能与"int""long"相加

-------------------分界线-------------------------

排列组合

#include<bits/stdc++.h>
#include<windows.h>
//#include<iostream>
using namespace std;
int main(){
    int m,n,t=1,zf=1;
    system("pause");
    cout<<"加载中......"<<'\n';
	Sleep(1000);
	system("cls");
	cout<<"35.578%"<<'\n';
	Sleep(1000);
	system("cls");
	cout<<"62.435%"<<'\n';
	Sleep(1000);
	system("cls");
	cout<<"90.911%"<<'\n';
	Sleep(1000);
	system("cls");
	cout<<"99.999%"<<'\n';
	Sleep(400);
	system("cls");
	cout<<"100%"<<'\n';
	Sleep(100);
	system("cls");
    while(1){
    system("cls");
    cout<<"排列or组合"<<'\n';
	cout<<"排列写1，组合写2"<<'\n'; 
	int w;cin>>w;
	switch(w){
		case 1:
			cout<<"在m个中选n个排列"<<'\n'<<"请输入m的值：" ;
			cin>>m;
			cout<<"请输入n的值：";
			cin>>n;
			if(m<n){
			cout<<"? 你这不对吧！  n>m?"; 
			}else{
				for(int q=m;q>=(m-n+1);q--){
		            t*=q;
	            }
	            cout<<"共有"<<t<<"种可能";
			}
			break;	
		case 2:
			cout<<"在m个中选n个组合"<<'\n'<<"请输入m的值：" ;
			cin>>m;
			cout<<"请输入n的值：";
			cin>>n;
			if(m<n){
			cout<<"? 你这不对吧！  n>m?"; 
			}else{
			for(int q1=m;q1>=(m-n+1);q1--){
		            t*=q1;
	            }
				for(int q2=n;q2>=1;q2--){
		            zf*=q2;
	            }
	            cout<<"共有"<<t/zf<<"种可能";
			}
			break;
	}
	cout<<'\n'<<"5秒后自动清除"<<'\n'; 
	Sleep(1000);
	cout<<'5';
	Sleep(1000);
	cout<<'4';
	Sleep(1000);
	cout<<'3';
	Sleep(1000);
	cout<<'2';
    Sleep(1000);
	cout<<'1';
   	Sleep(1000);
	cout<<'0';                  
    }
	return 0;
} 

#include <bits/stdc++.h>
using namespace std;
vector<int> ve;
int m,n;
int main(){
	scanf("%d%d",&n,&m);
	int op,x,y,z;
	for (int i=0;i<n;i++) {
		int val;
		scanf("%d",&val);
		ve.push_back(val);
	}
	for (int i=0;i<m;i++) {
		scanf("%d",&op);
		switch (op){
			case 1:
				scanf("%d%d",&x,&y);
				ve.insert(ve.begin()+x,y);
		        break;
		    case 2:
		    	scanf("%d",&x);
		    	ve.erase(ve.begin()+x-1);
		    	break;
		    case 3:
		    	scanf("%d%d",&x,&y);
		    	sort(ve.begin()+x-1,ve.begin()+y);
		    	break;
		    case 4:
		    	scanf("%d%d",&x,&y);
		    	reverse(ve.begin()+x-1,ve.begin()+y);
		    	break;
		    case 5:
		    	scanf("%d%d%d",&x,&y,&z);
		    	for (int j=x-1;j<=y-1;){
		    		if(ve[j]==z){
		    			ve.erase(ve.begin()+j);
		    			y--;
					}else{
						j++;
					}
				}
				break;
		}   
	}
	for (auto it=ve.begin();it!=ve.end();it++){
		cout<<*it<<" ";
	}
	
	
	
	return 0;
}

I am the king God of math!

我是数学的狗 我爱数学 我爱物理 我爱化学 我爱生物 我爱语文 我爱英语