C++ এ গ্রাফ বৈধ গাছ

ধরুন আমাদের n নোড আছে যেগুলিকে 0 থেকে n-1 পর্যন্ত লেবেল করা হয়েছে এবং অনির্দেশিত প্রান্ত [u,v]গুলির একটি তালিকা, এই প্রান্তগুলি একটি বৈধ গাছ তৈরি করে কিনা তা পরীক্ষা করার জন্য আমাদের একটি ফাংশন সংজ্ঞায়িত করতে হবে৷

সুতরাং, যদি ইনপুট n =5, এবং প্রান্ত =[[0,1], [0,2], [0,3], [1,4]] হয়, তাহলে আউটপুট সত্য হবে

এটি সমাধান করতে, আমরা এই পদক্ষেপগুলি অনুসরণ করব -

• একটি ফাংশন dfs() সংজ্ঞায়িত করুন, এটি নোড, par, গ্রাফ এবং ভিজিটেড নামে আরেকটি অ্যারে নেবে,

• যদি পরিদর্শন করা [নোড] 1 এর মত হয়, তাহলে −

  • প্রত্যাবর্তন সত্য

• যদি পরিদর্শন করা [নোড] 2 এর মত হয়, তাহলে −

  • ফেরত মিথ্যা

• পরিদর্শন করা হয়েছে [নোড] :=2

• ret :=সত্য

• আরম্ভ করার জন্য i :=0, যখন i <গ্রাফের আকার [নোড], আপডেট করুন (i 1 দ্বারা বৃদ্ধি করুন), করুন −

  • যদি গ্রাফ[নোড, i] সমান সমান না হয়, তাহলে −

    • ret :=ret AND dfs(গ্রাফ[নোড, আই], নোড, গ্রাফ, পরিদর্শন করা হয়েছে)

• পরিদর্শন [নোড] :=1

• রিটার্ন রিটার্ন

• প্রধান পদ্ধতি থেকে নিম্নলিখিতগুলি করুন -

• n আকারের পরিদর্শন করা অ্যারে সংজ্ঞায়িত করুন এবং এটি 0 দিয়ে পূরণ করুন।

• গ্রাফ অফ সাইজ n

  নামের তালিকার একটি তালিকা সংজ্ঞায়িত করুন

• আরম্ভ করার জন্য i :=0, যখন i <প্রান্তের আকার, আপডেট (i 1 দ্বারা বৃদ্ধি), −

  • u :=প্রান্ত[i, 0], v :=প্রান্ত[i, 1]

  • গ্রাফ[u]

    -এর শেষে v সন্নিবেশ করান

  • গ্রাফের শেষে u ঢোকান[v]

• যদি dfs(0, -1, গ্রাফ, পরিদর্শন করা) মিথ্যা হয়, তাহলে −

  • ফেরত মিথ্যা

• আরম্ভ করার জন্য i :=0, যখন i

  • যদি পরিদর্শন করা হয় [i] শূন্য হয়, তাহলে −

    • ফেরত মিথ্যা

• প্রত্যাবর্তন সত্য

উদাহরণ

আরো ভালোভাবে বোঝার জন্য আসুন নিচের বাস্তবায়ন দেখি -

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
   bool dfs(int node, int par, vector <int< graph[], vector <int<& visited){
      if (visited[node] == 1)
         return true;
      if (visited[node] == 2)
         return false;
      visited[node] = 2;
      bool ret = true;
      for (int i = 0; i < graph[node].size(); i++) {
         if (graph[node][i] != par)
            ret &= dfs(graph[node][i], node, graph, visited);
      }
      visited[node] = 1;
      return ret;
   }
   bool validTree(int n, vector<vector<int<>& edges) {
      vector<int< visited(n, 0);
      vector<int< graph[n];
      for (int i = 0; i < edges.size(); i++) {
         int u = edges[i][0];
         int v = edges[i][1];
         graph[u].push_back(v);
         graph[v].push_back(u);
      }
      if (!dfs(0, -1, graph, visited))
         return false;
      for (int i = 0; i < n; i++) {
         if (!visited[i])
            return false;
      }
      return true;
   }
};
main(){
   Solution ob;
   vector<vector<int<> v = {{0,1},{0,2},{0,3},{1,4}};
   cout << (ob.validTree(5,v));
}

ইনপুট

5, {{0,1},{0,2},{0,3},{1,4}}

আউটপুট

1