秀蓉主义万岁！

作文怎么才能写上43分！！！

怒斥一名！！！

Welcome to PhigrOS

-O2 -std=c++14 -static 代码寄放处 小游戏

#include <bits/stdc++.h>
#include <random>
#include <cstdlib>
#include <ctime>
#include <thread>
#include <windows.h>
#include <cstdlib>
using namespace std;
const int N=10;
int ans[N],blood;
bool vis[N],flag[N],vis2[N];
char c[N];
void print(string s){
	for(int i=0;i<s.size();i++){
		cout<<s[i];
		Sleep(50);
	}
} 
void sp(string s){
	for(int i=0;i<s.size();i++){
		cout<<s[i];
		Sleep(100);
	}
} 
void wrong_in(){
	print("别闹，好好输入——\n"); 
} 
void skip(){
	print("年轻气盛啊~\n"); 
}
void legacyRandom(int n) {
    srand(static_cast<unsigned int>(time(nullptr)));
    for (int i = 1; i <=n; ++i) {
    	int x=rand()%10;
    	while(vis[x]){if(x==9)x=0;else x++;}
		vis[x]=1,ans[i]=x;flag[x]=1;
	}
}
void backboard(){
	Sleep(1000); 
	system("cls");
	print("果然，史莱克是天选之子！\n正在他在废墟之中探索时   \n一道黑光吸引了史莱克的注意……"); 
	Sleep(2000);
	system("cls");
	print("神秘的声音：\n"); 
	Sleep(500);
	print("你TM终于来啦~我等了你好久，天选之人~\n");
	print("史莱克出意外地不出意外，因为他在进入游戏前就知道自己要面临什么了……\n而且这勾石剧情一进入就不能跳出了\n"); 
	Sleep(2500); 
	system("cls");
	print("史莱克靠近黑光，竟然是一个上锁的宝箱！\n从中蹦出一个全息屏\n") ;
	Sleep(2000);
	system("cls");
	print("“I am the guardian of this treasure chest.”\n") ;
	Sleep(1000);
	print("史莱克挠挠头，想：他说什么？\n");
	Sleep(500);
	print("“总之你想要的就在这个宝箱之中，显而易见，需要密码，你肯定不知道”\n"); 
	Sleep(1000); 
	print("“为了让你拯救世界完成剧情，就告诉你解开的方法吧”\n"); 
	Sleep(2000); 
	print("史莱克感受了一下空虚的kua下，它能隐约感受到箱子里是什么\n或许真的需要解开它");
	Sleep(2000);
	system("cls");
	print("全息屏：显而易见这是一个n位数的密码锁，这是由n个不同的数字构成的，\n就如同天上的星星一样，每一颗都不同，\n");
	sp("你应该知道意大利面吧，我觉得，42号混凝土就应该拌它，这真的很好吃，你不觉得吗？\n") ;
	print("不过它与密码没关系,我是在浪费你时间，哈哈哈……\n");
	Sleep(3000);
	print("其实你已经知道解锁规则了，不是吗？\n还要我教吗？\n");
	Sleep(1000);
	print("哎，看你这么可怜，我就再说一次吧……\n");
	Sleep(500);
	print("你可以猜测密码，我会告诉你你所猜的数中有几个数在答案中有，也会告诉你有几个位置是对的\n");
	Sleep(2233);
	sp("怎么样？简单吧\n");
	Sleep(500);
	sp("你要开始游戏了，我会一直陪着你的，你，准备好了吗？\n");
	Sleep(1000);
	cout<<"1.没有  2.没有  3.没有  4.没有  5.没有  6.没有  7.好的  8.没有  9.没有"; 
	int op;
	do{
		cin>>op;
		if(op==7)return;
		if(op<1||op>9) wrong_in();
		else {
			cout<<"没准备好你玩个毛！！！"; 
			exit(0); 
		}
	}while(op<1||op>9);
}
void chaofeng(){
	srand(static_cast<unsigned int>(time(nullptr)));
    int op=rand()%10;
	if(op<5)cout<<"垃圾，不对啊！\n";
	else if(op>=5&&op<8) cout<<"杂鱼~还是不对\n";
	else if(op==8) cout<<"“头”被混凝土砸了！？"; 
	else print("你脑子呢，用一下啊\n"); 
}
void win(int n){
	srand(static_cast<unsigned int>(time(nullptr)));
    if(n<5){
    	sp("宝箱打开了，冒出了蓝光，史莱克有种不祥的预感……\n");
    	Sleep(1000);
    	int op=rand()%2;
    	if(op){
    		sp("竟然是，");
    		Sleep(1000);
    		print("《五年高考，三年模拟》全套！\n");
    		print("“知识可以拯救一切！！！”");
		} else{
			sp("竟然是，");
    		Sleep(1000);
    		print("火箭模型！\n");
    		print("但是不能起飞和拯救世界……");
		} 
	}else{
		sp("宝箱打开了，冒出了金光，史莱克心想：“出金了？”\n");
    	Sleep(1000);
    	sp("竟然是，");
    	Sleep(1000);
    	print("解开史莱克神器的解封符！他可以拯救世界了！！！\n");
    	Sleep(1000);
		print("预知后事如何，且听2.0分解（但是可能没有了）\n");
	} 
}
void game(int n){
	legacyRandom(n);
	int now_b=blood;
	for(int i=1;i<=n;i++)cout<<ans[i]<<' ';
	cout<<endl;
	cout<<"                         位 数 次数\n";
	int wei,shu;
	do{
		wei=0,shu=0;
		memset(vis2,0,sizeof(vis2));
		for(int i=1;i<=n;i++){
			cin>>c[i];
			if(c[i]-'0'==ans[i])wei++;
			if(flag[c[i]-'0']&&!vis2[c[i]-'0'])shu++,vis2[c[i]-'0']=1;
		}
		now_b--;
		if(!now_b){
			sp("你拿不回你的***了，策划告诉我，你输了，就不能拯救世界了\n");
			Sleep(2000);
			sp("再见");
			exit(0); 
		}
		if(now_b<=blood/2){
			if(now_b==blood/2)cout<<"条已过半，好自为之！\n"; 
			else chaofeng();
		}
		cout<<"                         "<<wei<<"   "<<shu<<"    "<<blood-now_b<<endl;
	}while(wei!=n);
	cout<<"显示屏：你终于做出来了！！！\n"; 
	Sleep(2000);
	system("cls");
	win(n);
	return;
}
int main() {
	cout<<"噔噔咚！！！";
	print("           \n");
	print("世界陷入了危险！！！（至于是什么危险我也不知道，欢迎补充）\n史莱克奉臭果子之命寻求拯救世界的办法……\n") ;
	print("       \n") ;
	cout<<"1.开始游戏   2.开始游戏   3.开始游戏   4.开始游戏   5.废话少说直接进入正轨！！！"; 
	int m;
	do{
		cin>>m;
		if(m<1||m>5)wrong_in();
	}while(m<1||m>5);
	if(m!=5)backboard();
	else skip(); 
	print("请输入难度（1-9）："); 
    int n;
	cin>>n;
	system("cls");
	blood=n*6;
	cout<<"你有"<<blood<<"次尝试机会，桀桀桀……\n"; 
	game(n);
    return 0;
}

