 Open in App
Not now

# Check if every pair in Array B follows the same relation as their corresponding values in A

• Last Updated : 02 May, 2022

Given two Arrays A[] and B[] each of size N, the task is to check if the given arrays are valid or not, based on the following conditions:

• Every element in A at index i, will be mapped with the element in B at the same index only, i.e. (A[i] can be mapped with B[i] only)
• For any pair in A (A[i], A[j]), if A[i] > A[j], then its corresponding value in B should also be greater, i.e. B[i] > B[j] should be true.
• For any pair in A (A[i], A[j]), if A[i] = A[j], then its corresponding value in B should also be equal, i.e. B[i] = B[j] should be true.

Examples:

Input: N = 3, A[ ] = {10, 1, 17}, B[ ] = {10, 5, 15}
Output: true
Explanation: Consider all pairs in array A:
=> (10 and 1): Since 10>1, and their values in B (10 and 5 respectively) follow the same relation, therefore this is a valid pair.
=> (1 and 17): Since 1<17, and their values in B (5 and 15 respectively) follow the same relation, therefore this is a valid pair.
=> (10 and 17): Since 10<17, and their values in B (10 and 15 respectively) follow the same relation, therefore this is a valid pair.
As all the pairs are valid, therefore the given arrays are also valid. Hence the output is true.

Input: N = 5, A[ ] = {8, 5, 5, 10, 15}, B[ ] = {50, 10, 10, 15, 5 }
Output: false

Naive Approach: The most basic approach to solve is problem is to find each pair in array A, and check if the relation between that pair is satisfied for corresponding values in array B. If any such pair exists, where the values are not satisfied, then return false. Else return true.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach:

Intuition:

The idea for this approach is based on the observation that if the elements in an Array are sorted in ascending order,

• Then the first element will be always smaller than or equal to the second element
• Similarly, the first element will also be smaller than or equal to the last element
• Hence any element at index i will be smaller than or equal to element at index j, if (i < j)

Based on the above observation:

• If we try to sort the array A by remembering their corresponding values in array B, then instead of checking every pair in A, we can simply check for adjacent pairs in A to follow the conditions given in the problem.
• If all adjacent pairs in sorted A follows the conditions to be valid, then the given Arrays will be valid.

Illustration:

Suppose A[ ] = {10, 1, 17}, and B[ ] = {10, 5, 15}

If we sort A, by remembering their corresponding values in B, we get A[] = {1, 10, 17}, B[] = {5, 10, 15}

Now if we check adjacent pairs in A to follow the conditions given in problem, we get:

• Pair (1, 10): Since 1<10 and their values in B (5, 10) also follow same relation. Therefore this is a valid pair.
• Pair (10, 17): Since 10<17 and their values in B (10, 15) also follow same relation. Therefore this is a valid pair.

Since all the values in A has been verified, therefore the given arrays are also valid.

Algorithm: Follow the steps below to implement the above approach:

