मान लीजिए कि कुल n पाठ्यक्रम हैं जिन्हें हम ले सकते हैं, पाठ्यक्रमों को 0 से n-1 तक लेबल किया गया है।
कुछ पाठ्यक्रमों में प्रत्यक्ष पूर्वापेक्षाएँ हो सकती हैं, उदाहरण के लिए, पाठ्यक्रम 0 लेने के लिए हमें पहले पाठ्यक्रम 1 लेना होगा, जिसे एक जोड़ी के रूप में व्यक्त किया जाता है:[1,0]।
इसलिए, यदि हमारे पास कई पाठ्यक्रम n हैं, तो प्रत्यक्ष पूर्वापेक्षित जोड़ियों की सूची और प्रश्नों के जोड़े की एक सूची है।
आपको प्रत्येक प्रश्न का उत्तर खोजना चाहिए [i] क्या पाठ्यक्रम प्रश्न [i] [0] पाठ्यक्रम प्रश्नों के लिए एक पूर्वापेक्षा है [i] [1] या नहीं। अंत में, हमें बूलियन की एक सूची लौटानी होगी, दिए गए प्रश्नों के उत्तर।
हमें यह ध्यान रखना होगा कि यदि पाठ्यक्रम a, पाठ्यक्रम b की पूर्वापेक्षा है और पाठ्यक्रम b, पाठ्यक्रम c की पूर्वापेक्षा है, तो पाठ्यक्रम a, पाठ्यक्रम c की एक पूर्वापेक्षा है।
इसलिए, यदि इनपुट n =3, पूर्वापेक्षाएँ =[[1,2], [1,0], [2,0]], क्वेरीज़ =[[1,0], [1,2]] की तरह है, तो आउटपुट [true,true]
. होगाइसे हल करने के लिए, हम इन चरणों का पालन करेंगे -
-
एन:=110
-
एक सरणी रिट परिभाषित करें
-
एक मानचित्र को इसमें परिभाषित करें
-
v में प्रत्येक तत्व के लिए, करें
-
इसे [1] ग्राफ़ के अंत में डालें[it[0]]
-
(इसमें [यह [1]] 1 से वृद्धि करें)
-
-
एक कतार को परिभाषित करें q
-
इनिशियलाइज़ i :=0 के लिए, जब i
-
अगर [i] 0 के समान है, तो -
-
q में i डालें
-
-
-
एक नक्शा idx परिभाषित करें
-
lvl को इनिशियलाइज़ करने के लिए:=1, जब q खाली न हो, तो अपडेट करें (lvl को 1 से बढ़ाएँ), करें -
-
sz :=q का आकार
-
जबकि sz 0 नहीं है, प्रत्येक पुनरावृत्ति में sz घटाएं, करें -
-
नोड:=q का पहला तत्व
-
q से तत्व हटाएं
-
प्रत्येक तत्व के लिए यह ग्राफ़ में [नोड]
-
(इसमें [इसे] 1 से घटाएं)
-
c[नोड] में प्रत्येक तत्व x के लिए, करें
-
c[it]
. में x डालें
-
-
c[it]
. में नोड डालें -
अगर [यह] 0 के समान है, तो -
-
इसे q में डालें
-
-
-
-
-
प्रत्येक तत्व के लिए इसे x में करें
-
रिट के अंत में डालें (इसकी आवृत्ति [0] c[it[1]] में)
-
-
वापसी रिट
उदाहरण
आइए बेहतर समझ पाने के लिए निम्नलिखित कार्यान्वयन देखें -
#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<bool> v){
cout << "[";
for(int i = 0; i<v.size(); i++){
cout << v[i] << ", ";
}
cout << "]"<<endl;
}
const int N = 110;
class Solution {
public:
vector <int> graph[N];
map <int, set <int>> c;
vector<bool> checkIfPrerequisite(int n, vector<vector<int>>& v, vector<vector<int>>& x) {
vector<bool> ret;
map<int, int> in;
for (auto& it : v) {
graph[it[0]].push_back(it[1]);
in[it[1]]++;
}
queue<int> q;
for (int i = 0; i < n; i++) {
if (in[i] == 0)
q.push(i);
}
map<int, int> idx;
for (int lvl = 1; !q.empty(); lvl++) {
int sz = q.size();
while (sz--) {
int node = q.front();
q.pop();
for (auto& it : graph[node]) {
in[it]--;
for (auto& x : c[node])
c[it].insert(x);
c[it].insert(node);
if (in[it] == 0) {
q.push(it);
}
}
}
}
for (auto& it : x) {
ret.push_back(c[it[1]].count(it[0]));
}
return ret;
}
};
main(){
Solution ob;
vector<vector<int>> prerequisites = {{1,2},{1,0},{2,0}}, queries = {{1,0},{1,2}};
print_vector(ob.checkIfPrerequisite(3, prerequisites, queries));
} इनपुट
3, {{1,2},{1,0},{2,0}}, {{1,0},{1,2}} आउटपुट
[1, 1, ]