神秘

#include<bits/stdc++.h>
using namespace std;
const int N=3e2+10;
char g[N][N];
bool vis[N][N];
struct node{
	int x,y,t;
};
int sx,sy,ds,dy,n,m;
queue<node>q;
map<char,node>mp;
map<node,node>cs;
int d1[]={0,0,-1,1},d2[]={-1,1,0,0},ans;
void bfs(node v){
	q.push(v);
	vis[sx][sy]=1;
	while(!q.empty()){
		int x=q.front().x,y=q.front().y;
		ans=q.front().t;
		if(g[x][y]=='='){
			cout<<ans;
			return;
		}
		q.pop();
		if(g[x][y]<='Z'&&g[x][y]>='A'){
			int nx=cs[node{x,y,0}].x,ny=cs[node{x,y,0}].y;
			q.push(node{nx,ny,ans+1});
			vis[nx][ny]=1;
		}
		for(int i=0;i<4;i++){
			int nx=x+d1[i],ny=y+d2[i];
			if(nx<1||ny<1||nx>n||ny>m||vis[nx][ny])continue;
			vis[nx][ny]=1;
			q.push(node{nx,ny,ans+1});
		}
	}
	cout<<ans;
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>g[i][j];
			if(g[i][j]=='#')vis[i][j]=1;
			if(g[i][j]=='@')sx=i,sy=j;
			if(g[i][j]<='Z'&&g[i][j]>='A'){
				if(mp[g[i][j]].t==1){
					cs[node{i,j,0}]=mp[g[i][j]];
					cs[mp[g[i][j]]]=node{i,j,0};
				}
				else mp[g[i][j]]=node{i,j,1};
			}
		}
	}
	bfs(node{sx,sy,0});
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int g[N][N],ans[N][N],vis[N][N],d1[]={0,0,1,-1},d2[]={1,-1,0,0};
int n,m;
void dfs(int x,int y,int c,int sum){
	if(sum>=ans[x][y])return;
	
	ans[x][y]=sum;
	if(x==m&&y==m){
		cout<<sum<<endl;
		return;
	}
	for(int i=0;i<4;i++){
		int nx=x+d1[i],ny=y+d2[i];
		if(nx<1||ny<1||nx>m||ny>m||vis[nx][ny])continue;
		if(g[nx][ny]==-1&&g[x][y]==-1)continue;
		vis[nx][ny]=1;
		cout<<x<<','<<y<<'-'<<nx<<','<<ny<<':'<<sum<<endl;
		if(g[nx][ny]==-1) dfs(nx,ny,c,sum+2);
		else dfs(nx,ny,g[nx][ny],sum+=(c!=g[nx][ny]));
		vis[nx][ny]=0;
	}
}
int main(){
	int x,y,z;
	cin>>m>>n;
	for(int i=1;i<=m;i++)
		for(int j=1;j<=m;j++)g[i][j]=-1;
	memset(ans,0x3f,sizeof(ans));
	while(n--){
		cin>>x>>y>>z;
		g[x][y]=z;
	}
	for(int i=1;i<=m;i++){
		for(int j=1;j<=m;j++){
			cout<<g[i][j]<<' ';
		}
		cout<<endl;
	}
	vis[1][1]=1;
	dfs(1,1,g[1][1],0);
	for(int i=1;i<=m;i++){
		for(int j=1;j<=m;j++){
			cout<<ans[i][j]<<' ';
		}
		cout<<endl;
	}
	if(ans[m][m]==0x3f3f3f3f)cout<<-1;
	else cout<<ans[m][m];
	return 0;
}

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1e2+10,M=1e5+10;
ll dp[M];
struct food{
	int a,b,c;
}arr[N];
bool cmp(food a,food b){
	return a.c*b.b<a.b*b.c;
}
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++)cin>>arr[i].a;
	for(int i=1;i<=m;i++)cin>>arr[i].b;
	for(int i=1;i<=m;i++)cin>>arr[i].c;
//	sort(arr+1,arr+1+m,cmp);
	for(int i=1;i<=m;i++){
		for(int j=n;j>=arr[i].c;j--){
			dp[j]=max(dp[j],dp[j-arr[i].c]+arr[i].a-(j-arr[i].c)*arr[i].b);
		}
//		for(int j=arr[i].c;j<=n;j++)cout<<dp[i]<<' ';
//		cout<<endl;
	}
	cout<<dp[n];
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e3+10;
int dp[65][100000];
struct node{
	int w,v;
};
vector<node>a[N],th[N];
int cnt;
void dfs(int i,int j,int w,int v){
	if(j>=a[i].size()){
		th[cnt].push_back({w+a[i][0].w,v+a[i][0].v});
		return;
	}
	dfs(i,j+1,w+a[i][j].w,v+a[i][j].v);
	dfs(i,j+1,w,v);
	return;
}
int main(){
	int n,m,w,p,q;
	scanf("%d%d",&n,&m);
	n/=10;
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&w,&p,&q);
		if(q)a[q].push_back({p*w,w/10});
		else a[i].push_back({p*w,w/10});
	}
	for(int i=1;i<=m;i++){
		if(a[i].size())cnt++,dfs(i,1,0,0);
	}
//	for(int i=1;i<=cnt;i++){
//		for(auto x:th[i]){
//			cout<<x.w<<' '<<x.v<<endl;
//		}
//	}
	for(int i=1;i<=cnt;i++){
		for(auto x:th[i]){
			for(int j=n;j>=x.v;j++){
				dp[i][j]=max(dp[i-1][j-x.v]+x.w,dp[i][j]);
			}
		}
	}
	cout<<dp[cnt][n];
	return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+10;
