图论模板

最新推荐文章于 2017-11-09 09:09:23 发布
最新推荐文章于 2017-11-09 09:09:23 发布
阅读量246 收藏 1
点赞数
分类专栏： 复习 文章标签： 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40280028/article/details/78186529
版权

图论模板

LCA

离线

tarjan

//可使用快读
#include <iostream>
#include <cstdio>
using namespace std;
const int MAXN=500050;
int po[MAXN],qs[MAXN],fa[MAXN],nume,numq,n,m,root,ans[MAXN];
bool f[MAXN];
struct edge{
    int to,nxt;
}e[2*MAXN];
struct ques{
    int to,nxt,num;
}q[2*MAXN];
void adde(int from,int to){
    e[++nume].nxt=po[from];
    e[nume].to=to;
    po[from]=nume;
}
void addq(int from,int to,int num){
    q[++numq].nxt=qs[from];
    q[numq].to=to;
    q[numq].num=num;
    qs[from]=numq;
}
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void merge(int x,int y){
    int r1=find(x),r2=find(y);
    if(r1!=r2){
        fa[r1]=r2;
    }
}
void tarjan(int u){
    f[u]=1;
    for(int i=qs[u];i;i=q[i].nxt){
        int v=q[i].to;
        if(f[v]) ans[q[i].num]=find(v);
    }
    for(int i=po[u];i;i=e[i].nxt){
        int v=e[i].to;
        if(!f[v]) {   //此处是v不是i
            tarjan(v);merge(v,u);
        }
    }
}
int main(){
//  freopen("in.txt","r",stdin);
    scanf("%d%d%d",&n,&m,&root);
    for(int i=1;i<n;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        adde(u,v);adde(v,u);
    }
    for(int i=1;i<=n;i++) fa[i]=i;//记得初始化
    for(int i=1;i<=m;i++){
        int u,v;
        scanf("%d%d",&u,&v);
        addq(u,v,i);addq(v,u,i);
    }
    tarjan(root);
    for(int i=1;i<=m;i++){
        printf("%d\n",ans[i]);
    }
//  fclose(stdin);
    return 0;
}

洛谷P3379

最短路径

dijkstra

稠密图就用它
朴素的dijkstra的时间复杂度是O(N^2)，对于数据量大的，一般过不了。
STL堆优化dijkstra O(M*logN)，网上的博客对时间复杂度的分析大都是错的，使用方便，较优，一般可以使用。
由于每次松弛操作都要进队列，导致时间复杂度偏高。

#include <iostream>
#include <cstdio>
#include <queue>
#include <algorithm>
#include <cstdlib>
#include <cstring>
using namespace std;
const int MAXN=10005,MAXM=500005;
int head[MAXN],nume,n,m,start,dis[MAXN];
struct edge{
    int to,nxt,dis;
}e[MAXM];//如果是无向边 就要开两倍数组大小。
void adde(int from,int to,int dis){
    e[++nume].to=to;
    e[nume].nxt=head[from];
    e[nume].dis=dis;
    head[from]=nume;
}
int read(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-'){
            fh=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return rv*fh;//记得返回值
}
struct cmp{
    bool operator() (const int &a,const int &b) const{
        return dis[a]>dis[b];
    }
}; //     ATTENTION！！！！
int main(){
    freopen("in.txt","r",stdin);
    n=read();m=read();start=read();
    for(int i=1;i<=m;i++){
        int u=read(),v=read(),dis=read();
        adde(u,v,dis);
    }
    for(int i=1;i<=n;i++) dis[i]=0x7fffffff/3;
    dis[start]=0;
    priority_queue <int,vector<int>,cmp >he;
    he.push(start);
    while(!he.empty()){
        int u=he.top();
        he.pop();
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].dis){
                dis[v]=dis[u]+e[i].dis;
                he.push(v);
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(dis[i]==0x7fffffff/3) printf("%d ",0x7fffffff);
        else printf("%d ",dis[i]);
    }
    fclose(stdin);
    return 0;
}

