Check if the given Binary Expressions are valid

• Difficulty Level : Medium
• Last Updated : 09 Jun, 2022

Given n expressions of the type x = y and x != y where 1 â‰¤ x, y â‰¤ n, the task is to check whether the integers from 1 to n can be assigned to x and y such that all the equations are satisfied.

Examples:

Input: x[] = {1, 2, 3}, op[] = {“=”, “=”, “!=”}, y[] = {2, 3, 1}
Output: Invalid
If 1 = 2 and 2 = 3 then 3 must be equal to 1.

Input: x[] = {1, 2}, op[] = {“=”, “=”}, y[] = {2, 3}
Output: Valid

Approach: The idea is to use union-find. For each statement check if there exists “=” sign then find the parent values for the two variables and union them using the rank method. Now once the union has been done for all the variables having “=” operator between them, start checking for “!=” operator, if this operator exists between any two variables whose parents are the same then the expressions are invalid, else they are valid.

Below is the implementation of the above approach:

C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `// Function to return the parent of an integer` `int` `findParent(``int` `i, vector<``int``> parent)` `{` `    ``if` `(parent[i] == i)` `        ``return` `i;` `    ``return` `findParent(parent[i], parent);` `}`   `// Find union for both the integers x and y` `// using rank method` `void` `findUnion(``int` `x, ``int` `y, vector<``int``>& parent,` `               ``vector<``int``>& rank)` `{` `    ``int` `xroot = findParent(x, parent);` `    ``int` `yroot = findParent(y, parent);`   `    ``// Union using rank method` `    ``if` `(xroot != yroot) {` `        ``if` `(rank[xroot] > rank[yroot]) {` `            ``parent[y] = x;` `            ``rank[xroot]++;` `        ``}` `        ``else` `if` `(rank[x] < rank[y]) {` `            ``parent[x] = y;` `            ``rank[yroot]++;` `        ``}` `        ``else` `{` `            ``parent[y] = x;` `            ``rank[xroot]++;` `        ``}` `    ``}` `}`   `// Function that returns true if` `// the expression is invalid` `bool` `isInvalid(vector<``int``> u, vector<``int``> v,` `               ``vector op, ``int` `n)` `{` `    ``// Vector to store parent values` `    ``// of each integer` `    ``vector<``int``> parent;`   `    ``// Vector to store rank` `    ``// of each integer` `    ``vector<``int``> rank;`   `    ``parent.push_back(-1);` `    ``rank.push_back(-1);`   `    ``// Initialize parent values for` `    ``// each of the integers` `    ``for` `(``int` `i = 1; i <= n; i++)` `        ``parent.push_back(i);`   `    ``// Initialize rank values for` `    ``// each of the integers` `    ``for` `(``int` `i = 1; i <= n; i++)` `        ``rank.push_back(0);`   `    ``// Check for = operator and find union` `    ``// for them` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``if` `(op[i] == ``"="``)` `            ``findUnion(u[i], v[i], parent, rank);`   `    ``// Check for != operator` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(op[i] == ``"!="``) {` `            ``// If the expression is invalid` `            ``if` `(findParent(u[i], parent)` `                ``== findParent(v[i], parent))` `                ``return` `true``;` `        ``}` `    ``}`   `    ``// Expression is valid` `    ``return` `false``;` `}`   `// Driver code` `int` `main()` `{` `    ``vector<``int``> u;` `    ``vector<``int``> v;` `    ``vector op;`   `    ``// Store the first integer` `    ``u.push_back(1);` `    ``u.push_back(2);` `    ``u.push_back(3);`   `    ``// Store the second integer` `    ``v.push_back(2);` `    ``v.push_back(3);` `    ``v.push_back(1);`   `    ``// Store the operators` `    ``op.push_back(``"="``);` `    ``op.push_back(``"="``);` `    ``op.push_back(``"!="``);`   `    ``// Number of expressions` `    ``int` `n = u.size();` `    ``if` `(isInvalid(u, v, op, n))` `        ``cout << ``"Invalid"``;` `    ``else` `        ``cout << ``"Valid"``;`   `    ``return` `0;` `}`

