Leetcode——743. 网络延迟时间

最新推荐文章于 2023-07-29 14:56:36 发布

JLUspring

最新推荐文章于 2023-07-29 14:56:36 发布

阅读量239

点赞数

分类专栏： leetcode 文章标签：数据结构 leetcode 算法

本文链接：https://blog.csdn.net/qq_37724465/article/details/104433671

版权

leetcode 专栏收录该内容

72 篇文章 0 订阅

订阅专栏

在这里插入图片描述
首先一个比较坑的点，不要误以为给你的nums就是我们通常意义的二维数组，而是单纯的存储边的一个数组，所以我们首先要构建一个二维的vector容器。

创建mn的二维vector:
直接定义
1.vector<vector > nums(m ,vector(n)); //mn的二维vector
2.vector<vector > nums;
nums.resize(m);
for(int i=0;i<m;i++)
nums[i].resize(n);

赋值方式
1.这种方法要和vector的size一致
vector<vector> vec;
vector a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
vector b;
b.push_back(4);
b.push_back(5);
b.push_back(6);
vec.push_back(a);
vec.push_back(b);
2.
直接赋值

dijkstra算法

class Solution
{
public:
    int networkDelayTime(vector<vector<int> >& times, int N, int K)
    {
        int n=N;
        int k=K;
        vector<vector<int> > v(N+1,vector<int>(N+1));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(j==i)
                {
                    v[i][j]=0;
                }
                else
                {
                    v[i][j]=100000000;
                }
            }
        }
        for(int i=0;i<times.size();i++)
        {
            v[times[i][0]][times[i][1]]=times[i][2];
        }


        bool flag[n+1]={false};
        flag[k]=true;
        for(int i=1;i<=n;i++)
        {
            int min=100000000;
            int index;
            for(int i=1;i<=n;i++)
            {
                if(flag[i]==false&&v[k][i]<min)
                {
                    min=v[k][i];
                    index=i;
                }
            }
            flag[index]=true;
            for(int i=1;i<=n;i++)
            {
                if(flag[i]==false&&v[k][i]>v[k][index]+v[index][i])
                {
                    v[k][i]=v[k][index]+v[index][i];
                }
            }
        }
        int max=0;
        for(int i=1;i<=n;i++)
        {
            if(flag[i]==false)
            {
                return -1;
            }
            if(i!=k&&v[k][i]>max)
            {
                max=v[k][i];
            }
        }
        return max;
    }
};

int main()
{
    Solution so=Solution();

    vector<vector<int> >nums;
    vector<int> a;
    a.push_back(2);
    a.push_back(1);
    a.push_back(1);

    vector<int> b;
    b.push_back(2);
    b.push_back(3);
    b.push_back(1);

    vector<int> c;
    c.push_back(3);
    c.push_back(4);
    c.push_back(1);

    nums.push_back(a);
    nums.push_back(b);
    nums.push_back(c);

    cout<<so.networkDelayTime(nums,4,2);
    return 0;
}