Највећи плус или '+' формиран од свих јединица у бинарној квадратној матрици

Највећи плус или '+' формиран од свих јединица у бинарној квадратној матрици

С обзиром на ан н × н бинарна матрица заједно са који се састоји од и . Ваш задатак је да пронађете величину највеће '+' облик који се може формирати само помоћу .

знак плус

А '+' облик се састоји од централне ћелије са четири крака који се пружају у сва четири правца ( горе доле лево и десно ) док остаје унутар граница матрице. Величина а '+' се дефинише као укупан број ћелија формирајући га укључујући центар и све кракове.

Задатак је вратити максимална величина било каквог важећег '+' ин заједно са . Ако не '+' може се формирати поврат .

Примери:

Улаз: са = [ [0 1 1 0 1] [0 0 1 1 1] [1 1 1 1 1] [1 1 1 0 1] [0 1 1 1 0] ]
Излаз: 9
Објашњење: „+“ са дужином руке од 2 (2 ћелије у сваком правцу + 1 центар) може се формирати у центру простирке.
0 1 1 0 1
0 0 1 1 1
1 1 1 1 1
1 1 1 0 1
0 1 1 1 0
Укупна величина = (2 × 4) + 1 = 9

Улаз: са = [ [0 1 1] [0 0 1] [1 1 1] ]
Излаз: 1
Објашњење: „+“ са дужином руке од 0 (0 ћелија у сваком правцу + 1 центар) може се формирати са било којом од 1.

Улаз: са = [ [0] ]
Излаз:
Објашњење: бр Знак „+“ се може формирати.

[Наивни приступ] - Сматрајте сваку тачку као центар - О(н^4) Време и О(н^4) простор

Прођите кроз ћелије матрикса једну по једну. Сматрајте сваку пређену тачку као центар плуса и пронађите величину +. За сваки елемент прелазимо лево десно доле и горе. Најгори случај у овом решењу се дешава када имамо све 1.

[Очекивани приступ] - Прерачунај 4 низа - О(н^2) Време и О(н^2) простор

Тхе идеја је одржавање четири помоћне матрице лево[][] десно[][] горе[][] доле[][] за чување узастопних 1 у сваком правцу. За сваку ћелију (и ј) у улазној матрици чувамо информације испод у њима четири матрице -

  • лево (и ј) чува максималан број узастопних 1 у лево ћелије (и ј) укључујући ћелију (и ј).
  • десно (и ј) чува максималан број узастопних 1 у право ћелије (и ј) укључујући ћелију (и ј).
  • врх (и ј) чува максималан број узастопних 1 на топ ћелије (и ј) укључујући ћелију (и ј).
  • дно (и ј) чува максималан број узастопних 1 на дну ћелије (и ј) укључујући ћелију (и ј).

Након израчунавања вредности за сваку ћелију горњих матрица највећи'+' би био формиран од ћелије улазне матрице која има максималну вредност узимајући у обзир минимум ( лево (и ј) десно (и ј) горе (и ј) доле (и ј) )

Можемо користити Динамичко програмирање да се израчуна укупан износ узастопних јединица у сваком правцу:

ако је мат(и ј) == 1
лево (и ј) = лево (и ј - 1) + 1

остало лево (и ј) = 0


ако је мат(и ј) == 1
топ(и ј) = топ(и - 1 ј) + 1;

иначе топ(и ј) = 0;


ако је мат(и ј) == 1
боттом(и ј) = боттом(и + 1 ј) + 1;

иначе боттом(и ј) = 0;


ако је мат(и ј) == 1
десно (и ј) = десно (и ј + 1) + 1;

иначе десно(и ј) = 0;

Испод је примена горњег приступа:

