关于图论

(没写完qwq这玩意我慢慢写)

最短路算法

首先我用一句话做引子

最短路有四种写法，我教给你
这些算法应该记着，将来考NOI的时候，写图论要用。
我暗想我和NOI的等级还很远呢......

Floyd

首先是最朴素的Floyd，这个算法基本思想是dp，枚举中间段点，然后逐渐更新两点之间的最短路，最后可以得到任意两点之间的最短路.（好写就对了）

for(int i=1;i<=n;i++)
    for(ri j=1;j<=n;j++)
        if(i!=j)
            dis[i][j]=inf;
for(int i=1;i<=m;i++)
    read(a),read(b),read(c),dis[b][a]=dis[a][b]=min(dis[a][b],c);
for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
        if(i!=k&&dis[i][k]!=inf)
          for(int j=1;j<=n;j++)
              if(i!=j&&j!=k&&dis[k][j]!=inf)
                  dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);

Dijkastra

然后是Dijkastra，加上了堆优化，基本思想是贪心选择最短路径，进行松弛，将松弛后的点加入堆中，去松弛其它点，持续如此，最后就可以求出最短路径。其实不需要使用小根堆，只用在进行push操作时push边权的相反数就可以用大根堆做到小根堆一样的效果。

inline void Dijkastra()
{
    int tp,tp_;
    dis[s]=0;
    q.push(make_pair(dis[s],s));
    while(!q.empty())
    {
        tp=q.top().num;
        q.pop();
        if(!vis[tp])
        {
            vis[tp]=1;
            for(ri i=head[tp];i;i=e[i].nxt)
            {
                tp_=e[i].to;
                if(dis[tp_]>dis[tp]+e[i].dis)
                {
                    dis[tp_]=dis[tp]+e[i].dis;
                    q.push(make_pair(-dis[tp_],tp_));
                }
            }
        }
    }
}

最小生成树

prim堆优化

其实和Dijkastra思想很一致，都运用了贪心的思想，prim每次将源点所连通的点加入堆中，选择距离源点最近的点，将它加入到最小生成树，每次用距离源点最近的点作为新的源点，继续更新。

inline void prim()
{
    dis[1]=0;
    q.push(make_pair(0,1));
    while(!q.empty()&&cnt<m)
    {
        tempa=q.top().first;tempb=q.top().second;
        q.pop();
        if(vis[tempb])continue;
        ++cnt,ans+=-tempa,vis[tempb]=1;
        for(ri j=head[tempb];j;j=e[j].nxt)
            if(dis[e[j].to]>e[j].val)
            {
                dis[e[j].to]=e[j].val;
                q.push(make_pair(-dis[e[j].to],e[j].to));
            }
    }
}

转载于:https://www.cnblogs.com/superMB/p/10311403.html