Given two binary trees T1 and T2 and integer K, the task is to check whether both trees are identical or not after making exactly K changes in the first tree. In each change, one tree element can be converted into any other integer.
Examples:
Input: K = 1
T1 = 1 T2 = 1
/ \ / \
2 4 2 3
Output: Yes
Explanation: Change the node with value 4 to value 3Input: K = 5
T1 = 1 T2 = 1
/ \ / \
2 5 3 5
/ \ / \ / \ / \
7 9 10 11 7 6 10 21Output: Yes
Explanation: In the above two tree there are 3 node value which are different in first tree i.e, 2, 9, 11.
Hence we make atleast 3 changes to convert them to 3, 6, 21 respectively to make tree identical.
After 3 changes left K = 5 – 3 = 2 changes.
Utilize these two changes by converting any node to any random one then convert back to original one.
In this way we have exactly K = 5 changes.
Approach: The problem is solved using an iterative approach using a stack.
- We check all the respective nodes of both the trees one by one with the help of iterative inorder traversal.
- If we found that the respective data parts of both the trees are not matching then we simply increment the count.
- If the structure of both the trees is different, return false.
- At the end we check if our count is less than K and (k-count) is even or not if so then return true else return false.
Below is the implementation of the above approach.
C++
// C++ code to implement the above approach#include <bits/stdc++.h>using namespace std;
// A binary tree node has data,// pointer to left child// and a pointer to right childclass node {
public:
int data;
node* left;
node* right;
};// Function to create new node.node* newNode(int data)
{ node* Node = new node();
Node->data = data;
Node->left = NULL;
Node->right = NULL;
return (Node);
}// Given two trees, return// true if they are// convertible to identicalbool checkIdentical(node* p, node* q, int k)
{ stack<node *> st1, st2;
int count = 0;
while (p || !st1.empty() && q || !st2.empty()) {
// If p are q are not null
// push in stack
if (p && q) {
st1.push(p);
st2.push(q);
// Send p and q to its left child
p = p->left;
q = q->left;
}
// when one of them is null means
// they have different
// structure return false
else if (p && !q || !p && q)
return 0;
// If p and q are null
// pop node from stack
else {
p = st1.top();
q = st2.top();
st1.pop();
st2.pop();
// If data not match increment count
if (p->data != q->data)
count++;
// Send p and q to its right child
p = p->right;
q = q->right;
}
}
if (count <= k && (k - count) % 2 == 0)
return 1;
else
return 0;
}// Driver codeint main()
{ /* 1 1
/ \ / \
2 4 2 3
*/
node* root1 = newNode(1);
root1->left = newNode(2);
root1->right = newNode(4);
node* root2 = newNode(1);
root2->left = newNode(2);
root2->right = newNode(3);
int K = 1;
if (checkIdentical(root1, root2, K))
cout << "Yes";
else
cout << "No";
return 0;
} |
Java
// Java code to implement the above approachimport java.util.*;
class GFG{
// A binary tree node has data,// pointer to left child// and a pointer to right childstatic class node {
int data;
node left;
node right;
};// Function to create new node.static node newNode(int data)
{ node Node = new node();
Node.data = data;
Node.left = null;
Node.right = null;
return (Node);
}// Given two trees, return// true if they are// convertible to identicalstatic boolean checkIdentical(node p, node q, int k)
{ Stack<node > st1 = new Stack<>();
Stack<node > st2 = new Stack<>();
int count = 0;
while (p!=null || (st1.isEmpty()) && q!=null || !st2.isEmpty()) {
// If p are q are not null
// push in stack
if (p!=null && q!=null) {
st1.add(p);
st2.add(q);
// Send p and q to its left child
p = p.left;
q = q.left;
}
// when one of them is null means
// they have different
// structure return false
else if (p!=null && q==null || p==null && q!=null)
return false;
// If p and q are null
// pop node from stack
else {
p = st1.peek();
q = st2.peek();
st1.pop();
st2.pop();
// If data not match increment count
if (p.data != q.data)
count++;
// Send p and q to its right child
p = p.right;
q = q.right;
}
}
if (count <= k && (k - count) % 2 == 0)
return true;
else
return false;
}// Driver codepublic static void main(String[] args)
{ /* 1 1
/ \ / \
2 4 2 3
*/
node root1 = newNode(1);
root1.left = newNode(2);
root1.right = newNode(4);
node root2 = newNode(1);
root2.left = newNode(2);
root2.right = newNode(3);
int K = 1;
if (checkIdentical(root1, root2, K))
System.out.print("Yes");
else
System.out.print("No");
}}// This code contributed by shikhasingrajput |
Python3
# Python code for the above approach## A binary tree node has data,## pointer to left child## and a pointer to right childclass node:
def __init__(self, d):
self.data = d
self.left = None
self.right = None
## Function to create new node.def newNode(data):
Node = node(data);
Node.left = None;
Node.right = None;
return Node
## Given two trees, return## true if they are## convertible to identicaldef checkIdentical(p, q, k):
st1 = []
st2 = []
count = 0
while (p or (len(st1) > 0) and q or (len(st2) > 0)):
## If p are q are not null
## push in stack
if (p and q):
st1.append(p)
st2.append(q)
## Send p and q to its left child
p = p.left
q = q.left
## when one of them is null means
## they have different
## structure return false
elif (p and (not q) or (not p) and q):
return 0
## If p and q are null
## pop node from stack
else:
p = st1.pop()
st1.append(p)
q = st2.pop()
st2.append(q)
st1.pop()
st2.pop()
## If data not match increment count
if (p.data != q.data):
count+=1
## Send p and q to its right child
p = p.right
q = q.right
if (count <= k and (k - count) % 2 == 0):
return 1
else:
return 0
# Driver Codeif __name__=='__main__':
## 1 1
## / \ / \
## 2 4 2 3
root1 = newNode(1);
root1.left = newNode(2);
root1.right = newNode(4);
root2 = newNode(1);
root2.left = newNode(2);
root2.right = newNode(3);
K = 1;
if (checkIdentical(root1, root2, K)):
print("Yes")
else:
print("No")
# This code is contributed by subhamgoyal2014.
|
C#
// C# code to implement the above approachusing System;
using System.Collections.Generic;
public class GFG{
// A binary tree node has data,
// pointer to left child
// and a pointer to right child
public
class node {
public int data;
public node left;
public node right;
};
// Function to create new node.
static node newNode(int data)
{
node Node = new node();
Node.data = data;
Node.left = null;
Node.right = null;
return (Node);
}
// Given two trees, return
// true if they are
// convertible to identical
static bool checkIdentical(node p, node q, int k)
{
Stack<node > st1 = new Stack<node>();
Stack<node > st2 = new Stack<node>();
int count = 0;
while (p!=null || (st1.Count!=0) && q!=null || st2.Count!=0) {
// If p are q are not null
// push in stack
if (p!=null && q!=null) {
st1.Push(p);
st2.Push(q);
// Send p and q to its left child
p = p.left;
q = q.left;
}
// when one of them is null means
// they have different
// structure return false
else if (p!=null && q==null || p==null && q!=null)
return false;
// If p and q are null
// pop node from stack
else {
p = st1.Peek();
q = st2.Peek();
st1.Pop();
st2.Pop();
// If data not match increment count
if (p.data != q.data)
count++;
// Send p and q to its right child
p = p.right;
q = q.right;
}
}
if (count <= k && (k - count) % 2 == 0)
return true;
else
return false;
}
// Driver code
public static void Main(String[] args)
{
/* 1 1
/ \ / \
2 4 2 3
*/
node root1 = newNode(1);
root1.left = newNode(2);
root1.right = newNode(4);
node root2 = newNode(1);
root2.left = newNode(2);
root2.right = newNode(3);
int K = 1;
if (checkIdentical(root1, root2, K))
Console.Write("Yes");
else
Console.Write("No");
}
}// This code contributed by shikhasingrajput |
Javascript
// JavaScript code to implement the above approachclass Node { constructor(data) {
this.data = data;
this.left = null;
this.right = null;
}
}let root1, root2;// Given two trees, return// true if they are// convertible to identicalfunction checkIdentical(p, q, k) {
let st1 = [];
let st2 = [];
let count = 0;
while (p || st1.length != 0 && q || st2.length !== 0) {
// If p are q are not null
// push in stack
if (p && q) {
st1.push(p);
st2.push(q);
// Send p and q to its left child
p = p.left;
q = q.left;
}
// when one of them is null means
// they have different
// structure return false
else if (p && !q || !p && q) return false;
// If p and q are null
// pop node from stack
else {
p = st1[0];
q = st2[0];
st1.shift();
st2.shift();
// If data not match increment count
if (p.data !== q.data) count++;
// Send p and q to its right child
p = p.right;
q = q.right;
}
}
if (count <= k && (k - count) % 2 === 0) return true;
else return false;
}// Driver coderoot1 = new Node(1);
root1.left = new Node(2);
root1.right = new Node(4);
root2 = new Node(1);
root2.left = new Node(2);
root2.right = new Node(3);
let k = 1;if (checkIdentical(root1, root2, k)) console.log("Yes");
else console.log("No");
// This code is contributed by adityamaharshi21 |
Output
Yes
Time Complexity: O(N)
Auxiliary Space: O(N)