Tuesday, December 31, 2024
Google search engine
HomeData Modelling & AIFind a specific pair in Matrix

Find a specific pair in Matrix

Given an n x n matrix mat[n][n] of integers, find the maximum value of mat(c, d) – mat(a, b) over all choices of indexes such that both c > a and d > b.

Example: 

Input:
mat[N][N] = {{ 1, 2, -1, -4, -20 },
             { -8, -3, 4, 2, 1 }, 
             { 3, 8, 6, 1, 3 },
             { -4, -1, 1, 7, -6 },
             { 0, -4, 10, -5, 1 }};
Output: 18
The maximum value is 18 as mat[4][2] 
- mat[1][0] = 18 has maximum difference. 

The program should do only ONE traversal of the matrix. i.e. expected time complexity is O(n2)
A simple solution would be to apply Brute-Force. For all values mat(a, b) in the matrix, we find mat(c, d) that has maximum value such that c > a and d > b and keeps on updating maximum value found so far. We finally return the maximum value.

Below is its implementation. 

C++




// A Naive method to find maximum value of mat[d][e]
// - ma[a][b] such that d > a and e > b
#include <bits/stdc++.h>
using namespace std;
#define N 5
 
// The function returns maximum value A(d,e) - A(a,b)
// over all choices of indexes such that both d > a
// and e > b.
int findMaxValue(int mat[][N])
{
    // stores maximum value
    int maxValue = INT_MIN;
 
    // Consider all possible pairs mat[a][b] and
    // mat[d][e]
    for (int a = 0; a < N - 1; a++)
    for (int b = 0; b < N - 1; b++)
        for (int d = a + 1; d < N; d++)
        for (int e = b + 1; e < N; e++)
            if (maxValue < (mat[d][e] - mat[a][b]))
                maxValue = mat[d][e] - mat[a][b];
 
    return maxValue;
}
 
// Driver program to test above function
int main()
{
int mat[N][N] = {
                { 1, 2, -1, -4, -20 },
                { -8, -3, 4, 2, 1 },
                { 3, 8, 6, 1, 3 },
                { -4, -1, 1, 7, -6 },
                { 0, -4, 10, -5, 1 }
            };
    cout << "Maximum Value is "
        << findMaxValue(mat);
 
    return 0;
}


Java




// A Naive method to find maximum value of mat1[d][e]
// - ma[a][b] such that d > a and e > b
import java.io.*;
import java.util.*;
  
class GFG
{
    // The function returns maximum value A(d,e) - A(a,b)
    // over all choices of indexes such that both d > a
    // and e > b.
    static int findMaxValue(int N,int mat[][])
    {
        // stores maximum value
        int maxValue = Integer.MIN_VALUE;
      
        // Consider all possible pairs mat[a][b] and
        // mat1[d][e]
        for (int a = 0; a < N - 1; a++)
          for (int b = 0; b < N - 1; b++)
             for (int d = a + 1; d < N; d++)
               for (int e = b + 1; e < N; e++)
                  if (maxValue < (mat[d][e] - mat[a][b]))
                      maxValue = mat[d][e] - mat[a][b];
      
        return maxValue;
    }
      
    // Driver code
    public static void main (String[] args)
    {
        int N = 5;
 
        int mat[][] = {
                      { 1, 2, -1, -4, -20 },
                      { -8, -3, 4, 2, 1 },
                      { 3, 8, 6, 1, 3 },
                      { -4, -1, 1, 7, -6 },
                      { 0, -4, 10, -5, 1 }
                   };
 
        System.out.print("Maximum Value is " +
                         findMaxValue(N,mat));
    }
}
  
// This code is contributed
// by Prakriti Gupta


Python 3




# A Naive method to find maximum
# value of mat[d][e] - mat[a][b]
# such that d > a and e > b
N = 5
 
# The function returns maximum
# value A(d,e) - A(a,b) over
# all choices of indexes such
# that both d > a and e > b.
def findMaxValue(mat):
     
    # stores maximum value
    maxValue = 0
 
    # Consider all possible pairs
    # mat[a][b] and mat[d][e]
    for a in range(N - 1):
        for b in range(N - 1):
            for d in range(a + 1, N):
                for e in range(b + 1, N):
                    if maxValue < int (mat[d][e] -
                                       mat[a][b]):
                        maxValue = int(mat[d][e] -
                                       mat[a][b]);
 
    return maxValue;
 
