C++竞赛向火车头

原创 已于 2025-10-31 18:22:47 修改 · 552 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #图论 #算法

于 2025-10-29 13:49:02 首次发布
部署运行你感兴趣的模型镜像

可以直接复制，后面是常用算法，包括图论、数论、树论和常见的算法

注意：这部分请不要在csp/NOIP/NOI中使用

#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)

以下可以随意使用

#define re register
#define il inline
#define ls u<<1
#define rs u<<1|1
#define lowbit(x) (x&-x)
#define PII pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define clr(x) memset(x,0,sizeof(x))
#define ll long long
#define ld long double
#define pi acos(-1.0)


#define il inline
#define getchar() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<20,stdin),p1==p2)?0:*p1++)
char buf[1<<20],*p1,*p2;
template <typename T>
il void read(T &x)
{
	x=0;int f=1;char ch=getchar();
	while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
	x*=f;
}
template <typename T>
il void write(T x)
{
	if(x<0) putchar('-'),x=~x+1;
	if(x>9) write(x/10);
	putchar(x%10^48);
}
il char getc()
{
	char ch=getchar();
	while(ch=='\n'||ch=='\r'||ch==' ') ch=getchar();
	return ch;
}


int n,m,dis[N][N];
void Floyd()
{
	read(n),read(m);
	memset(dis,0x3f,sizeof dis);
	for(int i=1;i<=n;i++) dis[i][i]=0;
	for(int i=1,u,v,w;i<=m;i++)
	{
		read(u),read(v),read(w);
		dis[u][v]=dis[v][u]=min(dis[u][v],w);
	}
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(i^j&&i^k&&j^k&&dis[i][k])
					dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}

// 无优化
int n,m,s,dis[N];
bool vis[N];
struct Edge
{
	int v,w;
};
vector<Edge> g[N];
void Dijkstra(int s)
{
	for(int i=1;i<=n;i++) dis[i]=INF;
	dis[s]=0;
	for(int i=1;i<n;i++)
	{
		int mindis=INF,u;
		for(int j=1;j<=n;j++)
			if(!vis[j]&&mindis>dis[j])
				mindis=dis[j],u=j;
		vis[u]=1;
		for(auto [v,w]:g[u])
			if(!vis[v]&&dis[v]>mindis+w)
				dis[v]=mindis+w;
	}
}

// 堆优化
int n,m,s,dis[N];
bool vis[N];
priority_queue<PII,vector<PII>,greater<PII>> q;
struct Edge
{
	int v,w;
};
vector<Edge> g[N];
void Dijkstra(int s)
{
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0,q.push(mp(0,s));
	while(!q.empty())
	{
		int u=q.top().se;q.pop();
		if(vis[u]) continue;
		vis[u]=1;
		for(auto [v,w]:g[u])
			if(dis[v]>dis[u]+w)
			{
				dis[v]=dis[u]+w;
				if(!vis[v]) q.push(mp(dis[v],v));
			}
	}
}


int n,m,dis[N];
struct Edge
{
	int u,v,w;
};
vector<Edge> e;
bool Bellman_Ford(int s)
{
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0;
	bool flag=false;
	for(int i=1;i<=n;i++)
	{
		flag=false;
		for(auto [u,v,w]:e)
		{
			if(dis[u]==INF) continue;
			if(dis[v]>dis[u]+w)
				dis[v]=dis[u]+w,flag=true;
		}
		if(!flag) break;
	}
	return flag;
}



int n,m,dis[N],cnt[N];
bool vis[N];
struct Edge
{
	int v,w;
};
vector<Edge> g[N];
queue<int> q;
bool SPFA(int s)
{
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0,vis[s]=1;
	q.push(s);
	while(!q.empty())
	{
	    int u=q.front();
		q.pop(),vis[u]=0;
	    for(auto [v,w]:g[u])
			if(dis[v]>dis[u]+w)
			{
				dis[v]=dis[u]+w;
				cnt[v]=cnt[u]+1;
				if(cnt[v]>=n) return false;
				if(!vis[v]) q.push(v),vis[v]=1;
			}
  	}
	return true;
}



int n,m,dis[N],cnt[N];
bool vis[N];
struct Edge
{
	int v,w;
};
vector<Edge> g[N];
queue<int> q;
bool SPFA(int s)
{
	memset(dis,0x3f,sizeof(dis));
	dis[s]=0,vis[s]=1;
	q.push(s);
	while(!q.empty())
	{
	    int u=q.front();
		q.pop(),vis[u]=0;
	    for(auto [v,w]:g[u])
			if(dis[v]>dis[u]+w)
			{
				dis[v]=dis[u]+w;
				cnt[v]=cnt[u]+1;
				if(cnt[v]>=n) return false;
				if(!vis[v]) q.push(v),vis[v]=1;
			}
  	}
	return true;
}