C++
   // C++ program to find the largest '+' in a binary matrix   // using Dynamic Programming   #include          using     namespace     std  ;   int     findLargestPlus  (  vector   <  vector   <  int  >>     &  mat  )     {          int     n     =     mat  .  size  ();          vector   <  vector   <  int  >>     left  (  n       vector   <  int  >  (  n       0  ));      vector   <  vector   <  int  >>     right  (  n       vector   <  int  >  (  n       0  ));      vector   <  vector   <  int  >>     top  (  n       vector   <  int  >  (  n       0  ));      vector   <  vector   <  int  >>     bottom  (  n       vector   <  int  >  (  n       0  ));          // Fill left and top matrices      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      left  [  i  ][  j  ]     =     (  j     ==     0  )     ?     1     :     left  [  i  ][  j     -     1  ]     +     1  ;      top  [  i  ][  j  ]     =     (  i     ==     0  )     ?     1     :     top  [  i     -     1  ][  j  ]     +     1  ;      }      }      }          // Fill right and bottom matrices      for     (  int     i     =     n     -     1  ;     i     >=     0  ;     i  --  )     {      for     (  int     j     =     n     -     1  ;     j     >=     0  ;     j  --  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      right  [  i  ][  j  ]     =     (  j     ==     n     -     1  )     ?     1     :     right  [  i  ][  j     +     1  ]     +     1  ;      bottom  [  i  ][  j  ]     =     (  i     ==     n     -     1  )     ?     1     :     bottom  [  i     +     1  ][  j  ]     +     1  ;      }      }      }          int     maxPlusSize     =     0  ;          // Compute the maximum '+' size      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      int     armLength     =     min  ({  left  [  i  ][  j  ]     right  [  i  ][  j  ]      top  [  i  ][  j  ]     bottom  [  i  ][  j  ]});          maxPlusSize     =     max  (  maxPlusSize        (  4     *     (  armLength     -     1  ))     +     1  );      }      }      }          return     maxPlusSize  ;   }   int     main  ()     {          // Hardcoded input matrix      vector   <  vector   <  int  >>     mat     =     {      {  0       1       1       0       1  }      {  0       0       1       1       1  }      {  1       1       1       1       1  }      {  1       1       1       0       1  }      {  0       1       1       1       0  }      };          cout      < <     findLargestPlus  (  mat  )      < <     endl  ;      return     0  ;   }   
Java
   // Java program to find the largest '+' in a binary matrix   // using Dynamic Programming   class   GfG     {          static     int     findLargestPlus  (  int  [][]     mat  )     {          int     n     =     mat  .  length  ;          int  [][]     left     =     new     int  [  n  ][  n  ]  ;      int  [][]     right     =     new     int  [  n  ][  n  ]  ;      int  [][]     top     =     new     int  [  n  ][  n  ]  ;      int  [][]     bottom     =     new     int  [  n  ][  n  ]  ;          // Fill left and top matrices      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      left  [  i  ][  j  ]     =     (  j     ==     0  )     ?     1     :     left  [  i  ][  j     -     1  ]     +     1  ;      top  [  i  ][  j  ]     =     (  i     ==     0  )     ?     1     :     top  [  i     -     1  ][  j  ]     +     1  ;      }      }      }          // Fill right and bottom matrices      for     (  int     i     =     n     -     1  ;     i     >=     0  ;     i  --  )     {      for     (  int     j     =     n     -     1  ;     j     >=     0  ;     j  --  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      right  [  i  ][  j  ]     =     (  j     ==     n     -     1  )     ?     1     :     right  [  i  ][  j     +     1  ]     +     1  ;      bottom  [  i  ][  j  ]     =     (  i     ==     n     -     1  )     ?     1     :     bottom  [  i     +     1  ][  j  ]     +     1  ;      }      }      }          int     maxPlusSize     =     0  ;          // Compute the maximum '+' size      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ==     1  )     {      int     armLength     =     Math  .  min  (  Math  .  min  (  left  [  i  ][  j  ]       right  [  i  ][  j  ]  )      Math  .  min  (  top  [  i  ][  j  ]       bottom  [  i  ][  j  ]  ));          maxPlusSize     =     Math  .  max  (  maxPlusSize        (  4     *     (  armLength     -     1  ))     +     1  );      }      }      }          return     maxPlusSize  ;      }      public     static     void     main  (  String  []     args  )     {          // Hardcoded input matrix      int  [][]     mat     =     {      {  0       1       1       0       1  }      {  0       0       1       1       1  }      {  1       1       1       1       1  }      {  1       1       1       0       1  }      {  0       1       1       1       0  }      };          System  .  out  .  println  (  findLargestPlus  (  mat  ));      }   }   
