【板子】数据结构 && 图论 && 数论

最新推荐文章于 2024-01-26 22:09:38 发布
最新推荐文章于 2024-01-26 22:09:38 发布
阅读量970 收藏 2
点赞数 2
分类专栏： 程序设计思维实践 图论 算法 文章标签： 图论 算法 c++ 程序设计 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Aloneingchild/article/details/78492436
版权

文章目录

更新

2021-05-10 加入split

2020-12-13 加入技巧章节

2020-06-27 加入Kosaraju

2020-06-26 加入前向星、二分、修复割顶

2020-06-25 加入Trie树、O2优化、万能头部、二进制拆分、拓扑排序

2020-06-25 加入最小生成树、KMP、Dijkstra。更新矩阵快速幂

2020-06-25 更新代码片段，调整文档结构

2020-06-25 重新排版

2017-11-09 NOIP第一次整理上传

前言

自用板子，经测试代码均正确，可以放心食用，源自于17年准备NOIP（当时还不会md😭）。大学程序设计课对板子进行完善。

代码片段

// #pragma GCC optimize(2) 
// #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define LL long long
using namespace std;
inline int get_num() {
    char c;
    int f = 1, num = 0;
    while ((c = getchar()) == ' ' || c == '\n' || c == '\r')
        ;
    if (c == '-')
        f = -1;
    else
        num = c - '0';
    while (isdigit(c = getchar())) num = num * 10 + c - '0';
    return num * f;
}
int main() {
    // ios::sync_with_stdio(false);
    // cout.tie(NULL);
    freopen("a.in", "r", stdin);
    freopen("a.out", "w", stdout);

    fclose(stdin);
    fclose(stdout);
    return 0;
}

数据结构

线段树

inline void push_up(int p){
	tr[p].w=tr[p<<1].w+tr[p<<1|1].w;
}
inline void push_down(int p){
	if(!tr[p].lazy) return ;
	tr[p<<1].w+=tr[p].lazy*(tr[p<<1].r-tr[p<<1].l+1);
	tr[p<<1].lazy+=tr[p].lazy;
	tr[p<<1|1].w+=tr[p].lazy*(tr[p<<1|1].r-tr[p<<1|1].l+1);
	tr[p<<1|1].lazy+=tr[p].lazy;
	tr[p].lazy=0;
}
void build(int p,int l,int r){
	tr[p].l=l;tr[p].r=r;
	if(l==r){
		tr[p].w=get_num();
		return ;
	}
	int mid=(l+r)>>1;
	build(p<<1,l,mid);build(p<<1|1,mid+1,r);
	push_up(p);
}
void add(int p,int l,int r,LL k){
	if(tr[p].l==l&&tr[p].r==r){
		tr[p].w+=(r-l+1)*k;
		tr[p].lazy+=k;
		return ;
	}
	push_down(p);
	int mid=(tr[p].r+tr[p].l)>>1;
	if(r<=mid) add(p<<1,l,r,k);
	else if(l>mid) add(p<<1|1,l,r,k);
	else{
		add(p<<1,l,mid,k);add(p<<1|1,mid+1,r,k);
	}
	push_up(p);
	
}
LL query(int p,int l,int r){
	if(tr[p].l==l&&tr[p].r==r){
		return tr[p].w;
	}
	LL ans=0;
	push_down(p);
	int mid=(tr[p].r+tr[p].l)>>1;
	if(r<=mid) ans=query(p<<1,l,r);
	else if(l>mid) ans=query(p<<1|1,l,r);
	else{
		ans=query(p<<1,l,mid)+query(p<<1|1,mid+1,r);
	}
	push_up(p);
	return ans;
	
}
int main()
{
	int n,m;n=get_num();m=get_num();
	build(1,1,n);
	int c,x,y;LL k;
	for(int i=1;i<=m;i++){
		c=get_num();x=get_num();y=get_num();
		if(c==1){
			k=get_num();
			add(1,x,y,k);
		}else{
			cout<<query(1,x,y)<<'\n';
		}
	}
	return 0;
}

树链剖分

