Tel nullen in een rij- en kolomsgewijs gesorteerde matrix

Gegeven een n x n binaire matrix (elementen in de matrix kunnen 1 of 0 zijn) waarbij elke rij en kolom van de matrix in oplopende volgorde is gesorteerd, tel dan het aantal nullen dat daarin aanwezig is.

Voorbeelden:  

Invoer:
[0 0 0 0 1]
[0 0 0 1 1]
[0 1 1 1 1]
[1 1 1 1 1]
[1 1 1 1 1]
Uitgang: 8

Invoer:
[0 0]
[0 0]
Uitgang: 4

Invoer:
[1 1 1 1]
[1 1 1 1]
[1 1 1 1]
[1 1 1 1]
Uitgang:

Het idee is heel eenvoudig. We beginnen vanuit de linkerbenedenhoek van de matrix en herhalen de onderstaande stappen totdat we de boven- of rechterrand van de matrix vinden.

  1. Verlaag de rij-index totdat we een 0 vinden. 
  2. Voeg het aantal nullen toe in de huidige kolom, dat wil zeggen de huidige rijindex + 1, aan het resultaat en ga naar rechts naar de volgende kolom (verhoog de colindex met 1).

De bovenstaande logica werkt omdat de matrix rijsgewijs en kolomsgewijs is gesorteerd. De logica werkt ook voor elke matrix die niet-negatieve gehele getallen bevat.

Hieronder ziet u de implementatie van bovenstaand idee:

C++
   #include          #include         using     namespace     std  ;   // Function to count number of 0s in the given   // row-wise and column-wise sorted binary matrix.   int     countZeroes  (  const     vector   <  vector   <  int  >>&     mat  )     {      int     n     =     mat  .  size  ();             // start from the bottom-left corner      int     row     =     n     -     1       col     =     0  ;      int     count     =     0  ;         while     (  col      <     n  )     {          // move up until you find a 0      while     (  row     >=     0     &&     mat  [  row  ][  col  ])     {      row  --  ;      }      // add the number of 0s in the current      // column to the result      count     +=     (  row     +     1  );      // move to the next column      col  ++  ;      }      return     count  ;   }   int     main  ()     {      vector   <  vector   <  int  >>     mat     =     {      {     0       0       0       0       1     }      {     0       0       0       1       1     }      {     0       1       1       1       1     }      {     1       1       1       1       1     }      {     1       1       1       1       1     }      };      cout      < <     countZeroes  (  mat  );      return     0  ;   }   
C
   // C program to count number of 0s in the given   // row-wise and column-wise sorted binary matrix.   #include         // define size of square matrix   #define N 5   // Function to count number of 0s in the given   // row-wise and column-wise sorted binary matrix.   int     countZeroes  (  int     mat  [  N  ][  N  ])   {      // start from bottom-left corner of the matrix      int     row     =     N     -     1       col     =     0  ;      // stores number of zeroes in the matrix      int     count     =     0  ;      while     (  col      <     N  )      {      // move up until you find a 0      while     (  mat  [  row  ][  col  ])      // if zero is not found in current column      // we are done      if     (  --  row      <     0  )      return     count  ;      // add 0s present in current column to result      count     +=     (  row     +     1  );      // move right to next column      col  ++  ;      }      return     count  ;   }   // Driver Program to test above functions   int     main  ()   {      int     mat  [  N  ][  N  ]     =      {      {     0       0       0       0       1     }      {     0       0       0       1       1     }      {     0       1       1       1       1     }      {     1       1       1       1       1     }      {     1       1       1       1       1     }      };          printf  (  '%d'    countZeroes  (  mat  ));      return     0  ;   }   
