16.网络延迟时间

网络延迟时间
有 n 个网络节点，标记为 1 到 n。

给你一个列表 times，表示信号经过 有向 边的传递时间。 times[i] = (ui, vi, wi)，其中 ui 是源节点，vi 是目标节点， wi 是一个信号从源节点传递到目标节点的时间。

现在，从某个节点 K 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 -1 。

示例 1：

输入：times = [[2,1,1],[2,3,1],[3,4,1]], n = 4, k = 2
输出：2
示例 2：

输入：times = [[1,2,1]], n = 2, k = 1
输出：1
示例 3：

输入：times = [[1,2,1]], n = 2, k = 2
输出：-1

提示：

1 <= k <= n <= 100
1 <= times.length <= 6000
times[i].length == 3
1 <= ui, vi <= n
ui != vi
0 <= wi <= 100
所有 (ui, vi) 对都 互不相同（即，不含重复边）

思路：该问题是典型的利用最小生成树解决图问题，由于题中给的是边的数组，要通过一个临时的二维数组来构建图的代价矩阵，有了图的代价矩阵就可以利用迪杰斯特拉算法求最小生成树，如果从k出发可以到达所以节点那么所有的节点都会加入到以该节点为根的树中，若树中节点数小于图的节点数那么就是无法到达的，因为迪杰斯特拉算法每次都要添加一个节点到树中在还有剩余节点但是找不到可以放入树时说明已经不可达了。若都可达，则在构建树的同时可以利用一个临时数组来储存每个节点到k节点的最小距离，最后再遍历该数组找到最大距离即为延迟时间。

#include<iostream>
using namespace std;
int networkDelayTime(int a[][3],int n,int k,int c);
int main()
{
    int a[][3]={1,2,1};//边数组
    cout << networkDelayTime(a,2,2,1);
    return 0;
}
int networkDelayTime(int a[][3],int n,int k,int c)//n是节点数，k是目标节点，c是边的数量
{
   int **T=new int *[n];//代价矩阵
   int* t1=new int [n];
   int* t2=new int [n];
   int* t3=new int [n];
   int min,m=0;
   for(int i=0;i<n;i++)
     T [i]=new int [n];
   for(int i=0;i<n;i++)
     for(int j=0;j<n;j++)
       T[i][j]=200;
   for(int i=0;i<c;i++)
       T[a[i][0]-1][a[i][1]-1]=a[i][2];
   for(int i=0;i<n;i++)
   {
      t1[i]=T[k-1][i];
      t2[i]=0;
      t3[i]=T[k-1][i];
   }
   t2[k-1]=1;
   t3[k-1]=0;
   for(int i=0;i<n-1;i++)
   {
      min=200;
      for(int j=0;j<n;j++)
      {
         if(t1[j]<min && t2[j]==0)
         {
            min=t1[j];
            m=j;
         }
      }
      if(min!=200)
      {
         t2[m]=1;
         for(int j=0;j<n;j++)
            if(T[m][j]<t1[j])
            {
               t1[j]=T[m][j];
               t3[j]=t3[m]+T[m][j];
            }
      }
      else
        return -1;
   }
   m=0;
   for(int i=0;i<n;i++)
     if(t3[i]>m)
       m=t3[i];
   delete t1,t2,t3;
   for(int i=0;i<n;i++)
     delete T[i];
   delete T;
   return m;  
}