Added tasks 728, 729, 730, 731, 732.

Author: ThanhNIT

src/main/java/g0701_0800/s0728_self_dividing_numbers/Solution.java

@@ -0,0 +1,32 @@
+package g0701_0800.s0728_self_dividing_numbers;
+
+// #Easy #Math
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+    public List<Integer> selfDividingNumbers(int left, int right) {
+        List<Integer> selfDividingNumbers = new ArrayList<>();
+        for (int i = left; i <= right; i++) {
+            int num = i;
+            boolean dividing = false;
+            if (num % 10 != 0) {
+                while (num > 0) {
+                    int temp = num % 10;
+                    if (i % temp == 0) {
+                        dividing = true;
+                    } else {
+                        dividing = false;
+                        break;
+                    }
+                    num = num / 10;
+                }
+                if (dividing) {
+                    selfDividingNumbers.add(i);
+                }
+            }
+        }
+        return selfDividingNumbers;
+    }
+}

src/main/java/g0701_0800/s0728_self_dividing_numbers/readme.md

@@ -0,0 +1,27 @@
+728\. Self Dividing Numbers
+
+Easy
+
+A **self-dividing number** is a number that is divisible by every digit it contains.
+
+*   For example, `128` is **a self-dividing number** because `128 % 1 == 0`, `128 % 2 == 0`, and `128 % 8 == 0`.
+
+A **self-dividing number** is not allowed to contain the digit zero.
+
+Given two integers `left` and `right`, return _a list of all the **self-dividing numbers** in the range_ `[left, right]`.
+
+**Example 1:**
+
+**Input:** left = 1, right = 22
+
+**Output:** [1,2,3,4,5,6,7,8,9,11,12,15,22]
+
+**Example 2:**
+
+**Input:** left = 47, right = 85
+
+**Output:** [48,55,66,77]
+
+**Constraints:**
+
+*   <code>1 <= left <= right <= 10<sup>4</sup></code>

src/main/java/g0701_0800/s0729_my_calendar_i/MyCalendar.java