Python
   # Python program to find the largest '+' in a binary matrix   # using Dynamic Programming   def   findLargestPlus  (  mat  ):   n   =   len  (  mat  )   left   =   [[  0  ]   *   n   for   i   in   range  (  n  )]   right   =   [[  0  ]   *   n   for   i   in   range  (  n  )]   top   =   [[  0  ]   *   n   for   i   in   range  (  n  )]   bottom   =   [[  0  ]   *   n   for   i   in   range  (  n  )]   # Fill left and top matrices   for   i   in   range  (  n  ):   for   j   in   range  (  n  ):   if   mat  [  i  ][  j  ]   ==   1  :   left  [  i  ][  j  ]   =   1   if   j   ==   0   else   left  [  i  ][  j   -   1  ]   +   1   top  [  i  ][  j  ]   =   1   if   i   ==   0   else   top  [  i   -   1  ][  j  ]   +   1   # Fill right and bottom matrices   for   i   in   range  (  n   -   1     -  1     -  1  ):   for   j   in   range  (  n   -   1     -  1     -  1  ):   if   mat  [  i  ][  j  ]   ==   1  :   right  [  i  ][  j  ]   =   1   if   j   ==   n   -   1   else   right  [  i  ][  j   +   1  ]   +   1   bottom  [  i  ][  j  ]   =   1   if   i   ==   n   -   1   else   bottom  [  i   +   1  ][  j  ]   +   1   maxPlusSize   =   0   # Compute the maximum '+' size   for   i   in   range  (  n  ):   for   j   in   range  (  n  ):   if   mat  [  i  ][  j  ]   ==   1  :   armLength   =   min  (  left  [  i  ][  j  ]   right  [  i  ][  j  ]   top  [  i  ][  j  ]   bottom  [  i  ][  j  ])   maxPlusSize   =   max  (  maxPlusSize     (  4   *   (  armLength   -   1  ))   +   1  )   return   maxPlusSize   if   __name__   ==   '__main__'  :   # Hardcoded input matrix   mat   =   [   [  0     1     1     0     1  ]   [  0     0     1     1     1  ]   [  1     1     1     1     1  ]   [  1     1     1     0     1  ]   [  0     1     1     1     0  ]   ]   print  (  findLargestPlus  (  mat  ))   
C#
   // C# program to find the largest '+' in a binary matrix   // using Dynamic Programming   using     System  ;   class     GfG     {          static     int     FindLargestPlus  (  int  []     mat  )     {          int     n     =     mat  .  GetLength  (  0  );          int  []     left     =     new     int  [  n       n  ];      int  []     right     =     new     int  [  n       n  ];      int  []     top     =     new     int  [  n       n  ];      int  []     bottom     =     new     int  [  n       n  ];          // Fill left and top matrices      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i       j  ]     ==     1  )     {      left  [  i       j  ]     =     (  j     ==     0  )     ?     1     :     left  [  i       j     -     1  ]     +     1  ;      top  [  i       j  ]     =     (  i     ==     0  )     ?     1     :     top  [  i     -     1       j  ]     +     1  ;      }      }      }          // Fill right and bottom matrices      for     (  int     i     =     n     -     1  ;     i     >=     0  ;     i  --  )     {      for     (  int     j     =     n     -     1  ;     j     >=     0  ;     j  --  )     {      if     (  mat  [  i       j  ]     ==     1  )     {      right  [  i       j  ]     =     (  j     ==     n     -     1  )     ?     1     :     right  [  i       j     +     1  ]     +     1  ;      bottom  [  i       j  ]     =     (  i     ==     n     -     1  )     ?     1     :     bottom  [  i     +     1       j  ]     +     1  ;      }      }      }          int     maxPlusSize     =     0  ;          // Compute the maximum '+' size      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  int     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i       j  ]     ==     1  )     {      int     armLength     =     Math  .  Min  (  Math  .  Min  (  left  [  i       j  ]     right  [  i       j  ])      Math  .  Min  (  top  [  i       j  ]     bottom  [  i       j  ]));          maxPlusSize     =     Math  .  Max  (  maxPlusSize        (  4     *     (  armLength     -     1  ))     +     1  );      }      }      }          return     maxPlusSize  ;      }      public     static     void     Main  ()     {          // Hardcoded input matrix      int  []     mat     =     {      {  0       1       1       0       1  }      {  0       0       1       1       1  }      {  1       1       1       1       1  }      {  1       1       1       0       1  }      {  0       1       1       1       0  }      };          Console  .  WriteLine  (  FindLargestPlus  (  mat  ));      }   }   