# Driver Code
mat = [[ 1, 2, -1, -4, -20 ],
       [ -8, -3, 4, 2, 1 ],
       [ 3, 8, 6, 1, 3 ],
       [ -4, -1, 1, 7, -6 ],
       [ 0, -4, 10, -5, 1 ]];
        
print("Maximum Value is " +
       str(findMaxValue(mat)))
       
# This code is contributed
# by ChitraNayal


C#




// A Naive method to find maximum
// value of mat[d][e] - mat[a][b]
// such that d > a and e > b
using System;
class GFG
{
     
    // The function returns
    // maximum value A(d,e) - A(a,b)
    // over all choices of indexes
    // such that both d > a
    // and e > b.
    static int findMaxValue(int N,
                            int [,]mat)
    {
         
        //stores maximum value
        int maxValue = int.MinValue;
     
        // Consider all possible pairs
        // mat[a][b] and mat[d][e]
        for (int a = 0; a< N - 1; a++)
        for (int b = 0; b < N - 1; b++)
            for (int d = a + 1; d < N; d++)
            for (int e = b + 1; e < N; e++)
                if (maxValue < (mat[d, e] -
                                mat[a, b]))
                    maxValue = mat[d, e] -
                               mat[a, b];
 
        return maxValue;
    }
     
    // Driver code
    public static void Main ()
    {
        int N = 5;
 
        int [,]mat = {{1, 2, -1, -4, -20},
                      {-8, -3, 4, 2, 1},
                      {3, 8, 6, 1, 3},
                      {-4, -1, 1, 7, -6},
                      {0, -4, 10, -5, 1}};
        Console.Write("Maximum Value is " +
                      findMaxValue(N,mat));
    }
}
 
// This code is contributed
// by ChitraNayal


PHP




<?php
// A Naive method to find maximum
// value of $mat[d][e] - ma[a][b]
// such that $d > $a and $e > $b
$N = 5;
 
// The function returns maximum
// value A(d,e) - A(a,b) over
// all choices of indexes such
// that both $d > $a and $e > $b.
function findMaxValue(&$mat)
{
    global $N;
     
    // stores maximum value
    $maxValue = PHP_INT_MIN;
 
    // Consider all possible
    // pairs $mat[$a][$b] and
    // $mat[$d][$e]
    for ($a = 0; $a < $N - 1; $a++)
    for ($b = 0; $b < $N - 1; $b++)
        for ($d = $a + 1; $d < $N; $d++)
        for ($e = $b + 1; $e < $N; $e++)
            if ($maxValue < ($mat[$d][$e] -
                             $mat[$a][$b]))
                $maxValue = $mat[$d][$e] -
                            $mat[$a][$b];
 
    return $maxValue;
}
 
// Driver Code
$mat = array(array(1, 2, -1, -4, -20),
             array(-8, -3, 4, 2, 1),
             array(3, 8, 6, 1, 3),
             array(-4, -1, 1, 7, -6),
             array(0, -4, 10, -5, 1));
             
echo "Maximum Value is " .
       findMaxValue($mat);
 
// This code is contributed
// by ChitraNayal
?>


Javascript




<script>
// A Naive method to find maximum value of mat1[d][e]
// - ma[a][b] such that d > a and e > b   
     
    // The function returns maximum value A(d,e) - A(a,b)
    // over all choices of indexes such that both d > a
    // and e > b.
    function findMaxValue(N,mat)
    {
     
        // stores maximum value
        let maxValue = Number.MIN_VALUE;
         
        // Consider all possible pairs mat[a][b] and
        // mat1[d][e]
        for (let a = 0; a < N - 1; a++)
          for (let b = 0; b < N - 1; b++)
             for (let d = a + 1; d < N; d++)
               for (let e = b + 1; e < N; e++)
                  if (maxValue < (mat[d][e] - mat[a][b]))
                      maxValue = mat[d][e] - mat[a][b];
        
        return maxValue;
    }
     
    // Driver code
    let N = 5;
    let mat=[[ 1, 2, -1, -4, -20],[-8, -3, 4, 2, 1],[3, 8, 6, 1, 3],[ -4, -1, 1, 7, -6 ],[ 0, -4, 10, -5, 1 ]];
    document.write("Maximum Value is " +findMaxValue(N,mat));
     
    // This code is contributed by rag2127