int arr[N],s[N],dp[N][N];
int main(){
	int n,k;
	memset(dp,127/3,sizeof(dp));
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>arr[i];
		s[i]=s[i-1]+arr[i];
		dp[1][i]=arr[i];
	}
	for(int i=2;i<=k;i++){
		for(int j=1;j<=n;j++){
			for(int l=1;l<=j;l++){
				dp[i][j]=min(max(dp[i-1][j-l]+s[j]-s[l]),dp[i][j])
			}
		}
	}
	return 0;
}

我去！那么多模板呢？ 哦~在这儿！

快点击下方链接去看stone9070分享的算法模版吧！

快速传送~http://xx.ncyzedu.cn:4326/pdfbrowser/web/viewer.html?file=/downloads/knowledge_list/算法模板.pdf

极致压缩的gcd和lcm

int gcd(int a,int b){return (b==0)?a:gcd(b,a%b);}//最大公因数 
int lcm(int a,int b){return a*b/(gcd(a,b));}//最小公倍数 

堆

priority_queue<int>q;//默认大顶堆 
priority_queue<int,vector<int>,less<int>>q;//小顶堆 
priority_queue<int,vector<int>,greater<int>>q;//大顶堆 

树形背包（理解版）

#include<iostream>
#include<vector>
using namespace std;
struct Thing//定义一个物品结构体包括物品属性体积和价值 
{
	int vi;
	int wi;
};
/*定义以下全局变量*/ 
vector< vector<int> >tree;//定义一个二维数组存储各个节点的子节点信息 
vector<Thing>things; //定义物品数组存储物品的信息 
int N,V;//定义物品的数量和背包的体积 
int ans[110][110]; //定义二维数组存储答案ans[i][j]表示在选节点i且体积不超过j的前提下所能得到的最大价值 
void dfs(int Node)
{/*此函数的功能是在得到一个节点后我们要把在选这个节点的情况下
   的每一体积下的最大值都求出来并存入ans数组中 */
	if(things[Node].vi <= V)//先判断背包能否放下该节点代表的物品如果可以则进入判断 
	{
		if(tree[Node].size()==0||things[Node].vi == V)
    	{/*判断如果该节点没有子节点或其代表的物品体积恰好等于背包体积
		   在这两种情况下都不必再去考虑该节点的子节点怎么选择直接赋值*/ 
    		for(int i=things[Node].vi;i<=V;i++)
    		{/*将大于或等于该物品的各个体积全赋为该物品的价值
			   并将其他体积全赋值为0这里因为ans为全局变量所以
			   各点本身就以赋初值为0在这里就不再进行这一操作*/
    			ans[Node][i]=things[Node].wi;
    		}	
    	}
    	else//否则我们需要考虑其子节点的选择情况 
    	{
    		for(int k=0;k<tree[Node].size();k++)//我们要遍历各个子节点 
    		{
				dfs(tree[Node][k]);//首先我们求出选这个子节点的情况下各体积下的最优解 
    			for(int i=V-things[Node].vi;i>=0;i--)
    			{/*我们开始求选当前节点的情况下各体积下的最优解
				   我们的体积从V-things[Node].vi开始到0因为我们
				   确定了选当前物品所以要为他留出空间，体积从大
				   到小是因为和01背包一样子节点的每种体积至多可以选一遍*/
    				for(int j=0;j<=i;j++)//当前0到i这个范围就是这个子节点以下所能占用的体积我们要从这些体积中选出最优的那个体积 
    					ans[Node][i] = max(ans[Node][i],ans[Node][i-j]+ans[tree[Node][k]][j]);
						/*状态转移我们要用在不选、以及分别从这个子节点以下选总体积为1、2……i的物品中
						  选择一个最佳决策，即比较当前价值和选不同体积下的价值分别作比较*/
    			}
    		}
    		for(int i=V;i>=things[Node].vi;i--)//最后我们要将我们的根节点的价值加入即开始我们为之空出的体积 
    		{//在这个体积以上的全部加上这个节点代表的物品的价值 
    			ans[Node][i] = ans[Node][i-things[Node].vi] + things[Node].wi;
    		}
    		for(int i = 0;i < things[Node].vi;i++ )
			{/*这个体积以下的代表这个节点不能选这个节点不能选那么他所有的子节点也不能选所以全部赋初值为0
			   这里需要赋值是因为我们在上面的求大体积最优解的时候用到了这块体积我们已经为他们赋上值了
			   它们已经不是0了所以这里的赋0不能省*/
				ans[Node][i]=0;
			}
    	}
	}
}
int main()
{
	int root;      //定义一个变量一会储存根节点 
	cin>>N>>V;     //输入物品数和背包体积 
	tree.resize(N);//开辟空间一个数组储存各节点的子节点信息从而储存整棵树的结点关系 
	for(int i=0;i<N;i++)//遍历输入物品信息 
	{
		int v,w,f;
		cin>>v>>w>>f;
		things.push_back({v,w});//将物品信息放入物品数组things 
		if(f==-1)//检查该节点的父节点是哪一个如果它是父节点则记录它 
		{
			root=i;
		}
		else//如果不是父节点在在其父节点代表的一维数组中存入该节点 
		{
			tree[f-1].push_back(i);//我们的节点下标从0到n-1输入的父节点是1到n所以让输入的f减去1即我们要找的父节点 
		}
	}
	dfs(root);//从根节点调用递归函数 
	cout<<ans[root][V]<<endl;//输出最终结果 
	return 0;
} 
//https://zhuanlan.zhihu.com/p/648341058