inline void push_up(int p){
	tr[p].w=tr[p<<1].w+tr[p<<1|1].w;
}
inline void push_down(int p){
	if(!tr[p].lazy) return ;
	tr[p<<1].w+=tr[p].lazy*(tr[p<<1].r-tr[p<<1].l+1);
	tr[p<<1].lazy+=tr[p].lazy;
	tr[p<<1|1].w+=tr[p].lazy*(tr[p<<1|1].r-tr[p<<1|1].l+1);
	tr[p<<1|1].lazy+=tr[p].lazy;
	tr[p].lazy=0;
}
void build(int p,int l,int r){
	tr[p].l=l;tr[p].r=r;
	if(l==r){
		tr[p].w=w[l];
		return ;
	}
	int mid=(l+r)>>1;
	build(p<<1,l,mid);
	build(p<<1|1,mid+1,r);
	push_up(p);
}
void add(int p,int l,int r,LL k){
	if(tr[p].l==l&&tr[p].r==r)
	{
		tr[p].w+=(r-l+1)*k;
		tr[p].lazy+=k;
		return ;
	}
	push_down(p);
	int mid=(tr[p].l+tr[p].r)>>1;
	if(r<=mid) add(p<<1,l,r,k);
	else if(l>mid) add(p<<1|1,l,r,k);
	else{
		add(p<<1,l,mid,k);add(p<<1|1,mid+1,r,k);
	}
	push_up(p);
}
LL query(int p,int l,int r){
	if(tr[p].l==l&&tr[p].r==r)
	{
		return tr[p].w;
	}
	LL ans=0;
	push_down(p);
	int mid=(tr[p].l+tr[p].r)>>1;
	if(r<=mid) ans=query(p<<1,l,r);
	else if(l>mid) ans=query(p<<1|1,l,r);
	else{
		ans=query(p<<1,l,mid)+query(p<<1|1,mid+1,r);
	}
	push_up(p);
	return ans;
}
void dfs_1(int x){
	siz[x]=1;
	for(int i=0;i<v[x].size();i++){
		if(cur!=f[x]){
			f[cur]=x;
			deep[cur]=deep[x]+1;
			dfs_1(cur);
			siz[x]+=siz[cur];
			if(siz[son[x]]<siz[cur]) son[x]=cur;
		}
	}
}
void dfs_2(int x,int p){
	id[x]=++tot;w[tot]=d[x];top[x]=p;
	if(son[x]) dfs_2(son[x],p);
	for(int i=0;i<v[x].size();i++){
		if(cur!=f[x]&&cur!=son[x]){
			dfs_2(cur,cur);
		}
	}
}
void modify(int a,int b,int k){
	while(top[a]!=top[b]){
		if(deep[top[a]]>deep[top[b]]) swap(a,b);
		add(1,id[top[b]],id[b],k);
		b=f[top[b]];
	}if(deep[a]>deep[b]) swap(a,b);
	add(1,id[a],id[b],k);
}
LL find(int a,int b){
	LL ans=0;
	while(top[a]!=top[b]){
		if(deep[top[a]]>deep[top[b]]) swap(a,b);
		ans+=query(1,id[top[b]],id[b]); ans%=MOD;
		b=f[top[b]];
	}if(deep[a]>deep[b]) swap(a,b);
	ans+=query(1,id[a],id[b]);
	return ans%MOD;
}
int main()
{
	int n,m,root;
	n=get_num();m=get_num();root=get_num();MOD=get_num();
	for(int i=1;i<=n;i++) d[i]=get_num();
	for(int i=1;i<n;i++){
		int a,b;
		a=get_num();b=get_num();v[a].push_back(b);
		v[b].push_back(a);
	}
	dfs_1(root);
	dfs_2(root,root);
	build(1,1,n);
	int c,x,y;LL z;
	for(int i=1;i<=m;i++){
		c=get_num();x=get_num();
		if(c==1){
			y=get_num();
			z=get_num();
			modify(x,y,z%MOD);
		}else if(c==2)
		{
			y=get_num();
			cout<<find(x,y)<<'\n';
		}else if(c==3){
			z=get_num();
			add(1,id[x],id[x]+siz[x]-1,z%MOD);
		}else if(c==4){
			cout<<query(1,id[x],id[x]+siz[x]-1)%MOD<<'\n';
		}
	}
	return 0;
}

并查集

int find(int x){
	if(f[x]==x) return x;
	return f[x]=find(f[x]);
}

初始化 for(int i=1;i<=n;i++) f[i]=i;

树状数组 1

在全局有个 n n n，主函数有个 n n n，读入 n n n的时候，全局相当于 n n n是0。

树状数组 2

void modify(int x,LL p){
	for(int i=x;i<=n;i+=lowbit(i)) tr[i]+=p;
	//for和tr的i不要写错啊
}
LL query(int x){
	LL ans=0;
	for(int i=x;i;i-=lowbit(i)) ans+=tr[i];
	return ans;
}

  • modify(x,k);modify(y+1,-k); 写的 modify(x,k);modify(y+1,k);

  • for(int i=x;i<=n;i+=lowbit(i)) tr[i]+=p; 写的 for(int i=x;i<=n;i+=lowbit(i)) tr[x]+=p;

STL堆，priority_queue

priority_queue<int,vector<int>,greater<int> >Q;
	int n;n=get_num();
	int c,x;
	for(int i=1;i<=n;i++){
		c=get_num();
		if(c==1){
			x=get_num();
			Q.push(x);
		}else if(c==2){
			cout<<Q.top()<<'\n';
		}else {
			Q.pop();
		}
	}

前向星

inline void add(int x,int y,int w){
	v[++p].to=y;
	v[p].nxt=fa[x];
	v[p].w=w;
	fa[x]=p;
}

好久没用了，记一下吧

图论

最近公共祖先

最近公共祖先（LCA)

void dfs(int x){
	vis[x]=1;
	for(int b=fa[x];b;b=v[b].nxt){
		if(!vis[cur])
		{
			deep[cur]=deep[x]+1;
			lca[cur][0]=x;
			dfs(cur);
		}
	}
}
int query(int a,int b)
{
	if(deep[a]>deep[b]) swap(a,b);
	for(int i=19;i>=0;i--) if(deep[lca[b][i]]>=deep[a]) b=lca[b][i];
	if(a==b) return a;
	for(int i=19;i>=0;i--){// 是大于等于0不是(int i=19;i;i--)
		if(lca[a][i]!=lca[b][i]){
			a=lca[a][i];b=lca[b][i];
		}
	}
	return lca[a][0];
}
	deep[s]=1;
	dfs(s);
	for(int j=1;j<=19;j++){
		for(int i=1;i<=n;i++){
			lca[i][j]=lca[lca[i][j-1]][j-1];
		}
	}

