Skip to content
Related Articles

Related Articles

Check if the given matrix is increasing row and column wise
  • Last Updated : 27 Apr, 2021

Given a matrix mat[][], the task is to check if the given matrix is strictly increasing or not. A matrix is said to be strictly increasing if all of its rows as well as all of its columns are strictly increasing.
Examples: 
 

Input: mat[][] = {{2, 10}, {11, 20}} 
Output: Yes 
All the rows and columns are strictly increasing.
Input: mat[][] = {{2, 1}, {11, 20}} 
Output: No 
First row doesn’t satisfy the required condition. 
 

 

Approach: Linearly traverse for every element and check if there are increasing row-wise and column-wise or not. The two conditions are (a[i][j] > a[i – 1][j]) and (a[i][j] > a[i][j – 1]) . If any of the two conditions fail, then the matrix is not strictly increasing. 
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define N 2
#define M 2
 
// Function that returns true if the matrix
// is strictly increasing
bool isMatrixInc(int a[N][M])
{
 
    // Check if the matrix
    // is strictly increasing
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
 
            // Out of bound condition
            if (i - 1 >= 0) {
                if (a[i][j] <= a[i - 1][j])
                    return false;
            }
 
            // Out of bound condition
            if (j - 1 >= 0) {
                if (a[i][j] <= a[i][j - 1])
                    return false;
            }
        }
    }
 
    return true;
}
 
// Driver code
int main()
{
 
    int a[N][M] = { { 2, 10 },
                    { 11, 20 } };
 
    if (isMatrixInc(a))
        cout << "Yes";
    else
        cout << "No";
 
    return 0;
}

Java




// Java implementation of the approach
import java.io.*;
 
class GFG
{
 
static int N = 2;
static int M = 2;
 
// Function that returns true if the matrix
// is strictly increasing
static boolean isMatrixInc(int a[][])
{
 
    // Check if the matrix
    // is strictly increasing
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
 
            // Out of bound condition
            if (i - 1 >= 0)
            {
                if (a[i][j] <= a[i - 1][j])
                    return false;
            }
 
            // Out of bound condition
            if (j - 1 >= 0)
            {
                if (a[i][j] <= a[i][j - 1])
                    return false;
            }
        }
    }
 
    return true;
}
 
// Driver code
 
public static void main (String[] args)
{
     
    int a[][] = { { 2, 10 },
                    { 11, 20 } };
     
    if (isMatrixInc(a))
        System.out.print( "Yes");
    else
        System.out.print( "No");
}
}
 
// This code is contributed by anuj_67..

Python3




# Python3 implementation of the approach
 
N, M = 2, 2
 
# Function that returns true if the matrix
# is strictly increasing
def isMatrixInc(a) :
 
    # Check if the matrix
    # is strictly increasing
    for i in range(N) :
        for j in range(M) :
 
            # Out of bound condition
            if (i - 1 >= 0) :
                if (a[i][j] <= a[i - 1][j]) :
                    return False;
 
            # Out of bound condition
            if (j - 1 >= 0) :
                if (a[i][j] <= a[i][j - 1]) :
                    return False;
                     
    return True;
 
 
# Driver code
if __name__ == "__main__" :
 
    a = [ [ 2, 10 ],
        [11, 20 ] ];
 
    if (isMatrixInc(a)) :
        print("Yes");
    else :
        print("No");
         
# This code is contributed by AnkitRai01

C#




// C# implementation of the approach
using System;
     
class GFG
{
 
static int N = 2;
static int M = 2;
 
// Function that returns true if the matrix
// is strictly increasing
static Boolean isMatrixInc(int [,]a)
{
 
    // Check if the matrix
    // is strictly increasing
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < M; j++)
        {
 
            // Out of bound condition
            if (i - 1 >= 0)
            {
                if (a[i,j] <= a[i - 1,j])
                    return false;
            }
 
            // Out of bound condition
            if (j - 1 >= 0)
            {
                if (a[i,j] <= a[i,j - 1])
                    return false;
            }
        }
    }
 
    return true;
}
 
// Driver code
public static void Main (String[] args)
{
     
    int [,]a = { { 2, 10 },
                    { 11, 20 } };
     
    if (isMatrixInc(a))
        Console.WriteLine( "Yes");
    else
        Console.WriteLine( "No");
}
}
 
// This code is contributed by Princi Singh

Javascript




<script>
// Java Script implementation of the approach
let N = 2;
let M = 2;
 
// Function that returns true if the matrix
// is strictly increasing
function isMatrixInc(a)
{
 
    // Check if the matrix
    // is strictly increasing
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < M; j++)
        {
 
            // Out of bound condition
            if (i - 1 >= 0)
            {
                if (a[i][j] <= a[i - 1][j])
                    return false;
            }
 
            // Out of bound condition
            if (j - 1 >= 0)
            {
                if (a[i][j] <= a[i][j - 1])
                    return false;
            }
        }
    }
 
    return true;
}
 
// Driver code
 
 
     
    let a = [[2, 10 ],
                    [ 11, 20 ]];
     
    if (isMatrixInc(a))
        document.write( "Yes");
    else
        document.write( "No");
 
// This code is contributed by sravan kumar
</script>
Output: 
Yes

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :