一些模板（按字典序排序）

最新推荐文章于 2021-05-12 21:18:34 发布
最新推荐文章于 2021-05-12 21:18:34 发布
阅读量199 收藏 1
点赞数
分类专栏： 经验教训
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydfy_/article/details/99290026
版权

一些模板的实现（按字典序排序）

文章目录

埃式筛法（优化）

应该比普通的快了一倍左右。

typedef long long ll;
int p[100000000];
int Max1=100000000;
void prime()
{
    p[2]=1;
    for(ll i=3;i<Max1;i+=2)p[i]=1;
    ll l=sqrt(Max1);
    for(ll i=3;i<l;i+=2)
    {
        if(p[i])
        {
            ll k=2*i;
            for(ll j=3*i;j<=Max1;j+=k)p[j]=0;
        }
    }
    return ;
}

fft快速傅里叶变换：

#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
const int MAXN=1e7+10;
inline int read()
{
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
const double Pi=acos(-1.0);
struct complex
{
    double x,y;
    complex (double xx=0,double yy=0){x=xx,y=yy;}
}a[MAXN],b[MAXN];
complex operator + (complex a,complex b){ return complex(a.x+b.x , a.y+b.y);}
complex operator - (complex a,complex b){ return complex(a.x-b.x , a.y-b.y);}
complex operator * (complex a,complex b){ return complex(a.x*b.x-a.y*b.y , a.x*b.y+a.y*b.x);}//不懂的看复数的运算那部分 
int N,M;
int l,r[MAXN];
int limit=1;
void fast_fast_tle(complex *A,int type)
{
    for(int i=0;i<limit;i++) 
        if(i<r[i]) swap(A[i],A[r[i]]);//求出要迭代的序列 
    for(int mid=1;mid<limit;mid<<=1)//待合并区间的中点
    {
        complex Wn( cos(Pi/mid) , type*sin(Pi/mid) ); //单位根 
        for(int R=mid<<1,j=0;j<limit;j+=R)//R是区间的右端点，j表示前已经到哪个位置了 
        {
            complex w(1,0);//幂 
            for(int k=0;k<mid;k++,w=w*Wn)//枚举左半部分 
            {
                 complex x=A[j+k],y=w*A[j+mid+k];//蝴蝶效应 
                A[j+k]=x+y;
                A[j+mid+k]=x-y;
            }
        }
    }
}
int main()
{
    int N=read(),M=read();
    for(int i=0;i<=N;i++) a[i].x=read();
    for(int i=0;i<=M;i++) b[i].x=read();
    while(limit<=N+M) limit<<=1,l++;
    for(int i=0;i<limit;i++)
        r[i]= ( r[i>>1]>>1 )| ( (i&1)<<(l-1) ) ;
    // 在原序列中 i 与 i/2 的关系是 ： i可以看做是i/2的二进制上的每一位左移一位得来
    // 那么在反转后的数组中就需要右移一位，同时特殊处理一下复数 
    fast_fast_tle(a,1);
    fast_fast_tle(b,1);
    for(int i=0;i<=limit;i++) a[i]=a[i]*b[i];
    fast_fast_tle(a,-1);
    for(int i=0;i<=N+M;i++)
        printf("%d ",(int)(a[i].x/limit+0.5));
    return 0;
}

KMP

用来搞字符串配对的。

void GetNextval(char* p, int next[])  
{  
    int pLen = strlen(p);  
    next[0] = -1;  
    int k = -1;  
    int j = 0;  
    while (j < pLen - 1)  
    {  
        if (k == -1 || p[j] == p[k])  
        {  
            ++j;  
            ++k;   
            if (p[j] != p[k])  
                next[j] = k;
            else  
                next[j] = next[k];  
        }  
        else  
        {  
            k = next[k];  
        }  
    }  
} 
int KmpSearch(char* s, char* p)  
{  
    int i = 0;  
    int j = 0;  
    int sLen = strlen(s);  
    int pLen = strlen(p);  
    while (i < sLen && j < pLen)  
    {  
        if (j == -1 || s[i] == p[j])  
        {  
            i++;  
            j++;  
        }  
        else  
        {  
        	j = next[j];  
        }  
    }  
    if (j == pLen)  
        return i - j;  
    else  
        return -1;  
}

快速幂

int fastPow(int a, int n){
    int base = a;        
    int res = 1; 
    while(n) {
        if(n & 1)   //如果n的最后一位是1，表示这个地方需要乘
              res *= base;  
        base *= base;       //推算乘积，a2 --> a4 --> a8--> a16...
        n >>= 1;     //n右移一位，把刚处理过的n的最后一位去掉
    }
    return res;
}

扩展欧几里得

求方程ax+by=gcd(a,b)的一个特解(x0, y0)

void extend_gcd(int a, int b, int &x, int &y){ 
                          //返回x，y，即一个特解(x0, y0)
    if(b==0) {
        x=1, y=0;      return ;
    }
    extend_gcd(b, a%b, x, y);
    int tmp = x;
    x = y;
    y = tmp - (a/b)*y;
}

(1)判断ax+by=n有解
(2)用扩展欧几里得求 ax+by=gcd(a,b)的特解(x0, y0)
(3)在ax0+by0=gcd(a,b)的两边同乘n/gcd(a,b)，得：
ax0n/gcd(a,b)+by0n/gcd(a,b)=n
(4)对照ax+by=n，一个特解是：
x0 n /gcd(a,b), y0 n /gcd(a,b)

特例1：
在这里插入图片描述

特例2：
逆元

int mod_inverse(int a, int m){
    int x, y;
    extend_gcd(a, m, x, y);
    return (m + x % m) % m;    //x可能是负数
}

求逆元的另一个方法：费马小定理。

母函数：

通过三阶循环来实现，这里展示的是一个从x的一次方到二次方到三次方…n次方的母函数。

#include <iostream>
using namespace std;
const int _max = 10001; 
int c1[_max], c2[_max];   
int main()
{
	int nNum;   
	int i, j, k;
 
	while(cin >> nNum)
	{
		for(i=0; i<=nNum; ++i)//第一个式子 
		{
			c1[i] = 1;
			c2[i] = 0;
		}
		for(i=2; i<=nNum; ++i)
		{
 
			for(j=0; j<=nNum; ++j)
				for(k=0; k+j<=nNum; k+=i)
				{
					c2[j+k] += c1[j];
				}
				for(j=0; j<=nNum; ++j)
				{
					c1[j] = c2[j];
					c2[j] = 0;
				}
		}
		cout << c1[nNum] << endl;
	}
	return 0;
}

rmq（区间最值查询）：

这个是用来找一段数据内某个区间内的极大值或者极小值。
通过二进制来实现，十分巧妙。

	代码实现：

#include<bits/stdc++.h>

using namespace std;
#define MAX 10000
int dp[MAX][MAX],a[MAX],b[MAX],n;
void rmq()
{
    for(int i=0;i<n;i++)dp[i][0]=a[i];
    for(int j=1;(1<<j)<n;j++)
    {
        for(int i=0;i+(1<<j)-1<n;i++)
        {
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<j-1)][j-1]);
        }
    }
}
int cz(int o,int p)
{
    int k=log2(p-o+1);
    return min(dp[o][k],dp[p-(1<<k)+1][k]);
}
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i];
    rmq();
    for(int i=0;i<n;i++)
    {
        for(int j=i;j<n;j++)
        {
            cout<<cz(i,j)<<' ';
        }
        cout<<endl;
    }
}