</script>


Output

Maximum Value is 18

Time complexity: O(N4).
Auxiliary Space: O(1)

The above program runs in O(n^4) time which is nowhere close to expected time complexity of O(n^2)

An efficient solution uses extra space. We pre-process the matrix such that index(i, j) stores max of elements in matrix from (i, j) to (N-1, N-1) and in the process keeps on updating maximum value found so far. We finally return the maximum value.

Implementation:

C++




// An efficient method to find maximum value of mat[d]
// - ma[a][b] such that c > a and d > b
#include <bits/stdc++.h>
using namespace std;
#define N 5
 
// The function returns maximum value A(c,d) - A(a,b)
// over all choices of indexes such that both c > a
// and d > b.
int findMaxValue(int mat[][N])
{
    //stores maximum value
    int maxValue = INT_MIN;
 
    // maxArr[i][j] stores max of elements in matrix
    // from (i, j) to (N-1, N-1)
    int maxArr[N][N];
 
    // last element of maxArr will be same's as of
    // the input matrix
    maxArr[N-1][N-1] = mat[N-1][N-1];
 
    // preprocess last row
    int maxv = mat[N-1][N-1];  // Initialize max
    for (int j = N - 2; j >= 0; j--)
    {
        if (mat[N-1][j] > maxv)
            maxv = mat[N - 1][j];
        maxArr[N-1][j] = maxv;
    }
 
    // preprocess last column
    maxv = mat[N - 1][N - 1];  // Initialize max
    for (int i = N - 2; i >= 0; i--)
    {
        if (mat[i][N - 1] > maxv)
            maxv = mat[i][N - 1];
        maxArr[i][N - 1] = maxv;
    }
 
    // preprocess rest of the matrix from bottom
    for (int i = N-2; i >= 0; i--)
    {
        for (int j = N-2; j >= 0; j--)
        {
            // Update maxValue
            if (maxArr[i+1][j+1] - mat[i][j] >
                                            maxValue)
                maxValue = maxArr[i + 1][j + 1] - mat[i][j];
 
            // set maxArr (i, j)
            maxArr[i][j] = max(mat[i][j],
                               max(maxArr[i][j + 1],
                                   maxArr[i + 1][j]) );
        }
    }
 
    return maxValue;
}
 
// Driver program to test above function
int main()
{
    int mat[N][N] = {
                      { 1, 2, -1, -4, -20 },
                      { -8, -3, 4, 2, 1 },
                      { 3, 8, 6, 1, 3 },
                      { -4, -1, 1, 7, -6 },
                      { 0, -4, 10, -5, 1 }
                    };
    cout << "Maximum Value is "
         << findMaxValue(mat);
 
    return 0;
}


Java




// An efficient method to find maximum value of mat1[d]
// - ma[a][b] such that c > a and d > b
import java.io.*;
import java.util.*;
  
class GFG
{
    // The function returns maximum value A(c,d) - A(a,b)
    // over all choices of indexes such that both c > a
    // and d > b.
    static int findMaxValue(int N,int mat[][])
    {
        //stores maximum value
        int maxValue = Integer.MIN_VALUE;
      
        // maxArr[i][j] stores max of elements in matrix
        // from (i, j) to (N-1, N-1)
        int maxArr[][] = new int[N][N];
      
        // last element of maxArr will be same's as of
        // the input matrix
        maxArr[N-1][N-1] = mat[N-1][N-1];
      
        // preprocess last row
        int maxv = mat[N-1][N-1];  // Initialize max
        for (int j = N - 2; j >= 0; j--)
        {
            if (mat[N-1][j] > maxv)
                maxv = mat[N - 1][j];
            maxArr[N-1][j] = maxv;
        }
      
        // preprocess last column
        maxv = mat[N - 1][N - 1];  // Initialize max
        for (int i = N - 2; i >= 0; i--)
        {
            if (mat[i][N - 1] > maxv)
                maxv = mat[i][N - 1];
            maxArr[i][N - 1] = maxv;
        }
      
        // preprocess rest of the matrix from bottom
        for (int i = N-2; i >= 0; i--)
        {
            for (int j = N-2; j >= 0; j--)
            {
                // Update maxValue
                if (maxArr[i+1][j+1] - mat[i][j] > maxValue)
                    maxValue = maxArr[i + 1][j + 1] - mat[i][j];
      
                // set maxArr (i, j)
                maxArr[i][j] = Math.max(mat[i][j],
                                   Math.max(maxArr[i][j + 1],
                                       maxArr[i + 1][j]) );
            }
        }
      
        return maxValue;
    }
     
