省赛前整理

最新推荐文章于 2021-05-13 13:52:10 发布

恋花飘落

最新推荐文章于 2021-05-13 13:52:10 发布

阅读量258

点赞数

文章标签：模板

本文链接：https://blog.csdn.net/qq_42279796/article/details/89816554

版权

常用函数

二分查找函数：

数组:a,长度:n,查找数:x
upper_bound(a,a+n,x)-a (可以插入的下界，第一个大于等于的)
lower_bound(a,a+n,x)-a (可以插入的上界，第一个大于的)

排列：

头文件：#include< algorithm>
next_permutation(a,a+3) //求数组a中前3个元素的下一个排列
prev_permutation(a,a+3) //求数组a中前3个元素的前一个排列
a可为普通数组，string，vector……

求1-10的第10个排列
a[10]={1,2,3,4,5,6,7,8,9,10};
for(int i=1;i< k;i++)
next_permutation(a,a+10);
for(int i=0;i<10;i++)
cout<< a[i]< < ” “;

java大数：

import java.util.*;
import java.math.*;
public class Main{
    public static void main(String args[]){
       Scanner cin = new Scanner(System.in);
       BigInteger a, b;
       //以文件EOF结束
       while (cin.hasNext()){
           a = cin.nextBigInteger();
           b = cin.nextBigInteger();
           System.out.println(a.add(b)); //大整数加法
           System.out.println(a.subtract(b)); //大整数减法
           System.out.println(a.multiply(b)); //大整数乘法
           System.out.println(a.divide(b)); //大整数除法(取整)
           System.out.println(a.remainder(b)); //大整数取模
           //大整数的比较
           if( a.compareTo(b) == 0 ) System.out.println("a == b"); //大整数a==b
           else if( a.compareTo(b) > 0 ) System.out.println("a > b"); //大整数a>b
           else if( a.compareTo(b) < 0 ) System.out.println("a < b"); //大整数a<b
           //大整数绝对值
           System.out.println(a.abs()); //大整数a的绝对值
           //大整数的幂
           int exponent=10;
           System.out.println(a.pow(exponent)); //大整数a的exponent次幂
           //返回大整数十进制的字符串表示
           System.out.println(a.toString());
           //返回大整数p进制的字符串表示
           int p=8;
           System.out.println(a.toString(p));
       }
    }
}

图论

二分图：

独立集：指一个图中两两不相邻的点构成的集合。
最小顶点覆盖：选择最少的顶点能覆盖所有的边，即从原图中任选一条边，至少有一个顶点属于这个顶点集合。
在二分图中，最大匹配数=最小顶点覆盖数
最大独立集=定点数-最小顶点覆盖数
二分图的最大匹配可以用匈牙利算法求得

bool dfs(int pos)  
{
	for(int i=0;i<n;i++){
		if(a[pos][i]&&vis[i]==0)
		{
			vis[i]=1;
			//printf("%d\n",i);
			if(book[i]==-1||dfs(book[i]))  //搜索是否可以腾位置
			{
				book[i]=pos;
				return true;
			}
		}
	}
	return false;
}
int hungary()  //匈牙利算法
{
	int ans=0;
	memset(book,-1,sizeof(book));
	for(int i=0;i<n;i++){
		memset(vis,0,sizeof(vis));
		if(dfs(i))
			ans++;
	}
	return ans;
}

最短路：

SPFA算法：