输入输出优化（面对一长串数字）：

这主要针对的是一长串的数字（就是有许多的数字）（一般情况下也是这样一次给你好多组数据），这样输入可以节约很多时间。

inline int read()
{
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
void print(int x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)print(x/10);
    putchar(x%10+'0');
}

Sunday算法（字符串配对）

比kpm与bm快。

int Sunday(const char *str1, const char *str2)
{
    int str1_len = strlen(str1);
    int str2_len = strlen(str2);
    int i = 0;
    int j = 0;
    enum{FALSE,TRUE};
    int Y = FALSE;   

    if(str1 == NULL || str2 == NULL){
    return -1;
    }

    while(i < str1_len && j < str2_len){
        if(str1[i] == str2[j])
        {
        	i++;
        	j++; 
        }
        else
        {
        	int num = i - j + str2_len ;
        	for(j = str2_len-1; j >= 0; j--)
        	{
        		if(str1[num] == str2[j])
        		{
            		i = num - j;
                	Y = TRUE;
            		break;
            	}
        	}
        	if(Y == FALSE)
        	{
        		i = num + 1; 
        	}
        	Y = FALSE;
        	j = 0;
        }
    }       
    if(i == str1_len){
    return -1;
    }
    else
    return i - str2_len;
}

通用外框：

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define pc putchar
inline int read()
{
    char c=getchar();int x=0,f=1;
    while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
    while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
    return x*f;
}
void print(int x)
{
    if(x<0)putchar('-'),x=-x;
    if(x>9)print(x/10);
    putchar(x%10+'0');
}
const int MAXN=1e7+10;

