GeeksForGeeks - POTD | GFG POTD Answer

class Solution 
{ 
    public: 
        void inorder(Node *root,int &sum) 
     { 
         if(root==NULL) 
         return ; 
        if(root->left==NULL && root->right==NULL) 
      {  sum=sum+root->data; 
        return ;} 
         
        inorder(root->left,sum); 
        inorder(root->right,sum); 
     } 
    public: 
        
        int sumOfLeafNodes(Node *root ){ 
             int sum=0; 
             inorder(root,sum); 
             return sum; 
        } 
};

class Solution{ 
    public: 
    bool isMaxHeap(int arr[], int n) 
    { 
        queue<int> q; 
        q.push(arr[0]); 
         
        for(int i = 1; i < n; i++){ 
            int big = q.front(); 
            q.pop(); 
             
            if(arr[i] > big) 
                return 0; 
                 
            q.push(arr[i]); 
                 
            if(i + 1 < n){ 
                if(arr[i + 1] > big) 
                    return 0; 
                     
                q.push(arr[i + 1]); 
                ++i; 
            } 
        } 
         
        return 1; 
    } 
};

class Solution 
{ 
public: 
    void solve(Node* root,Node*&head) 
    { 
        if(root == NULL) 
        return; 
         
        solve(root->right,head); 
         
        root->right = head; 
        head = root; 
         
        solve(root->left,head); 
         
        root->left = NULL; 
    } 
     
    Node *flattenBST(Node *root) 
    { 
        Node* head = NULL; 
        solve(root,head); 
         
        return head; 
    } 
};

class Solution {
public:
 int isPossible(vector<vector<int>>paths){  
     for(auto &x : paths)  if(accumulate(x.begin(), x.end(), 0) & 1) return 0;
     return 1;
 }
};

class Solution { 
public:vector<vector<int>>ans; 
    int timer=0; 
    void dfs(int node,int parent,vector<int> adj[],vector<int>&vis,vector<int>&dis,vector<int>&low){ 
        vis[node]=1; 
        dis[node]=low[node]=++timer; 
        for(auto it:adj[node]){ 
            if(it==parent)continue; 
            else if(vis[it]==1){ 
                low[node]=min(low[node],dis[it]); 
            } 
            else{ 
                dfs(it,node,adj,vis,dis,low); 
                low[node]=min(low[node],low[it]); 
                if(low[it]>dis[node]){ 
                    ans.push_back({min(it,node),max(it,node)}); 
                } 
            } 
        } 
         
    } 
    vector<vector<int>>criticalConnections(int v, vector<int> adj[]){ 
       vector<int>vis(v,0),dis(v,-1),low(v,-1); 
       for(int i=0;i<v;i++){ 
           if(vis[i]==0){ 
               dfs(i,-1,adj,vis,dis,low); 
           } 
       } 
       sort(ans.begin(), ans.end()); 
       return ans; 
    } 
};