id int64 1 3.58k | problem_description stringlengths 516 21.8k | instruction int64 0 3 | solution_c dict |
|---|---|---|---|
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n \n vector<int>adj[n];\n vector<int>InDeg(n,0);\n for(int i=0;i<relations.size();i++)\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& edges, vector<int>& time) {\n vector<int > adj[n+1],indegree(n+1,0);\n int e = edges.size();\n for(int i=0;i<e;i++){\n int u = edges[i][0];\n int v =edges[i][1];\n adj[u].push... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int>adj[n];\n\n vector<int>indeg(n,0);\n for(int i=0;i<relations.size();i++){\n adj[relations[i][1]-1].push_back(relations[i][0]-1);\n indeg[relatio... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n \n vector<int>adj[50001];\n \n vector<int>indegree(n+1, 0);\n vector<bool>mp(n+1, false);\n \n for(int j=0; j<relations.size(); j++){\n ad... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int>indegree(n+1,0);\n vector<int>g[n+1];\n for(int i=0;i<relations.size();i++){\n int u = relations[i][0];\n int v = relations[i][1];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "static const auto Initialize = [] {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n return nullptr;\n}();\n\nint indegrees[50000] = {0}, maximumTime[50000];\narray<vector<int>, 50000> gotos;\n\nclass Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "const int MAXN = 5e4 + 5;\n\nclass Solution {\npublic:\n int dp[MAXN];\n vector<int> edges[MAXN];\n\n int calculate(int x, vector<int>& time) {\n if (dp[x] > 0) return dp[x];\n for (int child : edges[x]) {\n dp[x] = max(dp[x], calculate(child, time));\n }\n d... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> ans(n+1, INT_MIN);\n vector<int> adj[n+1];\n vector<int> inDegree(n+1, 0);\n for(int i=0; i<relations.size(); i++)\n {\n adj[relations[i][0]... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n + 1);\n vector<int> indegree(n + 1, 0);\n \n for (const auto& relation : relations) {\n int prevCourse = relation[0];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int m = relations.size();\n vector<vector<int> >adj(n);\n vector<int>indegree(n, 0);\n for(int i=0;i<m;i++){\n int prev = relations[i][0] - 1;\n int... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int m=relations.size();\n vector<vector<int>>adj(n+1);\n vector<int>indegree(n+1,0);\n vector<int>dist(n+1,0);\n dist[0]=0;\n for(int i=0;i<m;i++){\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 0 | {
"code": "\nclass Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n);\n vector<int> indegree(n, 0);\n vector<int> dp(n, 0);\n \n for (auto& relation : relations) {\n graph[relation[0] - 1].p... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n);\n vector<int> outDegree(n,0);\n vector<int> dp(n,0);\n\n for(const auto& rel : relations){\n graph[rel[1] - 1].push_back(rel[0] -... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int dp[50005], visit[50005];\n vector<int> v[50005];\n\n void dfs(int s, vector<int>& time) {\n visit[s] = 1;\n \n dp[s] = 0;\n for (int i = 0; i < v[s].size(); i++) {\n if (!visit[v[s][i]]) {\n dfs(v[s][i], time);\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n vector<int>vis;\n \n int func(int node,vector<int>adj[],vector<int>&time,vector<int>&dp)\n {\n if(dp[node]!=-1) return dp[node];\n int t=0;\n vis[node]=1;\n for(auto &it:adj[node])\n {\n t=max(t,func(it,adj,time,dp));\n }\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n void dfs(const vector <vector <int>> &input, vector <int> &maxTimes, const vector <int> &time, int vertex, int parent)\n {\n for(int node: input[vertex])\n {\n if(node != parent)\n {\n maxTimes[node] = max(maxTimes[node], ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\n bool toposort(int n, vector<int> &order, vector<vector<int>> &g,\n vector<int> &indegree) {\n queue<int> q;\n for (int i = 0; i < n; ++i)\n if (indegree[i] == 0)\n q.push(i);\n\n while (!q.empty()) {\n int u = q.front();\n q.pop();\n or... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adj(n+1, vector<int>());\n vector<int> inDeg(n+1, 0);\n for(auto &it: relations){\n adj[it[0]].push_back(it[1]);\n inDeg[it[1]]++;\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\n vector<vector<int>>graph;\n vector<int>dp;\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n if(!n)\n return 0;\n dp = vector<int>(n, INT_MIN);\n graph = vector<vector<int>>(n, vector<int>());\n for(co... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n Solution(){\n ios_base::sync_with_stdio(false);\n cin.tie(NULL); cout.tie(NULL);\n }\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int szRelations = relations.size();\n \n vector<vector<int>> adj(n), r... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n\n int dfs(int course_num, vector<vector<int>>& prereq, vector<int>& time, vector<int>& max_time, vector<int>& visited) {\n // cout << \"course_num is \" << course_num << \"\\n\";\n visited[course_num] = 1;\n int max_prereq_time = 0;\n for (auto pre... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n // int sol1(int n, vector<vector<int>>& adj, vector<int>& time){\n // queue<int>q;\n // vector<int>ftime(n,0);\n // for(int i = 0; i < n; i++){\n // if(indegree[i]==0){\n // q.push(i);\n // ftime[i] = time[i];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int szRelations = relations.size();\n \n vector<vector<int>> adj(n), rev(n);\n {\n int cnt[50000] = {0}, rcnt[50000] = {0};\n for (int i = 0; i < sz... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int szRelations = relations.size();\n vector<int> ingree(n, 0);\n vector<vector<int>> adj(n), rev(n);\n {\n int cnt[50000] = {0}, rcnt[50000] = {0};\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "using ll = long long;\nusing pl = pair<ll,ll>;\nusing vl = vector<ll>;\nusing vvl = vector<vector<ll>>;\nusing vll = vector<pair<ll,ll>>;\n\n#define all(a) a.begin(),a.end()\n#define rall(a) a.rbegin(),a.rend()\n\nvoid read(vl& a){for(auto &x : a) cin >> x;}\nvoid read(vll& a){for(auto &x : a) cin >> x.fir... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "#include <vector>\n#include <algorithm>\n\nclass Solution {\npublic:\n int minimumTime(int n, std::vector<std::vector<int>>& relations, std::vector<int>& time) {\n std::vector<std::vector<int>> adj(n); // Adjacency list for the graph\n std::vector<int> memo(n, -1); // Memoization... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& r, vector<int>& time) {\n int indegree[n+1];\n for(int i =0 ;i<n+1;i++)\n {\n indegree[i]=0;\n }\n vector<int> adj[n+1];\n for(int i = 0;i<r.size();i++)\n {\n ad... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution\n{\npublic:\n int minimumTime(int n, const std::vector<std::vector<int>>& relations, const std::vector<int>& time)\n {\n std::vector<std::vector<int>> graph(n + 1);\n for (const std::vector<int>& relation: relations) {\n const int prev_course = relation[0];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n void topofun(int node,vector<int>&vis,stack<int>&st,vector<int>adj[])\n {\n vis[node]=1;\n for(int i=0;i<adj[node].size();i++)\n {\n if(!vis[adj[node][i]]) topofun(adj[node][i],vis,st,adj);\n }\n st.push(node);\n }\n int ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n void topofun(int node,vector<int>&vis,stack<int>&st,vector<int>adj[])\n {\n vis[node]=1;\n for(int i=0;i<adj[node].size();i++)\n {\n if(!vis[adj[node][i]]) topofun(adj[node][i],vis,st,adj);\n }\n st.push(node);\n }\n int ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n unordered_map<int, vector<int>> adj(n + 1);\n vector<int> indegree(n + 1);\n \n \n for (auto& relation : relations) {\n int x = relation[0];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adj(n+1);\n for(vector<int>& r: relations) adj[r[1]].push_back(r[0]);\n \n vector<int> memo(n+1, -1);\n function<int (int)> dfs = [&dfs, &memo,... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>>graph(n);\n vector<int>indegree(n,0);\n\n for(int i=0;i<relations.size();i++) {\n graph[relations[i][0]-1].push_back(relations[i][1]-1);\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n vector<int> adj[50001];\n int res[50001];\n int indegree[50001];\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n for(auto i : relations){\n int a = i[0];\n int b = i[1];\n a--; b--;\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int dfsCyc(vector<vector<int>>& G, vector<int> & vis, int v,vector<int> & topo){\n if(vis[v]==1){\n return 1;\n } \n vis[v]=1;\n for(auto e : G[v]){\n \n dfsCyc(G,vis,e,topo);\n \n }\n top... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> nextCourses(n + 1, vector<int>());\n vector<int> preReqCount(n + 1, 0);\n for (int i = 0; i < relations.size(); i++) {\n preReqCount[relations[i][... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n\n\n vector<int>indg(n,0);\n vector<int>adj[n];\n vector<int>dis(n,0);\n\n for(auto it:relations){\n int a=it[0]-1;\n int b=it[1]-1;\n adj[a].push... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 1 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> adj[n], indegree(n, 0);\n for(auto it: relations) adj[it[0]-1].push_back(it[1]-1), indegree[it[1]-1]++;\n queue<int> q;\n vector<int> t(n, 0);\n for(in... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> startTime(n,0),endTime(n,0);\n vector<int> indegree(n,0);\n vector<int> adj[n];\n for(auto edge:relations){\n int u = edge[0]-1;\n int v... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> startTime(n,0),endTime(n,0);\n vector<int> indegree(n,0);\n vector<int> adj[n];\n for(auto edge:relations){\n int u = edge[0]-1;\n int v... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n unordered_map<int, vector<int>> graph;\n \n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) { \n unordered_map<int, vector<int>> graph;\n vector<int> indegree = vector(n, 0);\n\n for (vector<int>& edge: relations) {\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> indegree(n,0);\n unordered_map<int,vector<int>> adj;\n for(auto & vec: relations){\n adj[vec[0]-1].push_back(vec[1]-1);\n indegree[vec[1]-1]+... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n);\n vector<int> indeg(n,0);\n\n for(auto rel : relations){\n graph[rel[0]-1].push_back(rel[1]-1);\n indeg[rel[1]-1]++;\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adj(n);\n vector<int> in(n);\n for(auto relation : relations) {\n adj[relation[0]-1].push_back(relation[1]-1);\n in[relation[1]-1]++;\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "const static auto fast = []\n{ \n std::ios_base::sync_with_stdio(false);\n std::cin.tie(nullptr);\n std::cout.tie(nullptr);\n return 0;\n}();\n\nclass Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n disc.resize(n + 1);\n low.r... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 2 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> indegrees (n);\n queue<int> zeroIndegree;\n vector<vector<int>> graph (n);\n\n for (auto edge : relations) {\n graph[edge[0] - 1].push_back(edge[1]... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> adj[n];\n vector<int> indeg(n,0),ans(n,0);\n for(auto edge:relations)\n {\n int u=edge[0]-1;\n int v=edge[1]-1;\n adj[u].push... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "// struct Compare{\n// public:\n// bool operator()(pair<int,int> a,pair<int,int> b)const\n// {\n// return a.second<b.second;\n// }\n// };\nclass Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n unordered_map<int,vect... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int topo(vector<vector<int>>&adj,vector<int>&time1,int n){\n vector<int>indegree(n);\n for(int i=0;i<n;i++){\n for(auto it:adj[i]){\n indegree[it]++;\n }\n }\n vector<int>Time(n,0);\n queue<pair<int,int>>... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n int szRelations = relations.size();\n vector<int> ingree(n, 0);\n vector<vector<int>> adj(n), rev(n);\n for (int i = 0; i < szRelations; i++)\n {\n int ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n void dfs(int x,vector<vector<int>>&v,vector<bool>&vis,vector<int>&topo){\n vis[x]=true;\n for(auto it:v[x]){\n if(!vis[it])dfs(it,v,vis,topo);\n }\n topo.push_back(x);\n }\n int minimumTime(int n, vector<vector<int>>& ed, vector<in... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n void dfs(int x,vector<vector<int>>&v,vector<bool>&vis,vector<int>&topo){\n vis[x]=true;\n for(auto it:v[x]){\n if(!vis[it])dfs(it,v,vis,topo);\n }\n topo.push_back(x);\n }\n int minimumTime(int n, vector<vector<int>>& ed, vector<in... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> adj;\n vector<int> indeg;\n int dp[50003];\n int dfs(int u, vector<int>& time){\n if(dp[u]!=-1) return dp[u];\n int ans=0;\n for(auto v:adj[u]){\n ans=max(ans,dfs(v,time));\n }\n ans=ans+time[u-1];\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n long long dp[50001];\n vector<long long>adj[50001];\n\n long long dfs(vector<int>&t,int node){\n if(dp[node]!=-1)return dp[node];\n long long maxt=0;\n for(auto i:adj[node]){\n maxt=max(maxt,dfs(t,i));\n }\n return dp[nod... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int> topologicalSortingUsingBFS(vector<vector<int> > &adj) {\n int n = adj.size() - 1;\n vector<int> inDegree(n + 1);\n for (int i = 1; i<=n; i++) {\n for (auto it : adj[i]) {\n inDegree[it]++;\n }\n }\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adjm(n);\n vector<vector<int>> rev_adjm(n);\n vector<int> indegree(n,0);\n for(auto &rel : relations){\n adjm[rel[0]-1].push_back(rel[1]-1)... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> res(n, 0);\n vector<vector<int>> map(n);\n for (auto relation: relations) {\n map[relation[1] - 1].push_back(relation[0] - 1);\n }\n int ans... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<vector<int>> adj;\n vector<int> cstart;\n const int inf = 1e9+7;\n int dfs(int v, int p, vector<int>&time){\n int start = 0;\n if(cstart[v]!= -1) return cstart[v];\n for(auto x : adj[v]){\n if(x == p) continue;\n star... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\n int dfs(int node, vector<vector<int>> &adj, vector<int> &vis, vector<int> &time, vector<int> &nodeTime)\n {\n vis[node] = 1;\n int maxi = 0;\n for(auto adjNode:adj[node])\n {\n if(!vis[adjNode])\n maxi = max(maxi, dfs... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\n int solve(vector<vector<int>>&v ,vector<int>& time , int node , vector<int>&dp){\n if(dp[node] !=-1)return dp[node];\n int t = time[node - 1];\n cout<<t<<\" \";\n int next = 0;\n for(auto i:v[node]){\n next= max(next , sol... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\tvoid dfs(int node, vector<int> &t, int &m, vector<vector<int>> &adj, vector<int> &dp) {\n if (dp[node] != -1) {\n return; \n }\n dp[node] = t[node - 1];\n for (auto it : adj[node]) {\n dfs(it, t, m, adj, dp); \n dp[node] = max(dp[node], t[node-1... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\tvoid dfs(int node, vector<int> &t, int &m, vector<vector<int>> &adj, vector<int> &dp) {\n if (dp[node] != -1) {\n return; \n }\n dp[node] = t[node - 1];\n for (auto it : adj[node]) {\n dfs(it, t, m, adj, dp); \n dp[node] = max(dp[node], t[node-1... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> indegree(n,0);\n vector<int> ans(n,0);\n\n vector<vector<int>> adjList(n,vector<int>(0));\n queue<int> q;\n int maxi = -1;\n // int ans = 0 ;\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adj(n+1);\n vector<int> indegree(n+1, 0);\n\n for(vector<int> vec: relations){\n adj[vec[0]].push_back(vec[1]);\n indegree[vec[1]]++;\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> indegree(n,0);\n vector<int> ans(n,0);\n\n vector<vector<int>> adjList(n,vector<int>(0));\n queue<int> q;\n // int ans = 0 ;\n for(auto it : rel... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& e, vector<int>& t) {\n vector<int> adj[n];\n for (auto it : e) {\n adj[it[0] - 1].push_back(it[1] - 1);\n }\n vector<int> vis(n);\n vector<int> dp(n);\n for (int i = 0; i < t.size... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& e, vector<int>& t) {\n vector<int> adj[n];\n for (auto it : e) {\n adj[it[0] - 1].push_back(it[1] - 1);\n }\n vector<int> vis(n);\n vector<int> dp(n);\n for (int i = 0; i < t.size... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int> mxtime(n);\n vector<int> indegree(n,0);\n unordered_map<int,list<int> > mp;\n for(int i=0;i<relations.size();i++){\n indegree[relations[i][1]-1]++;... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& r, vector<int>& t){\n vector<vector<int>> adj(n);\n for(auto x:r){\n int u = x[0] , v = x[1];\n adj[v-1].push_back(u-1);\n }\n vector<int> dp(n,-1);\n function<int(int)> rec =... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& r, vector<int>& t){\n vector<vector<int>> adj(n);\n for(auto x:r){\n int u = x[0] , v = x[1];\n adj[v-1].push_back(u-1);\n }\n vector<int> dp(n,-1);\n function<int(int)> rec =... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n // khudki appraoch se karo!\n // important to do by that approach!\n // the approach we use here is TOPO sort\n // in example 2 -> if you see that 1,2,3 nodes have 0 ind... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n unordered_map<int, vector<int>> digraph;\n unordered_map<int,int> indegree;\n\n // construct digraph\n for (auto& e : relations) {\n // adjust to zero-offset\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n unordered_map<int, vector<int>> digraph;\n unordered_map<int,int> indegree;\n\n // construct digraph\n for (auto& e : relations) {\n // adjust to zero-offset\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> g(n + 1);\n for(auto it : relations) {\n g[it[0]].push_back(it[1]);\n }\n\n vector<int> dp(n + 1, -1);\n\n function<int(int)> go = [... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<int>indegree(n+1,0);\n vector<int>totalTime(n+1,0);\n vector<int>adj[n+1];\n vector<int>adjRev[n+1];\n for(auto it:relations){\n adj[it[0]].push_... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int helper(int n, vector<vector<int>>& list, vector<int>& time, int course, vector<int>& vis) {\n int timeNeeded = time[course - 1];\n int extraTimeNeeded = 0;\n for(auto nextCourse : list[course]) {\n if(vis[nextCourse] == 0) {\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n);\n vector<int>indegree(n);\n for(vector<int> i:relations){\n graph[i[0]-1].push_back(i[1]-1);\n indegree[i[1]-1]++;\n }\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> graph(n);\n vector<int>indegree(n);\n for(vector<int> i:relations){\n graph[i[0]-1].push_back(i[1]-1);\n indegree[i[1]-1]++;\n }\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> adjacency_list (n+1);\n unordered_map<int, int> indegrees;\n for(auto relation : relations)\n {\n adjacency_list[relation[0]].push_back(rel... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n map<int, vector<int> > g;\n vector<int> dist(n + 1, 0);\n vector<int> in_deg(n + 1, 0);\n queue<int> q;\n for(auto i : relations) {\n g[i[0]].push_back(... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n // vector<vector<int>> transposed = transposeGraph(relations, n);\n vector<vector<int>> graph = getGraph(relations, n);\n // get outdegree\n vector<int> indegrees (n);\n ... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n stack<int> toposort;\n vector<vector<int>> adj;\n vector<bool> vis;\n void dfs(int i){\n vis[i] = true;\n for(auto it:adj[i]){\n if(!vis[it])\n dfs(it);\n }\n // toposort.push_back(i);\n toposort.push(i);\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\n int solve(vector<vector<int>>&v ,vector<int>& time , vector<bool>&vis , int node , vector<int>&dp){\n if(dp[node] !=-1)return dp[node];\n vis[node] = true;\n int t = time[node - 1];\n cout<<t<<\" \";\n int next = 0;\n for(auto i:v[... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>>g(n+1);\n vector<vector<int>>rg(n+1);\n vector<int>in(n+1,0);\n for(auto x:relations){\n g[x[0]].push_back(x[1]);\n rg[x[1]].push... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> parent;\n parent.resize(n);\n vector<vector<int>> adj(n);\n vector<int> indeg(n);\n for(auto rel: relations)\n {\n adj[rel[0]... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n // for each node calc cum time -> max parent time + self time \n // return cum time for node with outdeg 0 \n\n // void display(vector<int>& v){\n // for(auto x:v){ printf(\"%d \",x); }\n // printf(\"\\n\");\n // }\n\n // void display_adj(vector<vect... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relns, vector<int>& time) {\n vector<int> indeg(n, 0);\n vector<vector<int>> adj(n), adj2(n);\n vector<int> top_sort;\n\n for(auto rel:relns){\n indeg[rel[1]-1]++;\n adj[rel[0]-1].pu... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int> getIn(int n, vector<vector<int>>& adj){\n vector<int> res(n+1,0);\n for(auto u : adj){\n for(auto v:u){\n res[v]++;\n }\n } \n return res;\n}\n\nint minimumTime(int n, vector<vector<int>> &relations, vector<int> &time) {\n v... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n void dfs(int u , vector<bool>& visited,vector<vector<int>>& graph , vector<int>& topo){\n visited[u]=true;\n for(int v : graph[u])\n if(!visited[v])\n dfs(v,visited,graph,topo);\n topo.push_back(u);\n }\n int minimumTime(in... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n unordered_map<int, vector<int>> um;\n \n int solve(int course, vector<int>& time, vector<int>& dp){\n if(um.find(course)== um.end()){\n return dp[course] = time[course-1];\n }\n if(dp[course]!=-1) return dp[course];\n int curr =0;... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& rel, vector<int>& time) {\n vector<vector<int>> g(n), r(n);\n vector<int> dp=time, in(n), top;\n int ans=-1;\n for(vector<int> v : rel) {\n g[v[0]-1].push_back(v[1]-1);\n r[v[1]-1].p... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int>dp;\n int check(int n,vector<vector<int>>&cp,vector<int>& t){\n if(dp[n]!=-1){\n return dp[n];\n }\n int cost=t[n-1];\n int ma=0;\n for(auto x:cp[n]){\n ma=max(ma,check(x,cp,t));\n }\n return... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int>dp;\n int check(int n,vector<vector<int>>&cp,vector<int>& t){\n if(dp[n]!=-1){\n return dp[n];\n }\n int cost=t[n-1];\n int ma=0;\n for(auto x:cp[n]){\n ma=max(ma,check(x,cp,t));\n }\n return... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> transposed = transposeGraph(relations, n);\n // vector<vector<int>> graph = getGraph(relations, n);\n // get outdegree\n vector<int> outdegrees (n);\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n vector<vector<int>> transposed = transposeGraph(relations, n);\n // vector<vector<int>> graph = getGraph(relations, n);\n // get outdegree\n vector<int> outdegrees (n);\n... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {\n std::unordered_map<int, std::vector<int>> relationMap;\n std::unordered_map<int, int> totalTime;\n queue<int> courses;\n std::unordered_map<int, int> prerequisiteNumber;\... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n\n int getMinTimeToCompleteAllCourses(int n, int r, vector<vector<int>> relations, vector<int> time){\n\n vector<list<int>> adj(n);\n vector<int> indegree(n, 0);\n for(int i = 0; i < r; i++){\n adj[relations[i][0]-1].push_back(relations[i][1]-1);\n indegree[... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int>dp;\n int check(int x,vector<vector<int>>&cc,vector<vector<int>>&cp,vector<int>& t){\n if(cp[x].size()==0){\n return t[x-1];\n }\n if(dp[x]!=-1){\n return dp[x];\n }\n int ans=INT_MIN;\n for(auto y:... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int>memo; \n unordered_map<int,vector<int>>mp;\n int dfs(int i, vector<int>&time)\n {\n if(~memo[i]) return memo[i]; \n int curr_time = time[i]; \n for(auto it : mp[i])\n { \n int dep =dfs(it, time);\n curr_t... |
2,176 | <p>You are given an integer <code>n</code>, which indicates that there are <code>n</code> courses labeled from <code>1</code> to <code>n</code>. You are also given a 2D integer array <code>relations</code> where <code>relations[j] = [prevCourse<sub>j</sub>, nextCourse<sub>j</sub>]</code> denotes that course <code>prevC... | 3 | {
"code": "class Solution {\npublic:\n vector<int>memo; \n unordered_map<int,vector<int>>mp;\n int dfs(int i, vector<int>&time)\n {\n if(~memo[i]) return memo[i]; \n int curr_time = time[i]; \n for(auto it : mp[i])\n { \n int dep =dfs(it, time);\n curr_t... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.