用vector TLE 了俩点 还是好好用struct 吧

最近公共祖先（Tarjan）

void tarjan(int x){
	vis[x]=1;
	f[x]=x;
	for(int b=fa[x];b;b=v[b].nxt){
		if(!vis[cur]){
			tarjan(cur);
			f[find(cur)]=x;
		}
	}
	for(int b=faa[x];b;b=qv[b].nxt){
		if(vis[qv[b].to]){
			qv[b^1].ans=qv[b].ans=find(qv[b].to);
		}
	}
}

void add(int x,int y){
	v[++p].to=y;
	v[p].nxt=fa[x];
	fa[x]=p;
}

v[++p].to=y;y写成了x

最近公共祖先（树剖）

void dfs_1(int x){
	siz[x]=1;
	for(int b=fa[x];b;b=v[b].nxt){
		if(cur!=f[x]){
			f[cur]=x;
			deep[cur]=deep[x]+1;
			dfs_1(cur);
			siz[x]+=siz[cur];//忘写了一开始
			if(siz[son[x]]<siz[cur]) son[x]=cur;
		}
	}
}
void dfs_2(int x,int p){
	top[x]=p;
	if(son[x]) dfs_2(son[x],p);
	for(int b=fa[x];b;b=v[b].nxt){
		if(cur!=f[x]&&cur!=son[x]){
			dfs_2(cur,cur);
		}
	}
}
int query(int a,int b){
	while(top[a]!=top[b]){
		if(deep[top[a]]>deep[top[b]]) swap(a,b);
		b=f[top[b]];
	}
	return (deep[a]<=deep[b])? a : b;
}

dfs_1的时候
dfs_1(cur)后
忘记写：siz[x]+=siz[cur];
就相当于没有长长的链链了
就跳的很慢很慢了 然后就T了
其实常数是比LCA小的 OK的说

单源最短路径

