干货系列——模板 之 图论1

图论常用模板：

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

图的建立

1.邻接矩阵建图。

无向图：

int g[1001][1001],x,y,z,n,m;
cin>>n>>m;
for(int i=1;i<=m;i++)
{
    cin>>x>>y>>z;
    g[x][y]=g[y][x]=z;
}

有向图：

int g[1001][1001],x,y,z,n,m;
cin>>n>>m;
for(int i=1;i<=m;i++)
{
    cin>>x>>y>>z;
    g[x][y]=z;
}

2.链式前向星建图：

无向图：

struct Edge{
    int next,to,val;
}e[10001];
int n,m,x,y,z,tot=0,head[10001];
void add(int x,int y,int z)
{
    e[++tot].to=y;
    e[tot].val=z;
    e[tot].next=head[x];
    head[x]=tot; 
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,z);
    }
}

有向图

struct Edge{
    int next,to,val;
}e[10001];
int n,m,x,y,z,head[10001],tot=0;
void add(int x,int y,int z)
{
    e[++tot].to=y;
    e[tot].val=z;
    e[tot].next=head[x];
    head[x]=tot; 
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        add(x,y,z);
    }
}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~··~~~~~~~~~~~

最短路

1.Floyd算法

int d[1001][1001],n,m;
//邻接矩阵建图略 , d[i][j]为i到j的最短路 
for(int k=1;k<=n;k++)
{
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
        }
    }
}

2.Dijkstra算法

int a[3010][3010],d[3010],n,m;
bool v[3010];
void dijkstra(int v0)
{
    memset(d,0x3f3f3f3f,sizeof(d));
    memset(v,0,sizeof(v));
    d[v0]=0;
    for(int i=1;i<n;i++) 
    {
        int x=0;
        for(int j=1;j<=n;j++)
            if(!v[j]&&(x==0||d[j]<d[x])) 
                x=j;
        v[x]=1;
        for(int y=1;y<=n;y++)
            d[y]=min(d[y],d[x]+a[x][y]); 
    }
}

堆优化的Dijkstra算法

const int N=10001,M=1000010;
int head[N],ver[M],edge[M],Next[M],d[N];
bool v[N];
int n,m,tot=0;
priority_queue<pair<int,int>>q;
void add(int x,int y,int z)
{
    ver[++tot]=y,edge[tot]=z,Next[tot]=head[x],head[x]=tot;
}//链式前向星的另一种写法
void dijkstra(int v0)
{
    memset(d,0x3f3f3f3f,sizeof(d));
    memset(v,0,sizeof(v));
    d[v0]=0;
    q.push(make_pair(0,v0));
    while(q.size())
    {
        int x=q.top().second;
        q.pop();
        if(v[x]) continue;
        v[x]=1;
        for(int i=head[x];i;i=Next[i])//非常重要的写法，一定要记住 
        {
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z)
            {
                d[y]=d[x]+z;
                q.push(make_pair(-d[y],y));
            }
        }
    }
}

3.bellman算法

int n,m,d[10001];
struct Edge{
    int a,b,w;
}e[10001];
bool bellman(int v0)
{
    memset(d,0x3f3f3f3f,sizeof(d));
    d[v0]=0;
    for(int i=1;i<n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(d[e[j].a]+e[j].w<d[e[j].b])
            {
                d[e[j].b]=d[e[j].a]+e[j].w;
            }
        }
    }
    for(int j=1;j<=m;j++)
    {
        if(d[e[j].a]+e[j].w<d[e[j].b])//判断负环 
            return false;
    }
    return true;
}

4.SPFA算法

int head[3010],ver[3010],edge[3010],Next[3010],d[3010];
int n,m,tot=0;
bool v[3010];
queue<int>q;
void add(int x,int y,int z)
{
    ver[++tot]=y,edge[tot]=z,next[tot]=head[x],head[x]=tot;
}
void SPFA(int v0)
{
    memset(d,0x3f3f3f3f,sizeof(d));
    memset(v,0,sizeof(v));
    d[v0]=0;
    v[v0]=1;
    q.push(v0);
    while(q.size())
    {
        int x=q.front();
        q.pop();
        v[x]=0;
        for(int i=head[x];i;i=Next[i])
        {
            int y=ver[i],z=edge[i];
            if(d[y]>d[x]+z)
            {
                d[y]=d[x]+z;
                if(!v[y])
                q.push(y),v[y]=1;
            }
        }
    }
}

其实和堆优化Dijkstra很像

好的，今天的干货分享就到这里呢，还有一些正在啃，后续会慢慢分享给大家