JavaScript
   // JavaScript program to find the largest '+' in a binary matrix   // using Dynamic Programming   function     findLargestPlus  (  mat  )     {          let     n     =     mat  .  length  ;          let     left     =     Array  .  from  ({     length  :     n     }     ()     =>     Array  (  n  ).  fill  (  0  ));      let     right     =     Array  .  from  ({     length  :     n     }     ()     =>     Array  (  n  ).  fill  (  0  ));      let     top     =     Array  .  from  ({     length  :     n     }     ()     =>     Array  (  n  ).  fill  (  0  ));      let     bottom     =     Array  .  from  ({     length  :     n     }     ()     =>     Array  (  n  ).  fill  (  0  ));          // Fill left and top matrices      for     (  let     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  let     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ===     1  )     {      left  [  i  ][  j  ]     =     (  j     ===     0  )     ?     1     :     left  [  i  ][  j     -     1  ]     +     1  ;      top  [  i  ][  j  ]     =     (  i     ===     0  )     ?     1     :     top  [  i     -     1  ][  j  ]     +     1  ;      }      }      }          // Fill right and bottom matrices      for     (  let     i     =     n     -     1  ;     i     >=     0  ;     i  --  )     {      for     (  let     j     =     n     -     1  ;     j     >=     0  ;     j  --  )     {      if     (  mat  [  i  ][  j  ]     ===     1  )     {      right  [  i  ][  j  ]     =     (  j     ===     n     -     1  )     ?     1     :     right  [  i  ][  j     +     1  ]     +     1  ;      bottom  [  i  ][  j  ]     =     (  i     ===     n     -     1  )     ?     1     :     bottom  [  i     +     1  ][  j  ]     +     1  ;      }      }      }          let     maxPlusSize     =     0  ;          // Compute the maximum '+' size      for     (  let     i     =     0  ;     i      <     n  ;     i  ++  )     {      for     (  let     j     =     0  ;     j      <     n  ;     j  ++  )     {      if     (  mat  [  i  ][  j  ]     ===     1  )     {      let     armLength     =     Math  .  min  (  left  [  i  ][  j  ]     right  [  i  ][  j  ]      top  [  i  ][  j  ]     bottom  [  i  ][  j  ]);          maxPlusSize     =     Math  .  max  (  maxPlusSize        (  4     *     (  armLength     -     1  ))     +     1  );      }      }      }          return     maxPlusSize  ;   }   // Hardcoded input matrix   let     mat     =     [      [  0       1       1       0       1  ]      [  0       0       1       1       1  ]      [  1       1       1       1       1  ]      [  1       1       1       0       1  ]      [  0       1       1       1       0  ]   ];   console  .  log  (  findLargestPlus  (  mat  ));   

Излаз
9  

Временска сложеност: О(н²) због четири пролаза за израчунавање матрица усмерења и једног коначног пролаза за одређивање највећег '+'. Сваки пролаз траје О(н²) времена што доводи до укупне сложености од О(н²).
Сложеност простора: О(н²) због четири помоћне матрице (лево десно горе доле) које троше О(н²) додатног простора.