SPFA

	int n,m,s;n=get_num();m=get_num();s=get_num();	for(int i=1;i<=m;i++){		int a,b,c;		a=get_num();b=get_num();c=get_num();		add(a,b,c);//注意单项边还是双向边	}	for(int i=1;i<=n;i++) d[i]=2147483647;	d[s]=0;	vis[s]=1;//忘写了一开始	Q.push(s);	while(!Q.empty()){		int h=Q.front();		vis[h]=0;		Q.pop();		for(int b=fa[h];b;b=v[b].nxt)		{			if(d[cur]>d[h]+v[b].w)			{				d[cur]=d[h]+v[b].w;				if(!vis[cur])				{					vis[cur]=1;					Q.push(cur);				}			}		}	}

queue 里 vis[h]进来的时候 没有写vis[h]=0;

Floyd

	int n;n=get_num();	for(int i=1;i<=n;i++){		for(int j=1;j<=n;j++){			v[i][j]=get_num();		}	}for(int i=0;i<=n;i++) v[i][i]=0;	for(int k=1;k<=n;k++){		for(int i=1;i<=n;i++){			for(int j=1;j<=n;j++){				v[i][j]=min(v[i][j],v[i][k]+v[k][j]);			}		}	}	int m=get_num();	for(int i=1;i<=m;i++){		int a,b;a=get_num();b=get_num();		cout<<v[a][b]<<'\n';	}

Dijkstra

int main() {    int n;    n = get_num();    for (int i = 1; i <= n; i++) {        v[0][i] = v[i][0] = get_num();    }    for (int i = 1; i <= n; i++) {        for (int j = 1; j <= n; j++) {            v[i][j] = get_num();        }    }    for (int i = 0; i <= n; i++) {        vis[i] = 0;        d[i] = 1e9;    }    d[0] = 0;    int ans = 0;    for (int i = 0; i <= n; i++) {        int sum = 1e9, k;        for (int i = 0; i <= n; i++) {            if (!vis[i] && d[i] < sum) {                sum = d[i];                k = i;            }        }        ans += d[k];        vis[k] = 1;        for (int i = 0; i <= n; i++) {            d[i] = min(d[i], d[k] + v[k][i]);        }    }    cout << ans;    return 0;}

堆优化Dijkstra

struct re{
	int d,k;
};
struct cmp{
	inline bool operator () (re a, re b){
		return a.d>b.d;
	}
}; 
priority_queue<re,vector<re>,cmp >Q;
int main()
{
	int n,m;
	re s;
	n=get_num();m=get_num();s.k=get_num();
	for(int i=1;i<=m;i++){
		int a,b,c;a=get_num();b=get_num();c=get_num();
		add(a,b,c);
	}
	for(int i=1;i<=n;i++) d[i]=2147483647;
	d[s.k]=0;re B;s.d=0;
	Q.push(s);
	while(!Q.empty()){
		re h=Q.top();
		Q.pop();
		if(vis[h.k]) continue;
		vis[h.k]=1;
		for(int b=fa[h.k];b;b=v[b].nxt){
			if(d[cur]>d[h.k]+v[b].w){
				d[cur]=d[h.k]+v[b].w;
				B.d=d[cur];B.k=v[b].to;
				Q.push(B);
			}
		}
	}
	for(int i=1;i<=n;i++) cout<<d[i]<<" ";
	return 0;
}

负环

void dfs(int x){
	if(ans) return ;
	vis[x]=1;
	for(int b=fa[x];b;b=v[b].nxt){
		if(d[cur]>d[x]+v[b].w){
			d[cur]=d[x]+v[b].w;
			if(vis[cur])
			{
				ans=1;
				break;
			}
			dfs(cur);
		}
	}
	vis[x]=0;
}
	while(t)
	{
		t--;int n,m;
		memset(vis,0,sizeof(vis));
		memset(d,0,sizeof(d));
		memset(fa,0,sizeof(fa));p=0;
		n=get_num();m=get_num();
		for(int i=1;i<=m;i++){
			int a,b,w;
			a=get_num();b=get_num();w=get_num();
			add(a,b,w);
			if(w>=0) add(b,a,w); 
		}
		ans=0;
		for(int i=1;i<=n;i++){
			dfs(i);
			if(ans) break;
		}
		if(ans) cout<<"YE5\n";
		else cout<<"N0\n";
	}

最小生成树

Kruskal

const int MAXN = 3e2 + 7;int par[MAXN];struct re {    int x, y, w;    bool operator<(const re& a) const { return w < a.w; }} v[MAXN * MAXN];int find(int x) { return par[x] == x ? x : par[x] = find(par[x]); }int main() {    int n;    cin >> n;    int cnt = 1;    for (int i = 1; i <= n; i++) {        v[cnt].x = 0;        v[cnt].y = i;        cin >> v[cnt].w;        ++cnt;    }    for (int i = 1; i <= n; i++) {        for (int j = 1; j <= n; j++) {            int w = get_num();            if (i == j) continue;            v[cnt].x = i;            v[cnt].y = j;            v[cnt].w = w;            cnt++;        }    }    sort(v + 1, v + cnt);    int ans = 0, sum = 0;    for (int i = 1; i <= n; i++) par[i] = i;    for (int i = 1; i < cnt; i++) {        if (sum == n) break;        if (find(v[i].x) != find(v[i].y)) {            ans += v[i].w;            par[find(v[i].x)] = find(v[i].y);            sum++;        }    }    cout << ans;    return 0;}

Prim

const int MAXN = 3e2 + 7;int v[MAXN][MAXN], vis[MAXN], d[MAXN];int main() {    int n;    n = get_num();    for (int i = 1; i <= n; i++) {        v[0][i] = v[i][0] = get_num();    }    for (int i = 1; i <= n; i++) {        for (int j = 1; j <= n; j++) {            v[i][j] = get_num();        }    }    for (int i = 0; i <= n; i++) {        vis[i] = 0;        d[i] = 1e9;    }    d[0] = 0;    int ans = 0;    for (int i = 0; i <= n; i++) {        int sum = 1e9, k;        for (int i = 0; i <= n; i++) {            if (!vis[i] && d[i] < sum) {                sum = d[i];                k = i;            }        }        ans += d[k];        vis[k] = 1;        for (int i = 0; i <= n; i++) {            d[i] = min(d[i], v[k][i]);        }    }    cout << ans;    return 0;}

堆优化的Prim

const int MAXN = 3e2 + 7;int v[MAXN][MAXN], vis[MAXN], d[MAXN];struct re {    int d, w;    bool operator<(const re &a) const { return w > a.w; }};priority_queue<re> Q;int main() {    int n;    n = get_num();    for (int i = 1; i <= n; i++) {        v[0][i] = v[i][0] = get_num();    }    for (int i = 1; i <= n; i++) {        for (int j = 1; j <= n; j++) {            v[i][j] = get_num();        }    }    for (int i = 0; i <= n; i++) {        vis[i] = 0;        d[i] = 1e9;    }    d[0] = 0;    Q.push({0, 0});    int ans = 0;    while (!Q.empty()) {        re h = Q.top();        Q.pop();        if (vis[h.d]) continue;        vis[h.d] = 1;        ans += h.w;        for (int i = 0; i <= n; i++) {            if (d[i] > v[h.d][i]) {                d[i] = v[h.d][i];                Q.push({i, d[i]});            }        }    }    cout << ans;    return 0;}

二分图匹配 再打一遍

int dfs(int x){	for(int i=0;i<v[x].size();i++){		if(!vis[cur])		{			vis[cur]=1;			if(!match[cur]||dfs(match[cur]))			{				match[cur]=x;				match[x]=cur;				return 1;			}		}	}	return 0;}int n;int query(){	int ans=0;	for(int i=1;i<=n;i++){		if(!match[i]){			memset(vis,0,sizeof(vis));			if(dfs(i)) ans++;		}	}	return ans;}int main(){	int m,e;n=get_num();m=get_num();e=get_num();	for(int i=1;i<=e;i++){		int a,b;a=get_num();b=get_num();		if(b<=m) v[a].push_back(b+n);	}	cout<<query();	return 0;}

强连通分量

缩点 再打一遍

void tarjan(int x){	my_s.push(x);in_s[x]=1;//注意不要忘了	dfn[x]=low[x]=++tot;	for(int b=fa[x];b;b=v[b].nxt){		if(!dfn[cur]){			tarjan(cur);			low[x]=min(low[x],low[cur]);		} else if(in_s[cur]) low[x]=min(low[x],dfn[cur]);	}	if(low[x]==dfn[x])	{		++bcnt;		while(my_s.top()!=x){			fd[my_s.top()]=bcnt;d[bcnt]+=w[my_s.top()];in_s[my_s.top()]=0;my_s.pop();		}		d[bcnt]+=w[my_s.top()];fd[my_s.top()]=bcnt;in_s[my_s.top()]=0;my_s.pop();	}}void build(){	for(int i=1;i<=n;i++){		for(int b=fa[i];b;b=v[b].nxt)		{			if(fd[i]!=fd[cur])			{				qv[fd[i]].push_back(fd[cur]);			}		}	}}int dfs(int x){	if(dp[x]) return dp[x];	for(int i=0;i<qv[x].size();i++){		dp[x]=max(dp[x],dfs(qv[x][i]));	}	dp[x]+=d[x];	return dp[x];}

割顶（割点）

void tarjan(int x){	dfn[x]=low[x]=++tot;	int rt=0;	for(int b=fa[x];b;b=v[b].nxt){		if(!dfn[cur]){			rt++;			f[cur]=f[x];			tarjan(cur);			low[x]=min(low[x],low[cur]);			if(low[cur]>=dfn[x]&&f[x]!=x&&!vis[x]) vis[x]=1,ans++; //重要		}else  low[x]=min(low[x],dfn[cur]);	}	if(f[x]==x&&rt>=2) ans++,vis[x]=1;}

Kosaraju

int n, c[N], dfn[N], vis[N], dcnt, scnt;
vector<int> G1[N], G2[N];  // G1 原图，G2 反向图
void dfs1(int x) {
    vis[x] = 1;
    for (auto y : G1[x]) {
        if (!vis[y]) dfs1(y);
    }
    dfn[++dcnt] = x;
}
void dfs2(int x) {
    c[x] = scnt;
    for (auto y : G2[x]) {
        if (!c[y]) dfs2(y);
    }
}
void kosaraju() {
    dcnt = scnt = 0;
    memset(c, 0, sizeof(c));
    memset(vis, 0, sizeof(vis));
    for (int i = 1; i <= n; i++) {
        if (!vis[i]) dfs1(i);
    }
    for (int i = n; i >= 1; i--) {
        if (!c[dfn[i]]) ++scnt, dfs2(dfs[i]);
    }
}
  • 前序序列
  • 后序序列
  • 逆逆序序列（后序序列的逆序，原图缩点后的的拓扑顺序）

拓扑排序

bool topoSort(int n) {    queue<int> Q;    for (int i = 0; i < n; i++) {        if (in_deg[i] == 0) Q.push(i);    }    vector<int> ans;    while (!Q.empty()) {        int u = Q.front();        Q.pop();        ans.push_back(u);        for (auto& i : v[u]) {            if (--in_deg[i] == 0) Q.push(i);        }    }    if (ans.size() == n) {        for (auto& i : ans) {            cout << i << " ";        }        cout << endl;    } else        return false;}

树上差分

LL fast_pow(LL a,LL p,LL k){	LL ans=(a==0)?0:1;	a%=k;	for(;p;p>>=1,a=(a*a)%k)	{		if(p&1) ans=(ans*a)%k;	}return ans;}int main(){	LL n,l,r;cin>>n>>l>>r;	for(int i=1;i<=n;i++){		v[i].m=get_num();v[i].a=get_num();	}	LL M=1;	for(int i=1;i<=n;i++) M*=v[i].m;	for(int i=1;i<=n;i++){		v[i].M=M/v[i].m;		v[i].k=fast_pow(v[i].M,v[i].m-2,v[i].m);	}	LL ans=0;	for(int i=1;i<=n;i++) ans=(ans+v[i].a*v[i].M*v[i].k)%M;	//cout<<ans;	LL anss=0;	if(r>=ans) anss=(r-ans)/M+1;	if(l-1>=ans) anss-=(l-ans-1)/M+1;	if(anss==0) cout<<0<<'\n'<<0;	else{		cout<<anss<<'\n';		if(l-1>=ans){			cout<<((l-1-ans)/M+1)*M+ans;		}else cout<<ans;	}	return 0;}

最大流量

const int maxn=50010;struct re{	int fd,to,nxt,ans;}qv[maxn<<2];vector<int> v[maxn];int p=1,fa[maxn],vis[maxn],d[maxn],f[maxn],fath[maxn];int n,k;inline void add(int x,int y){	qv[++p].to=y;	qv[p].nxt=fa[x];	qv[p].fd=x;	fa[x]=p;}inline int get_num(){	char c;	int f=1,num=0;	while((c=getchar())==' '||c=='\n'||c=='\r');	if(c=='-') f=-1;	else num=c-'0';	while(isdigit(c=getchar())) num=num*10+c-'0';	return num*f;}int find(int x){	if(f[x]==x) return x;	return f[x]=find(f[x]);}void tarjan(int x){	vis[x]=1;	f[x]=x;	for(int i=0;i<v[x].size();i++){		if(!vis[cur]){			fath[cur]=x;			tarjan(cur);			f[find(cur)]=x;		}	}	for(int b=fa[x];b;b=qv[b].nxt){		if(vis[qv[b].to]){			qv[b].ans=qv[b^1].ans=find(qv[b].to);		}	}}void dfs(int x){	vis[x]=1;	for(int i=0;i<v[x].size();i++){		if(!vis[cur]){			dfs(cur);			d[x]+=d[cur]; 		}	}}int query(){	for(int i=2;i<=p;i+=2){		++d[qv[i].fd];++d[qv[i].to];--d[qv[i].ans];		--d[fath[qv[i].ans]];	}	memset(vis,0,sizeof(vis));	dfs(1);	int ans=0;	for(int i=1;i<=n;i++){		ans=max(ans,d[i]);	}return ans;}int main(){	n=get_num();k=get_num();	for(int i=1;i<n;i++){		int a,b;a=get_num();b=get_num();		v[a].push_back(b);v[b].push_back(a);	}	for(int i=1;i<=k;i++){		int a,b;a=get_num();b=get_num();		add(a,b);add(b,a);	}	for(int i=1;i<=n;i++){		if(!vis[i]) tarjan(i);	}	cout<<query();	return 0;}

算法

二分法

int find(int x) {
    int l = 1, r = n, ans = -1;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (a[mid] >= x) {
            ans = mid;
            r = mid - 1;
        } else
            l = mid + 1;
    }
    return ans;
}

int find(int x) {
    int l = 1, r = n;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (a[mid] >= x) {
            r = mid - 1;
        } else
            l = mid + 1;
    }
    return l;
}

三分法

int n;
double v[20];
double eps = 1e-7;
double find(double x) {  //find类型不要写错
    double ans = v[n + 1];
    double p = 1;
    for (int i = n; i; i--) {
        p *= x;
        ans += v[i] * p;
    }
    return ans;
}
int main() {
    double l, r, mid, midd;
    cin >> n >> l >> r;
    for (int i = 1; i <= n + 1; i++) cin >> v[i];
    while (l + eps <= r) {
        mid = (l + r) / 2;
        midd = (l + mid) / 2;
        if (find(midd) < find(mid))
            l = midd;
        else
            r = mid;
    }
    printf("%.5lf", l);
    return 0;
}

double 类型用的get_num()读进去了
其实应该用cin>>
能过样例也是奇迹

LCS（最长公共子序列） O ( n l o g n ) O(nlogn) O(nlogn)做法

	int n;n=get_num();
	for(int i=1;i<=n;i++) f[get_num()]=i;
	for(int i=1;i<=n;i++){
		int c=f[get_num()];
		if(c>dp[len]) dp[++len]=c;
		else{
			int l=1,r=len,mid;
			while(l<=r){
				mid=(l+r)>>1;
			    if(dp[mid]>c) r=mid-1;
			    else l=mid+1;
			}dp[l]=c;
		}		
	}
	cout<<len;

二进制拆分

void solv(int n) {
    cnt = 0;
    for (int i = 1; i <= n; i++) {
        int w, k;
        cin >> k >> w;
        for (int j = 1; j <= k; j <<= 1) {
            cnt++;
            v[cnt] = j * w;
            k -= j;
        }
        if (k) {
            cnt++;
            v[cnt] = k * w;
        }
    }
}

数论

快速幂

LL fast_pow(LL a, LL p, LL k) {
    LL ans = (a == 0) ? 0 : 1;  //注意是a不是p	a%=k;
    for (; p; p >>= 1, a = (a * a) % k) {
        if (p & 1) ans = (ans * a) % k;
    }
    return ans;
}

gcd

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

exgcd 同余方程

void exgcd(LL a, LL b, LL &x, LL &y) {
    if (b == 0) {
        x = 1, y = 0;
        return;
    }
    exgcd(b, a % b, x, y);
    LL x2 = x, y2 = y;
    x = y2;
    y = x2 - (a / b) * y2;  //手推即可
}

线性筛素数

{
    int n, m;
    n = get_num();
    m = get_num();
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) pri[++cnt] = i;
        for (int j = 1; j <= cnt && pri[j] * i <= n; j++) {
            vis[i * pri[j]] = 1;  //注意谁%谁 后者%不动
            if (i % pri[j] == 0) break;
        }
    }
    vis[1] = 1;  //注意1首先啥都不是 其次他不是素数	for(int i=1;i<=m;i++){		if(vis[get_num()]) cout<<"No\n";
    else cout << "Yes\n";
}

没有考虑vis[1]=1的情况 详情看日记

矩阵快速幂

const int N = 3;
LL p = 10007;
struct Matrix {
    LL x[N][N];
    Matrix operator*(const Matrix &t) const {
        Matrix ret;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                ret.x[i][j] = 0;
                for (int k = 0; k < N; ++k) {
                    ret.x[i][j] += (x[i][k] * t.x[k][j]) % p;
                    ret.x[i][j] %= p;
                }
            }
        }
        return ret;
    }  // 为了防止奇怪的错误，最好写上构造函数
    Matrix() { memset(x, 0, sizeof(x)); }
    Matrix(const Matrix &t) { memcpy(x, t.x, sizeof(x)); }
};
Matrix quick_pow(Matrix a, LL x) {
    Matrix ret;
    for (int i = 0; i < N; i++) {
        ret.x[i][i] = 1;
    }
    while (x) {
        if (x & 1) ret = ret * a;
        a = a * a;
        x >>= 1;
    }
    return ret;
}
int main() {
    int T;
    cin >> T;
    while (T--) {
        LL n;
        cin >> n;
        Matrix a;
        a.x[0][0] = a.x[1][1] = a.x[2][0] = a.x[2][1] = a.x[2][2] = 2;
        a.x[0][2] = a.x[1][2] = 1;
        Matrix P = quick_pow(a, n);
        cout << P.x[0][0] << '\n';
    }
    return 0;
}

