Largest sub-tree having equal no of 1’s and 0’s

Given a tree having every node’s value as either 0 or 1, the task is to find the maximum size of the sub-tree in the given tree that has equal number of 0’s and 1’s, if no such sub-tree exists then print -1.

Examples:

Input:

Output: 6

Input:

Output: -1

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Change all the nodes of the tree which are 0 to -1. Now the problem gets reduced to finding the maximum size of a sub-tree sum of whose nodes is 0.
2. Update all the nodes of the tree so that they represent the sum of all nodes in the sub-tree rooted at the current node.
3. Now find the size of the maximum sub-tree rooted at a node whose value is 0. If no such node is found then print -1

Below is the implementation of the above approach:

C++

 // C++ implementation of the approach #include using namespace std;    // To store the size of the maximum sub-tree // with equal number of 0's and 1's int maxSize = -1;    // Represents a node of the tree struct node {     int data;     struct node *right, *left; };    // To create a new node struct node* newnode(int key) {     struct node* temp = new node;     temp->data = key;     temp->right = NULL;     temp->left = NULL;     return temp; }    // Function to perform inorder traversal on // the tree and print the nodes in that order void inorder(struct node* root) {     if (root == NULL)         return;     inorder(root->left);     cout << root->data << endl;     inorder(root->right); }    // Function to return the maximum size of // the sub-tree having equal number of 0's and 1's int maxsize(struct node* root) {     int a = 0, b = 0;     if (root == NULL)         return 0;        // Max size in the right sub-tree     a = maxsize(root->right);        // 1 is added for the parent     a = a + 1;        // Max size in the left sub-tree     b = maxsize(root->left);        // Total size of the tree     // rooted at the current node     a = b + a;        // If the current tree has equal     // number of 0's and 1's     if (root->data == 0)            // If the total size exceeds         // the current max         if (a >= maxSize)             maxSize = a;        return a; }    // Function to update and return the sum // of all the tree nodes rooted at // the passed node int sum_tree(struct node* root) {        if (root != NULL)            // If current node's value is 0         // then update it to -1         if (root->data == 0)             root->data = -1;        int a = 0, b = 0;        // If left child exists     if (root->left != NULL)         a = sum_tree(root->left);        // If right child exists     if (root->right != NULL)         b = sum_tree(root->right);     root->data += (a + b);        return root->data; }    // Driver code int main() {     struct node* root = newnode(1);     root->right = newnode(0);     root->right->right = newnode(1);     root->right->right->right = newnode(1);     root->left = newnode(0);     root->left->left = newnode(1);     root->left->left->left = newnode(1);     root->left->right = newnode(0);     root->left->right->left = newnode(1);     root->left->right->left->left = newnode(1);     root->left->right->right = newnode(0);     root->left->right->right->left = newnode(0);     root->left->right->right->left->left = newnode(1);        sum_tree(root);        maxsize(root);        cout << maxSize;        return 0; }

Java

 // Java implementation of the approach class GFG {    // To store the size of the maximum sub-tree // with equal number of 0's and 1's static int maxSize = -1;    // Represents a node of the tree static class node  {     int data;     node right, left; };    // To create a new node static node newnode(int key) {     node temp = new node();     temp.data = key;     temp.right = null;     temp.left = null;     return temp; }    // Function to perform inorder traversal on // the tree and print the nodes in that order static void inorder(node root) {     if (root == null)         return;     inorder(root.left);     System.out.print(root.data +"\n");     inorder(root.right); }    // Function to return the maximum size of // the sub-tree having equal number of 0's and 1's static int maxsize(node root) {     int a = 0, b = 0;     if (root == null)         return 0;        // Max size in the right sub-tree     a = maxsize(root.right);        // 1 is added for the parent     a = a + 1;        // Max size in the left sub-tree     b = maxsize(root.left);        // Total size of the tree     // rooted at the current node     a = b + a;        // If the current tree has equal     // number of 0's and 1's     if (root.data == 0)            // If the total size exceeds         // the current max         if (a >= maxSize)             maxSize = a;        return a; }    // Function to update and return the sum // of all the tree nodes rooted at // the passed node static int sum_tree(node root) {        if (root != null)            // If current node's value is 0         // then update it to -1         if (root.data == 0)             root.data = -1;        int a = 0, b = 0;        // If left child exists     if (root.left != null)         a = sum_tree(root.left);        // If right child exists     if (root.right != null)         b = sum_tree(root.right);     root.data += (a + b);        return root.data; }    // Driver code public static void main(String[] args) {     node root = newnode(1);     root.right = newnode(0);     root.right.right = newnode(1);     root.right.right.right = newnode(1);     root.left = newnode(0);     root.left.left = newnode(1);     root.left.left.left = newnode(1);     root.left.right = newnode(0);     root.left.right.left = newnode(1);     root.left.right.left.left = newnode(1);     root.left.right.right = newnode(0);     root.left.right.right.left = newnode(0);     root.left.right.right.left.left = newnode(1);        sum_tree(root);        maxsize(root);        System.out.print(maxSize); } }    // This code is contributed by PrinciRaj1992

C#

 // C# implementation of the approach using System;    class GFG {    // To store the size of the maximum sub-tree // with equal number of 0's and 1's static int maxSize = -1;    // Represents a node of the tree public class node  {     public int data;     public node right, left; };    // To create a new node static node newnode(int key) {     node temp = new node();     temp.data = key;     temp.right = null;     temp.left = null;     return temp; }    // Function to perform inorder traversal on // the tree and print the nodes in that order static void inorder(node root) {     if (root == null)         return;     inorder(root.left);     Console.Write(root.data +"\n");     inorder(root.right); }    // Function to return the maximum size of // the sub-tree having equal number of 0's and 1's static int maxsize(node root) {     int a = 0, b = 0;     if (root == null)         return 0;        // Max size in the right sub-tree     a = maxsize(root.right);        // 1 is added for the parent     a = a + 1;        // Max size in the left sub-tree     b = maxsize(root.left);        // Total size of the tree     // rooted at the current node     a = b + a;        // If the current tree has equal     // number of 0's and 1's     if (root.data == 0)            // If the total size exceeds         // the current max         if (a >= maxSize)             maxSize = a;        return a; }    // Function to update and return the sum // of all the tree nodes rooted at // the passed node static int sum_tree(node root) {        if (root != null)            // If current node's value is 0         // then update it to -1         if (root.data == 0)             root.data = -1;        int a = 0, b = 0;        // If left child exists     if (root.left != null)         a = sum_tree(root.left);        // If right child exists     if (root.right != null)         b = sum_tree(root.right);     root.data += (a + b);        return root.data; }    // Driver code public static void Main(String[] args) {     node root = newnode(1);     root.right = newnode(0);     root.right.right = newnode(1);     root.right.right.right = newnode(1);     root.left = newnode(0);     root.left.left = newnode(1);     root.left.left.left = newnode(1);     root.left.right = newnode(0);     root.left.right.left = newnode(1);     root.left.right.left.left = newnode(1);     root.left.right.right = newnode(0);     root.left.right.right.left = newnode(0);     root.left.right.right.left.left = newnode(1);        sum_tree(root);        maxsize(root);        Console.Write(maxSize); } }    // This code is contributed by Rajput-Ji

Output:

6

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : princiraj1992, Rajput-Ji

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.