图论(最短路&最小生成树)

图论

图的定义与概念

图的分类

图，根据点数和边数可分为三种：彻底图，稠密图与稀疏图。

彻底图，即\(m=n^2\)的图\((m\)为边数，\(n\)为点数\()\)。如：

1 1 0
1 2 1
1 3 2
2 1 1
2 2 0
2 3 3
3 1 2
3 2 3
3 3 0

这个数据是一个彻底图。

稠密图，即\(m\)十分接近于\(n^2\)的图。如：

1 1 0
1 2 1
1 3 2
2 1 1
2 2 0
2 3 3
3 1 2

这个数据是一个稠密图。

稀疏图，即\(m\)远远低于\(n^2\)的图。如：

1 2 1
1 3 5
2 3 7
2 4 3
3 4 5

这个数据是一个稀疏图。

根据方向可分为两种：有向图和无向图。

有向图，就是边有方向，好比说，\(1\)~\(2\)有一条边，而\(2\)~\(1\)没有边，则只能从\(1\)前往\(2\)，不能从\(2\)前往\(1\)，相似于现实中的单行道。

无向图，就是边无方向，好比说，\(1\)~\(2\)有一条边，而\(2\)~\(1\)没有边，则能够从\(1\)前往\(2\)，也能够从\(2\)前往\(1\)，相似于现实中的双行道。

图的边权

就相似于现实中路的长度。

图大概长这样：

图的存储

邻接矩阵

适用于\(n \le 10000\)。

\(Code:\)

int dis[n][n];
int inf=99999999;
for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
        if(i!=j)dis[i][j]=inf;
cin>>u>>v>>w;
dis[u][v]=w;

邻接矩阵，就是用矩阵来存储图，\(dis[i][j]\)即表明\(i\)~\(j\)的最短路径。如一个有向图：

1 1 0
1 2 1
1 3 2
2 1 1
2 2 0
2 3 3
3 1 2

这个数据用邻接表存储是这样的：

\(dis\)	\(1\)	\(2\)	\(3\)
\(1\)	0	1	2
\(2\)	1	0	3
\(3\)	2	inf	0

边表

适用于全部状况。

struct edge
{
    int u,v,w;
}e[m];
...
cin>>u>>v>>w;
e[cnt]={(edge)u,v,w};

邻接表

适用于全部状况。

int u[m],v[m],w[m],next[2*m],first[m];
...
cin>>u[cnt]>>v[cnt]>>w[cnt];
next[cnt]=first[u[cnt]];
first[u[cnt]]=cnt;

图的最短路

\(dijkstra(\)堆优化\()\)

时间复杂度：\(O((m+n)\) \(log\) \(n)\)

使用邻接表。

void dijkstra(int i)
{
    for(int j=0;j<=n;j++)
        dis[j]=inf;
    dis[i]=0;
    memset(book,false,sizeof(book));
    priority_queue<pair<int,int>>q;
    q.push(make_pair(0,i));
    while(q.size())
    {
        int x=q.top().second;
        q.pop();
        if(book[x])continue;
        book[x]=true;
        for(int k=first[x];k;k=next[k])
        {
            if(dis[v[k]]>dis[u[k]]+w[k])
            {
                dis[v[k]]=dis[u[k]]+w[k];
                q.push(make_pair(-dis[v[k]],v[k]));
            }
        }
    }
}

\(SPFA\)

时间复杂度：\(O(\)玄\()\)。

使用邻接表\(/\)边表。

void spfa(int i)
{
    for(int j=0;j<=n;j++)
        dis[j]=inf;
    dis[i]=0;
    memset(book,false,sizeof(book));
    queue<int>q;
    q.push(i);
    book[i]=true;
    while(!q.empty())
    {
        int k=first[q.front()];
        while(k!=-1)
        {
            if(dis[v[k]]>dis[u[k]]+w[k])
            {
                dis[v[k]]=dis[u[k]]+w[k];
                if(book[v[k]]==false)
                {
                    q.push(v[k]);
                    book[v[k]]=true;
                }
            }
            k=next[k];
        }
        book[q.front()]=false;
        q.pop();
    }
}

\(Floyd\)

时间复杂度：\(O(n^3)\)

使用邻接矩阵。

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]);

图的最小生成树

图的最小生成树指，权值和最小的生成树。

struct edge
{
    int u,v,w;
}e[3240010];
struct bcj
{
    int father[1810];
    void start(int n)
    {for(int i=0;i<=n;i++)father[i]=i;}
    int find(int x)
    {if(father[x]!=x)father[x]=find(father[x]);return father[x];}
    void unionn(int x,int y)
    {x=find(x);y=find(y);if(x!=y)father[y]=x;}
    bool judge(int x,int y)
    {if(find(x)==find(y))return true;return false;}
};
bool cmp(edge a,edge b)
{
    return a.w<b.w;
}
...
sort(e+1,e+1+m,cmp);
uf.start(n);
for(int i=1;i<=m;i++)
{
    if(!uf.judge(e[i].u,e[i].v))
    {
        cnt++;
        ans+=e[i].w;
        uf.unionn(e[i].u,e[i].v);
     }
     if(cnt==n-1)break;
}