图论模板……未完待续

把所有能想到的图论模板合到一起，由以下算法组成：

1.DFS（两款存储方式）

2.BFS（邻接矩阵）

3.floyd（邻接矩阵）

4.dijsktra（邻接矩阵）

5.spfa（两款存储方式）

6.tarjan（邻接链表）

7.prim（邻接矩阵）

8.kruskal（并查集）

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
using namespace std;
struct union_find_set
{
    int x,y,v;
    int father(int x)
    {
        if (fat[x] != x) fat[x] = father(fat[x]);
        return fat[x];
    }
    void unionn(int x,int y)
    {
        int fa = father(x);
        int fb = father(y);
        if (fa != fb) fat[fa] = fb;
    }
    void init()
    {
        for (i = 1; i <= n; i++) fat[i] = i;
    }
    void sort()
    {
        sort(a+1,a+m+1);
    }
    bool operator < (const union_find_set &b) const
    {
        return this->v < b.v;
    }
}a[10001];
struct Edge
{
    int pre,to,w;
};
void dfs(int p)
{
    cout<<p<<" ";
    vis[p]=true;
    for(int i=1; i<=m; i++)
        if(!vis[i])
            dfs(i);
}
void bfs(int p)
{
    queue<int> q;
    q.push(p);
    vis[p]=true;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        cout<<t<<" ";
        for(int i=1; i<=n; i++)
        {
            if(map[i][t]&&!vis[i])
            {
                q.push(i);
                vis[i]=true;
            }
        }
    }
}
void floyd()
{
    for(int k=1; k<=m; k++)
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(map[i][j]>map[i][k]+map[k][j])
                    map[i][j]=map[i][k]+map[k][j];
}
void dijsktra(int p)
{
    for(int i=1; i<=n; i++)
        dis[i]=map[p][i];
    vis[p]=true;
    dis[p]=0;
    for(int i=1; i<=n-1; i++)
    {
        min1=MAXN1;
        k=0;
        for(int j=1; j<=n; j++)
        {
            if(!vis[j]&&dis[j]<min1)
            {
                min1=dis[j];
                k=j;
            }
            vis[k]=true;
        }
        for(int i=1; i<=n; i++)
        {
            if(!vis[i]&&map[k][i]<MAXN1&&dis[i]>dis[k]+map[k][i])
                dis[i]=dis[k]+map[k][i];
        }
    }
    cout<<dis[e]<<endl;
}
void spfa(int p)
{
    queue<int> q;
    q.push(p);
    vis[p]=true;
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=false;
        for(int i=1; i<=n; i++)
        {
            if(dis[i]>dis[t]+map[t][i])
            {
                dis[i]=dis[t]+map[t][i];
                if(!vis[i])
                    q.push(i);
            }
        }
    }
    cout<<dis[ep];
}
void add_edge(int from,int to,int w)
{
    edge[++num_edge].pre=head[from];
    edge[num_edge].to=to;
    edge[num_edge].w=w;
    head[from]=num_edge;
}
void dfs(int now,int fa)
{

    for(int i=head[now]; i!=-1; i=edge[i].next)
    {
        if(v[edge[i].v]==0)
        {
            cout<<" "<<edge[i].v;
            dfs(edge[i].v,now);
            v[edge[i].v]=1;
        }
    }
}
void SPFA(int u)
{
    q.push(u);
    if_q[u]=true;
    while(!q.empty())
    {
        u=q.front();
        for(int i=head[u]; i!=0; i=edge[i].pre)
        {
            int v=edge[i].to;
            if(dis[u]+edge[i].w<dis[v])
            {
                dis[v]=dis[u]+edge[i].w;
                if_q[v]=true;
                q.push(v);
            }
        }
        if_q[u]=false;
        q.pop();
    }
}
void tarjan(int x)
{
    DFN[x]=LOW[x]=++tot;
    stack[++index]=x;
    visit[x]=1;
    for(int i=heads[x]; i!=-1; i=edge[i].next)
    {
        if(!DFN[edge[i].v])
        {
            tarjan(edge[i].v);
            LOW[x]=min(LOW[x],LOW[edge[i].v]);
        }
        else if(visit[edge[i].v ])
        {
            LOW[x]=min(LOW[x],DFN[edge[i].v]);
        }
    }
    if(LOW[x]==DFN[x])
    {
        do
        {
            printf("%d ",stack[index]);
            visit[stack[index]]=0;
            index--;
        }
        while(x!=stack[index+1]);
        printf("
");
    }
}
void prim()
{
    memset(map,0x7f,sizeof(map));
    int n,e,x,y,w;
    cin>>n>>e;
    for(int i=0; i<e; i++)
    {
        cin>>x>>y>>w;
        map[x][y]=map[y][x]=w;
    }
    memset(minn,0x7f,sizeof(minn));
    minn[1]=0;
    for(int i=1; i<=n; i++)
    {
        int k=0;
        for(int j=1; j<=n; j++)
            if(!vis[j]&&minn[j]<minn[k])
                k=j;
        vis[k]=true;
        for(int j=1; j<=n; j++)
            if(!vis[j]&&map[k][j]<minn[j])
                minn[j]=map[k][j];
    }
    //输出请手动遍历，就像这样：
    for(int i=1; i<=n; i++)
        for(int j=1; j<=n; j++)
            if(map[i][j]==minn[i])cout<<j<<" "<<i<<endl;
}
void kruskal()
{
    a[0].sort();
    for (i = 1; i <= m; i++)
    {
        if (a[i].father(a[i].x) != a[i].father(a[i].father()))
        {
            a[i].unionn(a[i].x,a[i].y);
            tot += a[i].v;
            k++;
        }
        if (k == n-1) break;
    }
    cout << tot<<endl;
    //留坑，这里需要输出这棵树。
    ; 
}
void init_for_different_template(int usage)
{
    ;
} 
int main()
{
    //我不想写了，太多了，编译器炸出了77个错误。
    ;
    return 0; 
}

尚未实现的部分：

1.main函数，init_for_different_template函数

2.kruskal输出最小生成树。

3.编译不过。