struct stu
{
	int v;
	double r,c;
};
vector<stu> x[10000];
void add(int u,int v,double r,double c)
{
	stu t;
	t.c=c;
	t.r=r;
	t.v=v;
	x[u].push_back(t);
}
int n,m,s,vis[10000];
double v1,mi[10000];
void spfa()
{
	for(int i=0;i<=n;i++){
		mi[i]=0;vis[i]=0;
	}
	mi[s]=v1;
	queue<int> q;
	while(!q.empty())  q.pop();
	q.push(s);
	vis[s]=1;
	while(!q.empty())
	{
		int u=q.front();
		q.pop();
		vis[u]=0;
		for(int i=0;i<x[u].size();i++){
			int v=x[u][i].v;
			double r=x[u][i].r,c=x[u][i].c;
			if(mi[v]<(mi[u]-c)*r)
			{
				mi[v]=(mi[u]-c)*r;
				if(!vis[v])
				{
					q.push(v);
					vis[v]=1;
				}
			}
			if(mi[s]>v1)   //原 
			{
				printf("YES\n");
				return;
			}
		}
	}
	printf("NO\n");
}
int main()
{
	while(scanf("%d%d%d%lf",&n,&m,&s,&v1)!=EOF)
	{
		for(int i=0;i<=n;i++)
		  x[i].clear();
		for(int i=0;i<m;i++){
			int a,b;
			double c,d,e,f;
			scanf("%d%d%lf%lf%lf%lf",&a,&b,&c,&d,&e,&f);
			add(a,b,c,d);
			add(b,a,e,f);
		}
		spfa();
	}
	return 0;
}

bellman(可以判负环)

int n,m,w,s,e,t,cnt[100000],mi[100000],sum;
bool vis[100000];
struct stu
{
	int cost,u,v;
};
vector<stu> x;
void add(int a,int b,int c)
{
	struct stu t;
	t.u=a;t.v=b;t.cost=c;
	x.push_back(t);
}
void bellman()
{
	for(int i=0;i<=n;i++)
	   mi[i]=INF;
	mi[1]=0;
	for(int j=1;j<n;j++){
		for(int i=0;i<x.size();i++){
			int u=x[i].u,v=x[i].v,cost=x[i].cost;
			if(mi[v]>mi[u]+cost)
			  mi[v]=mi[u]+cost;
		}
	}
	for(int i=0;i<x.size();i++){
		int u=x[i].u,v=x[i].v,cost=x[i].cost;
		if(mi[v]>mi[u]+cost)
		{
			printf("YES\n");
			return; 
		}    
	}
	printf("NO\n");
}
int main()
{
	int tt;
	cin>>tt;
	while(tt--)
	{
		int a,b,c;
		x.clear();
		scanf("%d%d%d",&n,&m,&w);
		for(int i=0;i<m;i++){
			scanf("%d%d%d",&a,&b,&c);
			add(a,b,c);
			add(b,a,c);
		}
		for(int i=0;i<w;i++){
			scanf("%d%d%d",&a,&b,&c);
			add(a,b,-c);
		}
		bellman();
	}
	return 0;
}

Dijkstra算法：

int t,n,map[2010][2010];
int lc[2010],vis[2010];
void dij()
{
	for(int i=0;i<n;i++){
		vis[i]=0;
		lc[i]=INF;
	}
	lc[0]=0;
	for(int j=0;j<n;j++){
		int mi=INF,k=-1;
		for(int i=0;i<n;i++){
			if(!vis[i]&&mi>lc[i])
			{
				mi=lc[i];
				k=i;
			}
		}
		if(k==-1)   return;
		vis[k]=1;
		for(int i=0;i<n;i++){
			if(!vis[i]&&lc[k]+map[k][i]<lc[i])

			   lc[i]=map[k][i]+lc[k];
		}
	}
}
int main()
{
	int a,b,c;
	cin>>t>>n;
	for(int i=0;i<n;i++)
	   for(int j=0;j<n;j++)
	      map[i][j]=INF;
	for(int k=0;k<t;k++){
		scanf("%d%d%d",&a,&b,&c);
		if(c<map[a-1][b-1])
		{
			map[a-1][b-1]=map[b-1][a-1]=c;
		}
	}
	dij();
	printf("%d\n",lc[n-1]);
	return 0;
}

注意的点：

单元最短路与多元最短路：方向反转是多元变单元

博弈论

尼姆博弈

