图论总结

最新推荐文章于 2023-10-06 16:35:20 发布
置顶 最新推荐文章于 2023-10-06 16:35:20 发布
阅读量353 收藏 1
点赞数 1
分类专栏： ----------------图论---------------- -------------模版------------ 模版
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33362864/article/details/77396689
版权

图论总结

二分图最大匹配

int match[MAXN];
bool vis[MAXN];
bool dfs(int u)
{
    for(int v = 1; v <= b; ++v)
    {
        if(!vis[v]&&!tu[u][v])
        {
            vis[v] = 1;
            if(match[v] == -1 || dfs(match[v]))
            {
                match[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

km最大权最小权

int w[MAXN][MAXN1],pre[MAXN1],kx[MAXN],ky[MAXN1];  
bool visx[MAXN1],visy[MAXN1];  
void init()  
{  
    memset(ky,0,sizeof(ky));  
    memset(pre,-1,sizeof(pre));  
    for(int i=0; i<n; ++i)  
    {  
        kx[i]=w[i][0];  
        for(int j=1; j<m; ++j)  
        {  
            kx[i]=max(kx[i],w[i][j]);  
        }  
    }  
}  
bool dfs(int u)  
{  
    visx[u]=1;  
    for(int i=0; i<m; ++i)  
    {  
        if(!visy[i])  
        {  
            int t=kx[u]+ky[i]-w[u][i];  
            if(!t)  
            {  
                visy[i]=1;  
                if(pre[i]==-1||dfs(pre[i]))  
                {  
                    pre[i]=u;  
                    return 1;  
                }  
            }  
            else d=min(d,t);  
        }  
    }  
    return 0;  
}  
int km()  
{  
    for(int i=0; i<n; ++i)  
    {  
        while(1)  
        {  
            memset(visx,0,sizeof(visx));  
            memset(visy,0,sizeof(visy));  
            d=inf;  
            if(dfs(i))break;  
            for(int j=0; j<m; ++j)  
            {  
                if(visx[j])kx[j]-=d;  
                if(visy[j])ky[j]+=d;  
            }  
        }  
    }  
    int ans=0;  
    for(int i=0; i<m; ++i)  
    {  
        if(pre[i]!=-1)ans+=w[pre[i]][i];  
    }  
    return -ans;  
}

最大流

struct node  
{  
    int u,v,f;  
    int next;  
} edge[MAXN*520];  

int head[MAXN];  
int cnt;  
void add(int u,int v,int f)  
{  
    edge[cnt].u=u;  
    edge[cnt].v=v;  
    edge[cnt].f=f;  
    edge[cnt].next=head[u];  
    head[u]=cnt++;  
    edge[cnt].u=v;  
    edge[cnt].v=u;  
    edge[cnt].f=0;  
    edge[cnt].next=head[v];  
    head[v]=cnt++;  
}  

int dis[MAXN];  
int bfs(int s,int t)  
{  
    int u, v ;  
    memset(dis,-1,sizeof(dis));  
    dis[s] = 0 ;  
    queue<int>q;  
    q.push(s) ;  
    while( !q.empty() )  
    {  
        u = q.front();  
        q.pop();  
        for(int i = head[u] ; i != -1 ; i = edge[i].next)  
        {  
            v = edge[i].v ;  
            if( dis[v] == -1 && edge[i].f )  
            {  
                dis[v] = dis[u] + 1 ;  
                q.push(v) ;  
            }  
        }  
    }  
    if( dis[t] > 0 )  
        return 1 ;  
    return 0 ;  
}  
int dfs(int s,int t,int min1)  
{  
    if( s == t )  
        return min1 ;  
    int  flow, ans = 0 ;  
    for(int i = head[s] ; i != -1 ; i = edge[i].next)  
    {  
        int v = edge[i].v ;  
        if( dis[v] == dis[s] + 1 && edge[i].f && (flow = dfs(v,t,min(min1,edge[i].f) ) ) )  
        {  
            edge[i].f -= flow ;  
            edge[i^1].f += flow ;  
            ans += flow ;  
            min1 -= flow ;  
            if( !min1 )  
                break;  
        }  
    }  
    if( ans )  
        return ans ;  
    dis[s] = -1 ;  
    return 0;  
}  
int getMaxFlow()  
{  
    int maxFlow=0,flow;  
    while(bfs(s,e))  
    {  
        while((flow=dfs(s,e,inf))>0)  
            maxFlow+=flow;  
    }  
    return maxFlow;  
}

最小费用最大流

int cnt,head[MAXN];  
struct node  
{  
    int u,v,w,f,next;  
} edge[8000];  

void init()  
{  
    cnt=0;  
    for(int i=0; i<=e; ++i)head[i]=-1;
}  

void add(int u,int v,int w,int f)  
{  
    edge[cnt].u=u;  
    edge[cnt].v=v;  
    edge[cnt].w=w;  
    edge[cnt].f=f;  
    edge[cnt].next=head[u];  
    head[u]=cnt++;  
    edge[cnt].u=v;  
    edge[cnt].v=u;  
    edge[cnt].w=-w;  
    edge[cnt].f=0;  
    edge[cnt].next=head[v];  
    head[v]=cnt++;  
}  

bool vis[MAXN];  
int dis[MAXN],pre[MAXN];  
bool spfa()  
{  
    int i;  
    for(i=0; i<=e; ++i)  
    {  
        dis[i]=inf;  
        pre[i]=-1;  
        vis[i]=0;  
    }  
    queue<int>q;  
    q.push(0);  
    dis[0]=0;  
    while(!q.empty())  
    {  
        int u=q.front();  
        q.pop();  
        vis[u]=0;  
        for(i=head[u]; i!=-1; i=edge[i].next)  
        {  
            int v=edge[i].v;  
            int w=edge[i].w;  
            int f=edge[i].f;  
            if(f>0&&dis[v]>dis[u]+w)  
            {  
                dis[v]=dis[u]+w;  
                pre[v]=i;  
                if(!vis[v])  
                {  
                    vis[v]=1;  
                    q.push(v);  
                }  
            }  
        }  
    }  
    if(pre[e]==-1)return 0;  
    return 1;  
}  
int get_mincost()  
{  
    int max_flow=0,min_cost=0;  
    while(spfa())  
    {  
        int p=pre[e];  
        int flow=inf;  
        while(p!=-1)  
        {  
            flow=min(flow,edge[p].f);  
            p=pre[edge[p].u];  
        }  
        max_flow+=flow;  
        min_cost+=flow*dis[e];  
        p=pre[e];  
        while(p!=-1)  
        {  
            edge[p].f-=flow;  
            edge[p^1].f+=flow;  
            p=pre[edge[p].u];  
        }  
    }  
    return min_cost;  
}

强联通分量

vector<int>head[MAXN],G[MAXN];  
int dfn[MAXN],sccno[MAXN],sum[MAXN],dfs_clock,scc_cnt;  
stack<int>S;  
int dfs(int u)  
{  
    int lowu=dfn[u]=++dfs_clock;  
    S.push(u);  
    for(int i=0,l=head[u].size(); i<l; ++i)  
    {  
        int v=head[u][i];  
        if(!dfn[v])  
        {  
            int lowv=dfs(v);  
            lowu=min(lowu,lowv);  
        }  
        else if(!sccno[v])  
        {  
            lowu=min(lowu,dfn[v]);  
        }  
    }  
    if(lowu==dfn[u])  
    {  
        scc_cnt++;  
        while(1)  
        {  
            int x=S.top();  
            S.pop();  
            sccno[x]=scc_cnt;  
            if(x==u)break;  
        }  
    }  
    return lowu;  
}  
void find_scc()  
{  
    dfs_clock=scc_cnt=0;  
    fill(dfn+1,dfn+1+n,0);  
    fill(sccno+1,sccno+1+n,0);  
    for(int i = 1; i <= n; ++i)if(!dfn[i])dfs(i);  
}

割点点双联通

struct Edge  
{  
    int u,v;  
    Edge(int x,int y)  
    {  
        u=x;  
        v=y;  
    }  
};  
//查找双联通分量  
int pre[MAXN],bccno[MAXN],iscut[MAXN],sum[MAXN],dfs_clock,bcc_cnt;  
vector<int>G[MAXN],bcc[MAXN];  
stack<Edge>S;  
int dfs(int u,int fa)  
{  
    int lowu=pre[u]=++dfs_clock;  
    int child=0,l=G[u].size();  
    for(int i=0; i<l; ++i)  
    {  
        int v=G[u][i];  
        Edge e=Edge(u,v);  
        if(!pre[v])  
        {  
            S.push(e);  
            child++;  
            int lowv=dfs(v,u);  
            lowu=min(lowu,lowv);  
            if(lowv>=pre[u])  
            {  
                iscut[u]=1;  
                bcc_cnt++;  
                while(1)  
                {  
                    Edge x=S.top();  
                    S.pop();  
                    if(bccno[x.u]!=bcc_cnt)  
                    {  
                        bccno[x.u]=bcc_cnt;  
                        sum[x.u]++;  
                    }  
                    if(bccno[x.v]!=bcc_cnt)  
                    {  
                        bccno[x.v]=bcc_cnt;  
                        sum[x.v]++;  
                    }  
                    if(x.u==u&&x.v==v)break;  
                }  
            }  
        }  
        else if(pre[u]>pre[v]&&v!=fa)  
        {  
            S.push(e);  
            lowu=min(lowu,pre[v]);  
        }  
    }  
    if(fa<0&&child==1)iscut[u]=0;  
    return lowu;  
}  
void find_bcc()  
{  
    int i;  
    for(i=1; i<=n; ++i)  
    {  
        pre[i]=bccno[i]=iscut[i]=sum[i]=0;  
    }  
    bcc_cnt=dfs_clock=0;  
    for(i=1; i<=n; ++i)if(!pre[i])dfs(i,-1);  
}

割边边双联通

int dfn[MAXN],bccno[MAXN],bridge[MAXN][MAXN],dfs_clock,bcc_cnt;  
int dfs(int u,int fa)  
{  
    int lowu=dfn[u]=++dfs_clock;  
    for(int i=0,l=G[u].size(); i<l; ++i)  
    {  
        int v=G[u][i];  
        if(!dfn[v])  
        {  
            int lowv=dfs(v,u);  
            lowu=min(lowu,lowv);  
            if(lowv>dfn[u])  
            {  
                bridge[u][v]=bridge[v][u]=1;  
            }  
        }  
        else if(dfn[u]>dfn[v]&&v!=fa)  
        {  
            lowu=min(lowu,dfn[v]);  
        }  
    }  
    return lowu;  
}  
void find_bridge()  
{  
    for(int i=0; i<n; ++i)  
    {  
        dfn[i]=0;  
        bccno[i]=0;  
        for(int j=i+1; j<n; ++j)bridge[i][j]=bridge[j][i]=0;  
    }  
    dfs_clock=bcc_cnt=0;  
    for(int i=0; i<n; ++i)if(!dfn[i])dfs(i,-1);  
}  
int vis[MAXN];  
void dfse(int u,int x)  
{  
    bccno[u]=x;  
    vis[u]=1;  
    for(int i=0,l=G[u].size(); i<l; ++i)  
    {  
        int v=G[u][i];  
        if(!vis[v]&&!bridge[u][v])  
        {  
            dfse(v,x);  
        }  
    }  
}  

void find_bcc()  
{  
    for(int i=0; i<n; ++i)vis[i]=0;  
    for(int i=0; i<n; ++i)if(!vis[i])dfse(i,++bcc_cnt);  
}

最大团

#include<cstdio>
#include<cstring>
#define N 1010
bool flag[N], a[N][N];
int ans, cnt[N], group[N], n, vis[N];
// 最大团： V中取K个顶点，两点间相互连接
// 最大独立集： V中取K个顶点，两点间不连接 
// 最大团数量 = 补图中最大独立集数

bool dfs( int u, int pos ){
    int i, j;
    for( i = u+1; i <= n; i++){
        if( cnt[i]+pos <= ans ) return 0;
        if( a[u][i] ){
             // 与目前团中元素比较，取 Non-N(i) 
            for( j = 0; j < pos; j++ ) if( !a[i][ vis[j] ] ) break; 
            if( j == pos ){     // 若为空，则皆与 i 相邻，则此时将i加入到 最大团中 
                vis[pos] = i;
                if( dfs( i, pos+1 ) ) return 1;    
            }    
        }
    }    
    if( pos > ans ){
            for( i = 0; i < pos; i++ )
                group[i] = vis[i]; // 最大团 元素 
            ans = pos;
            return 1;    
    }    
    return 0;
} 
void maxclique()
{
    ans=-1;
    for(int i=n;i>0;i--)
    {
        vis[0]=i;
        dfs(i,1);
        cnt[i]=ans;
    }
}

带权并查集

int findx(int x)  
{  
    if(pre[x]==x)  
    {  
        return x;  
    }  
    int order=pre[x];  
    pre[x]=findx(pre[x]);  
    relation[x]=(relation[x]+relation[order])%2;  
    return pre[x];  
}  

if(a!=b)//关系还没有建立过  
        {  
            puts("YES");  
            //更新结点值  
            pre[b]=a;  
            relation[b]=(relation[x]-relation[y]+z+2)%2;  
        }  
        else//关系已经建立  
        {  
            int p=(relation[x]-relation[y]+2)%2;//得到关系  
            if(p==z)puts("YES");  
            else puts("NO");  
        }
UMR小豪
关注
专栏目录
图论的一些概念 支配集 覆盖集 独立集
Dizzz的博客
08-22 4712
点支配集(Vertex Dominating Set)设无向图为G(V,E)，顶点集合V*⊆\subseteq V，若对于∀ \forall v ∈\in (V-V*)， ∃\exists u ∈\in V*,使得(u,v) ∈\in E，则称u支配v，V* 为G的一个点支配集。 通俗地讲，V中的顶点要么是V*集合中的元素，要么与V* 中的一个顶点相邻。极小支配集: 若支配集V*的任何真子集都不
图论总结（一）二分图最大匹配
PGQ的博客
05-11 4万+
一、二分图最大匹配 （一）、二分图的定义性质及判定 1、定义 2、性质 3、判定 （二）、二分图的匹配与最大匹配 一、二分图最大匹配 （一）、二分图的定义性质及判定 1、定义 二分图又称作二部图，是图论中的一种特殊模型。 设G=(V, E)是一个无向图。如果顶点集 V可分割为两个互不相交的子集X和Y，并且图中每条边连接的两个顶点一个在 X中，另一个在 Y中...
图论练习
weixin_30652271的博客
10-30 202
（转载）图论精华精辟500题 Admin 2012年12月26日 名人名言：爱情使是非概念混淆不清；强烈的爱情和骄傲的野心都是没有疆界的——约·德莱顿 =============================以下是最小生成树+并查集====================================== 【HDU】 ...
图论期末复习（《图论机器应用》——朴月华）
小刘的博客
12-04 1645
该笔记为《图论及其应用（第2版）》的笔记，主要包括图的基本概念、图的连通性、树、Euler环游和Hamilton圈、图的对集和独立集、平面图以及网络流等内容。
图论总结与编程练习
热门推荐
张彦峰的博客
05-12 164万+
图论基本分析以及相关编程练习加深练习（单词接龙、克隆图、岛屿数量、网络延迟时间、单源最短路径、负权最短路径问题、具有最小生成树的连通图的最小代价、找到最终的安全状态、网络流问题的最大流、图中的可变流量、图中的割边、隐藏的好友、欧拉路径、哈密顿路径、判断是否为二分图、用颜色填充区域等）
搜索与图论总结
最新发布
m0_73569492的博客
10-06 651
搜索与图论总结（dfs+bfs+有向图与无向图+拓扑排序+最短路+二分图+匈牙利算法）
12.10_图论总结
Bfk的博客
12-10 313
首先梳理知识： 没有搞的：带上下界的网络流、无源无汇带下界可行流、有源有汇带下界可行流、带上下界的费用流。 还需要花时间的：最短路树相关问题（noip2017D1T3..）、网络流，差分约束，搜索，平面图。觉得很多图论题难点都在模型的转化，尤其是网络流，而且他们互相之间都可能相关。 看起来不像图论题的题，画出示意图来却发现是图论题。这周感觉还是练习基础东西比较多，学习新算法以及练习常用的优化，
图论总结_ftiasch1
08-03
【图论总结】 图论是计算机科学中一个重要的理论基础，尤其在算法设计和数据结构中扮演着核心角色。本文将对图论的一些关键概念进行总结，包括最小生成树、最短路径、最近公共祖先（LCA）以及二分图等相关算法。 1...
图论总结大纲
11-22
图论的一些总结，可以作为学习的纲要来用，没什么好说的，发在博客里乱码了，只能这样啦。
图论总结超强大.doc
10-07
图论是计算机科学、数学以及工程领域中的一个重要理论基础，它研究的是由点和线构成的图形结构及其性质。在本文中，我们将深入探讨图论的基本概念、表示方法、遍历算法、路径与回路、网络优化等问题。 1. **定义与...
FZU-2150 Fire Game
樱花满地集于我心，楪舞纷飞祈愿相随
05-16 3465
Fat brother and Maze are playing a kind of special (hentai) game on an N*M board (N rows, M columns). At the beginning, each grid of this board is consisting of grass or just empty and then they start
汽车加油行驶问题
樱花满地集于我心，楪舞纷飞祈愿相随
09-21 3294
给定一个N*N 的方形网格，设其左上角为起点◎，坐标为（1，1），X 轴向右为正，Y 轴向下为正，每个方格边长为1，如图所示。一辆汽车从起点◎出发驶向右下角终点▲，其 坐标为（N，N）。在若干个网格交叉点处，设置了油库，可供汽车在行驶途中加油。汽车在 行驶过程中应遵守如下规则： (1)汽车只能沿网格边行驶，装满油后能行驶K 条网格边。出发时汽车已装满油，在起 点与终点处不设油库。 (2)
喊山
樱花满地集于我心，楪舞纷飞祈愿相随
06-16 1437
L3-2. 喊山 （BFS） 时间限制 150 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 喊山，是人双手围在嘴边成喇叭状，对着远方高山发出“喂—喂喂—喂喂喂……”的呼唤。呼唤声通过空气的传递，回荡于深谷之间，传送到
Gym 100917F Find the Length
樱花满地集于我心，楪舞纷飞祈愿相随
08-22 1188
题意：给你一个无向图（邻接矩阵），求每个点所在的最小环的长度，不存在输出-1。 思路：不是很难想到，包含点s的最小环，应该是s到其余点的最短路的边加上一条不是最短路的边，因为单纯靠最短路并不会形成环。这样的话我们先构造出以s为根，以s到其余点的最短路为边的生成树。然后我们去枚举这样的两个点。无非就两种情况： 1.额外边的一个端点包含点s的情况。 2.额外边的两个端点都不包含s的情况。 红
poj2049 Finding Nemo
樱花满地集于我心，楪舞纷飞祈愿相随
07-27 1183
Finding Nemo Time Limit: 2000MS   Memory Limit: 30000K Total Submissions: 8804   Accepted: 2069 Description Nemo is a naughty boy. One day he went into the deep sea all
HDU 6038 Function
樱花满地集于我心，楪舞纷飞祈愿相随
07-26 514
Function Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 607    Accepted Submission(s): 243 Problem Description You are given a p
CF19E Fairy
樱花满地集于我心，楪舞纷飞祈愿相随
08-18 505
Once upon a time there lived a good fairy A. One day a fine young man B came to her and asked to predict his future. The fairy looked into her magic ball and said that soon the fine young man will meet
图论基础与应用总结
"amber的图论总结pdf版涵盖了图论的基本概念、术语、表示方法、遍历、拓扑排序、路径与回路、以及网络优化等核心内容，适合学习图论和组合优化的读者参考。" 图论是计算机科学、数学和网络分析中的重要分支，主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值