@@ -0,0 +1,40 @@
+package g0701_0800.s0729_my_calendar_i;
+
+import java.util.TreeSet;
+
+// #Medium #Design #Ordered_Set #Segment_Tree
+
+public class MyCalendar {
+    static class Meeting implements Comparable<Meeting> {
+        public final int start;
+        public final int end;
+
+        public Meeting(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
+
+        public int compareTo(Meeting anotherMeeting) {
+            return this.start - anotherMeeting.start;
+        }
+    }
+
+    private final TreeSet<Meeting> meetings;
+
+    public MyCalendar() {
+        meetings = new TreeSet<>();
+    }
+
+    public boolean book(int start, int end) {
+        Meeting meetingToBook = new Meeting(start, end);
+        Meeting prevMeeting = meetings.floor(meetingToBook);
+        Meeting nextMeeting = meetings.ceiling(meetingToBook);
+        if ((prevMeeting == null || prevMeeting.end <= meetingToBook.start)
+                && (nextMeeting == null || meetingToBook.end <= nextMeeting.start)) {
+
+            meetings.add(meetingToBook);
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/g0701_0800/s0729_my_calendar_i/readme.md

@@ -0,0 +1,36 @@
+729\. My Calendar I
+
+Medium
+
+You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a **double booking**.
+
+A **double booking** happens when two events have some non-empty intersection (i.e., some moment is common to both events.).
+
+The event can be represented as a pair of integers `start` and `end` that represents a booking on the half-open interval `[start, end)`, the range of real numbers `x` such that `start <= x < end`.
+
+Implement the `MyCalendar` class:
+
+*   `MyCalendar()` Initializes the calendar object.
+*   `boolean book(int start, int end)` Returns `true` if the event can be added to the calendar successfully without causing a **double booking**. Otherwise, return `false` and do not add the event to the calendar.
+
+**Example 1:**
+
+**Input** 
+
+["MyCalendar", "book", "book", "book"] 
+
+[[], [10, 20], [15, 25], [20, 30]]
+
+**Output:** [null, true, false, true]
+
+**Explanation:** 
+
+    MyCalendar myCalendar = new MyCalendar(); 
+    myCalendar.book(10, 20); // return True 
+    myCalendar.book(15, 25); // return False, It can not be booked because time 15 is already booked by another event. 
+    myCalendar.book(20, 30); // return True, The event can be booked, as the first event takes every time less than 20, but not including 20.
+
+**Constraints:**
+
+*   <code>0 <= start < end <= 10<sup>9</sup></code>
+*   At most `1000` calls will be made to `book`.

src/main/java/g0701_0800/s0730_count_different_palindromic_subsequences/Solution.java

@@ -0,0 +1,43 @@
+package g0701_0800.s0730_count_different_palindromic_subsequences;
+
+// #Hard #String #Dynamic_Programming
+
+public class Solution {
+    public int countPalindromicSubsequences(String s) {
+        int big = 1000000007;
+        int len = s.length();
+        if (len < 2) {
+            return len;
+        }
+        int[][] dp = new int[len][len];
+        for (int i = 0; i < len; i++) {
+            char c = s.charAt(i);
+            int deta = 1;
+            dp[i][i] = 1;
+            int l2 = -1;
+            for (int j = i - 1; j >= 0; j--) {
+                if (s.charAt(j) != c) {
+                    dp[j][i] = deal(dp[j][i - 1] + deta, big);
+                } else {
+                    if (l2 < 0) {
+                        l2 = j;
+                        deta = dp[j + 1][i - 1] + 1;
+                    } else {
+                        deta = dp[j + 1][i - 1] - dp[j + 1][l2 - 1];
+                    }
+                    deta = deal(deta, big);
+                    dp[j][i] = deal(dp[j][i - 1] + deta, big);
+                }
+            }
+        }
+        return deal(dp[0][len - 1], big);
+    }
+
+    private int deal(int x, int big) {
+        x %= big;
+        if (x < 0) {
+            x += big;
+        }
+        return x;
+    }
+}

src/main/java/g0701_0800/s0730_count_different_palindromic_subsequences/readme.md

@@ -0,0 +1,32 @@
+730\. Count Different Palindromic Subsequences
+
+Hard
+
+Given a string s, return _the number of different non-empty palindromic subsequences in_ `s`. Since the answer may be very large, return it **modulo** <code>10<sup>9</sup> + 7</code>.
+
+A subsequence of a string is obtained by deleting zero or more characters from the string.
+
+A sequence is palindromic if it is equal to the sequence reversed.
+
+Two sequences <code>a<sub>1</sub>, a<sub>2</sub>, ...</code> and <code>b<sub>1</sub>, b<sub>2</sub>, ...</code> are different if there is some `i` for which <code>a<sub>i</sub> != b<sub>i</sub></code>.
+
+**Example 1:**
+
+**Input:** s = "bccb"
+
+**Output:** 6
+
+**Explanation:** The 6 different non-empty palindromic subsequences are 'b', 'c', 'bb', 'cc', 'bcb', 'bccb'. Note that 'bcb' is counted only once, even though it occurs twice.
+
+**Example 2:**
+
+**Input:** s = "abcdabcdabcdabcdabcdabcdabcdabcddcbadcbadcbadcbadcbadcbadcbadcba"
+
+**Output:** 104860361
+
+**Explanation:** There are 3104860382 different non-empty palindromic subsequences, which is 104860361 modulo 10<sup>9</sup> + 7.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s[i]` is either `'a'`, `'b'`, `'c'`, or `'d'`.

src/main/java/g0701_0800/s0731_my_calendar_ii/MyCalendarTwo.java

@@ -0,0 +1,35 @@
+package g0701_0800.s0731_my_calendar_ii;
+
+// #Medium #Design #Ordered_Set #Segment_Tree
+
+import java.util.TreeMap;
+
+public class MyCalendarTwo {
+
+    private final TreeMap<Integer, Integer> map;
+    private final TreeMap<Integer, Integer> overlap;
+
+    public MyCalendarTwo() {
+        map = new TreeMap<>();
+        overlap = new TreeMap<>();
+    }
+
+    public boolean book(int start, int end) {
+        Integer ol = overlap.lowerKey(end);
+        if (ol == null || overlap.get(ol) <= start) {
+            while (true) {
+                Integer lower = map.lowerKey(end);
+                if (lower == null || map.get(lower) <= start) {
+                    break;
+                }
+                overlap.put(Math.max(start, lower), Math.min(end, map.get(lower)));
+                start = Math.min(start, lower);
+                end = Math.max(end, map.get(lower));
+                map.remove(lower);
+            }
+            map.put(start, end);
+            return true;
+        }
+        return false;
+    }
+}

src/main/java/g0701_0800/s0731_my_calendar_ii/readme.md

@@ -0,0 +1,39 @@
+731\. My Calendar II
+
+Medium
+
+You are implementing a program to use as your calendar. We can add a new event if adding the event will not cause a **triple booking**.
+
+A **triple booking** happens when three events have some non-empty intersection (i.e., some moment is common to all the three events.).
+
+The event can be represented as a pair of integers `start` and `end` that represents a booking on the half-open interval `[start, end)`, the range of real numbers `x` such that `start <= x < end`.
+
+Implement the `MyCalendarTwo` class:
+
+*   `MyCalendarTwo()` Initializes the calendar object.
+*   `boolean book(int start, int end)` Returns `true` if the event can be added to the calendar successfully without causing a **triple booking**. Otherwise, return `false` and do not add the event to the calendar.
+
+**Example 1:**
+
+**Input** 
+
+["MyCalendarTwo", "book", "book", "book", "book", "book", "book"] 
+
+[[], [10, 20], [50, 60], [10, 40], [5, 15], [5, 10], [25, 55]]
+
+**Output:** [null, true, true, true, false, true, true]
+
+**Explanation:** 
+
+    MyCalendarTwo myCalendarTwo = new MyCalendarTwo(); 
+    myCalendarTwo.book(10, 20); // return True, The event can be booked. 
+    myCalendarTwo.book(50, 60); // return True, The event can be booked. 
+    myCalendarTwo.book(10, 40); // return True, The event can be double booked. 
+    myCalendarTwo.book(5, 15); // return False, The event ca not be booked, because it would result in a triple booking. 
+    myCalendarTwo.book(5, 10); // return True, The event can be booked, as it does not use time 10 which is already double booked. 
+    myCalendarTwo.book(25, 55); // return True, The event can be booked, as the time in [25, 40) will be double booked with the third event, the time [40, 50) will be single booked, and the time [50, 55) will be double booked with the second event.
+
+**Constraints:**
+
+*   <code>0 <= start < end <= 10<sup>9</sup></code>
+*   At most `1000` calls will be made to `book`.

src/main/java/g0701_0800/s0732_my_calendar_iii/MyCalendarThree.java

@@ -0,0 +1,65 @@
+package g0701_0800.s0732_my_calendar_iii;
+
+// #Hard #Design #Ordered_Set #Segment_Tree
+
+public class MyCalendarThree {
+    private final Node root;
+
+    public MyCalendarThree() {
+        root = new Node(0, 1000000000, 0);
+    }
+
+    public int book(int start, int end) {
+        updateTree(root, start, end - 1);
+        return root.val;
+    }
+
+    private void updateTree(Node root, int start, int end) {
+        if (root == null) {
+            return;
+        }
+        if (root.low >= start && root.high <= end) {
+            root.val++;
+            if (root.left != null) {
+                updateTree(root.left, start, end);
+            }
+            if (root.right != null) {
+                updateTree(root.right, start, end);
+            }
+            return;
+        }
+
+        int mid = (root.low + root.high) / 2;
+        if (root.left == null) {
+            root.left = new Node(root.low, mid, root.val);
+        }
+
+        if (root.right == null) {
+            root.right = new Node(mid + 1, root.high, root.val);
+        }
+
+        if (start <= mid) {
+            updateTree(root.left, start, end);
+        }
+
+        if (end > mid) {
+            updateTree(root.right, start, end);
+        }
+
+        root.val = Math.max(root.left.val, root.right.val);
+    }
+
+    static class Node {
+        int low;
+        int high;
+        int val;
+        Node left;
+        Node right;
+
+        public Node(int low, int high, int val) {
+            this.low = low;
+            this.high = high;
+            this.val = val;
+        }
+    }
+}