    // Driver code
    public static void main (String[] args)
    {
        int N = 5;
 
        int mat[][] = {
                      { 1, 2, -1, -4, -20 },
                      { -8, -3, 4, 2, 1 },
                      { 3, 8, 6, 1, 3 },
                      { -4, -1, 1, 7, -6 },
                      { 0, -4, 10, -5, 1 }
                   };
 
        System.out.print("Maximum Value is " +
                           findMaxValue(N,mat));
    }
}
  
// Contributed by Prakriti Gupta


Python3




# An efficient method to find maximum value
# of mat[d] - ma[a][b] such that c > a and d > b
 
import sys
N = 5
 
# The function returns maximum value
# A(c,d) - A(a,b) over all choices of
# indexes such that both c > a and d > b.
def findMaxValue(mat):
 
    # stores maximum value
    maxValue = -sys.maxsize -1
 
    # maxArr[i][j] stores max of elements
    # in matrix from (i, j) to (N-1, N-1)
    maxArr = [[0 for x in range(N)]
                 for y in range(N)]
 
    # last element of maxArr will be
    # same's as of the input matrix
    maxArr[N - 1][N - 1] = mat[N - 1][N - 1]
 
    # preprocess last row
    maxv = mat[N - 1][N - 1]; # Initialize max
    for j in range (N - 2, -1, -1):
     
        if (mat[N - 1][j] > maxv):
            maxv = mat[N - 1][j]
        maxArr[N - 1][j] = maxv
     
    # preprocess last column
    maxv = mat[N - 1][N - 1] # Initialize max
    for i in range (N - 2, -1, -1):
     
        if (mat[i][N - 1] > maxv):
            maxv = mat[i][N - 1]
        maxArr[i][N - 1] = maxv
 
    # preprocess rest of the matrix
    # from bottom
    for i in range (N - 2, -1, -1):
     
        for j in range (N - 2, -1, -1):
         
            # Update maxValue
            if (maxArr[i + 1][j + 1] -
                mat[i][j] > maxValue):
                maxValue = (maxArr[i + 1][j + 1] -
                                       mat[i][j])
 
            # set maxArr (i, j)
            maxArr[i][j] = max(mat[i][j],
                           max(maxArr[i][j + 1],
                               maxArr[i + 1][j]))
         
    return maxValue
 
# Driver Code
mat = [[ 1, 2, -1, -4, -20 ],
       [-8, -3, 4, 2, 1 ],
       [ 3, 8, 6, 1, 3 ],
       [ -4, -1, 1, 7, -6] ,
       [0, -4, 10, -5, 1 ]]
                     
print ("Maximum Value is",
        findMaxValue(mat))
 
# This code is contributed by iAyushRaj


C#




// An efficient method to find
// maximum value of mat1[d]
// - ma[a][b] such that c > a
// and d > b
using System;
class GFG  {
     
    // The function returns
    // maximum value A(c,d) - A(a,b)
    // over all choices of indexes
    // such that both c > a
    // and d > b.
    static int findMaxValue(int N, int [,]mat)
    {
         
        //stores maximum value
        int maxValue = int.MinValue;
     
        // maxArr[i][j] stores max
        // of elements in matrix
        // from (i, j) to (N-1, N-1)
        int [,]maxArr = new int[N, N];
     
        // last element of maxArr
        // will be same's as of
        // the input matrix
        maxArr[N - 1, N - 1] = mat[N - 1,N - 1];
     
        // preprocess last row
         // Initialize max
        int maxv = mat[N - 1, N - 1];
        for (int j = N - 2; j >= 0; j--)
        {
            if (mat[N - 1, j] > maxv)
                maxv = mat[N - 1, j];
            maxArr[N - 1, j] = maxv;
        }
     
        // preprocess last column
        // Initialize max
        maxv = mat[N - 1,N - 1];
        for (int i = N - 2; i >= 0; i--)
        {
            if (mat[i, N - 1] > maxv)
                maxv = mat[i,N - 1];
            maxArr[i,N - 1] = maxv;
        }
     
        // preprocess rest of the
        // matrix from bottom
        for (int i = N - 2; i >= 0; i--)
        {
            for (int j = N - 2; j >= 0; j--)
            {
                 
                // Update maxValue
                if (maxArr[i + 1,j + 1] -
                     mat[i, j] > maxValue)
                    maxValue = maxArr[i + 1,j + 1] -
                                         mat[i, j];
     
                // set maxArr (i, j)
                maxArr[i,j] = Math.Max(mat[i, j],
                              Math.Max(maxArr[i, j + 1],
                              maxArr[i + 1, j]) );
            }
        }
     
        return maxValue;
    }
     