上文中的代码中应用了STL的priority_queue,此数据结构以堆的形式实现优先队列，默认大根堆，比较符号为小于号,即less< int >,
可使用greater< int >变成小根堆。但在定义的时候
priority_queue <(空格） < int>，vector< int >,greater< int >(空格）>
也可重载小于号.
也可定义一个比较类，如上文，注意重载(),且a < b时为大根堆。

手写堆优化dijkstra
clever

SPFA

稀疏图使用
O(kE) 不稳定可能退化成O(n^3)可以判负权回路
代码

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
const int MAXN=10005,MAXM=500005;
int head[MAXN],n,m,start,dis[MAXN],nume;
struct edge{
    int to,nxt,dis;
}e[MAXM];
queue <int> spfa;
bool f[MAXN];
int read(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-'){
            fh=-1;
        }
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return fh*rv;
}
void adde(int from,int to,int dis){
    e[++nume].to=to;
    e[nume].dis=dis;
    e[nume].nxt=head[from];
    head[from]=nume;
}

int main(){
    freopen("in.txt","r",stdin);
    n=read();m=read();start=read();
    for(int i=1;i<=m;i++){
        int u=read(),v=read(),dis=read();
        adde(u,v,dis);/*adde(v,u,dis);*/
    }
    for(int i=1;i<=n;i++) dis[i]=0x7fffffff/3;
    dis[start]=0;
    f[start]=1;
    spfa.push(start);
    while(!spfa.empty()){
        int u=spfa.front();
        spfa.pop();
        f[u]=0;
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].dis){
                dis[v]=dis[u]+e[i].dis;
                if(!f[v]){
                    f[v]=1;
                    spfa.push(v);
                }
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(dis[i]==0x7fffffff/3) printf("%d ",0x7fffffff);
        else printf("%d ",dis[i]);
    }
    fclose(stdin);
    return 0;
}

最小生成树

kruskal
O(E*logE) 稀疏图较好，代码简单。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
using namespace std;
struct edge{
    int from,to,dis;
}e[400005];
int fa[5005],n,m,nume,k,tot;
int find(int x){
    if(x!=fa[x]) fa[x]=find(fa[x]);
    return fa[x];
}
void merge(int x,int y){
    int r1=find(x),r2=find(y);
    if(r1!=r2) fa[r1]=r2;
}
bool cmp(edge a,edge b){
    return a.dis<b.dis;
}
int read(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-') fh=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return rv*fh;
}
int main(){
    freopen("in.txt","r",stdin);
    n=read();m=read();
    for(int i=1;i<=m;i++){
        int u=read(),v=read(),dis=read();
        e[++nume].from=u;e[nume].to=v;e[nume].dis=dis;
    }
    sort(e+1,e+nume+1,cmp);
    for(int i=1;i<=n;i++) fa[i]=i;
    for(int i=1;i<=nume;i++){
        int u=e[i].from,v=e[i].to;
        if(find(u)!=find(v)){
            k++;
            merge(u,v);
            tot+=e[i].dis;
            if(k>=n-1) break;
        }
    }
    //cout<<tot<<endl;
    if(k>=n-1){
        printf("%d ",tot);
    }else printf("orz");
    fclose(stdin);
    return 0;
}

prim，复杂度与dijkstra相似，稍后再看

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <cstdlib>
using namespace std;
const int MAXN=5005,MAXM=200005;
int init(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
         if(c=='-') fh=-1;
         c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return rv*fh;
}
struct edge{
    int to,nxt,dis;
}e[MAXM*2];
int head[MAXN],dis[MAXN],n,m,tot,nume;
bool f[MAXN];
void adde(int from,int to,int dis){
    e[++nume].to=to;
    e[nume].dis=dis;
    e[nume].nxt=head[from];
    head[from]=nume;
}
int main(){
    freopen("in.txt","r",stdin);
    n=init();m=init();
    for(int i=1;i<=m;i++){
        int u=init(),v=init(),dii=init();
        adde(u,v,dii);adde(v,u,dii);
    }
    memset(dis,0x3f,sizeof(dis));
    f[1]=1;
    dis[1]=0;
    for(int i=head[1];i;i=e[i].nxt){
        dis[e[i].to]=min(dis[e[i].to],e[i].dis);
    }
    for(int i=2;i<=n;i++){
        int mi=0x3f3f3f3f,k=0;
        for(int i=1;i<=n;i++){
            if(!f[i]){
                if(dis[i]<mi){
                    mi=dis[i];k=i;
                }
            }
        }
        if(k==0){
            printf("orz");return 0;
        }
        tot+=mi;
        f[k]=1;
        //cout<<tot<<endl;
        for(int i=head[k];i;i=e[i].nxt){
            int v=e[i].to;
            dis[v]=min(dis[v],e[i].dis);
        }
    }
    printf("%d",tot);
    fclose(stdin);
    return 0;
}

