id int64 1 3.58k | problem_description stringlengths 516 21.8k | instruction int64 0 3 | solution_c dict |
|---|---|---|---|
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 1 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) \n {\n vector<int>ans(n,-1);\n vector<pair<int,int>>v[n];\n for(auto it:edges){\n v[it[0]].push_back({it[1],it[2]});\n v[it[1]].push_back({it[0],it... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 1 | {
"code": "typedef pair<int, int> intPair;\n\nclass Solution {\nprivate:\n int startIndex = 0;\n int startDist = 0;\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int, vector<intPair>> graph;\n vector<int> distance (n, INT_MAX);\n... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n map<int,list<pair<int,int>>> mp;\n int m=edges.size();\n for(int i=0;i<m;i++){\n mp[edges[i][0]].push_back({edges[i][1],edges[i][2]});\n mp[edges[i][1]].push... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> dis,vis;\n unordered_map<int,vector<pair<int,int>>> gr;\n\n void djs(int src, vector<int>& disappear){\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;\n pq.push({0,src});\n while(!pq.empty()){\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "#pragma GCC optimize(\"03\")\nclass Solution {\npublic:\n Solution(){\n ios_base::sync_with_stdio(false);\n cin.tie(nullptr); cout.tie(nullptr);\n }\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n edges.shrink_to_fit(); \n disapp... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>&edges, vector<int>&dist) {\n map<int,vector<pair<int,int>>>mp;\n for(int i=0;i<edges.size();i++)\n {\n mp[edges[i][0]].push_back({edges[i][1],edges[i][2]});\n mp[edges[i][1]].push_ba... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "#include <bits/stdc++.h>\n#include <ext/pb_ds/assoc_container.hpp>\nusing namespace __gnu_pbds;\nusing namespace std;\nusing ll=long long;\ntypedef tree <pair<ll,ll>, null_type, less<>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;\n/*\n order_of_key (k)\n find_by_order(k)\n*/\ntemplat... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "#define l long long\nclass Solution {\npublic:\n\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n vector<pair<l,l>>adj[n];\n for(auto it:edges){\n adj[it[0]].push_back({(l)it[1], (l)it[2]});\n adj[it[1]].push_back({(l)... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n int m = edges.size();\n\n unordered_map<int, list<pair<int, int>>> adj;\n\n for(int i = 0; i < m; i++){\n int u = edges[i][0];\n int v = edges[i][... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int,int>>> adj(n);\n for(auto it:edges){\n int u=it[0];\n int v=it[1];\n int wt=it[2];\n bool e=false;\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "typedef pair<int,int> pii;\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pii>> graph(n);\n for(auto edge : edges){\n graph[edge[0]].push_back({edge[1],edge[2]});\n graph[edge[1]].push_... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& dis) {\n vector<pair<int,int>> adj[n];\n for(int i = 0;i<edges.size();i++){\n int u = edges[i][0] , v = edges[i][1] , w = edges[i][2];\n adj[u].push_back({v , w});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>> adj[n];\n for(auto &i: edges){\n int u=i[0];\n int v=i[1];\n int wt=i[2];\n\n adj[u].push_back({v, wt});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& v, vector<int>& d) {\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>q;\n vector<pair<int,int>>adj[n];\n for(int i=0;i<v.size();i++) {\n int a=v[i][0],b=v[i][1],t=v... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& v, vector<int>& d) {\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>q;\n vector<pair<int,int>>adj[n];\n for(int i=0;i<v.size();i++) {\n int a=v[i][0],b=v[i][1],t=v... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>pq;\n\n pq.push({0,0});\n\n vector<vector<pair<int,int>>>adjList(n);\n\n fo... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int, int>>> graph(n);\n for(const auto& edge : edges){\n int u = edge[0], v = edge[1], w = edge[2];\n graph[u].push_back({v, w});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int, int>>> adj(n);\n\n for(int i=0;i<edges.size();i++){\n int u = edges[i][0];\n int v = edges[i][1];\n int w = edges[i][2... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution\n{\nprivate:\n void dijkstra(int src, vector<vector<pair<int, int>>> &adj, vector<int> &dist, int n,vector<int>&disappear)\n {\n priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;\n pq.push({0, src}); // Distance to source is 0\n di... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class cmp\n{\n public:\n bool operator()(pair<int,int>&p,pair<int,int>&q)\n {\n return p.first>q.first;\n }\n};\n\nclass Solution \n{\npublic:\n vector<int> minimumTime(int n,vector<vector<int>>&e,vector<int>&d) \n {\n vector<vector<pair<int,int>>>v(n);\n for(int i=0;... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<vector<array<int,2>>> edge;\n vector<int> ShortestPath(vector<int> &disappear)\n {\n int n=disappear.size();\n vector<int> vdis(n,-1);\n priority_queue<array<int,2>,vector<array<int,2>>,greater<array<int,2>>> pq;\n pq.push({0,0});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n #define ll long long\n #define ff first \n #define ss second\n vector<int> minimumTime(int n, vector<vector<int>>& edge, vector<int>& dis) {\n int m = edge.size() ;\n vector<vector<pair<int , int>>> mp(n) ;\n\n for(int i = 0 ; i < m ; i++){\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<long long int> dist;\n vector<int> temp;\n void dijkstra(vector<vector<pair<int, int>>>& adj) {\n priority_queue<pair<long long int, int>,\n vector<pair<long long int, int>>,\n greater<pair<long long int, int>>>\... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int,int>> adj[n];\n if(n==0) return {};\n for(int i=0;i<edges.size();i++){\n adj[edges[i][0]].push_back({edges[i][1],edges[i][2]});\n adj[edges[i][1]... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n priority_queue<pair<int, int>> pq; // time, node\n vector<vector<pair<int, int>>> g(n + 10);\n for(int i = 0; i < edges.size(); i++){\n if(edges[i][0] == ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\nvector<int> minimumTime(int n, vector<vector<int>> &edges, vector<int> &disappear)\n{\n int edgesSize = edges.size();\n\n vector<vector<int>> nodeList(n);\n vector<int> times(n, -1);\n priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;\n\n for (i... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n unordered_map<int , list<pair<int,int>>>adj ;\n\n for(auto it : edges){\n int u = it[0];\n int v = it[1];\n int w = it[2];\n\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n // We need to find the minimum path cost from node 0 to all the nodes --> Dijkstra's algorithm.\n typedef pair<int, int> p;\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>> adj[n]; // Corrected type t... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n int m = edges.size();\n unordered_map<int, unordered_map<int, int>> hm;\n for (int i = 0; i < m; ++i) {\n int u = edges[i][0], v = edges[i][1], l = edges[i][... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& d) \n {\n vector<int>ans(n,INT_MAX);\n ans[0]=0;\n // vector<vector<pair<int,int>>>g(n);\n unordered_map<int,unordered_map<int,int>>g;\n for(auto &x:e)\n {\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n int k=edges.size();\n vector<vector<pair<int,int>>> adj(n);\n for(int i=0;i<k;i++){\n adj[edges[i][0]].push_back({edges[i][1],edges[i][2]});\n adj... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n unordered_map<int, unordered_map<int, int>> dirs;\n int maxTime = 0;\n for(auto&e :edges){\n #define fr e[0]\n #define to e[1]\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n typedef pair<int,int> P;\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int,vector<pair<int,int>>>adj;\n for(auto &edge : edges){\n adj[edge[0]].push_back({edge[1],edge[2]});\n adj[... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int V, vector<vector<int>>& edges, vector<int>& t) {\n unordered_map<int, vector<pair<int, int>>> adj;\n\n // Building the adjacency list\n for (auto& edge : edges) {\n int u = edge[0];\n int v = edge[1];\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int,int>>adj[n];\n for(auto it:edges){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push_back({it[0],it[2]});\n }\n vect... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& dis) {\n vector<pair<int,int>> adj[n];\n for(auto x:edges){\n adj[x[0]].push_back({x[1],x[2]});\n adj[x[1]].push_back({x[0],x[2]});\n }\n priority_queue<p... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> dijkstra(int n, unordered_map<int, vector<pair<int,int>>> &adj, vector<int>& disappear){\n vector<int> result(n, -1);\n priority_queue<pair<int, int>, vector<pair<int, int>>, greater<>> pq;\n vector<int> distance(n, INT_MAX);\n pq.push(... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 2 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int,int>> adj[n];\n for(auto a:edges){\n adj[a[0]].push_back({a[1],a[2]});\n adj[a[1]].push_back({a[0],a[2]});\n }\n priority_q... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "#include <vector>\n#include <queue>\n#include <unordered_set>\n#include <climits>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n // Build adjacency list\n vector<pair<int, int>> adj[n];\n fo... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "// Single Source, Shrotest path problem => Dijikstra Algo:\n// Dijikstra:\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>> adj[n];\n for (auto it: edges) {\n adj[it[0]].push_back({it[1], it... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& d) {\n vector<vector<pair<int,int>>> adj(n);\n for(auto it : e){\n int u = it[0];\n int v = it[1];\n int time = it[2];\n adj[u].push_back({v, time});\... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int, int>>> G(n);\n for(const auto& edge: edges){\n int a = edge[0], b = edge[1], length = edge[2];\n G[a].push_back({b, length});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<int> result;\n\n vector<vector<pair<int, int>>> adj (n) ;\n for (auto it :edges ){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int,int>>>adj(n);\n for(auto it:edges){\n int u = it[0];\n int v = it[1];\n int w = it[2];\n adj[u].push_back({v... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<int>ans(n,-1);\n vector<pair<int,int>>v[n];\n for(auto it:edges){\n v[it[0]].push_back({it[1],it[2]});\n v[it[1]].push_back({it[0],it[2]});... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int, int>>adj[n];\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& v) {\n vector<pair<int, int>> g[n];\n int m = e.size();\n for(auto it : e)\n {\n if(it[0] == it[1])\n continue;\n g[it[0]].push_back({it[1], it... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<pair<int,int>> adj[n];\n for(auto it:edges){\n int u = it[0];\n int v = it[1];\n int wt = it[2];\n adj[u].push_back({v,wt});... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "#include<queue>\n#include<vector>\nusing namespace std;\nusing int2 = pair<int,int>;\n\nclass Solution {\npublic:\n \n void dijkstara(int node,vector<int>&d,vector<vector<pair<int,int>>>& adj,vector<int>& disappear){ \n priority_queue<int2,vector<int2>,greater<int2>>pq;\n pq.emplace(0,n... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pair<int, int>>> adj(n);\n for(auto it: edges){\n adj[it[0]].push_back({it[1], it[2]});\n adj[it[1]].push_back({it[0], it[2]});\n }\... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int, vector<pair<int, int>>> edge;\n for (auto it : edges) {\n int el1 = it[0];\n int el2 = it[1];\n int len = it[2];\n\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "#define ll int\n#define REP(i,a,n)for(int i=a;i<n;i++)\n#define f first\n#define sec second\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& dis) {\n vector<vector<pair<ll,ll>>>g(n);\n for(auto e:edges)\n {\n g[e[0]].pus... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n typedef pair<int,int> ppi ;\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n // yes djk once more\n unordered_map<int,vector<pair<int,int>>>adj;\n for(auto edge : edges){\n int u = edge[0];\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n typedef pair<int,int> ppi ;\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n // yes djk once more\n unordered_map<int,vector<pair<int,int>>>adj;\n for(auto edge : edges){\n int u = edge[0];\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n // create graph\n unordered_map<int,vector<int>>graph;\n map<pair<int,int>,int>weight;\n for(auto el:edges){\n int u= el[0];\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n // create graph\n map<int,vector<int>>graph;\n map<pair<int,int>,int>weight;\n for(auto el:edges){\n int u= el[0];\n int v=e... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "#define ll long long\n\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<map<int, ll>> adj(n);\n for (auto &it : edges) {\n if (!adj[it[0]][it[1]]) {\n adj[it[0]][it[1]] = it[2];\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "typedef pair<int, int> PII;\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n int m = edges.size(); \n vector<vector<PII>> ad(n);\n\n for(int i=0; i<m; i++){\n int x = edges[i][0]; \n int y = edg... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "#define ll long long int\n#define pi pair<int,ll>\n#define mp make_pair\nclass Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<pi>> adj(n);\n for (auto edge : edges) {\n int x = edge[0];\n int y = edge... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n int szEdges = edges.size();\n vector<pair<int, int>> adj[50000];\n {\n unordered_map<int, unordered_map<int, int>> mp;\n mp.reserve(n);\... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int,vector<vector<int>>> graph;\n for (const auto& edge : edges) {\n graph[edge[0]].emplace_back(vector<int>{edge[1],edge[2]});\n graph[edg... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int,vector<vector<int>>> graph;\n for (const auto& edge : edges) {\n graph[edge[0]].emplace_back(vector<int>{edge[1],edge[2]});\n graph[edg... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int,vector<vector<int>>> graph;\n for (const auto& edge : edges) {\n graph[edge[0]].emplace_back(vector<int>{edge[1],edge[2]});\n graph[edg... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int,vector<vector<int>>> graph;\n for (const auto& edge : edges) {\n graph[edge[0]].emplace_back(vector<int>{edge[1],edge[2]});\n graph[edg... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;\n pq.push({0,0});\n vector<vector<vector<int>>> graph(n);\n for(int i=0;i<edges.si... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;\n pq.push({0,0});\n vector<vector<vector<int>>> graph(n);\n for(int i=0;i<edges.si... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n unordered_map<int, unordered_map<int, int>> dirs;\n for(auto&e :edges){\n if ( dirs[ e[0] ][ e[1] ] == 0){ dirs[ e[0] ][ e[1] ] = INT_MAX; }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n unordered_map<int, unordered_map<int, int>> dirs;\n for(auto&e :edges){\n if ( dirs[ e[0] ][ e[1] ] == 0){ dirs[ e[0] ][ e[1] ] = INT_MAX; }\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& ed, vector<int>& da) {\n vector<int> dis(n+1,(int)1e9),ans(n,0);ans[0]=0;\n vector<unordered_map<int,int>> v(n);\n for(int i=0;i<ed.size();i++){\n if(v[ed[i][0]].count(ed[i][1])){\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n unordered_map<int, vector<pair<int, int>>> adj;\n for (auto e : edges) {\n adj[e[0]].push_back({e[1], e[2]});\n adj[e[1]].push_back({e[0], e[2]});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& dis) {\n set<pair<int,int>> pq;\n\n vector<vector<vector<int>>> adj(n);\n\n for(int i=0; i<e.size(); i++ ){\n adj[e[i][0]].push_back({e[i][1], e[i][2]});\n adj[e[i][... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;\n vector<int> dis(n,1e9);\n dis[0]=0;\n vector<vector<int>> adj[n];\n for(a... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& disappear) {\n vector<vector<int>>adj[n];\n for(auto it:e){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push_back({it[0],it[2]});\n }\n vector<int>dis... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<int> dist(n,1e9);\n dist[0]=0;\n vector<vector<int>> adj[n];\n for(auto it:edges)\n {\n adj[it[0]].push_back({it[1],it[2]});\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n\n vector<vector<int>> adj[n];\n for(auto it: edges){\n int u = it[0];\n int v = it[1];\n int wt = it[2];\n adj[u].push_back({v,wt})... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n int szEdges = edges.size();\n vector<pair<int, int>> adj[50000];\n\n unordered_map<int, unordered_map<int, int>> mp;\n mp.reserve(n);\n for (int... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n \n int szEdges = edges.size();\n vector<pair<int, int>> adj[50000];\n {\n unordered_map<int, unordered_map<int, int>> mp;\n mp.reserve(n);\... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n // Dijkstra's algorithm with priority given to time\n unordered_map<int, list<pair<int, int>>> adj;\n for (auto it : edges) {\n int u = it[0];\n i... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> shortestPath(unordered_map<int,set<pair<int,int>>> &adj,int n,int S,vector<int>& disappear){\n //base cases\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> pq;\n pq.push({0,S});\n unordered_map<int,bool> vis... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n\nstatic const int N = 1e5+1;\nvector<pair<int,int>>adj[N];\n\n\n\nvoid f(int node,int n,vector<int>& disappear,vector<int>&dist)\n{\n priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>pq;\n pq.push({0,0});\n dist[0] =0;\n while(!pq.empty())\n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector< vector< pair<int,int> > > graph(n,vector<pair<int,int>>());\n map<pair<int,int>,int> mp;\n for(int i = 0; i < edges.size(); i++){\n if(edges[i][0] ==... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n //vector<pair<int, int>> adj[50000];\n unordered_map<int, unordered_map<int, int>> mp;\n\n int szEdges = edges.size();\n mp.reserve(n);\n for (int i = 0; ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& e, vector<int>& ds) {\n vector<vector<int>>adj[n];\n for(auto it:e){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push_back({it[0],it[2]});\n }\n\n\n \n vector<in... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<int>> adj[n];\n for(auto it:edges){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push_back({it[0],it[2]});\n } \n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<int>> adj[n];\n for(auto it:edges){\n adj[it[0]].push_back({it[1],it[2]});\n adj[it[1]].push_back({it[0],it[2]});\n } \n ... |
3,389 | <p>There is an undirected graph of <code>n</code> nodes. You are given a 2D array <code>edges</code>, where <code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, length<sub>i</sub>]</code> describes an edge between node <code>u<sub>i</sub></code> and node <code>v<sub>i</sub></code> with a traversal time of <code>length<sub>i... | 3 | {
"code": "class Solution {\npublic:\n vector<int> minimumTime(int n, vector<vector<int>>& edges, vector<int>& disappear) {\n vector<vector<vector<int>>> graph(n);\n for (auto &e : edges) {\n graph[e[0]].push_back({e[1], e[2]});\n graph[e[1]].push_back({e[0], e[2]});\n }\... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "//m0\n//O(n)\n#define tii tuple<int,int>\nstatic auto _ = [](){\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return nullptr;\n}();\n\nclass Solution {\npublic:\n long long numberOfSubarrays(vector<int>& nums) {\n int n = nums.size();\n long long ans... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "class Solution {\npublic:\n long long numberOfSubarrays(vector<int>& nums) {\n stack<pair<int,int>> s;\n long long res = 0;\n for (const int n : nums) {\n while (!s.empty() && s.top().first < n) {\n s.pop();\n }\n if (s.empty() || s.to... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "using ll = long long;\nusing pll = pair<ll, ll>;\n\nint speedup = []{\n ios::sync_with_stdio(0); cin.tie(0);\n return 0;\n}();\n\nclass Solution {\npublic:\n\n long long numberOfSubarrays(vector<int>& nums) {\n ll ans = 0;\n\n stack<pll> st; // {value, cnt}\n for (ll i = 0; i ... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "using ll = long long;\nusing pll = pair<ll, ll>;\n\nclass Solution {\npublic:\n\n long long numberOfSubarrays(vector<int>& nums) {\n ll ans = 0;\n\n stack<pll> st; // {value, cnt}\n for (ll i = 0; i < nums.size(); i++) {\n while (!st.empty() && st.top().first < nums[i]) s... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "class Solution {\npublic:\n long long numberOfSubarrays(vector<int>& nums) {\n \n stack<pair<int,int>>st;\n int n = nums.size();\n long long ans= 0;\n for(int i = n-1 ; i>=0 ;i--){\n\n while(!st.empty() && st.top().first < nums[i]){\n st.pop... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "class Solution {\npublic:\n long long numberOfSubarrays(vector<int>& nums) {\n vector<int>cnt(nums.size(),1);\n long long ans=0;\n stack<int>st;\n for(int i=0;i<nums.size();i++){\n while(!st.empty() and nums[st.top()]<nums[i]){\n st.pop();\n ... |
3,382 | <p>You are given an array of <strong>positive</strong> integers <code>nums</code>.</p>
<p>Return the number of <span data-keyword="subarray-nonempty">subarrays</span> of <code>nums</code>, where the <strong>first</strong> and the <strong>last</strong> elements of the subarray are <em>equal</em> to the <strong>largest<... | 0 | {
"code": "#include <iostream>\n#include <vector>\n#include <cmath>\n#include <algorithm>\n\nusing namespace std;\n\n// Store positive values only\nclass SegmentTreeArrayMaximum {\n private:\n int maximum; // always equals to 2^m for some m\n vector<int> arr;\n const vector<int> &source;\n ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.