Telle nuller på rad klokt og kolonnemessig sortert matrise

Gitt en n x n binær matrise (elementer i matrise kan være enten 1 eller 0) der hver rad og kolonne i matrisen er sortert i stigende ordreantall nummer 0s til stede i den.

Eksempler:  

:
[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]
Produksjon: 8

:
[0 0]
[0 0]
Produksjon: 4

:
[1 1 1 1]
[1 1 1 1]
[1 1 1 1]
[1 1 1 1]
Produksjon:

Ideen er veldig enkel. Vi starter fra hjørnet av matrisen nederste venstre og gjentar trinn under til vi finner toppen eller høyre kant av matrisen.

  1. Decrement Row Index til vi finner en 0. 
  2. Legg til nummer på 0s i gjeldende kolonne, dvs. gjeldende radindeks + 1 til resultatet og flytt til høyre til neste kolonne (Increment Col Index med 1).

Ovennevnte logikk vil fungere siden matrisen er radmessig og kolonnemessig sortert. Logikken vil også fungere for enhver matrise som inneholder ikke-negative heltall.

Nedenfor er implementeringen av ideen ovenfor:

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

Produksjon
8 

Tidskompleksitet av løsningen ovenfor er o (n) siden løsningen følger en stie fra venstre hjørne til toppen eller høyre kant av matrisen. 
Hjelpeplass Brukt av programmet er O (1). siden det ikke er tatt ekstra plass.