希尔排序：

这也是一种比较快的排序方法，所说有时比快排还要快，至于是不是真的我就不知道了，不过这个不能直接引用。

//函数功能，希尔排序算法对数字递增排序
//函数参数，数列起点，数列终点
void shell_sort(const int start, const int end) {
    int increment = end - start + 1;    //初始化划分增量
    int temp{ 0 };
    do {    //每次减小增量，直到increment = 1
        increment = increment / 3 + 1;
        for (int i = start + increment; i <= end; ++i) {    //对每个划分进行直接插入排序
            if (numbers[i - increment] > numbers[i]) {
                temp = numbers[i];
                int j = i - increment;
                do {    //移动元素并寻找位置
                    numbers[j + increment] = numbers[j];
                    j -= increment;
                } while (j >= start && numbers[j] > temp);
                numbers[j + increment] = temp;  //插入元素
            }
        }
    } while (increment > 1);
}
ydfy_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin acm模板超级好用
09-05
1 字符串处理 5 1.1 KMP . . . . . . . . ....1.2 e-KMP ....1.3 Manacher ....1.4 AC 自动机 ....1.5 后缀数组 ....1.5.1 DA ....1.5.2 DC3 ....1.6 后缀自动机 ....1.6.1 基本函数 ....1.6.2 例题 ....1.7 字符串 hash ....2.1 素数 ....
C++常用算法模板
06-04
插入排序的基本思想是将一个记录插入到已排好序的一组记录中，从而得到一个新的、记录增1的有序表。初始时认为数组中第一个元素是一个有序的子数组。从第二个元素开始，逐个对其排序，将当前元素与前面已排序的元素...
个人模板 字符串按字典序排序
xiaotuji的博客
05-06 374
#include using namespace std; struct A { char str[101]; }; char a[100][100]; int n; int cmp(const void *a,const void *b) { A *c, *d; c = (A *)a; d = (A *)b; return strcmp(c -> st
火星人 （字典序排序模板）（全排列函数）
chineseherofeng的博客
03-12 208
直接套板子的水题。。。。 附代码： #include <iostream> #include <algorithm> using namespace std; int A[10005]; int main(){ int a,b; cin>>a>>b; for(int i=0;i<a;i++){ cin>&g...
环形字典序最小模板
一条咸鱼
04-06 419
#include&lt;iostream&gt; using namespace std; int min_express(char * a,int len){ int i=0,j=1; //当前比较的位置 int t; //字典序比较结果 int k=0; //偏移 while(i&lt;len &amp;&amp; j&lt;len &amp;&a...
ACM常用模板 字典序全排列
穿袜子的流氓兔的专栏
09-07 1165
//字典序全排列与序号的转换 int perm2num(int n,int *p){ int i,j,ret=0,k=1; for (i=n-2;i>=0;k*=n-(i--)) for (j=i+1;j if (p[j] ret+=k; return ret; } void num2perm(int n,int *p,int t){ int i,j; for (i=
模板函数 比较字典序
zpf1998的博客
03-01 103
字典序比较的模板函数 可以直接使用下面的模板比较两个序列的字典序 template<class T> bool lexicographicallySmaller(vector<T> a,vector<T> b){ int n=a.size(); int m=b.size(); for(int i=0;i<n && i<m;++i...
文档拓扑排序-Kahn算法和字典序最小的拓扑排序
最新发布
04-17
### 文档拓扑排序-Kahn算法和字典序最小的拓扑排序 #### 拓扑排序概述 拓扑排序（Topological Sort）是指对于一个有向无环图（Directed Acyclic Graph, DAG），通过某种顺序对图中的所有顶点进行排序的一种方法。...
acm_浙大模板
09-27
组合数学部分提供了组合公式、排列组合生成、生成gray码、置换、字典序全排列和组合等内容。这些是处理排列组合问题的核心工具，比如在某些计数问题中，这些工具可以帮助我们枚举所有可能的组合。 3. 数据结构： ...
浙江大学ACM模板
08-28
2. **组合数学**：包括组合公式、排列和组合的生成方法、Gray码的生成、置换理论、字典序下的全排列和组合算法。 3. **数据结构**：涵盖并查集、堆、线段树、子段和及子阵和等数据结构的实现和应用。 4. **数论**...
小字典 排序 文件操作
07-05
一个适合初学者学习的关于文件操作，txt文件操作，实现的对文本的排序，以及添加，功能 文本操作 流操作 排序 泛型 类的封装
比较字典序的模版函数
qq_33901573的博客
09-30 546
#include using namespace std; template bool LexicograghicallySmaller(vector a,vector b) { int n=a.size(); int m=b.size(); int i; for(i=0;i<n&&i<m;i++) { if(a[i]<b[i]) retur
字典序排序
小博客
12-11 1394
我们先看一个例子。 示例： 1 2 3的全排列如下： 1 2 3 ， 1 3 2 ， 2 1 3 ， 2 3 1 ， 3 1 2 ， 3 2 1 我们这里是通过字典序法找出来的。那么什么是字典序法呢？ 对于数字1、2、3……n的排列，不同排列的先后关系是从左到右逐个比较对应的数字的先后来决定的。例如对于5个数字的排列 12354和12345，排列12345在前，排列12354在后。按照这样的
sort实现字典序
唐宋元明清的博客
04-04 2481
可以用stl的sort函数可以对sring数组进行字典序排序。注意必须是c++中的string类；代码如下#include&lt;stdio.h&gt; #include&lt;algorithm&gt; #include&lt;string&gt; #include&lt;iostream&gt; using namespace std; int main() { string data[...
字典序排序算法解析
zhanghui962623727的博客
08-29 9751
1.1简述 字典序排序算法是一种对于随机序列生成全排列的排序方法。例如对于随机变量X={1,2,3},则生成的全排列为：{1,2,3}、{1,3,2}、{2,1,3}、{2,3,1}、{3,1,2}、{3,2,1}。 1.2字典序排序的求解步骤： (1)从右至左找出数组（序列）中第一个正序（左边数字小于右边数字），计左边数字的下表为left，计当前左边数字为leftValue (2)再
对n以内的数字进行字典序排序(java)
iCoding91
11-21 8191
刷题时，遇到的问题，目前是想到了两种方式：一种是重写比较器；另一种是使用字符串的表达方式，然后进行自然排序。 下面给出例子。 1、改写比较器方式 package schooloffer17; import java.util.*; /** * @Author: cxh * @CreateTime: 17/11/21 15:28 * @ProjectName: JavaB
字典序排序问题
热门推荐
weixin_38450840的博客
06-11 1万+
其方法是，按照字母顺序，或者数字小大顺序，由小到大的形成序列。我们先看一个例子。示例： 1 2 3的全排列如下：1 2 3 ， 1 3 2 ， 2 1 3 ， 2 3 1 ， 3 1 2 ， 3 2 1我们这里是通过字典序法找出来的。那么什么是字典序法呢？从上面的全排列也可以看出来了，从左往右依次增大，对这就是字典序法。可是如何用算法来实现字典序法全排列呢？我们再来看一段文字描述：（用字典序法找1...
经典算法：字典序排列
codename_cys的博客
05-12 1万+
杂谈：经典算法之字典序排列 0. 引言 1. 字典序排序 2. 获取字典序排列的邻接元素 1. 获取字典序排序的次小字符串 2. 获取字典序排序的次大字符串 3. 参考链接 0. 引言 最近连着两周打比赛都遇到了字符串字典序的相关问题，然后还连着两周都在这个坑里面摔死，简直了…… 因此，就趁着这个假期来整理一下字典序相关的内容，省的后面再在同一个问题上摔倒了…… 1. 字典序排序 我们首先来看一下字典序排序的定义。 考察两个字符串s以及s'，s字典序在s'之前的判断条件为： def is..
字典序最小拓扑排序C++模版
08-17
以下是一个用C++实现的拓扑排序的模板： ...输出结果即为字典序最小的拓扑排序序列。输入部分需要提供节点数目n和边数目m，然后依次输入每一条边的起始节点u和终止节点v。输出结果为拓扑排序的节点序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值