सी ++ में प्रक्रिया को मारें

मान लीजिए कि हमारे पास n प्रक्रियाएं हैं, यहां प्रत्येक प्रक्रिया की एक विशिष्ट आईडी होती है जिसे PID या प्रक्रिया आईडी कहा जाता है और उसका PPID (पैरेंट प्रोसेस आईडी) भी होता है।

प्रत्येक प्रक्रिया में केवल एक पैरेंट प्रक्रिया होती है, लेकिन इसमें एक या अधिक चाइल्ड प्रक्रियाएं हो सकती हैं।

यह एक पेड़ की संरचना की तरह है। केवल एक प्रक्रिया में PPID =0 होता है, जिसका अर्थ है कि इस प्रक्रिया में कोई मूल प्रक्रिया नहीं है। सभी पीआईडी ​​अद्वितीय धनात्मक पूर्णांक होंगे।

हम प्रक्रियाओं की सूची का प्रतिनिधित्व करने के लिए पूर्णांकों की दो सूची का उपयोग करेंगे, जहां पहली सूची में प्रत्येक प्रक्रिया के लिए पीआईडी ​​​​शामिल है और दूसरी सूची में संबंधित पीपीआईडी ​​​​शामिल है। इसलिए, यदि हमारे पास दो सूचियां हैं, और एक पीआईडी ​​एक ऐसी प्रक्रिया का प्रतिनिधित्व करती है जिसे हम मारना चाहते हैं, तो हमें प्रक्रियाओं की पीआईडी ​​की एक सूची ढूंढनी होगी जो अंत में मारे जाएंगे। और हमें यह मान लेना चाहिए कि जब कोई प्रक्रिया समाप्त हो जाती है, तो उसके सभी बच्चों की प्रक्रिया समाप्त हो जाएगी।

इसलिए, यदि इनपुट पिड =[1, 3, 10, 5] पीपीआईडी ​​=[3, 0, 5, 3] किल =5 जैसा है, तो आउटपुट [5,10], होगा।

किल 5 भी 10 को मारेगा।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे -

• एक मानचित्र बच्चे को परिभाषित करें

• n :=pid का आकार

• एक सरणी रिट परिभाषित करें

• इनिशियलाइज़ i:=0 के लिए, जब i

  • यू:=पीपीआईडी[i]

  • वी:=पीआईडी[i]

  • बच्चे के अंत में v डालें[u]

• एक कतार को परिभाषित करें q

• q में किल डालें

• जबकि (नहीं q खाली है), करें -

  • curr :=q का पहला तत्व

  • q से तत्व हटाएं

  • रिट के अंत में करंट डालें

  • इनिशियलाइज़ करने के लिए:=0, जब मैं <बच्चे का आकार [कर्र], अपडेट (i से 1 तक बढ़ाएँ), करें -

    • बच्चे [कर्र, i] को q में डालें

• वापसी रिट

उदाहरण

आइए एक बेहतर समझ प्राप्त करने के लिए निम्नलिखित कार्यान्वयन देखें -

#include <bits/stdc++.h>
using namespace std;
void print_vector(vector<auto> v){
   cout << "[";
   for(int i = 0; i<v.size(); i++){
      cout << v[i] << ", ";
   }
   cout << "]"<<endl;
}
class Solution {
public:
   vector<int> killProcess(vector<int>& pid, vector<int>& ppid, int kill) {
      map<int, vector<int> > child;
      int n = pid.size();
      vector<int> ret;
      for (int i = 0; i < n; i++) {
         int u = ppid[i];
         int v = pid[i];
         child[u].push_back(v);
      }
      queue<int> q;
      q.push(kill);
      while (!q.empty()) {
         int curr = q.front();
         q.pop();
         ret.push_back(curr);
         for (int i = 0; i < child[curr].size(); i++) {
            q.push(child[curr][i]);
         }
      }
      return ret;
   }
};
main(){
   Solution ob;
   vector<int> v = {1,3,10,5}, v1 = {3,0,5,3};
   print_vector(ob.killProcess(v, v1, 5));
}

इनपुट

{1,3,10,5},{3,0,5,3},5

आउटपुट

[5, 10, ]