Java

 `// Java implementation of ` `// the above approach ` `import` `java.util.*;` `class` `GFG{` `  `  `// Function to return the parent ` `// of an integer` `public` `static` `int` `findParent(``int` `i, ` `                             ``Vector parent)` `{` `  ``if` `((``int``)parent.get(i) == i)` `    ``return` `i;`   `  ``return` `findParent((``int``)parent.get(i), ` `                         ``parent);` `}` `      `  `// Find union for both the integers x and y` `// using rank method` `public` `static` `void` `findUnion(``int` `x, ``int` `y, ` `                             ``Vector parent,` `                             ``Vector rank)` `{` `  ``int` `xroot = findParent(x, parent);` `  ``int` `yroot = findParent(y, parent);`   `  ``// Union using rank method` `  ``if` `(xroot != yroot)` `  ``{` `    ``if` `((``int``)rank.get(xroot) > ` `        ``(``int``)rank.get(yroot)) ` `    ``{` `      ``parent.set(y,x);` `      ``rank.set(xroot, ` `               ``(``int``)rank.get(xroot) + ``1``); ` `    ``}` `    ``else` `if` `((``int``)rank.get(x) < ` `             ``(``int``)rank.get(y))` `    ``{` `      ``parent.set(x,y);` `      ``rank.set(yroot, ` `               ``(``int``)rank.get(yroot) + ``1``); ` `    ``}` `    ``else` `    ``{` `      ``parent.set(y,x);` `      ``rank.set(xroot, ` `               ``(``int``)rank.get(xroot) + ``1``);` `    ``}` `  ``}` `}` `      `  `// Function that returns true if` `// the expression is invalid` `public` `static` `boolean` `isInvalid(Vector u, Vector v,` `                                ``Vector op, ``int` `n)` `{` `  ``// To store parent values` `  ``// of each integer` `  ``Vector parent = ``new` `Vector();`   `  ``// To store rank` `  ``// of each integer` `  ``Vector rank = ``new` `Vector();`   `  ``parent.add(-``1``);` `  ``rank.add(-``1``);`   `  ``// Initialize parent values for` `  ``// each of the integers` `  ``for``(``int` `i = ``1``; i <= n; i++)` `    ``parent.add(i);`   `  ``// Initialize rank values for` `  ``// each of the integers` `  ``for``(``int` `i = ``1``; i <= n; i++)` `    ``rank.add(``0``);`   `  ``// Check for = operator and find union` `  ``// for them` `  ``for``(``int` `i = ``0``; i < n; i++)` `    ``if` `((String)op.get(i) == ``"="``)` `      ``findUnion((``int``)u.get(i), ` `                ``(``int``)v.get(i), ` `                 ``parent, rank);`   `  ``// Check for != operator` `  ``for``(``int` `i = ``0``; i < n; i++)` `  ``{` `    ``if` `((String)op.get(i) == ``"!="``)` `    ``{` `      ``// If the expression is invalid` `      ``if` `(findParent((``int``)u.get(i), parent) == ` `          ``findParent((``int``)v.get(i), parent))` `        ``return` `true``;` `    ``}` `  ``}`   `  ``// Expression is valid` `  ``return` `false``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `  ``Vector u = ``new` `Vector();` `  ``Vector v = ``new` `Vector();` `  ``Vector op = ``new` `Vector();`   `  ``// Store the first integer` `  ``u.add(``1``);` `  ``u.add(``2``);` `  ``u.add(``3``);`   `  ``// Store the second integer` `  ``v.add(``2``);` `  ``v.add(``3``);` `  ``v.add(``1``);`   `  ``// Store the operators` `  ``op.add(``"="``);` `  ``op.add(``"="``);` `  ``op.add(``"!="``);`   `  ``// Number of expressions` `  ``int` `n = u.size();`   `  ``if` `(isInvalid(u, v, op, n))` `    ``System.out.print(``"Invalid"``);` `  ``else` `    ``System.out.print(``"Valid"``);` `}` `}`   `// This code is contributed by divyeshrabadiya07`

Python3

 `# Python3 implementation of the approach `   `# Function to return the parent of an integer ` `def` `findParent(i, parent): `   `    ``if` `parent[i] ``=``=` `i:` `        ``return` `i ` `    ``return` `findParent(parent[i], parent) `   `# Find union for both the integers ` `# x and y using rank method ` `def` `findUnion(x, y, parent, rank): `   `    ``xroot ``=` `findParent(x, parent) ` `    ``yroot ``=` `findParent(y, parent) `   `    ``# Union using rank method ` `    ``if` `xroot !``=` `yroot: ` `        ``if` `rank[xroot] > rank[yroot]: ` `            ``parent[y] ``=` `x ` `            ``rank[xroot] ``+``=` `1` `        `  `        ``elif` `rank[x] < rank[y]: ` `            ``parent[x] ``=` `y ` `            ``rank[yroot] ``+``=` `1` `        `  `        ``else``:` `            ``parent[y] ``=` `x ` `            ``rank[xroot] ``+``=` `1`   `# Function that returns true if ` `# the expression is invalid ` `def` `isInvalid(u, v, op, n): `   `    ``# Vector to store parent values ` `    ``# of each integer ` `    ``parent ``=` `[]`   `    ``# Vector to store rank ` `    ``# of each integer ` `    ``rank ``=` `[] `   `    ``parent.append(``-``1``) ` `    ``rank.append(``-``1``) `   `    ``# Initialize parent values for ` `    ``# each of the integers ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` `        ``parent.append(i) `   `    ``# Initialize rank values for ` `    ``# each of the integers ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` `        ``rank.append(``0``) `   `    ``# Check for = operator and ` `    ``# find union for them ` `    ``for` `i ``in` `range``(``0``, n): ` `        ``if` `op[i] ``=``=` `"="``: ` `            ``findUnion(u[i], v[i], parent, rank) `   `    ``# Check for != operator ` `    ``for` `i ``in` `range``(``0``, n): ` `        ``if` `op[i] ``=``=` `"!="``: ` `            `  `            ``# If the expression is invalid ` `            ``if` `(findParent(u[i], parent) ``=``=` `                ``findParent(v[i], parent)): ` `                ``return` `True` `        `  `    ``# Expression is valid ` `    ``return` `False`   `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: `   `    ``u ``=` `[``1``, ``2``, ``3``] ` `    ``v ``=` `[``2``, ``3``, ``1``]` `    ``op ``=` `[``"="``, ``"="``, ``"!="``] `   `    ``# Number of expressions ` `    ``n ``=` `len``(u) ` `    ``if` `isInvalid(u, v, op, n): ` `        ``print``(``"Invalid"``) ` `    ``else``:` `        ``print``(``"Valid"``) `   `# This code is contributed by Rituraj Jain`