• Create a new vector of pairs to store corresponding values in {A[i], B[i]} format.
• Sort the vector, based on values of array A.
• For each adjacent pairs in the vector, check if:
• if A[i] < A[i+1] and B[i] > B[i+1], then this is not a valid pair.
• Hence return false.
• if A[i] == A[i+1] and B[i] != B[i+1], then this is not a valid pair.
• Hence return false.
• If none of the pairs in the above iteration satisfy the invalid pair conditions
• Return true.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to check the given array relations are valid or not` `bool` `isValidArrays(``int` `A[], ``int` `B[], ``int` `n)` `{` `    ``// creating new vector of pair to store the array` `    ``// relations.` `    ``vector > v1;`   `    ``// push elements of A with its corresponding` `    ``// value in B;` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``v1.push_back(make_pair(A[i], B[i]));` `    ``}`   `    ``// sort vector by first value` `    ``sort(v1.begin(), v1.end());`   `    ``// check the given relations.` `    ``for` `(``int` `i = 0; i < v1.size() - 1; i++) {` `        ``if` `(v1[i].first == v1[i + 1].first) {` `            ``// if relation is not valid return false` `            ``if` `(v1[i].second != v1[i + 1].second) {` `                ``return` `false``;` `            ``}` `        ``}` `        ``else` `{` `            ``// if relation is not valid return false` `            ``if` `(v1[i].second >= v1[i + 1].second) {` `                ``return` `false``;` `            ``}` `        ``}` `    ``}`   `    ``return` `true``;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A[] = { 10, 1, 17 };` `    ``int` `B[] = { 10, 5, 15 };` `    ``int` `N = ``sizeof``(A) / ``sizeof``(A);`   `    ``cout << boolalpha << isValidArrays(A, B, N);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG` `{`   `  ``// Function to check the given array relations are valid` `  ``// or not` `  ``public` `static` `boolean` `isValidArrays(``int` `A[], ``int` `B[],` `                                      ``int` `n)` `  ``{`   `    ``// creating new array of pair to store the array` `    ``// relations.` `    ``int` `v1[][] = ``new` `int``[n][``2``];`   `    ``// push elements of A with its corresponding` `    ``// value in B.` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``v1[i][``0``] = A[i];` `      ``v1[i][``1``] = B[i];` `    ``}`   `    ``// sort array by first value` `    ``Arrays.sort(v1,` `                ``(a, b) -> Integer.compare(a[``0``], b[``0``]));`   `    ``// check the given relations.` `    ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {` `      ``if` `(v1[i][``0``] == v1[i + ``1``][``0``]) {` `        ``// if relation is not valid return false` `        ``if` `(v1[i][``1``] != v1[i + ``1``][``1``]) {` `          ``return` `false``;` `        ``}` `      ``}` `      ``else` `{` `        ``// if relation is not valid return false` `        ``if` `(v1[i][``1``] >= v1[i + ``1``][``1``]) {` `          ``return` `false``;` `        ``}` `      ``}` `    ``}`   `    ``return` `true``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `A[] = { ``10``, ``1``, ``17` `};` `    ``int` `B[] = { ``10``, ``5``, ``15` `};` `    ``int` `N = ``3``;`   `    ``System.out.print(isValidArrays(A, B, N));` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Python3 code for the above approach`   `# Function to check the given array relations are valid or not` `def` `isValidArrays(A, B, n):` `    `  `    ``# creating new 2d list to store the array` `    ``# relations` `    ``v1 ``=` `[]` `    `  `    ``# push elements of A with its corresponding` `    ``# value in B` `    ``for` `i ``in` `range``(n):` `        ``v1.append([A[i], B[i]])` `    `  `    ``# sort v1 by first value` `    ``v1.sort()` `    `  `    ``# check the given relations` `    ``for` `i ``in` `range``(``len``(v1) ``-` `1``):` `        ``if` `v1[i][``0``] ``=``=` `v1[i ``+` `1``][``0``]:` `            ``# if relation is not valid` `            ``# return false` `            ``if` `v1[i][``1``] !``=` `v1[i ``+` `1``][``1``]:` `                ``return` `False` `        ``else``:` `            ``# if relation is not valid` `            ``# return false` `            ``if` `v1[i][``1``] >``=` `v1[i ``+` `1``][``1``]:` `                ``return` `False` `    `  `    ``return` `True` `    `  `# Driver Code` `A ``=` `[``10``, ``1``, ``17``]` `B ``=` `[``10``, ``5``, ``15``]` `N ``=` `len``(A)`   `print``(isValidArrays(A, B, N))` `                 `  `# This code is contributed by phasing17`

## C#

 `// C# program for the above approach` `using` `System;`   `public` `class` `GFG` `{`   `  ``// Function to check the given array relations are valid` `  ``// or not` `  ``public` `static` `bool` `isValidArrays(``int``[] A, ``int``[] B,` `                                   ``int` `n)` `  ``{`   `    ``// creating two arrays to store the array` `    ``// relations.` `    ``int``[] v1 = ``new` `int``[n];` `    ``int``[] v2 = ``new` `int``[n];`   `    ``// push elements of A with its corresponding` `    ``// value in B.` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``v1[i] = A[i];` `      ``v2[i] = B[i];` `    ``}`   `    ``// sort both the arrays by v1 values` `    ``Array.Sort(v1, v2);`   `    ``// check the given relations.` `    ``for` `(``int` `i = 0; i < n - 1; i++) {` `      ``if` `(v1[i] == v1[i + 1]) {` `        ``// if relation is not valid return false` `        ``if` `(v2[i] != v2[i + 1]) {` `          ``return` `false``;` `        ``}` `      ``}` `      ``else` `{` `        ``// if relation is not valid return false` `        ``if` `(v2[i] >= v2[i + 1]) {` `          ``return` `false``;` `        ``}` `      ``}` `    ``}`   `    ``return` `true``;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(``string``[] args)` `  ``{` `    ``int``[] A = { 10, 1, 17 };` `    ``int``[] B = { 10, 5, 15 };` `    ``int` `N = 3;`   `    ``// Function Call` `    ``Console.WriteLine(isValidArrays(A, B, N));` `  ``}` `}`   `// This code is contributed by phasing17`

## Javascript

 ``

Output

`true`

Time Complexity: O(N * log N)
Auxiliary Space: O(N), for creating a vector of pairs.

My Personal Notes arrow_drop_up
Related Articles