    // Driver code
    public static void Main ()
    {
        int N = 5;
 
        int [,]mat = {{ 1, 2, -1, -4, -20 },
                      { -8, -3, 4, 2, 1 },
                      { 3, 8, 6, 1, 3 },
                      { -4, -1, 1, 7, -6 },
                      { 0, -4, 10, -5, 1 }};
        Console.Write("Maximum Value is " +
                        findMaxValue(N,mat));
    }
}
 
// This code is contributed by nitin mittal.


PHP




<?php
// An efficient method to find
// maximum value of mat[d] - ma[a][b]
// such that c > a and d > b
$N = 5;
 
// The function returns maximum
// value A(c,d) - A(a,b) over
// all choices of indexes such
// that both c > a and d > b.
function findMaxValue($mat)
{
    global $N;
     
    // stores maximum value
    $maxValue = PHP_INT_MIN;
 
    // maxArr[i][j] stores max
    // of elements in matrix
    // from (i, j) to (N-1, N-1)
    $maxArr[$N][$N] = array();
 
    // last element of maxArr
    // will be same's as of
    // the input matrix
    $maxArr[$N - 1][$N - 1] = $mat[$N - 1][$N - 1];
 
    // preprocess last row
    $maxv = $mat[$N - 1][$N - 1]; // Initialize max
    for ($j = $N - 2; $j >= 0; $j--)
    {
        if ($mat[$N - 1][$j] > $maxv)
            $maxv = $mat[$N - 1][$j];
        $maxArr[$N - 1][$j] = $maxv;
    }
 
    // preprocess last column
    $maxv = $mat[$N - 1][$N - 1]; // Initialize max
    for ($i = $N - 2; $i >= 0; $i--)
    {
        if ($mat[$i][$N - 1] > $maxv)
            $maxv = $mat[$i][$N - 1];
        $maxArr[$i][$N - 1] = $maxv;
    }
 
    // preprocess rest of the
    // matrix from bottom
    for ($i = $N - 2; $i >= 0; $i--)
    {
        for ($j = $N - 2; $j >= 0; $j--)
        {
            // Update maxValue
            if ($maxArr[$i + 1][$j + 1] -
                $mat[$i][$j] > $maxValue)
                $maxValue = $maxArr[$i + 1][$j + 1] -
                            $mat[$i][$j];
 
            // set maxArr (i, j)
            $maxArr[$i][$j] = max($mat[$i][$j],
                              max($maxArr[$i][$j + 1],
                                  $maxArr[$i + 1][$j]));
        }
    }
 
    return $maxValue;
}
 
// Driver Code
$mat = array(array(1, 2, -1, -4, -20),
             array(-8, -3, 4, 2, 1),
             array(3, 8, 6, 1, 3),
             array(-4, -1, 1, 7, -6),
             array(0, -4, 10, -5, 1)
                    );
echo "Maximum Value is ".
      findMaxValue($mat);
 
// This code is contributed
// by ChitraNayal
?>


Javascript