int n,m,fa[N];
struct Edge
{
	int u,v,w;
}e[M];
int find(int x)
{
	return fa[x]==x?x:fa[x]=find(fa[x]);
}
void Kruskal()
{
	int mst=0,tot=0;
	for(int i=1;i<=n;i++) fa[i]=i;
	sort(e+1,e+1+m,[](Edge a,Edge b){return a.w<b.w;});
	for(int i=1;i<=m;i++)
	{
		int x=find(e[i].u),y=find(e[i].v);
		if(x==y) continue;
		fa[x]=y,mst+=e[i].w;
		if(++tot==n-1) break;
	}
	printf("%d",mst);
}


int n,m,dis[N];
bool vis[N];
struct Edge
{
	int v,w;
};
vector<Edge> e[M];
void Prim()
{
	int u=1,tot=1,mst=0;
	memset(dis,0x3f,sizeof(dis));
	while(tot<n)
	{
		for(auto [v,w]:g[u])
			if(!vis[v]&&dis[v]>w) dis[v]=w;
		int mindis=INF;
		++tot,vis[u]=1;
		for(int i=1;i<=n;i++)
			if(!vis[i]&&mindis>dis[i])
				u=i,mindis=dis[i];
		mst+=mindis;
	}
	printf("%d",mst);
}


int n,m,s,dis[N];
bool vis[N];
priority_queue<PII,vector<PII>,greater<PII>> q;
struct Edge
{
	int v,w;
};
vector<Edge> g[N];
void Prim()
{
	int mst=0,tot=0;
	memset(dis,0x3f,sizeof(dis));
	dis[1]=0,q.push(mp(0,1));
	while(!q.empty()&&tot<n)
	{
		int u=q.top().se;
		if(vis[u]) continue;
		++tot,mst+=q.top().fi;
		vis[u]=1,q.pop();
		for(auto [v,w]:g[u])
			if(dis[v]>w)
				dis[v]=w,q.push(mp(dis[v],v));
	}
	printf("%d",mst); 
}


int n,m,f[N][21],dep[N];
vector<int> g[N];
void dfs(int u,int fa)
{
	f[u][0]=fa,dep[u]=dep[fa]+1;
	for(int i=1;i<=19;i++)
		f[u][i]=f[f[u][i-1]][i-1];
	for(auto v:g[u])
		if(v^fa) dfs(v,u);
}
int LCA(int u,int v)
{
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=19;~i;i--)
		if(dep[u]-dep[v]>=(1<<i)) u=f[u][i];
	if(u==v) return u;
	for(int i=19;~i;i--)
		if(f[u][i]^f[v][i])
			u=f[u][i],v=f[v][i];
	return f[v][0];
}



int n,m,fa[N],dep[N],siz[N],hs[N];
vector<int> g[N];
void dfs1(int u,int fath)
{
	fa[u]=fath,dep[u]=dep[fath]+1;
	siz[u]=1,hs[u]=-1;
	for(auto v:g[u])
	{
		if(v==fath) continue;
		dfs1(v,u),siz[u]+=siz[v];
		if(hs[u]==-1||siz[v]>siz[hs[u]]) hs[u]=v;
	}
}
int top[N];
void dfs2(int u,int t)
{
	top[u]=t;
	if(~hs[u]) dfs2(hs[u],t);
	for(auto v:g[u])
		if(v^fa[u]&&hs[u]^v) dfs2(v,v);
}
int LCA(int u,int v)
{
	while(top[u]^top[v])
	{
		if(dep[top[u]]<dep[top[v]]) swap(u,v);
		u=fa[top[u]];
	}
	if(dep[u]<dep[v]) swap(u,v);
	return v;
}