fast_pow里面p>>=1 写的p>>1 get_num()没改LL

乘法逆元

{
    LL n, p;
    cin >> n >> p;
    inv[1] = 1 % p;
    cout << inv[1] << '\n';
    for (int i = 2; i <= n; i++) {
        inv[i] = (p - p / i) * inv[p % i] % p;  //由p%i+(p/i)*i=p开始
        cout << inv[i] << '\n';
    }
}

字符串

KMP

void getNext(const string &p) {
    int len = p.size();
    nxt[0] = 0;
    for (int i = 1, j = 0; i < len; ++i) {
        while (j && p[i] != p[j]) j = nxt[j - 1];
        if (p[i] == p[j]) j++;
        nxt[i] = j;
    }
}
int KMP(const string &s, const string &p) {
    int ans = 0;
    getNext(p);
    int len1 = s.size(), len2 = p.size();
    for (int i = 0, j = 0; i < len1; ++i) {
        while (j && s[i] != p[j]) j = nxt[j - 1];
        if (s[i] == p[j]) j++;
        if (j == len2) {
            ans++;
            j = nxt[j - 1];
        }
    }
    return ans;
}

Trie

struct Trie {
    static const int N = 1e6 + 7, charset = 2;
    int tot, root, child[N][charset], flag[N];
    Trie() { clear(); }
    void clear() {
        memset(child, -1, sizeof(child));
        memset(flag, 0, sizeof(flag));
        root = tot = 0;
    }
    void insert(const string &s) {
        int now = root;
        for (int i = 0; i < (int)s.size(); i++) {
            int x = s[i] - 'a';
            if (child[now][x] == -1) {
                child[now][x] = ++tot;
                flag[now] = 0;
            }
            now = child[now][x];
        }
        flag[now] = 1;
    }
    // 查询字典树中是否存在某个完整的字符串是s的前缀
    bool query(const string &s) {
        int now = root;
        for (int i = 0; i < (int)s.size(); i++) {
            int x = s[i] - 'a';
            if (child[now][x] == -1) return false;
            if (flag[now]) return true;
            now = child[now][x];
        }
        return false;
    }
};