图的连通性

tarjan

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <stack>
using namespace std;
const int MAXN=5005,MAXM=50005;
int read(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-') fh=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return rv*fh;
}
struct edge{
    int to,nxt;
}e[MAXM*2];
int head[MAXN],fa[MAXN],dfn[MAXN],low[MAXN],index,bcnt,nume,n,m,ma,k;
bool f[MAXN];
void adde(int from,int to){
    e[++nume].to=to;
    e[nume].nxt=head[from];
    head[from]=nume;
}
stack<int> st;
void tarjan(int u){
    dfn[u]=low[u]=++index;
    f[u]=1;
    st.push(u);
    int v=0;
    for(int i=head[u];i;i=e[i].nxt){
         v=e[i].to;
        if(!dfn[v]) {
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(f[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u]){
        int tot=0;
        bcnt++;
        do{
            tot++;
            v=st.top();
            st.pop();
            f[v]=0;
            fa[v]=bcnt;
        }while(v!=u);
        if(tot>ma){
            ma=tot;
            k=bcnt;
        }
    }
}
int main(){
    freopen("in.txt","r",stdin);
    n=read();m=read();
    for(int i=1;i<=m;i++){
        int u=read(),v=read(),t=read();
        adde(u,v);
        if(t==2) adde(v,u);
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]) tarjan(i);
    }
    printf("%d\n",ma);
    for(int i=1;i<=n;i++) 
        if(fa[i]==k) printf("%d ",i);
    fclose(stdin);
    return 0;
}