线段树洛谷P3372（LAZY优化+每行注释）

#include<bits/stdc++.h>//万能头文件（并非完全万能） 
using namespace std;//命名空间 
const int N=1e6+10;//个人习惯，题目范围为1e5，但我开1e6，嘿嘿，+10防爆 
long long tr[N<<2],lazy[N<<2];//数据范围爆int，要用long long，一个存树一个存lazy标记 
//■更新函数 
void pushup(int u){tr[u]=tr[u<<1]+tr[u<<1|1];}//这点的值为左右子树和
//■下放lazy标记函数 
void addlazy(int u,int l,int r,int m){//当前节点，当前左、右边界，当前区间中点 
    tr[u<<1]+=(m-l+1)*lazy[u];//左子树总值更新 
    tr[u<<1|1]+=(r-m)*lazy[u];//右子树总值更新
    lazy[u<<1]+=lazy[u];//左子树lazy标记加上其父亲的标记以便后续下放标记 
    lazy[u<<1|1]+=lazy[u];//右子树lazy标记加上其父亲的标记以便后续下方标记 
    lazy[u]=0;//你现在已经没有价值了！以后再来吧（下放后清除标记） 
}//函数结尾你懂的 
//■建树函数 
void build(int u,int l,int r){//当前节点，当前左、右边界 
    if(l==r){scanf("%lld",&tr[u]);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;//修改这个点的值 = 区间大小 * 修改参数 
        lazy[u]+=v;return;}//存储lazy值表示他所有后代都要这样修改 
    int m=l+(r-l>>1);//你说呢 
    if(lazy[u]&&l!=r)addlazy(u,l,r,m);//如果这点有lazy值，下放lazy标记以便后续修改 
    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(lazy[u]&&l!=r)addlazy(u,l,r,m);//下放lazy标记更新即将查询的区间或点 
    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;//返回答案（区间和） 
}//为了每行注释 
//■主函数，懂得都懂 
int main(){//注意！“main”别写错了 
    int n,q,op,x,y;//个数和下标，int足矣 
    scanf("%d%d",&n,&q);//输入格式详见洛谷P3372 
    build(1,1,n);//建树 
    long long k;//后续计算可能为long long 
    while(q--){//q次行为 
        scanf("%d",&op);//是修改还是查询 
        if(op==1){//修改 
            scanf("%d%d%lld",&x,&y,&k);//输入不用说吧 
            update(1,1,n,x,y,k);//修改的传参 
        }else {//查询 
            scanf("%d%d",&x,&y);//这输入也不用说吧 
            printf("%lld\n",qry(1,1,n,x,y));//查询的传参和输出 
        }//有两行注释不能压行了 
    }//压成一行不好看 
    return 0;//可要可不要（最好还是要） 
}//完美收官 ~ ~ ~ 