Java
   import     java.util.Arrays  ;   public     class   GfG     {          // Function to count number of 0s in the given      // row-wise and column-wise sorted binary matrix.      public     static     int     countZeroes  (  int  [][]     mat  )     {      int     n     =     mat  .  length  ;          // start from the bottom-left corner      int     row     =     n     -     1       col     =     0  ;      int     count     =     0  ;      while     (  col      <     n  )     {          // move up until you find a 0      while     (  row     >=     0     &&     mat  [  row  ][  col  ]     ==     1  )     {      row  --  ;      }      // add the number of 0s in the current      // column to the result      count     +=     (  row     +     1  );      // move to the next column      col  ++  ;      }      return     count  ;      }      public     static     void     main  (  String  []     args  )     {      int  [][]     mat     =     {      {     0       0       0       0       1     }      {     0       0       0       1       1     }      {     0       1       1       1       1     }      {     1       1       1       1       1     }      {     1       1       1       1       1     }      };      System  .  out  .  println  (  countZeroes  (  mat  ));      }   }   
Python
   # Function to count number of 0s in the given   # row-wise and column-wise sorted binary matrix.   def   count_zeroes  (  mat  ):   n   =   len  (  mat  )   # start from the bottom-left corner   row   =   n   -   1   col   =   0   count   =   0   while   col    <   n  :   # move up until you find a 0   while   row   >=   0   and   mat  [  row  ][  col  ]:   row   -=   1   # add the number of 0s in the current   # column to the result   count   +=   (  row   +   1  )   # move to the next column   col   +=   1   return   count   if   __name__   ==   '__main__'  :   mat   =   [   [  0     0     0     0     1  ]   [  0     0     0     1     1  ]   [  0     1     1     1     1  ]   [  1     1     1     1     1  ]   [  1     1     1     1     1  ]   ]   print  (  count_zeroes  (  mat  ))   
C#
   // Function to count number of 0s in the given   // row-wise and column-wise sorted binary matrix.   using     System  ;   using     System.Collections.Generic  ;   class     Program     {      static     int     CountZeroes  (  int  []     mat  )     {      int     n     =     mat  .  GetLength  (  0  );          // start from the bottom-left corner      int     row     =     n     -     1       col     =     0  ;      int     count     =     0  ;      while     (  col      <     n  )     {          // move up until you find a 0      while     (  row     >=     0     &&     mat  [  row       col  ]     ==     1  )     {      row  --  ;      }          // add the number of 0s in the current      // column to the result      count     +=     (  row     +     1  );          // move to the next column      col  ++  ;      }      return     count  ;      }      static     void     Main  ()     {      int  []     mat     =     {      {     0       0       0       0       1     }      {     0       0       0       1       1     }      {     0       1       1       1       1     }      {     1       1       1       1       1     }      {     1       1       1       1       1     }      };      Console  .  WriteLine  (  CountZeroes  (  mat  ));      }   }   
JavaScript
   // Function to count number of 0s in the given   // row-wise and column-wise sorted binary matrix.   function     countZeroes  (  mat  )     {      const     n     =     mat  .  length  ;          // start from the bottom-left corner      let     row     =     n     -     1       col     =     0  ;      let     count     =     0  ;      while     (  col      <     n  )     {          // move up until you find a 0      while     (  row     >=     0     &&     mat  [  row  ][  col  ])     {      row  --  ;      }          // add the number of 0s in the current      // column to the result      count     +=     (  row     +     1  );          // move to the next column      col  ++  ;      }      return     count  ;   }   const     mat     =     [      [  0       0       0       0       1  ]      [  0       0       0       1       1  ]      [  0       1       1       1       1  ]      [  1       1       1       1       1  ]      [  1       1       1       1       1  ]   ];   console  .  log  (  countZeroes  (  mat  ));   

Uitvoer
8 

Tijdcomplexiteit van de bovenstaande oplossing is O(n), aangezien de oplossing een enkel pad volgt van de linkerbenedenhoek naar de boven- of rechterrand van de matrix. 
Hulpruimte gebruikt door het programma is O(1). omdat er geen extra ruimte is ingenomen.