tarjan缩点

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
using namespace std;
const int MAXN=10005,MAXM=100005;
int init(){
    int rv=0,fh=1;
    char c=getchar();
    while(c<'0'||c>'9'){
        if(c=='-') fh=-1;
        c=getchar();
    }
    while(c>='0'&&c<='9'){
        rv=(rv<<1)+(rv<<3)+c-'0';
        c=getchar();
    }
    return fh*rv;
}
stack <int> sta;
struct edge{
    int to,from,nxt;
}e[MAXM],nww[MAXM];
int n,m,val[MAXN],inn[MAXN],nume,head[MAXN],dp[MAXN],fa[MAXN],ind,cnt,dfn[MAXN],low[MAXN],sum[MAXN],nwh[MAXN];
bool f[MAXN];
void adde(int from,int to){
    e[++nume].to=to;
    e[nume].nxt=head[from];
    head[from]=nume;
    e[nume].from=from;
}
void addn(int from,int to){
    nww[++nume].to=to;
    nww[nume].nxt=nwh[from];
    nwh[from]=nume;
}
void tarjan(int u){
    low[u]=dfn[u]=++ind;
    sta.push(u);
    f[u]=1;
    for(int i=head[u];i;i=e[i].nxt){
        int v=e[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }else if(f[v]){
            low[u]=min(low[u],dfn[v]);
        }
    }
    if(dfn[u]==low[u]){
        cnt++;
        int v=0;
        do{
            v=sta.top();
            sta.pop();
            f[v]=0;
            fa[v]=cnt;
            sum[cnt]+=val[v];
        }while(v!=u);
    }
}
int main(){
    freopen("in.txt","r",stdin);
    n=init();m=init();
    for(int i=1;i<=n;i++){
        val[i]=init();
    }
    for(int i=1;i<=m;i++){
        int u=init(),v=init();
        adde(u,v);
    }
    for(int i=1;i<=n;i++){
        if(!dfn[i]) tarjan(i);
    }
    nume=0;
    for(int i=1;i<=m;i++){
        if(fa[e[i].from]!=fa[e[i].to]){
            addn(fa[e[i].from],fa[e[i].to]);
            inn[fa[e[i].to]]++;
        }
    }
    queue<int> q;
    for(int i=1;i<=cnt;i++){
        if(!inn[i]) {q.push(i);dp[i]=sum[i];}

    }
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=nwh[u];i;i=nww[i].nxt){
            int v=nww[i].to;
            inn[v]--;
            dp[v]=max(dp[v],dp[u]+sum[v]);
            if(!inn[v]) q.push(v);
        }
    }//cout<<cnt;
    //for(int i=1;i<=n;i++) cout<<fa[i]<<endl;
    int ans=0;
    for(int i=1;i<=cnt;i++){
        ans=max(ans,dp[i]);
    }
    cout<<ans;
    fclose(stdin);
    return 0;
}
Mr_Wolfram
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数论相关：同余方程与同余方程组的解法
Mr_Wolfram的高维空间
11-07 3442
形如a*x≡b(mod n)的式子称为线性同余方程。对于这样的式子有解的充要条件是gcd(a,n)|b. 于是扩展gcd求解 将原方程化为一次不定方程 a*y+n*y=b. 利用扩展欧几里得算法求解不定方程a * x + n* y = b的整数解的求解全过程，步骤如下： 1、先计算Gcd(a,n)，若n不能被Gcd(a,n)整除，则方程无整数解；否则，在方程两边同时除以b/gcd(a,n)
尺取法
Mr_Wolfram的高维空间
11-08 814
尺取法： 顾名思义，像尺子一样取一段，尺取法通常是对数组保存一对下标，即所选取的区间的左右端点，然后根据实际情况不断地推进区间左右端点以得出答案。之所以需要掌握这个技巧，是因为尺取法比直接暴力枚举区间效率高很多，尤其是数据量大的时候，所以尺取法是一种高效的枚举区间的方法，一般用于求取有一定限制的区间个数或最短的区间等等。当然任何技巧都存在其不足的地方，有些情况下尺取法不可行，无法得出正确答案。使用
组合数
Mr_Wolfram的高维空间
11-07 722
模意义下的组合数计算直接利用Pascal公式◦ n,k ≤ 1000 ◦ 对模数没有要求定义直接算逆元◦ k较小 ◦ 模数为质数预处理阶乘逆元◦ n,k≤ 10s ◦ 模数为质数错位排列表述为：编号是1、2、…、n的n封信，装入编号为1、2、…、n的n个信封，要求每封信和信封的编号不同，问有多少种装法？ 　　对这类问题有个固定的递推公式，记n封信的错位重排数为Dn，则D1=0，D2=1，
清北学堂复习笔记
Mr_Wolfram的高维空间
10-09 452
优秀的演算法笔记day1 day2 day3 day4 day5
NOIP要注意什么
Mr_Wolfram的高维空间
11-09 403
（https://www.cnblogs.com/shingen/p/7801970.html）
数据结构模板
Mr_Wolfram的高维空间
10-17 298
线段树#include <iostream> #include <cstdio> #include <algorithm> #include <cstdlib> #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 using namespace std; const int MAXN=100005; long long sum[MAXN<<2]; l
一些应该注意的问题
Mr_Wolfram的高维空间
10-25 254
朴素的素数筛法中bool chk(int x){ if(x==1) return 0; if(x==2)return 1;//一定要特判2 if(!(x&1)) return 0; int t=sqrt(x); for(register int i=3;i<=t;i++){ if(!(x%i)) return 0; } retu
Mr_Wolfram还要做什么
Mr_Wolfram的高维空间
10-26 227
二分借教室 营救
搜索有关的好题和思路
Mr_Wolfram的高维空间
10-19 184
枚举 等差数列（ZJOI2004） 给定 n(1 数列.求最长的等差数列的长度. 我们首先必须对这个数列进行排序，排序我们采用 QuickSort。然后我们 就能够很快想到一系列的方法：枚举头部、第二个与尾部。 但是我们为什么要枚举三个呢？头部当然不用说，第二个是为了与第一个作 差，得出公差。然后就可以递推地去枚举到最后。 这样我们就能够得出一个O(n3)的方法，而在n 时。
复习
Mr_Wolfram的高维空间
10-02 180
数据结构单调队列 https://www.luogu.org/problem/show?pid=1886#sub 笛卡尔树 https://www.luogu.org/problem/show?pid=2659
高精度模板
Mr_Wolfram的高维空间
11-06 164
高精度GCD#include <iostream> #include <cstdio> #include <cstdlib> #include <algorithm> #include <cstring> #include <cmath> using namespace std; void init(int num[]){ char s[10005]={0}; scanf("%s",
四台服务器分别部署组件内容.md
07-24
四台服务器分别部署组件内容.md
GitHub Issue 模板：提升团队协作效率的秘籍
07-24
GitHub是一个面向开源及私有软件项目的托管平台，因为只支持Git作为唯一的版本库格式进行托管，故名GitHub。GitHub提供了分布式版本控制和源代码管理（SCM）功能，此外还有一些特色功能，例如允许用户对项目进行跟踪、协调工作、管理任务和代码审查。 ### GitHub的主要特点包括： 1. **版本控制**：GitHub基于Git，一个分布式版本控制系统，可以跟踪代码的每一次更改。 2. **协作**：GitHub提供了多种工具来支持多人协作，包括分支管理、合并请求（Pull Request）、代码审查等。 3. **社区**：GitHub拥有庞大的开发者社区，用户可以探索其他项目，贡献代码，或者获取灵感。 4. **文档**：通过README文件和Wiki页面，项目可以拥有详细的文档说明。 5. **问题跟踪**：GitHub提供了问题跟踪系统，方便项目成员报告问题、讨论解决方案。 6. **Gist**：一种简单分享代码片段的方式。 7. **GitHub Actions**：自动化工作流程，可以自动运行测试、部署代码等。 8. **GitHub Pag
Day2-数据类型、常量、变量及运算符代码案例
07-24
Day2-数据类型、常量、变量及运算符代码案例
uart_top.v
07-24
uart_top
java程序设计—JAVA泡泡堂网络游戏的设计与实现(源代码+论文)49.rar
07-24
java程序设计，可供正在学习的同学研究参考。
使用 JavaScript 编写的杀死幽灵游戏及其源代码.zip
最新发布
07-24
项目：使用 JavaScript 编写的杀死幽灵游戏（附源代码） 杀死鬼魂游戏是使用 Vanilla JavaScript、CSS 和 HTML 画布开发的简单项目。这款游戏很有趣。玩家必须触摸/杀死游荡的鬼魂才能得分。您必须将鼠标悬停在鬼魂上 - 尽量得分。鬼魂在眨眼间不断从一个地方移动到另一个地方。您必须在 1 分钟内尽可能多地杀死鬼魂。 游戏制作 这个游戏项目只是用 HTML 画布、CSS 和 JavaScript 编写的。说到这个游戏的特点，用户必须触摸/杀死游荡的幽灵才能得分。游戏会根据你杀死的幽灵数量来记录你的总分。你必须将鼠标悬停在幽灵上——尽量得分。你必须在 1 分钟内尽可能多地杀死幽灵。游戏还会显示最高排名分数，如果你成功击败它，该分数会在游戏结束屏幕上更新。 该游戏包含大量的 javascript 以确保游戏正常运行。 如何运行该项目？ 要运行此游戏，您不需要任何类型的本地服务器，但需要浏览器。我们建议您使用现代浏览器，如 Google Chrome 和 Mozilla Firefox。要玩游戏，首先，单击 index.html 文件在浏览器中打开游戏。 演示： 该项目为国外大神项目，可以作为毕业设计的项目，也可以作为大作业项目，不用担心代码重复，设计重复等，如果需要对项目进行修改，需要具备一定基础知识。 注意：如果装有360等杀毒软件，可能会出现误报的情况，源码本身并无病毒，使用源码时可以关闭360，或者添加信任。
ACM图论模板：二分图判定与并查集实现
这个模板主要关注图论中的一个重要概念——二分图。二分图是图的一种特殊形式，其中的顶点可以被分为两个不相交的集合，使得每条边都连接不同集合中的顶点。 **二分图判定** 二分图的判定在图论中有着广泛的应用，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值