Added tasks 546, 547, 551, 552

Author: ThanhNIT

README.md

@@ -293,6 +293,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 229 | 79.73
 
 #### Day 9 Standard Traversal
 
@@ -615,6 +616,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 229 | 79.73
 
 #### Day 20 Brute Force/Backtracking
 
@@ -1205,6 +1207,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0200 |[Number of Islands](src.save/main/kotlin/g0101_0200/s0200_number_of_islands/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Depth_First_Search, Breadth_First_Search, Matrix, Union_Find | 252 | 95.41
+| 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find | 229 | 79.73
 
 #### Day 7 Breadth First Search Depth First Search
 
@@ -1651,6 +1654,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
+| 0552 |[Student Attendance Record II](src/main/kotlin/g0501_0600/s0552_student_attendance_record_ii/Solution.kt)| Hard | Dynamic_Programming | 151 | 100.00
+| 0551 |[Student Attendance Record I](src/main/kotlin/g0501_0600/s0551_student_attendance_record_i/Solution.kt)| Easy | String | 151 | 95.00
+| 0547 |[Number of Provinces](src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Graph, Union_Find, Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_8_Standard_Traversal, Level_2_Day_19_Union_Find | 229 | 79.73
+| 0546 |[Remove Boxes](src/main/kotlin/g0501_0600/s0546_remove_boxes/Solution.kt)| Hard | Array, Dynamic_Programming, Memoization | 283 | 100.00
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
 | 0542 |[01 Matrix](src/main/kotlin/g0501_0600/s0542_01_matrix/Solution.kt)| Medium | Array, Dynamic_Programming, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Graph_Theory_I_Day_5_Matrix_Related_Problems | 441 | 94.06
 | 0541 |[Reverse String II](src/main/kotlin/g0501_0600/s0541_reverse_string_ii/Solution.kt)| Easy | String, Two_Pointers | 200 | 83.33

src/main/kotlin/g0501_0600/s0546_remove_boxes/Solution.kt

@@ -0,0 +1,54 @@
+package g0501_0600.s0546_remove_boxes
+
+// #Hard #Array #Dynamic_Programming #Memoization
+// #2023_01_17_Time_283_ms_(100.00%)_Space_46.9_MB_(100.00%)
+
+internal class Solution {
+    // dp for memoization
+    lateinit var dp: Array<Array<IntArray>>
+    fun removeBoxes(boxes: IntArray): Int {
+        val n = boxes.size
+        dp = Array(n + 1) {
+            Array(n + 1) {
+                IntArray(
+                    n + 1
+                )
+            }
+        }
+        return get(boxes, 0, boxes.size - 1, 0)
+    }
+
+    operator fun get(boxes: IntArray, i: Int, j: Int, streak: Int): Int {
+        var i = i
+        var streak = streak
+        if (i > j) {
+            return 0
+        }
+
+        // first we traverse till the adjacent values are different
+        while (i + 1 <= j && boxes[i] == boxes[i + 1]) {
+            i++
+            streak++
+        }
+
+        // memoization
+        if (dp[i][j][streak] > 0) {
+            return dp[i][j][streak]
+        }
+
+        // we calculate the ans here which is streak (length of similar elements) and move
+        // forward to the remaining block through recursion
+        var ans = (streak + 1) * (streak + 1) + get(boxes, i + 1, j, 0)
+        // also another way we can choose is to choose the inner elements first then the outer similar elements can be combined to get even
+        // larger value
+        for (k in i + 1..j) {
+            // we traverse from k (i has moved from 0 to just before the beginning of different elements) and keep searching for same value as
+            // in i. after that the middle elements (between i+1 and k-1) are sent to differnt partition and from k to j(ending) we send the updated streak
+            if (boxes[i] == boxes[k]) {
+                ans = Math.max(ans, get(boxes, i + 1, k - 1, 0) + get(boxes, k, j, streak + 1))
+            }
+        }
+        // return ans here
+        return ans.also { dp[i][j][streak] = it }
+    }
+}

src/main/kotlin/g0501_0600/s0546_remove_boxes/readme.md

@@ -0,0 +1,34 @@
+546\. Remove Boxes
+
+Hard
+
+You are given several `boxes` with different colors represented by different positive numbers.
+
+You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (i.e., composed of `k` boxes, `k >= 1`), remove them and get `k * k` points.
+
+Return _the maximum points you can get_.
+
+**Example 1:**
+
+**Input:** boxes = [1,3,2,2,2,3,4,3,1]
+
+**Output:** 23
+
+**Explanation:** [1, 3, 2, 2, 2, 3, 4, 3, 1] ----> [1, 3, 3, 4, 3, 1] (3\*3=9 points) ----> [1, 3, 3, 3, 1] (1\*1=1 points) ----> [1, 1] (3\*3=9 points) ----> [] (2\*2=4 points)
+
+**Example 2:**
+
+**Input:** boxes = [1,1,1]
+
+**Output:** 9
+
+**Example 3:**
+
+**Input:** boxes = [1]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= boxes.length <= 100`
+*   `1 <= boxes[i] <= 100`

src/main/kotlin/g0501_0600/s0547_number_of_provinces/Solution.kt

@@ -0,0 +1,42 @@
+package g0501_0600.s0547_number_of_provinces
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Graph #Union_Find
+// #Algorithm_II_Day_6_Breadth_First_Search_Depth_First_Search
+// #Graph_Theory_I_Day_8_Standard_Traversal #Level_2_Day_19_Union_Find
+// #2023_01_17_Time_229_ms_(79.73%)_Space_43_MB_(66.22%)
+
+import java.util.Arrays
+
+class Solution {
+    fun findCircleNum(arr: Array<IntArray>): Int {
+        val parent = IntArray(arr.size)
+        Arrays.fill(parent, -1)
+        var ans = 0
+        for (i in 0 until arr.size - 1) {
+            for (j in i + 1 until arr[i].size) {
+                if (arr[i][j] == 1) {
+                    ans += union(i, j, parent)
+                }
+            }
+        }
+        return arr.size - ans
+    }
+
+    private fun union(a: Int, b: Int, arr: IntArray): Int {
+        val ga = find(a, arr)
+        val gb = find(b, arr)
+        if (ga != gb) {
+            arr[gb] = ga
+            return 1
+        }
+        return 0
+    }
+
+    private fun find(a: Int, arr: IntArray): Int {
+        if (arr[a] == -1) {
+            return a
+        }
+        arr[a] = find(arr[a], arr)
+        return arr[a]
+    }
+}

src/main/kotlin/g0501_0600/s0547_number_of_provinces/readme.md

@@ -0,0 +1,36 @@
+547\. Number of Provinces
+
+Medium
+
+There are `n` cities. Some of them are connected, while some are not. If city `a` is connected directly with city `b`, and city `b` is connected directly with city `c`, then city `a` is connected indirectly with city `c`.
+
+A **province** is a group of directly or indirectly connected cities and no other cities outside of the group.
+
+You are given an `n x n` matrix `isConnected` where `isConnected[i][j] = 1` if the <code>i<sup>th</sup></code> city and the <code>j<sup>th</sup></code> city are directly connected, and `isConnected[i][j] = 0` otherwise.
+
+Return _the total number of **provinces**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/24/graph1.jpg)
+
+**Input:** isConnected = [[1,1,0],[1,1,0],[0,0,1]]
+
+**Output:** 2
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/24/graph2.jpg)
+
+**Input:** isConnected = [[1,0,0],[0,1,0],[0,0,1]]
+
+**Output:** 3
+
+**Constraints:**
+
+*   `1 <= n <= 200`
+*   `n == isConnected.length`
+*   `n == isConnected[i].length`
+*   `isConnected[i][j]` is `1` or `0`.
+*   `isConnected[i][i] == 1`
+*   `isConnected[i][j] == isConnected[j][i]`

src/main/kotlin/g0501_0600/s0551_student_attendance_record_i/Solution.kt

@@ -0,0 +1,30 @@
+package g0501_0600.s0551_student_attendance_record_i
+
+// #Easy #String #2023_01_17_Time_151_ms_(95.00%)_Space_33.6_MB_(100.00%)
+
+class Solution {
+    fun checkRecord(s: String): Boolean {
+        var aCount = 0
+        var i = 0
+        while (i < s.length) {
+            if (s[i] == 'A') {
+                aCount++
+                if (aCount > 1) {
+                    return false
+                }
+            } else if (s[i] == 'L') {
+                var continuousLCount = 0
+                while (i < s.length && s[i] == 'L') {
+                    i++
+                    continuousLCount++
+                    if (continuousLCount > 2) {
+                        return false
+                    }
+                }
+                i--
+            }
+            i++
+        }
+        return true
+    }
+}

src/main/kotlin/g0501_0600/s0551_student_attendance_record_i/readme.md

@@ -0,0 +1,37 @@
+551\. Student Attendance Record I
+
+Easy
+
+You are given a string `s` representing an attendance record for a student where each character signifies whether the student was absent, late, or present on that day. The record only contains the following three characters:
+
+*   `'A'`: Absent.
+*   `'L'`: Late.
+*   `'P'`: Present.
+
+The student is eligible for an attendance award if they meet **both** of the following criteria:
+
+*   The student was absent (`'A'`) for **strictly** fewer than 2 days **total**.
+*   The student was **never** late (`'L'`) for 3 or more **consecutive** days.
+
+Return `true` _if the student is eligible for an attendance award, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "PPALLP"
+
+**Output:** true
+
+**Explanation:** The student has fewer than 2 absences and was never late 3 or more consecutive days.
+
+**Example 2:**
+
+**Input:** s = "PPALLL"
+
+**Output:** false
+
+**Explanation:** The student was late 3 consecutive days in the last 3 days, so is not eligible for the award.
+
+**Constraints:**
+
+*   `1 <= s.length <= 1000`
+*   `s[i]` is either `'A'`, `'L'`, or `'P'`.

src/main/kotlin/g0501_0600/s0552_student_attendance_record_ii/Solution.kt

@@ -0,0 +1,58 @@
+package g0501_0600.s0552_student_attendance_record_ii
+
+// #Hard #Dynamic_Programming #2023_01_17_Time_151_ms_(100.00%)_Space_33.3_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    fun checkRecord(n: Int): Int {
+        if (n == 0 || n == 1 || n == 2) {
+            return n * 3 + n * (n - 1)
+        }
+        val mod: Long = 1000000007
+        val matrix = arrayOf(
+            longArrayOf(1, 1, 0, 1, 0, 0),
+            longArrayOf(1, 0, 1, 1, 0, 0),
+            longArrayOf(1, 0, 0, 1, 0, 0),
+            longArrayOf(0, 0, 0, 1, 1, 0),
+            longArrayOf(0, 0, 0, 1, 0, 1),
+            longArrayOf(0, 0, 0, 1, 0, 0)
+        )
+        val e = quickPower(matrix, n - 1)
+        return (
+            (Arrays.stream(e[0]).sum() + Arrays.stream(e[1]).sum() + Arrays.stream(e[3]).sum()) %
+                mod
+            ).toInt()
+    }
+
+    private fun quickPower(a: Array<LongArray>, times: Int): Array<LongArray> {
+        var a = a
+        var times = times
+        val n = a.size
+        var e = Array(n) { LongArray(n) }
+        for (i in 0 until n) {
+            e[i][i] = 1
+        }
+        while (times != 0) {
+            if (times % 2 == 1) {
+                e = multiple(e, a, n)
+            }
+            times = times shr 1
+            a = multiple(a, a, n)
+        }
+        return e
+    }
+
+    private fun multiple(a: Array<LongArray>, b: Array<LongArray>, n: Int): Array<LongArray> {
+        val target = Array(n) { LongArray(n) }
+        for (j in 0 until n) {
+            for (k in 0 until n) {
+                for (l in 0 until n) {
+                    target[j][k] += a[j][l] * b[l][k]
+                    target[j][k] = target[j][k] % 1000000007
+                }
+            }
+        }
+        return target
+    }
+}

src/main/kotlin/g0501_0600/s0552_student_attendance_record_ii/readme.md

@@ -0,0 +1,40 @@
+552\. Student Attendance Record II
+
+Hard
+
+An attendance record for a student can be represented as a string where each character signifies whether the student was absent, late, or present on that day. The record only contains the following three characters:
+
+*   `'A'`: Absent.
+*   `'L'`: Late.
+*   `'P'`: Present.
+
+Any student is eligible for an attendance award if they meet **both** of the following criteria:
+
+*   The student was absent (`'A'`) for **strictly** fewer than 2 days **total**.
+*   The student was **never** late (`'L'`) for 3 or more **consecutive** days.
+
+Given an integer `n`, return _the **number** of possible attendance records of length_ `n` _that make a student eligible for an attendance award. The answer may be very large, so return it **modulo**_ <code>10<sup>9</sup> + 7</code>.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 8
+
+**Explanation:** There are 8 records with length 2 that are eligible for an award: "PP", "AP", "PA", "LP", "PL", "AL", "LA", "LL" Only "AA" is not eligible because there are 2 absences (there need to be fewer than 2).
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 3
+
+**Example 3:**
+
+**Input:** n = 10101
+
+**Output:** 183236316
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>