图论总结

1、图的储存方式

（1）邻接矩阵。   用map[i][j]表示i、j两点是否联通。

（2）邻接表。    

struct node{int y,next,v;}e[MAXN];
int len,Link[MAXN];
void insert(int x,int y,int z)
{
    e[++len].next=Link[x];
    Link[x]=len;
    e[len].y=y;
    e[len].v=z;
}

（3）边表。

struct node{int x,y,v;}e[MAXN];
int len;
void insert(int x,int y,int z)
{
    e[++len].x=x;
    e[len].y=y;
    e[len].v=z;
}

2、图的遍历。

dfs或bfs，学过搜索都会写，不再附代码了。

3、最短路。

（1）floyd

多源最短路，时间复杂度：O(n^3)，存图方式：邻接矩阵。

void floyd()
{
    for(int k=1;k<=n;k++)
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(dis[i][k]+dis[k][j]<dis[i][j])  {dis[i][j]=dis[i][k]+dis[k][j];   path[i][j]=k;}
}

输出路径

void dfs(int i,int j)
{
    if (path[i][j]>0) 
    {
        dfs(i,path[i][j]);
        cout<<path[i][j]<<' ';
        dfs(path[i][j],j);
    }
}

（2）dijkstra

单源最短路，时间复杂度：O(n^2)，存图方式：邻接矩阵或邻接表。

void dijkstra(int st)
{
    for(int i=1;i<=n;i++)  dis[i]=map[st][i];
    memset(vis,0,sizeof(vis));
    vis[st]=1;  dis[st]=0;
    for(int i=1;i<n;i++)
    {
        int minn=100000000,k=0;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&dis[j]<minn)  {minn=dis[j];  k=j;}
        if(k==0)  return;
        vis[k]=1;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&map[k][j]+dis[k]<dis[j])  {dis[j]=map[k][j]+dis[k];  path[j]=k;}
    }
}

可用堆优化之，将时间复杂度降到O(nlogn)

void dijkstra(int st)
{
    fill(dis+1,dis+n+1,INF);
    dis[st]=0;  vis[st]=1;
    pii temp=make_pair(dis[st],st);
    q.push(temp);
    for(int i=1;i<=n;i++)
    {
        while(!q.empty())
        {
            temp=q.top();
            q.pop();
            if(!vis[temp.second])  break;
        }
        int k=temp.second;
        vis[k]=1;
        for(int j=Link[k];j;j=e[j].next)
            if(dis[k]+e[j].v<dis[e[j].y])
            {
                dis[e[j].y]=dis[k]+e[j].v;
                temp=make_pair(dis[e[j].y],e[j].y);
                q.push(temp);
            }
    }
}

（3）SPFA

单源最短路，时间复杂度：O(nlogn)，存图方式：邻接表。

void spfa(int st)
{
    memset(dis,10,sizeof(dis));
    dis[st]=0;  vis[st]=1;
    q[++tail]=st;
    while(++head<=tail)
    {
        int tn=q[head];
        vis[tn]=0;
        for(int i=Link[tn];i;i=e[i].next)
        {
            int tmp=e[i].y;
            if(dis[tn]+e[i].v<dis[tmp])
            {
                dis[tmp]=dis[tn]+e[i].v;
                if(!vis[tmp])
                {
                    q[++tail]=tmp;
                    vis[tmp]=1;
                }
            }
        }
    }
}

4、最小生成树。

（1）Prim，时间复杂度：O(n^2)，存图方式：邻接矩阵。

void prim(int st)
{
    for(int i=1;i<=n;i++)  dis[i]=map[st][i];
    memset(vis,0,sizeof(vis));
    vis[st]=1;  dis[st]=0;
    for(int i=1;i<n;i++)
    {
        int minn=100000000,k=0;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&dis[j]<minn)  {minn=dis[j];  k=j;}
        if(k==0)  return;
        vis[k]=1;
        ans+=dis[k];
        for(int j=1;j<=n;j++)
            if(!vis[j]&&map[k][j]<dis[j])  dis[j]=map[k][j];
    }
}

（2）Kruskal，时间复杂度：O(nlogn)，存图方式：边表。

bool cmp(node a,node b)
{return a.v<b.v;}
int find(int x)
{return f[x]==x?x:f[x]=find(f[x]);}
void kruskal()
{
    for(int i=1;i<=n;i++)  f[i]=i;
    int k=0;
    sort(e+1,e+m+1,cmp);
    for(int i=1;i<=m;i++)
    {
        int u=find(e[i].x),v=find(e[i].y);
        if(u!=v)
        {
            f[u]=v;
            ans+=e[i].v;
            k++;
        }
        if(k==n-1)  break;
    }
}