update 849 java, cheatsheet

yennanliu · yennanliu · commit 619710ad2a4e · 2024-12-28T18:22:03.000+08:00
diff --git a/README.md b/README.md
@@ -287,7 +287,7 @@
 840 | [Magic Squares In Grid](https://leetcode.com/problems/magic-squares-in-grid/) | [Python](./leetcode_python/Array/magic-squares-in-grid.py) | _O(m * n)_ | _O(1)_ | Easy |`complex`| AGAIN (not start)
 842 | [Split Array into Fibonacci Sequence](https://leetcode.com/problems/split-array-into-fibonacci-sequence/) | [Python](./leetcode_python/Array/split-array-into-fibonacci-sequence.py) | _O(n^3)_ | _O(n)_ | Medium |check `# 306 Addictive Number`, `basic`, `dfs`, `fibonacci`| AGAIN* (not start)
 845 | [Longest Mountain in Array](https://leetcode.com/problems/longest-mountain-in-array/) | [Python](./leetcode_python/Array/longest-mountain-in-array.py) | _O(n)_ | _O(1)_ | Medium |`basic`, `trick`| AGAIN* (not start) 
-849 | [Maximize Distance to Closest Person](https://leetcode.com/problems/maximize-distance-to-closest-person/) | [Python](./leetcode_python/Array/maximize-distance-to-closest-person.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MaximizeDistanceToClosestPerson.java) | _O(n)_ | _O(1)_ | Medium |`basic`, 2 pointers, LC 855, google| AGAIN***** (1)
+849 | [Maximize Distance to Closest Person](https://leetcode.com/problems/maximize-distance-to-closest-person/) | [Python](./leetcode_python/Array/maximize-distance-to-closest-person.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MaximizeDistanceToClosestPerson.java) | _O(n)_ | _O(1)_ | Medium |`basic`, 2 pointers, LC 855, google| AGAIN********* (2)
 860 | [Lemonade Change](https://leetcode.com/problems/lemonade-change/) | [Python](./leetcode_python/Array/lemonade-change.py) | _O(n)_ | _O(1)_ | Easy |amazon| OK* (2)
 0868 | [Transpose Matrix](https://leetcode.com/problems/transpose-matrix/) | [Python](./leetcode_python/Array/transpose-matrix.py) | _O(r * c)_ | _O(1)_ | Easy |`basic`| OK*
 885 | [Spiral Matrix III](https://leetcode.com/problems/spiral-matrix-iii/) | [Python](./leetcode_python/Array/spiral-matrix-iii.py) | _O(max(m, n)^2)_ | _O(1)_ | Medium  |`basic`| AGAIN* (not start)
diff --git a/data/progress.txt b/data/progress.txt
@@ -1,5 +1,5 @@
-20241228: 379,173
-20241227: 079,212(todo),362,849,855(todo)
+20241228: 379,173,855(todo)
+20241227: 079,212(todo),362,849
 20241222: 369,311
 20241221: 370
 20241220: 815,871,593,1109
diff --git a/doc/cheatsheet/array.md b/doc/cheatsheet/array.md
@@ -787,4 +787,105 @@ class Vector2D:
     def hasNext(self):
         # If the next position is a valid index of nums, return True.
         return self.position + 1 < len(self.nums)
+```
+
+### 2-17) Maximize Distance to Closest Person
+
+```java
+// java
+// LC 849. Maximize Distance to Closest Person
+
+// V0-1
+// IDEA (fixed by gpt)
+/**
+*  IDEA :
+*
+*  Explanation of the Code:
+*    1.  Initial Setup:
+*        •   lastOccupied keeps track of the index of the last seat occupied by a person.
+*        •   maxDistance is initialized to 0 to store the maximum distance found.
+*
+*    2.  Iterate Through the Array:
+*        •   When a seat is occupied (seats[i] == 1):
+*        •   If it’s the first occupied seat, calculate the distance from the start of the array to this seat (i).
+*        •   Otherwise, calculate the middle distance between the current and the last occupied seat using (i - lastOccupied) / 2.
+*
+*    3.  Check the Last Segment:
+*        •   If the last seat is empty, calculate the distance from the last occupied seat to the end of the array (seats.length - 1 - lastOccupied).
+*
+*    4.  Return the Maximum Distance:
+*        •   The value of maxDistance at the end of the loop is the answer.
+*
+*
+* Example :
+*  input : seats = [1, 0, 0, 0, 1, 0, 1]
+*
+*   Execution Steps:
+*    1.  First occupied seat at index 0 → Distance to start = 0.
+*    2.  Second occupied seat at index 4 → Middle distance = (4 - 0) / 2 = 2.
+*    3.  Third occupied seat at index 6 → Middle distance = (6 - 4) / 2 = 1.
+*    4.  No empty seats after the last occupied seat.
+*    5.  maxDistance = 2.
+*
+*  output:  2
+*
+*/
+/**
+*  Cases
+*
+*  Case 1)  0001  ( all "0" till meat first "1")
+*  Case 2)  1001001 (all "0" are enclosed by "1")
+*  Case 3)  1001000 (there are "0" that NOT enclosed by "1" on the right hand side)
+*
+*/
+public int maxDistToClosest_0_1(int[] seats) {
+    int maxDistance = 0;
+    int lastOccupied = -1;
+
+    // Traverse the array to calculate maximum distances
+    for (int i = 0; i < seats.length; i++) {
+        /** NOTE !!! handle the seat val == 1 cases */
+        if (seats[i] == 1) {
+            if (lastOccupied == -1) {
+                // Handle the case where the `first` occupied seat is found
+                /**
+                 * NOTE !!!
+                 *
+                 *  for handling below case:
+                 *
+                 *    e.g. :  0001
+                 *
+                 *  (so, elements are all "0" till first visit "1")
+                 *  in this case, we still can get put a person to seat, and get distance
+                 *
+                 */
+                maxDistance = i; // Distance from the start to the first occupied seat
+            } else {
+                // Calculate the distance to the closest person for the middle segment
+                /** NOTE !!! need to divided by 2, since the person need to seat at `middle` seat */
+                maxDistance = Math.max(maxDistance, (i - lastOccupied) / 2);
+            }
+            lastOccupied = i;
+        }
+    }
+
+    // Handle the case where the last segment is empty
+   /**
+    *  NOTE !!!
+    *
+    *   the condition is actually quite straightforward,
+    *   just need to check if the last element in array is "0"
+    *   if is "0", means the array is NOT enclosed by "1"
+    *   then we need to handle such case
+    *   (example as below)
+    *
+    *   e.g.  100010000
+    *
+    */
+    if (seats[seats.length - 1] == 0) {
+        maxDistance = Math.max(maxDistance, seats.length - 1 - lastOccupied);
+    }
+
+    return maxDistance;
+}
 ```
diff --git a/leetcode_java/src/main/java/LeetCodeJava/Array/MaximizeDistanceToClosestPerson.java b/leetcode_java/src/main/java/LeetCodeJava/Array/MaximizeDistanceToClosestPerson.java
@@ -116,6 +116,14 @@ public class MaximizeDistanceToClosestPerson {
    *  output:  2
    *
    */
+  /**
+   *  Cases
+   *
+   *  Case 1)  0001  ( all "0" till meat first "1")
+   *  Case 2)  1001001 (all "0" are enclosed by "1")
+   *  Case 3)  1001000 (there are "0" that NOT enclosed by "1" on the right hand side)
+   *
+   */
   public int maxDistToClosest_0_1(int[] seats) {
         int maxDistance = 0;
         int lastOccupied = -1;
@@ -126,6 +134,17 @@ public int maxDistToClosest_0_1(int[] seats) {
             if (seats[i] == 1) {
                 if (lastOccupied == -1) {
                     // Handle the case where the `first` occupied seat is found
+                    /**
+                     * NOTE !!!
+                     *
+                     *  for handling below case:
+                     *
+                     *    e.g. :  0001
+                     *
+                     *  (so, elements are all "0" till first visit "1")
+                     *  in this case, we still can get put a person to seat, and get distance
+                     *
+                     */
                     maxDistance = i; // Distance from the start to the first occupied seat
                 } else {
                     // Calculate the distance to the closest person for the middle segment
@@ -137,6 +156,18 @@ public int maxDistToClosest_0_1(int[] seats) {
         }
 
         // Handle the case where the last segment is empty
+       /**
+        *  NOTE !!!
+        *
+        *   the condition is actually quite straightforward,
+        *   just need to check if the last element in array is "0"
+        *   if is "0", means the array is NOT enclosed by "1"
+        *   then we need to handle such case
+        *   (example as below)
+        *
+        *   e.g.  100010000
+        *
+        */
         if (seats[seats.length - 1] == 0) {
             maxDistance = Math.max(maxDistance, seats.length - 1 - lastOccupied);
         }
diff --git a/leetcode_java/src/main/java/dev/workspace6.java b/leetcode_java/src/main/java/dev/workspace6.java
@@ -730,31 +730,93 @@ public int getHits(int timestamp) {
    *
    *
    */
+  // 5.45 pm - 6.00 pm
+  /**
+   *  IDEA : 2 pointers
+   *
+   *    2 cases
+   *   -> seat between "1"
+   *      -> dist = dist(1,1) / 2
+   *   -> set is NOT between "1"
+   *      -> dist = dist(1, array_len)
+   *
+   *    and maintain the max dist within the looping
+   *
+   *
+   *    Exp :
+   *
+   *    1001001
+   *
+   *    100100100
+   *
+   *    1000
+   *
+   *    1000010
+   *
+   *    10100000
+   *
+   */
   public int maxDistToClosest(int[] seats) {
 
-      List<Integer> distances = new ArrayList<>();
+      if (seats.length == 2){
+          return 1; // ?? check
+      }
+
+      int maxDist = 0;
+     // int seatedCnt = 0;
       int lastIdx = -1;
-      for(int i = seats.length - 1; i >= 0; i--){
+      //int closed = -1; // ???
+
+      for(int i = 0; i < seats.length; i++){
+//          if (seats[i] == 1){
+//              //seatedCnt += 1;
+//              //closed = closed * closed;
+//          }
           if (seats[i] == 1){
-              if (lastIdx != -1){
-                  int diff = Math.abs(i - lastIdx);
-                  distances.add(diff);
-              }
-              lastIdx = i;
+              if (lastIdx == -1){
+                  lastIdx = i;
+              }else{
+                  int dist = (i - lastIdx) / 2;
+                  maxDist = Math.max(maxDist, (dist));
+                  }
           }
       }
 
-      System.out.println(">>> (before sort) distances = " + distances);
-      distances.sort(Integer::compareTo);
-      System.out.println(">>> (after sort) distances = " + distances);
-
-      // edge case : if only one "1"
-      if (distances.isEmpty()){
-          return seats.length-1;
+      // NOTE !!! ONLY need to check if the "last 0s" is NOT encclosed by "1"
+      // -> then we NEED to treat it as 2) case
+      // -> e.g. calculate dist from `last seen 1` to `last 0`
+      if (seats[seats.length-1] == 0){
+          //return seats.length - lastIdx;
+          maxDist = Math.max(maxDist, (seats.length - lastIdx));
       }
-      // return the max dist
-      return distances.get(distances.size()-1) / 2; // ??
-    }
+
+      return maxDist;
+  }
+//  public int maxDistToClosest(int[] seats) {
+//
+//      List<Integer> distances = new ArrayList<>();
+//      int lastIdx = -1;
+//      for(int i = seats.length - 1; i >= 0; i--){
+//          if (seats[i] == 1){
+//              if (lastIdx != -1){
+//                  int diff = Math.abs(i - lastIdx);
+//                  distances.add(diff);
+//              }
+//              lastIdx = i;
+//          }
+//      }
+//
+//      System.out.println(">>> (before sort) distances = " + distances);
+//      distances.sort(Integer::compareTo);
+//      System.out.println(">>> (after sort) distances = " + distances);
+//
+//      // edge case : if only one "1"
+//      if (distances.isEmpty()){
+//          return seats.length-1;
+//      }
+//      // return the max dist
+//      return distances.get(distances.size()-1) / 2; // ??
+//    }
 
     // LC 855
     // https://leetcode.com/problems/exam-room/description/
