update 731 java, cheatsheet

yennanliu · yennanliu · commit 09724b83120a · 2025-01-05T18:10:31.000+08:00
diff --git a/README.md b/README.md
@@ -271,7 +271,7 @@
 723 | [Candy Crush](https://leetcode.com/problems/candy-crush/) | [Python](./leetcode_python/Array/candy-crush.py) | _O((R * C)^2)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)
 724 | [Find Pivot Index](https://leetcode.com/problems/find-pivot-index/) | [Python](./leetcode_python/Array/find-pivot-index.py)  | _O(n)_ | _O(1)_ | Easy || OK*
 729 | [My Calendar I](https://leetcode.com/problems/my-calendar-i/) |  [Python](./leetcode_python/Array/my-calendar-i.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar1.java) | _O(nlogn)_ | _O(n)_ | Medium |good basic, brute force, binary search, google| AGAIN**** (1)
-731 | [My Calendar II](https://leetcode.com/problems/my-calendar-ii/) | [Python](./leetcode_python/Array/my-calendar-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar2.java) | _O(n^2)_ | _O(n)_ | Medium |`trick`, scanning line, google,| AGAIN******** (3)
+731 | [My Calendar II](https://leetcode.com/problems/my-calendar-ii/) | [Python](./leetcode_python/Array/my-calendar-ii.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar2.java) | _O(n^2)_ | _O(n)_ | Medium |`trick`, good trick, scanning line, google,| AGAIN******** (4)
 747 | [Largest Number At Least Twice of Others](https://leetcode.com/problems/largest-number-at-least-twice-of-others/) | [Python](./leetcode_python/Array/largest-number-at-least-twice-of-others.py) | _O(n)_ | _O(1)_ | Easy |`good basic`, `data structure`| OK* 
 755 | [Pour Water](https://leetcode.com/problems/pour-water/) | [Python](./leetcode_python/Array/pour-water.py) | _O(v * n)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)
 766 | [Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/) | [Python](./leetcode_python/Array/toeplitz-matrix.py)  | _O(m * n)_ | _O(1)_ | Easy |`basic`, `matrix`, `google`| AGAIN* (2)
diff --git a/data/progress.md b/data/progress.md
@@ -1,5 +1,8 @@
 # Progress
 
+# 2025-01-05
+- https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
+
 # 2025-01-04
 - https://github.com/yennanliu/CS_basics/blob/master/doc/Leetcode_company_frequency-master/Google%206months-%20LeetCode.pdf
 
diff --git a/data/progress.txt b/data/progress.txt
@@ -1,3 +1,4 @@
+20250105: 
 20250104: 1031,369
 20250101: 729,731
 20241231: 769,817,855(again)
diff --git a/doc/cheatsheet/scanning_line.md b/doc/cheatsheet/scanning_line.md
@@ -198,79 +198,89 @@ class Solution:
 
 ```java
 // java
-// LC 731 My Calendar II
-  // V1-1
-  // https://leetcode.com/problems/my-calendar-ii/editorial/
-  // IDEA:  Line Sweep (Scanning line)
+// LC 731
+// V0
+// IDEA: SCANNING LINE + CUSTOM SORTING (fixed by gpt)
+class MyCalendarTwo {
+
+  // Attributes
   /**
-   *  IDEA:
-   *
-   *
-   *  1) Class `MyCalendarTwo` will have two data members,
-   *     `maxOverlappedBooking` which is the maximum number of
-   *     concurrent bookings possible at a time,
-   *     and `bookingCount` which is a map from integer to integer
-   *     with the time point as the key and number of bookings as the value.
-   *
-   *
-   *  2) Initialize `maxOverlappedBooking` as 2, as we need to check for triple booking.
+   * NOTE !!!
    *
-   *  3) Define the function book(start, end) as:
-   *
-   *    - Increase the number of bookings for the time start and decrease
-   *      the number of bookings for end by 1 in the map bookingCount.
-   *
-   *    - Iterate over each key-value pair in the map
-   *      in ascending order of keys to find the prefix sum.
-   *      Add the value in the map to the count overlappedBooking.
-   *
-   *    - If overlappedBooking is more than two, it implies that this
-   *      is triple booking. Hence, we should return false.
-   *      Also, we need to revert the changes in the map as this booking shouldn't be added.
-   *
-   *    - If we reach here, it implies no triple booking and hence returns true.
    *
+   * statusList: {time, status, curBooked}
+   * time: start time or end time
+   * status: 1 for start, -1 for end
    */
-  class MyCalendarTwo_1_1 {
-
-
-
-        private TreeMap<Integer, Integer> bookingCount;
-        private int maxOverlappedBooking;
-
-        public MyCalendarTwo_1_1() {
-            bookingCount = new TreeMap<>();
-            maxOverlappedBooking = 2;
-        }
-
-        public boolean book(int start, int end) {
-            // Increase the booking count at 'start' and decrease at 'end'.
-            bookingCount.put(start, bookingCount.getOrDefault(start, 0) + 1);
-            bookingCount.put(end, bookingCount.getOrDefault(end, 0) - 1);
-
-            int overlappedBooking = 0;
-
-            // Calculate the prefix sum of bookings.
-            for (Map.Entry<Integer, Integer> entry : bookingCount.entrySet()) {
-                overlappedBooking += entry.getValue();
-
-                // If the number of overlaps exceeds the allowed limit, rollback and
-                // return false.
-                if (overlappedBooking > maxOverlappedBooking) {
-                    // Rollback changes.
-                    bookingCount.put(start, bookingCount.get(start) - 1);
-                    bookingCount.put(end, bookingCount.get(end) + 1);
-
-                    // Clean up if the count becomes zero to maintain the map clean.
-                    if (bookingCount.get(start) == 0) {
-                        bookingCount.remove(start);
-                    }
-
-                    return false;
-                }
-            }
-
-            return true;
-        }
-    }
+  List<Integer[]> statusList;
+
+  // Constructor
+  public MyCalendarTwo() {
+      this.statusList = new ArrayList<>();
+  }
+
+  public boolean book(int startTime, int endTime) {
+
+      // Create intervals
+      /**
+       * NOTE !!!
+       *
+       * 1) we can init array at once as `new Inteter[] {a,b,c};
+       * 2) we init curStart, curEnd array at first
+       */
+      Integer[] curStart = new Integer[] { startTime, 1, 0 }; // {time, status, placeholder}
+      Integer[] curEnd = new Integer[] { endTime, -1, 0 }; // {time, status, placeholder}
+
+      // Temporarily add them to the list for simulation
+      /**
+       * NOTE !!!
+       *
+       * -> we add curStart, curEnd to statusList directly
+       * -> if new time is `over 2 times overlap`, we can REMOVE them
+       *    from statusList and return `false` in this method,
+       *    and we can keep this method running and validate the
+       *    other input (startTime, endTime)
+       */
+      statusList.add(curStart);
+      statusList.add(curEnd);
+
+      // Sort by time, then by status (start before end)
+      /**
+       * NOTE !!!
+       *
+       *  custom sorting
+       *
+       *  -> so, sort time first,
+       *  if time are equal, then sort on `status` (0 or 1),
+       *  `open` goes first, `close` goes next
+       */
+      statusList.sort((x, y) -> {
+          if (!x[0].equals(y[0])) {
+              return x[0] - y[0];
+          }
+          return x[1] - y[1]; // start (+1) comes before end (-1)
+      });
+
+      // Scanning line to check overlaps
+      int curBooked = 0;
+      for (Integer[] interval : statusList) {
+          curBooked += interval[1];
+          if (curBooked >= 3) {
+              // Remove the temporary intervals
+              /**
+               * NOTE !!!
+               *
+               *  if overlap > 2, we just remove the new added times,
+               *  and return false as method response
+               */
+              statusList.remove(curStart);
+              statusList.remove(curEnd);
+              return false; // Booking not allowed
+          }
+      }
+
+      // Booking is valid, keep the intervals
+      return true;
+  }
+}
 ```
diff --git a/leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar2.java b/leetcode_java/src/main/java/LeetCodeJava/Array/MyCalendar2.java
@@ -64,81 +64,89 @@ public class MyCalendar2 {
    */
 
   // V0
-  // TODO: fix below
-//  class MyCalendarTwo {
-//
-//      List<List<Integer>> booked;
-//      Map<List<Integer>, Integer> overlapCnt;
-//
-//      public MyCalendarTwo() {
-//          this.booked = new ArrayList<>();
-//          this.overlapCnt = new HashMap<>();
-//      }
-//
-//      public boolean book(int startTime, int endTime) {
-//
-//          List<Integer> tmp = new ArrayList<>();
-//          tmp.add(startTime);
-//          tmp.add(endTime);
-//
-//          // case 1) booked is empty
-//          if(this.booked.isEmpty()){
-//              this.booked.add(tmp);
-//              return true;
-//          }
-//
-//          boolean lessEqualsThreeOverlap = false;
-//
-//
-//          for(List<Integer> x: this.booked){
-//              /**
-//               *   |----|
-//               *     |------| (old)
-//               *
-//               *     or
-//               *
-//               *    |-----|
-//               *  |----|  (old)
-//               *
-//               *    or
-//               *
-//               *    |---|
-//               *  |----------|  (old)
-//               *
-//               *
-//               */
-//              int existingStart = x.get(0);
-//              int existingEnd = x.get(1);
-//
-//              if (startTime < existingEnd && existingStart < endTime) {
-//                  // case 2) has overlap, but `overlap count` <= 3
-//                  List<Integer> tmpExisting = new ArrayList<>();
-//                  tmpExisting.add(existingStart);
-//                  tmpExisting.add(existingEnd);
-//                  if(this.overlapCnt.get(tmpExisting) <= 3){
-//                      // update existing start, end
-//                      existingStart = Math.min(existingStart, startTime);
-//                      existingEnd  = Math.max(existingEnd, endTime);
-//                      List<Integer> tmp2 = new ArrayList<>();
-//                      tmp2.add(existingStart);
-//                      tmp2.add(existingEnd);
-//                      this.overlapCnt.put(tmp2, this.overlapCnt.get(tmpExisting)+1); // update overlap cnt
-//                      this.overlapCnt.remove(tmpExisting);
-//                      return true;
-//                  }else{
-//                      // case 3) has overlap, and `overlap count` > 3
-//                      return false;
-//                  }
-//              }
-//
-//          }
-//
-//          // case 4) no overlap
-//          this.booked.add(tmp);
-//          this.overlapCnt.put(tmp, 1); // update overlap cnt
-//          return true;
-//      }
-//  }
+  // IDEA: SCANNING LINE + CUSTOM SORTING (fixed by gpt)
+  class MyCalendarTwo {
+
+      // Attributes
+      /**
+       * NOTE !!!
+       *
+       *
+       * statusList: {time, status, curBooked}
+       * time: start time or end time
+       * status: 1 for start, -1 for end
+       */
+      List<Integer[]> statusList;
+
+      // Constructor
+      public MyCalendarTwo() {
+          this.statusList = new ArrayList<>();
+      }
+
+      public boolean book(int startTime, int endTime) {
+
+          // Create intervals
+          /**
+           * NOTE !!!
+           *
+           * 1) we can init array at once as `new Inteter[] {a,b,c};
+           * 2) we init curStart, curEnd array at first
+           */
+          Integer[] curStart = new Integer[] { startTime, 1, 0 }; // {time, status, placeholder}
+          Integer[] curEnd = new Integer[] { endTime, -1, 0 }; // {time, status, placeholder}
+
+          // Temporarily add them to the list for simulation
+          /**
+           * NOTE !!!
+           *
+           * -> we add curStart, curEnd to statusList directly
+           * -> if new time is `over 2 times overlap`, we can REMOVE them
+           *    from statusList and return `false` in this method,
+           *    and we can keep this method running and validate the
+           *    other input (startTime, endTime)
+           */
+          statusList.add(curStart);
+          statusList.add(curEnd);
+
+          // Sort by time, then by status (start before end)
+          /**
+           * NOTE !!!
+           *
+           *  custom sorting
+           *
+           *  -> so, sort time first,
+           *  if time are equal, then sort on `status` (0 or 1),
+           *  `open` goes first, `close` goes next
+           */
+          statusList.sort((x, y) -> {
+              if (!x[0].equals(y[0])) {
+                  return x[0] - y[0];
+              }
+              return x[1] - y[1]; // start (+1) comes before end (-1)
+          });
+
+          // Scanning line to check overlaps
+          int curBooked = 0;
+          for (Integer[] interval : statusList) {
+              curBooked += interval[1];
+              if (curBooked >= 3) {
+                  // Remove the temporary intervals
+                  /**
+                   * NOTE !!!
+                   *
+                   *  if overlap > 2, we just remove the new added times,
+                   *  and return false as method response
+                   */
+                  statusList.remove(curStart);
+                  statusList.remove(curEnd);
+                  return false; // Booking not allowed
+              }
+          }
+
+          // Booking is valid, keep the intervals
+          return true;
+      }
+  }
 
   // V1-1
   // https://leetcode.com/problems/my-calendar-ii/editorial/
diff --git a/leetcode_java/src/main/java/dev/workspace6.java b/leetcode_java/src/main/java/dev/workspace6.java

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+20250105:`
`1`	`2`	`20250104: 1031,369`
`2`	`3`	`20250101: 729,731`
`3`	`4`	`20241231: 769,817,855(again)`