C#

 `// C# implementation of the approach ` `using` `System; ` `using` `System.Collections;` `using` `System.Collections.Generic;  `   `class` `GFG{ ` `  `  `// Function to return the parent of an integer` `static` `int` `findParent(``int` `i, ArrayList parent)` `{` `    ``if` `((``int``)parent[i] == i)` `        ``return` `i;` `  `  `    ``return` `findParent((``int``)parent[i], parent);` `}` ` `  `// Find union for both the integers x and y` `// using rank method` `static` `void` `findUnion(``int` `x, ``int` `y, ` `                      ``ArrayList parent,` `                      ``ArrayList rank)` `{` `    ``int` `xroot = findParent(x, parent);` `    ``int` `yroot = findParent(y, parent);` ` `  `    ``// Union using rank method` `    ``if` `(xroot != yroot)` `    ``{` `        ``if` `((``int``)rank[xroot] > (``int``)rank[yroot]) ` `        ``{` `            ``parent[y] = x;` `            ``rank[xroot] = (``int``)rank[xroot] + 1;` `        ``}` `        ``else` `if` `((``int``)rank[x] < (``int``)rank[y])` `        ``{` `            ``parent[x] = y;` `            ``rank[yroot] = (``int``)rank[yroot] + 1;` `        ``}` `        ``else` `        ``{` `            ``parent[y] = x;` `            ``rank[xroot] = (``int``)rank[xroot] + 1;` `        ``}` `    ``}` `}` ` `  `// Function that returns true if` `// the expression is invalid` `static` `bool` `isInvalid(ArrayList u, ArrayList v,` `                      ``ArrayList op, ``int` `n)` `{` `  `  `    ``// To store parent values` `    ``// of each integer` `    ``ArrayList parent = ``new` `ArrayList();` ` `  `    ``// To store rank` `    ``// of each integer` `    ``ArrayList rank = ``new` `ArrayList();` ` `  `    ``parent.Add(-1);` `    ``rank.Add(-1);` ` `  `    ``// Initialize parent values for` `    ``// each of the integers` `    ``for``(``int` `i = 1; i <= n; i++)` `        ``parent.Add(i);` ` `  `    ``// Initialize rank values for` `    ``// each of the integers` `    ``for``(``int` `i = 1; i <= n; i++)` `        ``rank.Add(0);` ` `  `    ``// Check for = operator and find union` `    ``// for them` `    ``for``(``int` `i = 0; i < n; i++)` `        ``if` `((``string``)op[i] == ``"="``)` `            ``findUnion((``int``)u[i], ` `                      ``(``int``)v[i],` `                      ``parent, rank);` ` `  `    ``// Check for != operator` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``if` `((``string``)op[i] == ``"!="``)` `        ``{` `          `  `            ``// If the expression is invalid` `            ``if` `(findParent((``int``)u[i], parent) == ` `                ``findParent((``int``)v[i], parent))` `                ``return` `true``;` `        ``}` `    ``}` ` `  `    ``// Expression is valid` `    ``return` `false``;` `}`   `// Driver Code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``ArrayList u = ``new` `ArrayList();` `    ``ArrayList v = ``new` `ArrayList();` `    ``ArrayList op = ``new` `ArrayList();` ` `  `    ``// Store the first integer` `    ``u.Add(1);` `    ``u.Add(2);` `    ``u.Add(3);` ` `  `    ``// Store the second integer` `    ``v.Add(2);` `    ``v.Add(3);` `    ``v.Add(1);` ` `  `    ``// Store the operators` `    ``op.Add(``"="``);` `    ``op.Add(``"="``);` `    ``op.Add(``"!="``);` ` `  `    ``// Number of expressions` `    ``int` `n = u.Count;` `  `  `    ``if` `(isInvalid(u, v, op, n))` `        ``Console.Write(``"Invalid"``);` `    ``else` `        ``Console.Write(``"Valid"``);` `} ` `} `   `// This code is contributed by rutvik_56`

Javascript

 ``

Output:

`Invalid`

Time Complexity: O(nlogn)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up
Recommended Articles
Page :