图论板子
图论板子
1.最短路
（1）Dijkstra
无堆优化：
int n,m,G[N][N],d[N];
bool vis[N] = {false};
void Dij(int s){
for(int i = 1;i <= n;i++) d[i] = inf;
d[s] = 0;
for(int i = 1;i <= n;i++){
int x,_m = inf;
for(int j = 1;j <= n;j++){//找到离起点距离最短并且没有找过的点
if(!vis[j] && d[j] <= _m) _m = d[x=j];
}
vis[x] = true;//找到了最短路，并且更新一遍最短路树
for(int j = 1;j <= n;j++)d[j] = min(d[j],d[x]+G[x][j]);
}
}
堆优化：
ll n,m,s;
struct edge{
ll to,w;
edge(ll v,ll ww){to = v;w = ww;}
};
struct node{
ll id,dis;
node(ll x,ll y){id = x;dis = y;}
bool operator < (const node &a)const
{return dis > a.dis;}
};
vector<edge> e[N];
void add(ll u,ll v,ll w){
e[u].push_back({v,w});
}
ll d[N];
bool done[N];
void dijkstra(){
for(ll i = 1;i <= n;i++){
d[i] = (i==s)?0:inf;
done[i] = false;
}
priority_queue<node> q;
q.push(node(s,d[s]));
while(!q.empty()){
node x = q.top();
q.pop();
if(done[x.id]) continue;
done[x.id] = true;
for(ll i = 0;i < e[x.id].size();i++){
edge u = e[x.id][i];
if(done[u.to])continue;
if(d[u.to] > x.dis+u.w){
d[u.to] = x.dis+u.w;
q.push(node(u.to,d[u.to]));
}
}
}
}
(2)bellman-ford
int n,m,s,d;
struct Edge{
int u,v,w;
Edge(int _u = 0,int _v = 0,int _w = 0):u(_u),v (_v),w(_w){}
};
vector<Edge> edge;
int dis[N];
void add(int u,int v,int w){
edge.push_back(Edge(u,v,w));
}
bool bellman(){
for(int i = 1;i <= n;i++) dis[i] = inf;
dis[s] = 0;
for(int i = 1;i <= n-1;i++){
bool flag = false;
for(int j = 0;j < edge.size();j++){
int u = edge[j].u,v= edge[j].v,w = edge[j].w;
if(dis[v] > dis[u]+w){
dis[v] = dis[u]+w;
flag = true;
}
}
if(!flag) return true;
}
for(int i = 0;i < edge.size();i++)
if(dis[edge[i].v] > dis[edge[i].u])
return false;
return true;
}
(3)Spfa
int n,m,s,t;//点数，边数，起点，终点
struct Edge{
int u,v;
int w;
Edge(int _u = 0,int _v = 0,int _w = 0):u(_u),v(_v),w(_w){}
};
vector<Edge> G[N];
void add(int u,int v,int w){
G[u].push_back(Edge(u,v,w));
}
bool vis[N];//检测是否在队列中
int cnt[N],dis[N];//cnt表示进入队列次数，dis表示距离
queue<int>q;
bool spfa(){
memset(vis,false,sizeof(vis));
for(int i = 1;i <= n;i++)dis[i] = inf;
vis[s] = true;dis[s] = 0;
while(!q.empty()) q.pop();
q.push(s);
memset(cnt,0,sizeof cnt);
cnt[s] = 1;
while(!q.empty()){
int u = q.front();
q.pop();vis[u] = false;
for(auto e:G[u]){
int v = e.v;
if(dis[v] > dis[u]+e.w){
dis[v] = dis[u]+e.w;
if(!vis[v]){
vis[v] = true;
q.push(v);
if(++cnt[v] > n)return false;
//因为存在一个点被访问了超过n次所以该回路存在负环回路
}
}
}
}
return true;
}
2.最小生成树
(1) Kruskal算法(和并查集的板子一起了)
ll n,m,cnt = 0;
struct Edge{
ll u,v,w;
bool operator < (const Edge &x)const{return x.w > w;}
}edge[N];
ll f[N] = {0};
ll find(ll x){
return x == f[x]?x:f[x] = find(f[x]);
}
void _union(ll x,ll y){
x = find(x),y = find(y);
if(x != y) f[x] = y;
}
ll ans = 0;
void Kruskal(){
for(int i = 1;i <= n;i++) f[i] = i;
sort(edge+1,edge+m+1);
ll ans = 0;
for(int i = 1;i <= m;i++){
ll u = edge[i].u,v = edge[i].v;
if(find(u) != find(v)){
ans += edge[i].w;
_union(u,v);
}
}
}
(2)prim算法
//dij改一下就是了
bool vis[N];
ll lowc[N],n;
void prim(){
memset(vis,false,sizeof vis);
ll ans = 0;
vis[1] = true;
for(ll i = 2;i <= n;i++) lowc[i] = G[1][i];
for(ll i = 2;i <= n;i++){
ll minc = inf;
ll tmp = -1;
for(ll j = 1;j <= n;j++){
if(!vis[j] && minc > lowc[j]){
minc = lowc[j];
tmp = j;
}
}
ans += minc;
vis[tmp] = true;
for(ll j = 1;j <= n;j++){
if(!vis[j] && lowc[j] > G[tmp][j]){
lowc[j] = G[tmp][j];
}
}
}
cout<<ans<<endl;
}
3.联通性
tarjan
int n,m;
struct Edge{
ll to,nxt;
}edge[N];
int head[N],tot;
int low[N],dfn[N],sta[N],co[N];
bool is_sta[N] = {false};
int cnt = 0,top = 0;
int scc = 0;//连通分量的个数
int num[N];//每个强连通分量的点数
void add(int u,int v){
edge[tot].to = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
void tarjan(int u){
int v;
low[u] = dfn[u] = ++cnt;
sta[top++] = u;
is_sta[u] = true;
for(int i = head[u];~i;i = edge[i].nxt){
v = edge[i].to;
if(!dfn[v]){
tarjan(v);
low[u] = min(low[u],low[v]);
}
else if(is_sta[v]) low[u] = min(low[u],dfn[v]);
}
if(low[u] == dfn[u]){
scc++;
do{
v = sta[--top];
is_sta[v] = false;
co[v] = scc;
num[scc]++;
}while(v != u);
}
}
void solve(){
memset(dfn,0,sizeof(dfn));
memset(is_sta,false,sizeof(is_sta));
memset(num,0,sizeof(num));
cnt = top = scc = 0;
for(int i = 1;i <= n;i++){
if (!dfn[i])tarjan(i);
}
}
void init(){
tot = 0;
memset(head,-1,sizeof(head));
}
(2)Kosaraju
struct Edge{
int to,next;
}edge1[N],edge2[N];
int head1[N],head2[N];
bool ok1[N],ok2[N];
int tot1,tot2;
int cnt1,cnt2;
int st[N],be[N],scc[N];//对原图dfs，标记时间;记录每一个点在哪个连通分量;记录某一连通分量的点数
int tmp = 0;//中间变量
void add(int u,int v){
edge1[tot1].to = v;edge1[tot1].next = head1[u];head1[u] = tot1++;//建立正图
edge2[tot2].to = u;edge2[tot2].next = head2[v];head2[v] = tot2++;//建立反图
}
void dfs1(int u){
ok1[u] = true;
for(int i = head1[u];~i;i = edge1[i].next){
int v = edge1[i].to;
if(!ok1[v]) dfs1(v);
}
st[cnt1++] = u;
}
void dfs2(int u){
ok2[u] = true;
tmp++;
be[u] = cnt2;
for(int i = head2[u];~i;i = edge2[i].next){
int v = edge2[i].to;
if(!ok2[v]) dfs2(v);
}
}
void slove(){
memset(ok1,false,sizeof ok1);
memset(ok2,false,sizeof ok2);
cnt1 = cnt2 = 0;
for(int i = 1;i <= n;i++){
if(!ok1[i]) dfs1(i);
}
for(int i = cnt1-1;i >= 0;i--){
if(!ok2[st[i]]){
tmp = 0;
dfs2(st[i]);
scc[cnt2++] = tmp;
}
}
}
4.二分图
(1)匈牙利算法
int m,n; //左右的集合的元素数量
int G[N][N]; //邻接矩阵存图
int p[N] = {0}; //右侧元素对应的左侧元素
bool vis[N]; //记录右侧元素是否被访问过
bool match(int i){
for(int j = 1;j <= n;j++){
if(G[i][j] && !vis[j]){ //有边且未访问
vis[j] = true; //记录状态被访问过
if(p[j] == 0 || match(p[j])){ //暂无匹配,原匹配的左侧元素可以找到新元素
p[j] = i; //当前左侧元素成为当前右侧元素的新匹配
return true; //返回匹配成功
}
}
}
return false; //循环结束，未找到匹配，返回匹配失败
}
int Hungarian(){
int cnt = 0;
for(int i = 1;i <= m;i++){
memset(vis,0,sizeof vis); //重置vis数组
if(match(i)) cnt++;
}
return cnt;
}
网络流Dinic
struct Edge{ll to,w,nxt;}edge[M];
ll head[N],cnt = 1;
void add(ll u,ll v,ll w){
edge[++cnt] = {v,w,head[u]};
head[u] = cnt;
}
void add2(ll u,ll v,ll w){
add(u,v,w);
add(v,u,0);
}
ll s,t,lv[N],cur[N];
bool bfs(){
memset(lv,-1,sizeof lv);
lv[s] = 0;
memcpy(cur, head, sizeof(head));
queue<ll>q;q.push(s);
while(!q.empty()){
ll p = q.front();q.pop();
for(ll eg = head[p];eg;eg = edge[eg].nxt){
ll to = edge[eg].to,vol = edge[eg].w;
if(vol > 0 && lv[to] == -1) lv[to] = lv[p] +1,q.push(to);
}
}
return lv[t] != -1;
}
ll dfs(ll p = s,ll flow = inf){
if(p == t)return flow;
ll rmn = flow;
for(ll &eg = cur[p];eg;eg = edge[eg].nxt){
if(!rmn)break;
ll to = edge[eg].to,vol = edge[eg].w;
if(vol > 0 && lv[to] == lv[p]+1){
ll c = dfs(to,min(vol,rmn));
rmn -= c;
edge[eg].w -= c;
edge[eg^1].w += c;
if(rmn == 0)break;
}
}
return flow-rmn;
}
ll dinic(){
ll ans = 0;
while(bfs()) ans += dfs();
return ans;
}
费用流
#include <iostream>
#include <queue>
#define ll long long
const ll N = 5e3+50,M = 5e4+50;
const ll inf = 0x3f3f3f3f;
using namespace std;
ll head[N],cnt = 1;
//将EK的bfs变为spfa
struct Edge{
ll to,w,cost,nxt;
}edge[M*2];
void add(ll u,ll v,ll w,ll c){
edge[++cnt] = {v,w,c,head[u]};
head[u] = cnt;
}
void add2(ll u,ll v,ll w,ll cost){
add(u,v,w,cost);
add(v,u,0,-cost);
}
ll s,t,dis[N],cur[N];
bool inq[N],vis[N];
queue<ll>Q;
bool spfa(){
while(!Q.empty()) Q.pop();
copy(head,head+N,cur);
fill(dis,dis+N,inf);
dis[s] = 0;
Q.push(s);
while(!Q.empty()){
ll p = Q.front();
Q.pop();
inq[p] = false;
for(ll e = head[p];e;e = edge[e].nxt){
ll to = edge[e].to,vol = edge[e].w;
if(vol > 0 && dis[to]>dis[p]+edge[e].cost){
dis[to] = dis[p] + edge[e].cost;
if(!inq[to]){
Q.push(to);
inq[to] = true;
}
}
}
}
return dis[t] != inf;
}
ll dfs(ll p = s,ll flow = inf){
if(p == t) return flow;
vis[p] = true;
ll rmn = flow;
for(ll eg = cur[p];eg && rmn;eg = edge[eg].nxt){
cur[p] = eg;
ll to = edge[eg].to,vol = edge[eg].w;
if(vol > 0 && !vis[to]&&dis[to] == dis[p]+edge[eg].cost){
ll c = dfs(to,min(vol,rmn));
rmn -= c;
edge[eg].w -= c;
edge[eg^1].w += c;
if(rmn == 0)break;`
}
}
vis[p] = false;
return flow-rmn;
}
ll maxflow = 0,mincost = 0;
void dinic(){
while(spfa()){
ll flow = dfs();
maxflow += flow;
mincost += dis[t]*flow;
}
}
int main() {
ios::sync_with_stdio(false);
ll n,m;
cin>>n>>m>>s>>t;
while(m--){
ll u,v,w,c;cin>>u>>v>>w>>c;
add2(u,v,w,c);
}
dinic();
cout<<maxflow<<' '<<mincost<<endl;
return 0;
}
LCA
（1）树上倍增
struct Edge{
ll to,nxt;
}edge[2*N];
ll head[2*N],tot;
void init(){
for(int i=0;i<2*N;++i){
edge[i].nxt = -1;
head[i] = -1;
}
tot = 0;
}
void add(ll u,ll v){
edge[tot].to = v;
edge[tot].nxt = head[u];
head[u] = tot++;
}
ll fa[N][20],deep[N];
//fa[x][i]表示，x的第2^i个祖先，fa[x][i] = fa[fa[x][i-1]][i-1]
//deep[x]是x的深度
void dfs(ll u,ll father){//求u的深度
deep[u] = deep[father]+1;
fa[u][0] = father;
for(ll i = 1;(1<<i)<=deep[u];i++){
fa[u][i] = fa[fa[u][i-1]][i-1];
}
for(ll i = head[u];~i;i = edge[i].nxt){
if(edge[i].to != father){
dfs(edge[i].to,u);
}
}
}
ll LCA(ll x,ll y){
if(deep[x] < deep[y]) swap(x,y);
for(ll i = 19;i >= 0;i--){//先让x跳到y的层数
if(deep[x]-(1<<i) >= deep[y]) x = fa[x][i];
}
if(x == y) return x;
for(ll i = 19;i >= 0;i--){//让x,y一起跳，最多只能跳到LCA的下一层
if(fa[x][i] != fa[y][i]){
x = fa[x][i];
y = fa[y][i];
}
}
return fa[x][0];
}
浙公网安备 33010602011771号