STL

Map

技巧

MAP初始化

// 方法一
map<char, int> M1({{'Q', 0}, {'W', 1}, {'E', 2}, {'R', 3}});
// 方法二：采用C++11新特性：
// C++11 还把初始化列表的概念绑定到了类型上，并将其称之为 std::initializer_list，允许构造函数或其他函数像参数一样使用初始化列表，
map<char, int> M2{{'Q', 0}, {'W', 1}, {'E', 2}, {'R', 3}};

split

vector<string> split(const string& s, char c) {  //分隔文件名
    vector<string> res;
    string tmp;
    stringstream ss(s);
    while (getline(ss, tmp, c)) res.push_back(tmp);  //res保存整体
    return res;
}
// std::vector<std::string> split(const std::string& line, char c) {
//     std::stringstream stm(line);
//     std::vector<std::string> ans;
//     std::string tmp;
//     while (std::getline(stm, tmp, c)) ans.push_back(tmp);
//     return ans;
// }
Anadem
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——图论
02-06
在IT领域，数据结构是计算机科学的基础，而图论则是数据结构中不可或缺的一部分。图论是一种用节点（顶点）和边来表示和解决各种问题的数学模型，它广泛应用于网络设计、路由算法、社交网络分析等领域。在这个“数据...
送一个大马给有需要的人，请不要做非法之事
qq_42966617的博客
06-16 8万+
今天站点被人爆破，并成功入马，现在把马放出来，给有需要的人。 <?php header("Content-type:text/html;charset=gbk"); $password='fool'; $shellname='MrFooL'; $myurl=null; error_reporting(0); ob_start(); define('myaddress',$_SERVER['SCRIPT_FILENAME']); define('postpass',$password); define(
贪心法
热门推荐
Me的专栏
05-07 23万+
贪心法 贪心算法并不是从整体最优上加以考虑， 而是从局部最优考虑， 每次总是做出当前看起来最好的选择，在某种意义上的局部最优选择； 最优子结构性质 ： 贪心选择性质： 1、  活动安排 ： 问题描述 ：设有n个活动集合E = {1 ,2,…,n} ，其中每个活动i都要求使用同一资源， 而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始
数据结构--队列和优先队列
一只啃着鸡翅写代码的白猫的成长记录
06-03 584
本文为转载，出处：https://blog.csdn.net/c20182030/article/details/70171231 https://blog.csdn.net/c20182030/article/details/70757660 一、队列 1.queue的声明 queue声明的基本结构是这样的：queue<数据结构>队列名; queue<int> i; ...
50个必须要会的微服务面试题
paolei的笔记
09-22 7502
https://segmentfault.com/a/1190000020092884 https://www.edureka.co/blog/interview-questions/microservices-interview-questions/ Top Microservices Interview Questions According to Gartner, microservices are the new application platform for cloud.
top 监控系统cpu、内存、进程的资源占用情况
MssGuo的博客
06-04 6156
top命令
计算机专业数据结构课程设计报告
11-11
数据结构课程设计报告涉及到多个经典的数据结构问题，包括约瑟夫环问题、魔方阵、迷宫问题、哈夫曼编码、简单个人电话号码查询系统和双向起泡排序。这里我们将详细讨论前两个问题——约瑟夫环问题和魔方阵。 首先，...
(15个)杭电ACM课件2014版_程序设计_数据结构_ACM_数论_
09-29
国际大学生程序设计竞赛（英文全称：International Collegiate Programming Contest（简称ICPC））是由国际计算机协会（ACM）主办的，一项旨在展示大学生创新能力、团队精神和在压力下编写程序、分析和解决问题能力...
蓝桥杯算法与数据结构的学习路线
最新发布
06-19
试题涉及的内容包括基础Python程序设计，以及高级算法如动态规划、图论、数论等。 为了备赛，参赛选手需要熟悉Python的基本语法和标准库，例如使用内置的math库进行数学计算。除此之外，刷题是提高编程能力和解题...
数据结构算法集锦.doc
05-06
文档"数据结构算法集锦.doc"涵盖了数论算法和图论算法两个主要领域，下面是这两个领域的详细解释： 一、数论算法 1. 最大公约数（Greatest Common Divisor, GCD）： 求两个整数的最大公约数可以使用欧几里得算法...
ACM 常用算法（数论，图论，搜索，动态规划，几何）
06-19
内涵盖ACM中的数论，图论，几何，动态规划，收索等经典精简代码模板
jnu第一大混子的训练纪录3：基础图论和基础数论
qq_51567843的博客
11-04 441
Part 1 ：图论 （接训练纪录2 part 3） 图的着色问题 泛指把图的相邻顶点染成不同颜色的问题，没有深究，以简单题为例：洛谷2819 #include<iostream> #include<algorithm> #include<cmath> #include<cstdio> #include<cstring> #include<vector> #include<queue> #include<ma
【HTML+CSS】静态网页设计期末大作业——西安旅游网页设计与实现
STU网页设计
10-15 1187
📔网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。📓网站程序方面：计划采用最新的网页编程语言HTML5+CSS3+JS程序语言完成网站的功能设计。并确保网站代码兼容目前市面上所有的主流浏览器，已达到打开后就能即时看到网站的效果。📘网站素材方面：计划收集各大平台好看的图片素材，并精挑细选适合网页风格的图片，然后使用PS做出适合网页尺寸的图片。📒网站文件方面：网站系统文件种类包含：html网页结构文件、css网页样式文件、js网页特效文件、images网页图片文件
搜索+图论+数论
人言束负
01-08 3563
DFS与BFS、树与图的遍历：拓扑排序、最短路、最小生成树、二分图：染色法、匈牙利算法、质数、约数、欧拉函数、快速幂、扩展欧几里得算法、中国剩余定理、高斯消元、组合计数、容斥原理、简单博弈论
图论的总结（知足）（板子）
MaydayMerlin的博客
01-26 380
有向/无向图 ：边具有/不具有方向完全图：每一对不同顶点恰有一条边相连的无向图路径：一些边和对应点的序列，使得前一条边的终止点等于下一条边的起始点。简单路径：经过的点不重复的路径环：一条首尾相连的路径简单环：一条首尾相连的简单路径自环：端点在同一点的边重边：两条端点相同的边以上板子来自lyn学长本人依照自己的码风稍加修改。马上就要HL了，希望这佛脚不会让我爆零（doge。
第六章--图论 板子
qq_45678698的博客
10-10 505
无
【蓝桥杯】什么算法才是版本答案？近三年（2019-2021）蓝桥杯省赛涉及算法出现频率分析
薛崇祥的博客
01-05 6531
本文分析蓝桥杯2019到2021年省赛中出现的算法，分析各种算法在题目中的比重，明确优先学习掌握哪些算法能对提升成绩有最大的帮助。
数据结构与算法之图论
Happy_Boy_z的博客
04-18 392
图论图基本介绍图的深度优先遍历广度优先遍历 图基本介绍 为什么要有图 前面我们学了线性表和树 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时， 这里我们就用到了图 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。 图的深度优先遍历 深度优先遍历基本思想 图的深度优先搜索(...
一次小总结：图论+数论+学长们
weixin_30765577的博客
07-14 244
　　用cnblogs就是好，用word编辑好了可以直接粘过去。 　　六 图论D1.串联位运算、bitset、搜索（迭代加深、估价）、树上数据结构、生成树、图的遍历（欧拉回路、拓扑排序、连通分量、2-SAT不懂不懂）+TEST 　　日 休息 　　一 图论D2.最短路、差分约束、网络流 　　二 图论D3.网络流加深+TEST 　　三 自习数学+数论讲解 　　四 数论讲解 　　五 即将进入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值