manacher

#include<bits/stdc++.h>
using namespace std;
int manacher(string s){
	int ans=0;
	const int n=s.size();
	int d1[n+1],d2[n+1];
	for(int i=0;i<=n;i++)d1[i]=1;
	for(int i=0;i<=n;i++)d2[i]=0;
	for(int i=0,l=0,r=0;i<n;i++){
		if(i<=r)d1[i]=min(d1[l+r-i],r-i+1);
		while(i-d1[i]>-1&&i+d1[i]<n&&s[i-d1[i]]==s[i+d1[i]]){d1[i]++;ans=max(ans,d1[i]*2-1);}
		if(i+d1[i]-1>r){l=i-d1[i]+1,r=i+d1[i]-1;}
	}
	for(int i=1,l=0,r=0;i<n;i++){
		if(i<=r)d2[i]=min(d2[l+r-i+1],r-i+1);
		while(i-d2[i]>0&&i+d2[i]<n&&s[i-d2[i]-1]==s[i+d2[i]]){d2[i]++;ans=max(ans,d2[i]*2);}
		if(i+d2[i]>r){l=i-d2[i];r=i+d2[i]-1;}
	}
	return ans;
}
int main(){
	string s;
	getline(cin,s);
	cout<<manacher(s);
	return 0;
}

kmp

#include<bits/stdc++.h>
using namespace std;
string s,t;
int nxt[1000001];
int main(){
	cin>>s>>t;
	int cnt=0;
	for(int i=1;i<t.size();i++){
		while(cnt&&t[i]!=t[cnt])cnt=nxt[cnt-1];
		if(t[i]==t[cnt])cnt++;
		nxt[i]=cnt;
	}
	cnt=0;
	for(int i=0;i<s.size();i++){
		while(cnt&&t[cnt]!=s[i]) cnt=nxt[cnt-1];
		if(t[cnt]==s[i])cnt++;
		if(cnt==t.size()){
			cout<<i-t.size()+2<<endl;
			cnt=nxt[cnt-1];
		}
	}
	for(int i=0;i<t.size();i++){
		cout<<nxt[i]<<' ';
	}
	return 0;
}

更好理解的快排和归并！

const int N=1e6+10;
int arr[N];
void quick_sort(int left,int right){
	if(left<right){
		int keynum=arr[right];//随定一个标准 
		int i=left;
		for(int j=left;j<right;j++){
			if(keynum>=arr[j])swap(arr[i],arr[j]),i++;
		}
		swap(arr[i],arr[right]);
		quick_sort(left,i-1);
		quick_sort(i+1,right);
	}
}
//使用
puick_sort(arr起始下标,arr终止下标); 

const int N=1e6+10;
long long a[N],b[N];
void m_sort(int left,int right){
	if(left>=right)return;
	long long mid=left+right>>1;
	m_sort(left,mid);
	m_sort(mid+1,right);
	long long i=left,j=mid+1,k=left;
	while(i<=mid&&j<=right){
		if(a[i]>a[j]){
			b[k++]=a[j++];
		}else{
			b[k++]=a[i++];
		}
	}
	while(i<=mid)b[k++]=a[i++];
	while(j<=right)b[k++]=a[j++];
	for(long long l=left;l<=right;l++)a[l]=b[l];
}
//使用
m_sort(a的起始下标,a的终止下标); 

非常重要的hash！！！

模版

#include<bits/stdc++.h>
using namespace std;
string s;
int n;
unsigned long long b=131,m=1e8+3;
vector<unsigned long long>p;//具体值 
vector<unsigned long long>h;//进制 
map<unsigned long long,int>cnt;
void built_hash(){
	p.resize(n+1,0);
	h.resize(n+1,1);
	for(int i=1;i<=n;i++){
		p[i]=(p[i-1]*b+s[i-1])%m;
		h[i]=(h[i-1]*b)%m;
	}
}
unsigned long long get_hash(int l,int r){
	int len=r-l+1;
	return (p[r+1]-p[l]*h[len]%m+m)%m;
}
int main(){
	built_hash();
	
	return 0;
}