算法导论机试复习（最短路问题）

单源最短路问题

对于有向无环图直接进行广度优先搜索

使用unordered-map记录每个结点第一次被发现的时候的从源节点到这个点的最短路径，每次遍历这个点的所有邻接点的时候，邻接点的最短路径就是前驱结点的长度加1；

#include<bits/stdc++.h>
using namespace std;
const int N=1000;
int n,m,qi,zh;
int G[N][N];
int book[N];
int pre[N];
unordered_map<int,int>mapp;
queue<int>q;
void prin(int num)
{
    if(num==1)
        cout<<1<<" ";
    else
    {
       prin(pre[num]);
       cout<<num<<" ";
    }
}
void bfs(int num)
{
    q.push(1);
    book[1]=1;
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        cout<<u<<" ";
        for(int i=1;i<=n;i++)
        {
            if(G[u][i]&&!book[i])
            {
                q.push(i);
                book[i]=1;
                mapp[i]=(mapp[u]+1);
                pre[i]=u;
            }
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
         cin>>qi>>zh;
         G[qi][zh]=1;
    }
    mapp[1]=0;
    bfs(1);
     for(int i=1;i<=n;i++)
     {
         cout<<"到"<<i<<"的最短路径长度是"<<mapp[i]<<endl;
         prin(i);
         cout<<endl;
     }

}

对于带权重的有向图求单源最短路问题用Dijkstra算法

初始化是一个部分：pre前驱结点//便于后面求路径

s:是否是当前最短的路，全部初始化为0

dis:当前距离源点 最短的路，除了和源点有关系的都初始化为max

G:与dis同

计算最短路

下面就是找n-1次最短的点，然后更新和它邻接的点，更新这些点的前驱和dis，便于下一轮的最短点的寻找。

//***带权图的单源最短路径问题***
//Dijkstra算法
#include<bits/stdc++.h>
using namespace std;
const int N=100;
const int maxx=65535;
int S[N];//是否已经找到最短路劲
int pre[N];//前驱结点
int dis[N];//最短路径长度i
int G[N][N];
int n,m,s,qi,zh,quan;
void prin(int num)
{
    if(num==s)
    {
        cout<<s<<" ";
    }
    else
    {
        prin(pre[num]);
        cout<<num<<" ";
    }
}
int main()
{
   cin>>n>>m>>s;
   //初始化矩阵所有的元素为maxx
   for(int i=0;i<=n;i++)
   {
       for(int j=0;j<=n;j++)
       {
           G[i][j]=maxx;
       }
       S[i]=0;
   }
   //更新有边连着的矩阵
   for(int i=0;i<m;i++)
   {
       cin>>qi>>zh>>quan;
       G[qi][zh]=quan;//对于有边连着源点的更新
   }
   //初始化dis，pre
   for(int i=0;i<=n;i++)
   {
       dis[i]=G[s][i];
       pre[i]=0;
       if(dis[i]<maxx)
       {
           pre[i]=s;
       }
   }
   pre[s]=-1;
   dis[s]=0;
   for(int i=1;i<=n-1;i++)
   {
       int minn=maxx;
       int u;
       for(int j=1;j<=n;j++)
       {
           if(S[j]==0&&dis[j]<minn)
           {
               minn=dis[j];
               u=j;
           }
       }
       S[u]=1;//找到了目前距离最小的，而且还没有进图
       for(int j=1;j<=n;j++)
       {
           if(!S[j]&&dis[u]+G[u][j]<dis[j])
           {
               dis[j]=dis[u]+G[u][j];
               pre[j]=u;
           }
       }
   }
for(int i=1;i<=n;i++)
{
cout<<"到"<<i<<"的最短路径长度为"<<dis[i]<<endl;
cout<<"具体路径为:"<<endl;
prin(i);
cout<<endl;
}


}

/*
5 7 1
1 2 4
1 4 2
2 4 1
2 3 4
4 3 1
4 5 7
3 5 3
*/

求任意两个点之间的最短路长度，并且输出具体的最短路

floyd算法求任意两个结点之间的最短路径

初始化操作：和dijkstra相似，只不过存最短路径的是一个二维的，开始都初始化为一个大数之后，输入边进行更新；

有一个前驱矩阵，p[i][j]表示从i到j上的最短路径上j前面的一个前驱结点，一直回溯会找到起点，从而得到一个最短路径，在循环中如果找到一个ns[i][j]>ans[i][k]+ans[k][j]，就更新

ans[i][j]=ans[i][k]+ans[k][j];

同时更新前驱矩阵，也就是i~j的前驱结点和i~k的前驱结点相同；
  p[i][j]=p[i][k];//前驱矩阵用来求路径的；

//***带权图的多源短路径问题***
//floyd算法
//Floyd算法
#include<bits/stdc++.h>
using namespace std;
const int N=100;
const int maxx=65535;
int G[N][N];//初始的图
int ans[N][N];//最短路径长度
int p[N][N];
int qi,zh,quan,n,m;
void Floyd()
{
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(ans[i][j]>ans[i][k]+ans[k][j])
                {
                    ans[i][j]=ans[i][k]+ans[k][j];
                    p[i][j]=p[i][k];//前驱矩阵用来求路径的。
                }

            }
        }
    }
}

void prin(int x,int y)
{
    cout<<"从"<<x<<"到"<<y<<"最短路径为：";
    int u=x;
    while(u!=y)
    {
        cout<<u<<"->";
        u=p[u][y];

    }
    cout<<y<<"   长度为"<<ans[x][y]<<endl;
}
int main()
{
    cin>>n>>m;
    for(int i=0;i<=n;i++)
    {
        for(int j=0;j<=n;j++)
        {
            G[i][j]=maxx;
            ans[i][j]=maxx;
            p[i][j]=j;
        }
    }

    for(int i=0;i<m;i++)
    {
        cin>>qi>>zh>>quan;
        G[qi][zh]=ans[qi][zh]=quan;
    }
    Floyd();
    prin(2,5);
}

/*
5 7
1 2 4
1 4 2
2 4 1
2 3 4
4 3 1
4 5 7
3 5 3
*/

拓扑排序

输入的时候计算出所有点的入度，把所有入度为0的点加入到栈中，然后逐个取出，取出的时候要更新所有点的入度，直到栈为空；

count计数，最后输出的少于n个，但是那时候栈已经是空的了，就判断有环存在。

#include<bits/stdc++.h>
using namespace std;
const int N=1000;
int n,m,qi,zh;
int G[N][N];
int indegree[N];
stack<int>s;
void TopolSort()
{
    //找出入度为0的点加入栈中
    int countt=0
    for(int i=1;i<=n;i++)
    {
        if(!indegree[i])
            s.push(i);
    }
    while(!s.empty())
    {
        int u=s.top();
        cout<<u<<" ";
        s.pop();
        for(int i=1;i<=n;i++)
        {
            if(G[u][i])
            {
                indegree[i]--;
                if(!indegree[i])
                {
                    s.push(i);
                }
            }
        }
    }
    if(countt<n)
    {
        cout<<"有环存在"<<endk=l;
    }
}
int main()
{
  cin>>n>>m;
   for(int i=0;i<m;i++)
   {
       cin>>qi>>zh;
       G[qi][zh]=1;
       indegree[zh]=1;
   }
   TopolSort();
}