int n,m,st[N][21],dfn[N],cnt;
vector<int> g[N];
int get(int x,int y)
{
	return dfn[x]<dfn[y]?x:y;
}
void dfs(int u,int fa)
{
	st[dfn[u]=++cnt][0]=fa;
	for(auto v:g[u])
		if(v^fa) dfs(v,u);
}
int LOG[N];
void st_init()
{
	LOG[0]=-1;
	for(int i=1;i<=n;i++) LOG[i]=LOG[i>>1]+1;
	int p=LOG[n];
	for(int k=1;k<=p;k++)
		for(int s=1;s+(1<<k)<=n+1;s++)
			st[s][k]=get(st[s][k-1],st[s+(1<<(k-1))][k-1]);
}
int LCA(int u,int v)
{
	if(u==v) return u;
	u=dfn[u],v=dfn[v];
	if(u>v) swap(u,v);
	int k=LOG[v-u];
	return get(st[u+1][k],st[v-(1<<k)+1][k]);
}








// 高精度
// C = A + B, A >= 0, B >= 0
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;
}


// C = A - B, 满足A >= B, A >= 0, B >= 0
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;
}


// C = A * b, A >= 0, b >= 0
vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;
 
    int t = 0;
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }
 
    while (C.size() > 1 && C.back() == 0) C.pop_back();
 
    return C;
}


// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r)
{
    vector<int> C;
    r = 0;
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}




// 求n的第k位数字: n >> k & 1
// 返回n的最后一位1：lowbit(n) = n & -n

// shuangzhizhen
for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;
 
    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作



vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素
 
// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于x的位置
{
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
}




// 将所有存在交集的区间合并
void merge(vector<PII> &segs)
{
    vector<PII> res;
 
    sort(segs.begin(), segs.end());
 
    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);
 
    if (st != -2e9) res.push_back({st, ed});
 
    segs = res;
}

// 扩展欧几里得算法 (ax + by = gcd(a,b))
ll exgcd(ll a, ll b, ll &x, ll &y)
{
    if (!b) { x = 1; y = 0; return a; }
    ll d = exgcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}

// 逆元 (a^{-1} mod p)
ll inv(ll a, ll p = MOD)
{
    ll x, y;
    exgcd(a, p, x, y);
    return (x % p + p) % p;
}

ll fac[N], inv_fac[N];

// 组合数计算 (预处理阶乘和逆元)
void init (int n = 1e5)
{
    fac[0] = 1;
    REP1(i, n) fac[i] = fac[i - 1] * i % MOD;
    inv_fac[n] = inv(fac[n], MOD);
    FORD(i, n, 1) inv_fac[i - 1] = inv_fac[i] * i % MOD;
}

ll C(int n, int k)
{
    if (k < 0 || k > n) return 0;
    return fac[n] * inv_fac[k] % MOD * inv_fac[n - k] % MOD;
}

您可能感兴趣的与本文相关的镜像

Llama Factory

Llama Factory

模型微调
LLama-Factory

LLaMA Factory 是一个简单易用且高效的大型语言模型（Large Language Model）训练与微调平台。通过 LLaMA Factory，可以在无需编写任何代码的前提下，在本地完成上百种预训练模型的微调