<script>
// An efficient method to find maximum value of mat1[d]
// - ma[a][b] such that c > a and d > b
     
    // The function returns maximum value A(c,d) - A(a,b)
    // over all choices of indexes such that both c > a
    // and d > b.
    function findMaxValue(N,mat)
    {
     
        // stores maximum value
        let maxValue = Number.MIN_VALUE;
       
        // maxArr[i][j] stores max of elements in matrix
        // from (i, j) to (N-1, N-1)
        let maxArr=new Array(N);
        for(let i = 0; i < N; i++)
        {
            maxArr[i]=new Array(N);
        }
         
        // last element of maxArr will be same's as of
        // the input matrix
        maxArr[N - 1][N - 1] = mat[N - 1][N - 1];
       
        // preprocess last row
        let maxv = mat[N-1][N-1];  // Initialize max
        for (let j = N - 2; j >= 0; j--)
        {
            if (mat[N - 1][j] > maxv)
                maxv = mat[N - 1][j];
            maxArr[N - 1][j] = maxv;
        }
       
        // preprocess last column
        maxv = mat[N - 1][N - 1];  // Initialize max
        for (let i = N - 2; i >= 0; i--)
        {
            if (mat[i][N - 1] > maxv)
                maxv = mat[i][N - 1];
            maxArr[i][N - 1] = maxv;
        }
       
        // preprocess rest of the matrix from bottom
        for (let i = N-2; i >= 0; i--)
        {
            for (let j = N-2; j >= 0; j--)
            {
             
                // Update maxValue
                if (maxArr[i+1][j+1] - mat[i][j] > maxValue)
                    maxValue = maxArr[i + 1][j + 1] - mat[i][j];
       
                // set maxArr (i, j)
                maxArr[i][j] = Math.max(mat[i][j],
                                   Math.max(maxArr[i][j + 1],
                                       maxArr[i + 1][j]) );
            }
        }
       
        return maxValue;
    }
     
    // Driver code
    let N = 5;
    let mat = [[ 1, 2, -1, -4, -20 ],
           [-8, -3, 4, 2, 1 ],
           [ 3, 8, 6, 1, 3 ],
           [ -4, -1, 1, 7, -6] ,
           [0, -4, 10, -5, 1 ]];
    document.write("Maximum Value is " +
                           findMaxValue(N,mat));
           
     
    // This code is contributed by avanitrachhadiya2155
</script>


Output

Maximum Value is 18

Time complexity: O(N2).
Auxiliary Space: O(N2)

If we are allowed to modify of the matrix, we can avoid using extra space and use input matrix instead.

Exercise: Print index (a, b) and (c, d) as well.

An optimal approach is with space complexity O(N).

Instead of using the maxArr matrix, we can use two separate vectors (temp1 and temp2) to get maxArr[i+1][j] and maxArr[i][j+1] values.

C++




// An optimal method to find maximum value of mat[d]
// - ma[a][b] such that c > a and d > b
#include <bits/stdc++.h>
using namespace std;
#define N 5
 
// The function returns maximum value A(c,d) - A(a,b)
// over all choices of indexes such that both c > a
// and d > b.
int findMaxValue(int mat[][N])
{
    vector<int> temp1(N), temp2(N);
    temp1[N - 1] = mat[N - 1][N - 1];
 
    // Fill temp1
    for (int j = N - 2; j >= 0; j--)
        temp1[j] = max(temp1[j + 1], mat[N - 1][j]);
 
    // stores maximum value
    int maxValue = INT_MIN;
 
    // Iterate over the remaining rows
    for (int i = N - 2; i >= 0; i--) {
        // Initialize the last element of temp2
        temp2[N - 1] = max(temp1[N - 1], mat[i][N - 1]);
        for (int j = N - 2; j >= 0; j--) {
            // update temp2 and maxValue
            maxValue
                = max(maxValue, temp1[j + 1] - mat[i][j]);
            temp2[j] = max(
                { mat[i][j], temp1[j], temp2[j + 1] });
        }
        // Set temp1 to temp2 for the next iteration
        temp1 = temp2;
    }
 
    // Return the maximum value
    return maxValue;
}
 
// Driver program to test above function
int main()
{
    int mat[N][N] = { { 1, 2, -1, -4, -20 },
                      { -8, -3, 4, 2, 1 },
                      { 3, 8, 6, 1, 3 },
                      { -4, -1, 1, 7, -6 },
                      { 0, -4, 10, -5, 1 } };
    cout << "Maximum Value is " << findMaxValue(mat);
 
    return 0;
}
 
// This code is contributed by Tapesh(tapeshdua420)


Output

Maximum Value is 18

The time complexity of the findMaxValue() function is O(N^2) because it iterates over each element of the matrix exactly once.

The space complexity of the function is O(N) because it uses two vectors of size N (temp1 and temp2) to store the maximum values seen so far in each row and column.

This article is contributed by Aarti_Rathi and Aditya Goel. If you like neveropen and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the neveropen main page and help other Geeks.

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments