自己码的图论板子（实时更新）

自己码的图论板子（实时更新）

更新日志

2020.8.15 上传了 链式前向星，Floyd算法,Prim算法, 并查集，Kruskal，Dijkstra，BellmanFord算法，spfa，dp求树的直径，bfs求分层图，匈牙利算法，欧拉路，倍增LCA，Tarjan，Dinic，费用流，线段树，树链剖分
2020.8.17 小幅度改动了Kruskal和并查集的算法
2020.8.18 用struct中置函数优化了并查集
2020.8.19 用struct中放置函数又花了线段树，树链剖分，更改kru中使用并查集部分，更改了树链剖分的部分命名,对每条边的信息追加了起点u
2020.8.20 修复了费用流的bug

约定

不再对标有废弃的板子更新，但是此板子为正确且可套用的，只是出现了上级取代而已
一个图的点数为n，一个图的边数为m
边的具体信息通过 edge储存
一条边的起点为u，终点为v，权值信息为c
遍历边起点为x，终点为y
到点的距离通过 dis储存
分层图信息通过 d 储存
时间戳信息通过 dfn 储存
一个点是否被使用用used 一条边是否被使用用usedWay
需要建立反向图的情况在信息后面全部加2，如edge2，search2
根节点信息用 root ，源点用S，汇点用T
临时变量用tmp，临时队列用que，临时栈用s
涉及具体数据结构遍历名称随单词拼接大写
于栈中用 ins，于队列中用 inque
点的度为deg ，出度为outdeg 入度为indeg

前置内容

#define MAXN 25000//点数
#define MAXM (2*MAXN)//道路数
//#define int long long 
typedef pair<int,int> pii;
const int inf = 0x3f3f3f3f;
#define dis(i,j)  (sqrt(pow((nod[i].x-nod[j].x),2)+pow((nod[i].y-nod[j].y),2)))
struct {
    double x,y;
}nod[MAXN];//用于点以坐标表示的时候

链式前向星

#define search(i,y) for(int i=head[y];i;i=edge[i].next) //遍历一个点的出边
#define add(u,v,c)  {edge[++cnt]={u,v,c,head[u]};head[u]=cnt;}//加入一条边
int head[MAXN],cnt=1;//0说明没有下一个值
struct EDGE{
    int u,v,c;
    int next;//下一个值的位置;
}edge[MAXM];

Floyd算法

//floyd算法求任意两点之间的最短距离
//因为floyd求的一般都是稠密图，储存方式邻接矩阵
//floyd也可以用来在点数较小的情况下求区间闭包和可达性

int edge[MAXN][MAXN];      //邻接矩阵
int dis[MAXN][MAXN];
void Floyd(int n){//　编号从1 开始
    memcpy(dis,edge,sizeof(edge));
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
}

Prim算法

//从点的角度求最小生成树，复杂度为O(N^2)，储存方式邻接矩阵
//在稠密图中效果优于kru，稀疏图中劣于kru
//可以用二叉堆优化到O(M+N)但是涉及到边了不如直接上kru

int edge[MAXN][MAXN];//邻接矩阵存边
bool used[MAXN]={0};
int d[MAXN];
int Prim(int n){
    memset(d,inf,sizeof(d));
    memset(used,0,sizeof(used));
    d[1]=0;
    for(int i=1;i<n;i++){                     //一共只需要进行n-1次操作
        int x=0;
        for(int j=1;j<=n;j++)
            if(!used[j]&&(x==0||d[x]>d[j]))   //遍历找出没有用过并且距离已选遍最近的点
                x=j;
        used[x]= true;
        for(int y=1;y<=n;y++)
            if(!used[y])d[y]=min(d[y],edge[x][y]);
    }
    int  ans=0;
    for(int i=1;i<=n;i++){
        ans+=d[i];
        if(ans>=inf)return -1;//图不连通则返回-1
    }
    return ans;
}

并查集

struct DisjointSet {
    int n;
    int root[MAXN];
    void init(int x){
        n=x;
        for(int i=1;i<=n;i++)root[i]=i;
    }
    int find(int x){
        if(x!=root[x])
            root[x]=find(root[x]);
        return root[x];
    }
    void merge(int x,int y){root[find(x)]=find(y);}//将x合并到y中}
    bool judge(int x,int y){return find(x)==find(y);}
}grp;

Kruskal

//Kruskal算法 从边的角度算最小生成树
//复杂度为O（m） 需要并查集作为辅助
typedef  pair<int,pair<int ,int > > pi_ii;
int n;
vector<pair<int,pair<int,int> > > edge;
int  kruskal(int m){//m为边数
    int ans=0;
    grp.init(n);
    priority_queue<pi_ii ,vector<pi_ii>,greater<pi_ii > > que;
    for(auto i:edge)
        que.push(i);
    while(!que.empty()){
        pi_ii tmp;
        tmp=que.top();que.pop();
        int u=tmp.second.first,v=tmp.second.second;