图

相对于图来说，树还是太仁慈了，树就是在给图做铺垫。但是总结一下图也没学多少东西，Dijkstra、Floyd求最短路径，拓扑序列、Kruskal、Prim算法求最小生成树。感觉最麻烦的就是求关键路径了，其他的看懂代码就没啥了。下面一一分析:

1. Dijkstra最短路径

实现代码如下：

#include<iostream>
#include<cstring>
const int Maxsize=100;
const int Max=10000000;
using namespace std;
string panduan(int i)//这个代码是用来输出结点数据的，不同的题目不同的要求，也可以不加直接输出1，2，3等
{
    string str="v";
    int j=i;
    string news=str + to_string(i);;
    return news;
}
bool cunzaima(int a[],int v,int s)//判断这个节点是否已经被访问到
{
    for(int i=0;i<v;i++)
    {
        if(a[i]==s)
        {
            return false;
        }
    }
    return true;
}
void Dijkstra(int dis[Maxsize][Maxsize],int s,int v,int e)//这里就是主代码了
{
    int start=s;//开始节点
    int vex=v;//节点个数
    int endby=e;//终点，这个代码找的是从start到endby的最短径
    int nowdis[Maxsize],nums;//存放start到其他节点的权值||已存在节点的个数
    int cunzai[vex];//判断是否已经被访问
    string path[Maxsize];//存放路径
    for(int i=0;i<vex;i++)//初始化路径（start到其他节点的权值）
    {
        nowdis[i]=dis[start][i];
        if(nowdis[i]!=Max)
        {
            path[i]=panduan(start)+" "+panduan(i);
        }
        else
        {
            path[i]="";
        }
    }
    cunzai[0]=start;
    nums=1;
    while(nums<vex)//没有完全被访问就不停止
    {
        int k=0;
        for(int i=0;i<vex;i++)//找到最小的权值，前提是这个节点从来没被访问过
        {
            if(nowdis[i]<=nowdis[k]&&cunzaima(cunzai,vex,i))
            {
                k=i;
            }
        }
        cunzai[nums++]=k;
        for(int i=0;i<vex;i++)//更新权值，把新的节点加入后的权值
        {
            if(nowdis[k]+dis[k][i]<nowdis[i])
            {
                nowdis[i]=nowdis[k]+dis[k][i];
                path[i]=path[k]+" "+panduan(i);
            }
        }
    }
    if(nowdis[endby]==Max)
    {
        cout<<"no answer";
    }
    else
    {
        cout<<nowdis[endby]<<endl<<path[endby];
    }
}
int main()
{
    int v,a,s,e;
    cin>>v>>a;
    cin>>s>>e;
    int dis[Maxsize][Maxsize];
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            dis[i][j]=0;
        }
    }
    int from,tail,zhi;
    for(int i=0;i<a;i++)
    {
        cin>>from>>tail>>zhi;
        dis[from][tail]=zhi;
    }
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            if(dis[i][j]==0)
            {
                dis[i][j]=Max;
            }
        }
    }
    Dijkstra(dis,s,v,e);
}

2. Floyd求最短路径
   相比于Dijkstra算法来说，Floyd算法真的是容易理解多了，仅仅需要邻接矩阵，还有一个三重循环即可，但是比Dijkstra算法的复杂度要高，各有各的优点，自己选择即可。
   实现代码如下：

#include<iostream>
#include<cstring>
const int Maxsize=100;
const int Max=10000000;
using namespace std;
string panduan(int i)//同上
{
    string str="v";
    int j=i;
    string news=str + to_string(i);;
    return news;
}

void Floyd(int dis[Maxsize][Maxsize],int v)
{
    int vex=v;
    string path[Maxsize][Maxsize];
    for(int i=0;i<vex;i++)
    {
        for(int j=0;j<vex;j++)
        {
            if(dis[i][j]!=Max)//不为自己预设的最大值就代表着两个节点之间存在路径
            {
                path[i][j]=panduan(i)+" "+panduan(j);
            }
            else
            {
                 path[i][j]="";
            }
        }
    }
    for(int k=0;k<vex;k++)//在两个节点之间都插入一遍其他所有节点，如果小的话就更新权值
    {
        for(int i=0;i<vex;i++)
        {
            for(int j=0;j<vex;j++)
            {
                if(dis[i][k]+dis[k][j]<dis[i][j])
                {
                    dis[i][j]=dis[i][k]+dis[k][j];
                    path[i][j]=path[i][k]+" "+panduan(j);
                }
            }
        }
    }
    for(int i=0;i<vex;i++)//输出每两个节点之间的权值，如果仍未自己预设的最大值那么证明不存在路径，输入“no answer”
    {
        for(int j=0;j<vex;j++)
        {
            if(i!=j)
            {
                if(dis[i][j]==Max)
            {
                cout<<"no answer";
            }
            else
            {
                cout<<dis[i][j]<<" "<<path[i][j]<<endl;
            }
            }
        }
    }

}
int main()
{
    int v,a,s,e;
    cin>>v>>a;
    int dis[Maxsize][Maxsize];
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            dis[i][j]=0;
        }
    }
    int from,tail,zhi;
    for(int i=0;i<a;i++)
    {
        cin>>from>>tail>>zhi;
        dis[from][tail]=zhi;
    }
    for(int i=0;i<v;i++)
    {
        for(int j=0;j<v;j++)
        {
            if(dis[i][j]==0)
            {
                dis[i][j]=Max;
            }
        }
    }
    Floyd(dis,v);
}