有任意堆物品，每堆物品的个数是任意的，双方轮流从中取物品，每一次只能从一堆物品中取部分或全部物品，最少取一件，取到最后一件物品的人获胜。
结论：把每堆物品数全部异或起来，如果得到的值为0，那么先手必败，否则先手必胜。

巴什博弈

只有一堆n个物品，两个人轮流从中取物，规定每次最少取一个，最多取m个，最后取光者为胜
若 n%(m+1)==0 后手必胜
否则先手必胜，若n>m，第一次取n%(m+1)个，若n<=m，则第一次可取n~m间任意个

威佐夫博弈

有两堆各若干的物品，两人轮流从其中一堆取至少一件物品，至多不限，或从两堆中同时取相同件物品，规定最后取完者胜利。

数论基础

基础知识：

中位数的性质：所有数与中位数差值的绝对值最小。
海伦公式：s= $\sqrt{p*(p-a)*(p-b)*(p-c)}$ 其中(p=(a+b+c)/2)
浮点型误差注意！
n,n-1,n-2两两互质，他们的最小公倍数为他们的乘积。
任意两个大于1的相邻自然数互质。
在这里插入图片描述

乘法逆元

（1）涉及到减法的取模变成 (a-c+mod)%mod
（2）根据费马小定理：当p为质数时候， $a^{(p-1)}$ ≡1(mod p)。所以可以变成%mod-1
$a*a^{(p-2)}$ ≡1(mod p) 所以a和 $a^{p-2}$ 为逆元

long long PowMod(long long a,int b) {
    long long ret=1;
    while(b) {
        if(b&1)ret=ret*a%Mod;
        a=a*a%Mod;
        b>>=1;
    }
    return ret;
}

（3）拓展欧几里得

long long extend_gcd(long long a,long long b,long long &x,long long &y) {
    if(a==0&&b==0)
        return -1ll;
    if(b==0)
    {
        x=1ll;
        y=0ll;
        return a;
    }
    long long d=extend_gcd(b,a%b,y,x);
    y-=a/b*x;
    return d;
}
long long mod_reverse(long long a,long long n) {
    long long x,y,d=extend_gcd(a,n,x,y);
    if(d==1) {
        if(x%n<=0)return x%n+n;
        else return x%n;
    } else return -1ll;
}

欧拉函数

含义：欧拉函数Φ（n）表示小于n的数于n互质(gcd(x,y)=1,则互质)的个数。
性质：若n为素数，Φ（n）=n-1；
实现：

long long ol[mx]; 
void  getol()
{
	memset(ol,0,sizeof(ol));
	ol[1]=1;
	for(long long i=2;i<mx;i++){
		if(!ol[i])
		{
			for(long long j=i;j<mx;j+=i){
				if(!ol[j])
					ol[j]=j;
				ol[j]=ol[j]/i*(i-1);
			}
		}
	}
}

唯一分解定理

含义：任何一个数，都可以写成若干个素数乘积的形式，即 n= $P1^{E1}$ * $P2^{E2}$ * $P3^{E3}$ … $Pn^{En}$ .
且该表示形式可以写成唯一的表示。
性质：N的因子的个数=(1+E1) * (1+E2) * (1+E3)…(1+En) (Ei为素数的指数)
gcd(a,b)= $p1 ^ {min(a1,b1) }$ * $p2 ^ {min(a2,b2) }$ … $pn ^ {min(an,bn) }$
lcm(a,b)= $p1 ^ {max(a1,b1) }$ * $p2 ^ {max(a2,b2) }$ … $pn ^ {max(an,bn) }$

欧几里得算法

含义：gck(a,b)为求a,b的最大公约数
性质：
实现：

int gck(int a,int b)
{
	if(b==0)
	  return a;
	else
	  return gck(b,a%b);
}

扩展欧几里得算法

含义：求关于x,y的方程 ax + by = gcd(a,b) 的所有整数解
性质：
实现：

void exgcd(long long a,long long b,long long &d,long long &x,long long &y)
{
	if(!b)
	{
		d=a;
		x=1;
		y=0;
	}
	else
	{
		exgcd(b,a%b,d,y,x);
		y-=x*(a/b);
	}
}

BSGS算法

大步小步算法用于解决：已知A, B, C，求X使得
A^x = B (mod C)
成立。
例题：给定一个素数P, 2<=P< $2^{31}$ ,两个正整数B , 2 <=B<P; N , 1<=N<P;
求一个正整数L，使得 $B^L≡N (mod P)$


typedef long long ll;
ll qc(ll a,ll b,ll c)
{
	ll ans=1;
	while(b)
	{
		if(b&1)
			ans=(ans*a)%c;
		a=(a*a)%c;
		b>>=1;
	} 
	return ans%c;
}
ll bsgs(ll a,ll b,ll c)
{
	ll m=ceil(sqrt(c*1.0));
	ll t=qc(a,c-m-1,c),y=1;  //求逆元
	//printf("%lld\n",m);
	map<ll,ll>x;
	x[1]=m;
	for(int i=1;i<m;i++){
		y=(y*a)%c;
		if(!x[y])
			x[y]=i;
	}
	for(int i=0;i<m;i++){
		if(x[b]) //查找map表
		{
			int pos=x[b];
			x.clear();
			return m*i+(pos==m?0:pos);
		}
		b=(b%c*t%c)%c;
	}
	return -1;
}
int main()
{
	ll a,b,c;
	while(scanf("%lld%lld%lld",&c,&a,&b)!=EOF)
	{
		//printf("%lld %lld %lld\n",a,b,c);
		ll ans=bsgs(a,b,c);
		if(ans==-1)
			printf("no solution\n");
		else
			printf("%lld\n",ans);
	}
	return 0;
}

欧拉降幂

含义：对于 $A^B$ mod C来说，当幂数特别大，需要使B在模C的情况下减小，要使用欧拉降幂。
$A^B$ mod C= A^(B mod phi(c ) ) mod C …(B<phi(c ))
$A^B$ mod C= A^(B mod phi(c )+phi(C )) mod C …(B>=phi(c ))
phi(c )为c的欧拉函数

线性筛素数

注意点：当数据为 $10^6$ 左右时，数组应使用bool型。若数据大于 $10^7$ 则无法使用
实现：

const int mx=1e6+5;
bool f[mx];
int p[mx],num=0;
void f1()
{
	for(int i=2;i<mx;i++){
		if(!f[i])  p[num++]=i;
		for(int j=0;j<num&&i*p[j]<mx;j++){
			f[i*p[j]]=true;
			if(!(i%p[j]))  break;
		}
	}
}

数据结构

优先队列：

默认从大到小排列
普通优先队列：priority_queue< int>q;
从小到大优先队列：priority_queue< int,vector< int>,greater< int> >q;
对结构体应用优先队列：

struct Node
{
    int x,y,val;
    friend bool operator < (node n1,node n2)
    {
            if(n1.val==n2.val)
                return n1.x>n2.x;
        return n1.val<n2.val;    //和正常不同，"<"为从大到小，">"为从小到大
    }
};
priority_queue<node>q

线段树：

const int mx = 110000;
long long tree[4*mx],tr[4*mx],tp[4*mx];  //tr乘标记 tp加标记 
int mod,n; 
void build(int l,int r,int x)
{
	if(l==r)
	{
		scanf("%lld",&tree[x]);
		return;
	}
	tr[x]=1;
	int m=(l+r)>>1;
	build(l,m,x<<1);
	build(m+1,r,(x<<1)+1);
	tree[x]=(tree[x<<1]+tree[(x<<1)+1])%mod;  //push_up
}
void lazy(int l,int r,int x)
{
	int m=(l+r)>>1;
	if(tr[x]!=1)  //乘法时
	{
		tree[2*x]=(tree[2*x]*tr[x])%mod;
		tree[2*x+1]=(tree[2*x+1]*tr[x])%mod;
		if(l!=r)   非单点时
		{
			tr[2*x]=(tr[2*x]*tr[x])%mod;
			tr[2*x+1]=(tr[2*x+1]*tr[x])%mod;
			tp[2*x]=(tp[2*x]*tr[x])%mod;
			tp[2*x+1]=(tp[2*x+1]*tr[x])%mod;
		}
		tr[x]=1;
	}
	if(tp[x])
	{
		tree[2*x]=(tree[2*x]+tp[x]*(m-l+1))%mod;
		tree[2*x+1]=(tree[2*x+1]+tp[x]*(r-m))%mod;
		if(l!=r)
		{
			tp[2*x]=(tp[2*x]+tp[x])%mod;
			tp[2*x+1]=(tp[2*x+1]+tp[x])%mod;
		}
		tp[x]=0;
	}
}
void update(int l,int r,int x,int a,int b,int c,int op)
{
	if(l>=a&&r<=b)
	{
		if(op==1)
		{
			tree[x]=(tree[x]*c)%mod;
			if(l==r)
			  return ;
			tr[x]=(tr[x]*c)%mod;
			tp[x]=(tp[x]*c)%mod;   //乘法时要同时更新加法的懒标记
		}
		else
		{
			tree[x]=(tree[x]+c*(r-l+1))%mod;
			if(l==r)
			  return ;
			tp[x]=(tp[x]+c)%mod;
		}
		return;
	}
	int m=(r+l)>>1;
	lazy(l,r,x);
	if(a<=m)
	  update(l,m,x*2,a,b,c,op);
	if(m+1<=b)
	  update(m+1,r,x*2+1,a,b,c,op);
	tree[x]=(tree[x*2]+tree[x*2+1])%mod;
}
long long query(int l,int r,int x,int a,int b)  //区间查询
{
	if(l>=a&&r<=b)
	   return tree[x];
	int m=(l+r)/2;
	long long ans=0;
	lazy(l,r,x);
	if(a<=m)
		ans+=query(l,m,2*x,a,b);
	if(b>=m+1)
	 	ans+=query(m+1,r,2*x+1,a,b);
	return ans%mod;
}
int main()
{
	int t,m,op,a,b,c;
	scanf("%d%d",&n,&mod);
	memset(tree,0,sizeof(tree));
	build(1,n,1);
	scanf("%d",&m);
	for(int i=0;i<m;i++){
		scanf("%d",&op);
		if(op<3)
		{
			scanf("%d%d%d",&a,&b,&c);
			update(1,n,1,a,b,c,op);
		}
		else
		{
			scanf("%d%d",&a,&b);
			printf("%lld\n",query(1,n,1,a,b));
		}
		
	}
	return 0;
}

并查集:

int fa[N],rank[N];
void init(int n)    //初始化
{
      for(int i=0;i<n;i++)
       {
           fa[i]=i;
            rank[i]=0;
       }
}
int find(int x)
{
       if(fa[x]==x)
          return x;
        else
          return fa[x]=find(fa[x]);           //路径压缩
}
void unite(int x,int y)
{
        x=find(x);
        y=find(y);
        if(x==y) return ;
        if(rank[x]<rank[y])
          fa[x]=y;
        else
        {
          fa[y]=x;
          if(rank[x]==rank[y])
             rank[x]++;
        }
}
bool same(int x,int y)
{
          return find(x)==find(y);
}

恋花飘落

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
省赛前整理

文章目录常用函数二分查找函数：数论基础欧拉函数唯一分解定理欧几里得算法扩展欧几里得算法欧拉降幂线性筛素数常用函数二分查找函数：数组:a,长度:n,查找数:xupper_bound(a,a+n,x)-a (可以插入的下界，第一个大于等于的)lower_bound(a,a+n,x)-a (可以插入的上界，第一个大于的)数论基础欧拉函数含义：欧拉函数Φ（n）表示小于n...
复制链接

扫一扫