leetcode 743. 网络延迟时间 c++

算法思路：

通过迪杰斯特拉最短路径算法，求出从节点K出发到每一个节点的最短路径。其中最大值的就是所求结果，若有节点从未被访问过则返回-1。

class Solution {
public:
    typedef struct Dest
{
	Dest(int d, int w) :destnation(d), weight(w) {};
	int destnation;
	int weight;
}dest;

typedef struct Vertex
{
	vector<dest>adj;
	bool known;
	int dist;
}vertex;
    vertex* smallest_unknow_vertex(vector<vertex*>& vertex_array) 
	{
		vertex* ret = NULL;
		int dist = INT_MAX;
		for (int i = 1; i < vertex_array.size(); i++)
		{
			if (vertex_array[i]->known == true)//遍历已经被访问过的顶点的出边
			{
				for (int j = 0; j < vertex_array[i]->adj.size(); j++)
				{
					int dist_for = vertex_array[i]->adj[j].weight + vertex_array[i]->dist;
					if (vertex_array[vertex_array[i]->adj[j].destnation]->known==false && dist_for < dist)//目标还没被访问过且小于dist
					{
						dist = dist_for;
						ret = vertex_array[vertex_array[i]->adj[j].destnation];
						if(ret->dist> vertex_array[i]->adj[j].weight+ vertex_array[i]->dist)
							ret->dist = dist_for;
					}
				}
			}
		}
		return ret;
	}

	int networkDelayTime(vector<vector<int>>& times, int N, int K) {
		//vector<vector<int>> Matrix(N + 1, vector<int>(N + 1, INT_MAX));//从1开始，避免下标问题
		vector<vertex*>vertex_array(N + 1);
		for (int i = 1; i < N + 1; i++)//从1开始，避免下标问题
			vertex_array[i] = new vertex;
		for (int i = 1; i < N + 1; i++)
		{
		    vertex_array[i]->dist = INT_MAX;
			vertex_array[i]->known = false;
		}
		int u, v, w;
		for (int i = 0; i < times.size(); i++)
		{
			u = times[i][0];//src
			v = times[i][1];//des
			w = times[i][2];//weight
			dest tmp_dest(v, w);
			vertex_array[u]->adj.push_back(tmp_dest);
		}

		vertex_array[K]->known = true;
		vertex_array[K]->dist = 0;

		int know_count = 0;

		while (know_count<N)
		{		
			vertex* v = smallest_unknow_vertex(vertex_array);
			if (v == NULL)
				break;
			v->known = true;
			know_count++;

			for (int i = 0; i < v->adj.size(); i++)
			{
				int v_adj = v->adj[i].destnation;
				if (!vertex_array[v_adj]->known)
				{
					if (vertex_array[v_adj]->dist > v->dist + v->adj[i].weight)
						vertex_array[v_adj]->dist = v->dist + v->adj[i].weight;
				}
			}
		}	
		int i,dist_ret;
		for (i = 1, dist_ret=0; i < vertex_array.size(); i++)
		{
			if (vertex_array[i]->known == false)
				break;
			if (dist_ret < vertex_array[i]->dist)
				dist_ret = vertex_array[i]->dist;
		}
			
		return i == vertex_array.size() ? dist_ret : -1;
	}
};