Wuyutong08
关注
c++火车头N合一
m0_73020012的博客
10-19 4335
c++巨长火车头~其实也没有那么长~
C++火车头优化
weixin_54994444的博客
05-10 2357
本文章写了本人（C++OIer）在日常coding中常用的几种优化方法/卡常技巧（bushi
【C++】快读&快写模板及火车头优化代码
星河依旧长明的博客
08-11 1983
快读快写，顾名思义，就是提升输入和输出的速度。在这里简单介绍一下几种输入输出的优劣。C++cin / cout输入输出：优点是读入的时候不用管数据类型，但是缺点就是比scanf/printf慢一些。这里给一个关同步流的代码，可以显著优化cin / cout需要注意的是，关了同步流之后就不能再用了。C输入输出：与 C++ 对比，比cin / cout快一些，但使用方法细节比较多，容易出锅。快读/快写：只能处理整数读入 / 输出，但是要比标准输入输出函数都快得多。
CQOI2018day1 (XJOI contest908)
a380988182的博客
04-23 446
一题 破解D-H协议 时间限制：1S 内存限制：512M 具体思路:BSGS,没了 AC代码 #include<bits/stdc++.h> using namespace std; #define int long long int n,i,j,p,g,a,b,A,B; map<int,pair<...
C++竞赛向火车头(免费下载)
最新发布
10-29
C++竞赛向火车头是一种专门为竞赛编程设计的资源，它提供了丰富的算法模板和技巧，旨在帮助参赛者更高效地解决算法问题。在信息学竞赛中，比如CSP（中国大学生计算机程序设计竞赛）、NOIP（全国青少年信息学奥林匹克...
C++万能优化火车头模板
07-22
竞赛用了火车头，能手动开-O2和加速！！！ 总之一句话： C++万能火车头，模板必用！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！...
算法竞赛进阶指南0x11：火车进栈
qq_56721787的博客
11-26 852
火车进栈 这里有n列火车将要进站再出站，但是，每列火车只有1节，那就是车头。 这n列火车按1到n的顺序从东方左转进站，这个车站是南北方向的，它虽然无限长，只可惜是一个死胡同，而且站台只有一条股道，火车只能倒着从西方出去，而且每列火车必须进站，先进后出。 也就是说这个火车站其实就相当于一个栈，每次可以让右侧头火车进栈，或者让栈顶火车出站。 车站示意如图： 出站<—— <——进站 |车| ...
C++基本数学思想——排列组合是什么？
u013397613的博客
12-24 1622
至此，第二步中，第一种和第三种都是 A、B 的组合，完全一样，就会有一些算重的，至于有多少个算重，取决于抽出个数 m 的全排列种数，即 m 的阶乘。下面我们来点刺激的：假如这四个人中有一个是戏精本精，他最特殊，你会先问他来不来：①如果他来，但你还想一共约两个同学，那么就需要在其他三个同学中再约一个，有 C 3 抽 1 ，共3种方法；咱们聊的第二个概念是“组合”，它比排列更常用，组合的英文是 Combination，因此在数学符号中用 C 表示，美国和英国教材中，也常用“长括号”表示组合数。
上海市计算机学会竞赛平台 2024 年 7 月月赛 丙组详解
2301_76224755 的博客，一只 OIER，只会 C++。
06-15 1419
上海市计算机学会竞赛平台的月赛似乎越来越水了（或者是我变强了）。上一次参赛还是在202320232023年8768,7,6876月，那时候只能拿一、二等奖（190∼440190∼440分），现在可以 AK 了！愿所有比赛越来越水自己的实力越来越强。
C++模板集
lunjiahao的博客
11-21 1781
常用的模板集
火车头······
qq_52765554的博客
04-05 1135
【代码】火车头······
C++火车头代码
hejx0412的博客
03-07 968
【代码】C++火车头代码。
c/c++ 暴力火车头
qq_46399299的博客
07-14 2957
如果只超时了一点点，就用这个暴力过去吧。 #pragma GCC diagnostic error "-std=c++11" #pragma GCC target("avx") #pragma GCC optimize(3) #pragma GCC optimize("Ofast") #pragma GCC optimize("inline") #pragma GCC optimize("-fgcse") #pragma GCC optimize("-fgcse-lm") #pragma GCC optim
【string、stack与queue】
Aaronleoesr的博客
10-16 1043
:false// 数组大小常量 const double PI = acos(- 1.0);# define in inline # include <bits/stdc++.h> : 引入了 C ++ 的标准库，通常用于竞争编程，包含所有标准库头文件。: 使得不需要使用 std :: 前缀。# define 定义了一些常用的宏，包括输入输出的优化和常量。tie0// 数组大小常量 const double PI = acos(- 1.0);
简单理解C++链表结构--单链表
denton88的博客
07-21 1290
链表是一种数据结构，由若干个节点串联而成，构成一条完整的链表。可以把链表理解成为一列火车，每个节点，就是一节车厢。车厢可以装货物（存储数据），每节车厢有一个挂钩（指针），连接下一节车厢。火车头，就是链表的头节点。头节点没有数据（不装货物），实际第几个节点是从车厢开始算起。链表还可以分为单链表、双链表、循环链表。本文先介绍一下单链表。链表可以动态的存储数据，不需要一开始就把所有的空间创建出来，而且空间也不必连续。而数组则必须一开始就确定数组的大小，创建出数组的完整空间，并且空间必须是连续的。
C++火车头
Emma_goddess的博客
09-18 2023
做某道题想起的，留个在这 #pragma GCC optimize(3) #pragma GCC target("avx") #pragma GCC optimize("Ofast") #pragma GCC optimize("inline") #pragma GCC optimize("-fgcse") #pragma GCC optimize("-fgcse-lm") #pragma GCC optimize("-fipa-sra") #pragma GCC optimize("-ftree-pre"
Smart-C++ 1.2.5.174：Dev-C++ 6.0增强版助力程序设计竞赛
Dev-C++ 6.0（现更名为Smart-C++ 1.2.5.174）是一款针对程序设计竞赛进行大幅改进的集成开发环境（IDE），它基于前一版本Dev-C++ 5.3.0.2，并且在程序设计竞赛方面进行了针对性的增强。这个版本的开发者的行动虽然...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值