Compruebe si la array dada está aumentando en filas y columnas

Dada una array mat[][] , la tarea es verificar si la array dada es estrictamente creciente o no. Se dice que una array es estrictamente creciente si todas sus filas y todas sus columnas son estrictamente crecientes.
Ejemplos: 
 

Entrada: mat[][] = {{2, 10}, {11, 20}} 
Salida: Sí 
Todas las filas y columnas son estrictamente crecientes.
Entrada: mat[][] = {{2, 1}, {11, 20}} 
Salida: No 
La primera fila no cumple la condición requerida. 
 

Enfoque: recorrido lineal para cada elemento y verifique si hay un aumento en las filas y las columnas o no. Las dos condiciones son (a[i][j] > a[i – 1][j]) y (a[i][j] > a[i][j – 1]) . Si alguna de las dos condiciones falla, entonces la array no es estrictamente creciente. 
A continuación se muestra la implementación del enfoque anterior: 
 

// 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 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 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# 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

<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>

Yes

Complejidad temporal: O(N*M)
Espacio auxiliar: O(1)