Added tasks 526, 528, 529, 530.

Author: ThanhNIT

README.md

@@ -1455,6 +1455,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0154 |[Find Minimum in Rotated Sorted Array II](src.save/main/kotlin/g0101_0200/s0154_find_minimum_in_rotated_sorted_array_ii/Solution.kt)| Hard | Array, Binary_Search | 275 | 84.00
+| 0528 |[Random Pick with Weight](src/main/kotlin/g0501_0600/s0528_random_pick_with_weight/Solution.kt)| Medium | Math, Binary_Search, Prefix_Sum, Randomized | 393 | 91.38
 
 #### Day 14
 
@@ -1647,6 +1648,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.8'
 | 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
 | 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
+| 0530 |[Minimum Absolute Difference in BST](src/main/kotlin/g0501_0600/s0530_minimum_absolute_difference_in_bst/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Binary_Search_Tree | 209 | 86.96
+| 0529 |[Minesweeper](src/main/kotlin/g0501_0600/s0529_minesweeper/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix | 243 | 87.50
+| 0528 |[Random Pick with Weight](src/main/kotlin/g0501_0600/s0528_random_pick_with_weight/Solution.kt)| Medium | Math, Binary_Search, Prefix_Sum, Randomized, Binary_Search_II_Day_13 | 393 | 91.38
+| 0526 |[Beautiful Arrangement](src/main/kotlin/g0501_0600/s0526_beautiful_arrangement/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation, Backtracking, Bitmask | 107 | 100.00
 | 0525 |[Contiguous Array](src/main/kotlin/g0501_0600/s0525_contiguous_array/Solution.kt)| Medium | Array, Hash_Table, Prefix_Sum | 471 | 100.00
 | 0524 |[Longest Word in Dictionary through Deleting](src/main/kotlin/g0501_0600/s0524_longest_word_in_dictionary_through_deleting/Solution.kt)| Medium | Array, String, Sorting, Two_Pointers | 307 | 100.00
 | 0523 |[Continuous Subarray Sum](src/main/kotlin/g0501_0600/s0523_continuous_subarray_sum/Solution.kt)| Medium | Array, Hash_Table, Math, Prefix_Sum | 682 | 95.45

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

@@ -0,0 +1,27 @@
+package g0501_0600.s0526_beautiful_arrangement
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation #Backtracking #Bitmask
+// #2023_01_15_Time_107_ms_(100.00%)_Space_33.5_MB_(75.00%)
+
+class Solution {
+    fun countArrangement(n: Int): Int {
+        return backtrack(n, n, arrayOfNulls(1 shl n + 1), 0)
+    }
+
+    private fun backtrack(n: Int, index: Int, cache: Array<Int?>, cacheindex: Int): Int {
+        if (index == 0) {
+            return 1
+        }
+        var result = 0
+        if (cache[cacheindex] != null) {
+            return cache[cacheindex]!!
+        }
+        for (i in n downTo 1) {
+            if (cacheindex and (1 shl i) == 0 && (i % index == 0 || index % i == 0)) {
+                result += backtrack(n, index - 1, cache, cacheindex or (1 shl i))
+            }
+        }
+        cache[cacheindex] = result
+        return result
+    }
+}

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

@@ -0,0 +1,40 @@
+526\. Beautiful Arrangement
+
+Medium
+
+Suppose you have `n` integers labeled `1` through `n`. A permutation of those `n` integers `perm` (**1-indexed**) is considered a **beautiful arrangement** if for every `i` (`1 <= i <= n`), **either** of the following is true:
+
+*   `perm[i]` is divisible by `i`.
+*   `i` is divisible by `perm[i]`.
+
+Given an integer `n`, return _the **number** of the **beautiful arrangements** that you can construct_.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:**
+
+The first beautiful arrangement is [1,2]:
+
+- perm[1] = 1 is divisible by i = 1
+
+- perm[2] = 2 is divisible by i = 2
+
+The second beautiful arrangement is [2,1]:
+
+- perm[1] = 2 is divisible by i = 1
+
+- i = 2 is divisible by perm[2] = 1
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1
+
+**Constraints:**
+
+*   `1 <= n <= 15`

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

@@ -0,0 +1,34 @@
+package g0501_0600.s0528_random_pick_with_weight
+
+// #Medium #Math #Binary_Search #Prefix_Sum #Randomized #Binary_Search_II_Day_13
+// #2023_01_15_Time_393_ms_(91.38%)_Space_47_MB_(98.28%)
+
+import java.util.Random
+import java.util.TreeMap
+
+@Suppress("kotlin:S2245")
+class Solution(val w: IntArray) {
+
+    var x: IntArray = IntArray(w.size) { 0 }
+    val rand = Random()
+    val tree = TreeMap<Int, Int>()
+    var sum = 0
+
+    init {
+        for (i in w.indices) {
+            tree.put(sum, i)
+            sum += w[i]
+        }
+    }
+
+    fun pickIndex(): Int {
+        val r = rand.nextInt(sum)
+        return tree.floorEntry(r).value!!
+    }
+}
+
+/*
+ * Your Solution object will be instantiated and called as such:
+ * var obj = Solution(w)
+ * var param_1 = obj.pickIndex()
+ */

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

@@ -0,0 +1,54 @@
+528\. Random Pick with Weight
+
+Medium
+
+You are given a **0-indexed** array of positive integers `w` where `w[i]` describes the **weight** of the <code>i<sup>th</sup></code> index.
+
+You need to implement the function `pickIndex()`, which **randomly** picks an index in the range `[0, w.length - 1]` (**inclusive**) and returns it. The **probability** of picking an index `i` is `w[i] / sum(w)`.
+
+*   For example, if `w = [1, 3]`, the probability of picking index `0` is `1 / (1 + 3) = 0.25` (i.e., `25%`), and the probability of picking index `1` is `3 / (1 + 3) = 0.75` (i.e., `75%`).
+
+**Example 1:**
+
+**Input** ["Solution","pickIndex"] [[[1]],[]]
+
+**Output:** [null,0]
+
+**Explanation:**
+
+    Solution solution = new Solution([1]); 
+    solution.pickIndex(); // return 0. The only option is to return 0 since there is only one element in w.
+
+**Example 2:**
+
+**Input**
+
+    ["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
+    [[[1,3]],[],[],[],[],[]]
+
+**Output:** [null,1,1,1,1,0]
+
+**Explanation:**
+
+    Solution solution = new Solution([1, 3]); 
+    solution.pickIndex(); // return 1. It is returning the second element (index = 1) that has a probability of 3/4. 
+    solution.pickIndex(); // return 1 
+    solution.pickIndex(); // return 1 
+    solution.pickIndex(); // return 1 
+    solution.pickIndex(); // return 0. It is returning the first element (index = 0) that has a probability of 1/4. 
+
+    Since this is a randomization problem, multiple answers are allowed. 
+    All of the following outputs can be considered correct: 
+    [null,1,1,1,1,0] 
+    [null,1,1,1,1,1] 
+    [null,1,1,1,0,0] 
+    [null,1,1,1,0,1] 
+    [null,1,0,1,0,0] 
+    ...... 
+    and so on.
+
+**Constraints:**
+
+*   <code>1 <= w.length <= 10<sup>4</sup></code>
+*   <code>1 <= w[i] <= 10<sup>5</sup></code>
+*   `pickIndex` will be called at most <code>10<sup>4</sup></code> times.

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

@@ -0,0 +1,63 @@
+package g0501_0600.s0529_minesweeper
+
+// #Medium #Array #Depth_First_Search #Breadth_First_Search #Matrix
+// #2023_01_15_Time_243_ms_(87.50%)_Space_37_MB_(87.50%)
+
+class Solution {
+    private var row = 0
+    private var col = 0
+    private fun dfs(board: Array<CharArray>, row: Int, col: Int) {
+        if (row < 0 || row >= this.row || col < 0 || col >= this.col) {
+            return
+        }
+        if (board[row][col] == 'E') {
+            val numOfMine = bfs(board, row, col)
+            if (numOfMine != 0) {
+                board[row][col] = (numOfMine + '0'.code).toChar()
+                return
+            } else {
+                board[row][col] = 'B'
+            }
+            for (i in DIRECTION) {
+                dfs(board, row + i[0], col + i[1])
+            }
+        }
+    }
+
+    private fun bfs(board: Array<CharArray>, row: Int, col: Int): Int {
+        var numOfMine = 0
+        for (i in DIRECTION) {
+            val newRow = row + i[0]
+            val newCol = col + i[1]
+            if (newRow >= 0 && newRow < this.row && newCol >= 0 && newCol < this.col && board[newRow][newCol] == 'M') {
+                numOfMine++
+            }
+        }
+        return numOfMine
+    }
+
+    fun updateBoard(board: Array<CharArray>, c: IntArray): Array<CharArray> {
+        if (board[c[0]][c[1]] == 'M') {
+            board[c[0]][c[1]] = 'X'
+            return board
+        } else {
+            row = board.size
+            col = board[0].size
+            dfs(board, c[0], c[1])
+        }
+        return board
+    }
+
+    companion object {
+        private val DIRECTION = arrayOf(
+            intArrayOf(1, 0),
+            intArrayOf(-1, 0),
+            intArrayOf(0, 1),
+            intArrayOf(0, -1),
+            intArrayOf(-1, -1),
+            intArrayOf(-1, 1),
+            intArrayOf(1, -1),
+            intArrayOf(1, 1)
+        )
+    }
+}

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

@@ -0,0 +1,49 @@
+529\. Minesweeper
+
+Medium
+
+Let's play the minesweeper game ([Wikipedia](https://en.wikipedia.org/wiki/Minesweeper_(video_game)), [online game](http://minesweeperonline.com))!
+
+You are given an `m x n` char matrix `board` representing the game board where:
+
+*   `'M'` represents an unrevealed mine,
+*   `'E'` represents an unrevealed empty square,
+*   `'B'` represents a revealed blank square that has no adjacent mines (i.e., above, below, left, right, and all 4 diagonals),
+*   digit (`'1'` to `'8'`) represents how many mines are adjacent to this revealed square, and
+*   `'X'` represents a revealed mine.
+
+You are also given an integer array `click` where <code>click = [click<sub>r</sub>, click<sub>c</sub>]</code> represents the next click position among all the unrevealed squares (`'M'` or `'E'`).
+
+Return _the board after revealing this position according to the following rules_:
+
+1.  If a mine `'M'` is revealed, then the game is over. You should change it to `'X'`.
+2.  If an empty square `'E'` with no adjacent mines is revealed, then change it to a revealed blank `'B'` and all of its adjacent unrevealed squares should be revealed recursively.
+3.  If an empty square `'E'` with at least one adjacent mine is revealed, then change it to a digit (`'1'` to `'8'`) representing the number of adjacent mines.
+4.  Return the board when no more squares will be revealed.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_1.png)
+
+**Input:** board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0]
+
+**Output:** [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_2.png)
+
+**Input:** board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2]
+
+**Output:** [["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]
+
+**Constraints:**
+
+*   `m == board.length`
+*   `n == board[i].length`
+*   `1 <= m, n <= 50`
+*   `board[i][j]` is either `'M'`, `'E'`, `'B'`, or a digit from `'1'` to `'8'`.
+*   `click.length == 2`
+*   <code>0 <= click<sub>r</sub> < m</code>
+*   <code>0 <= click<sub>c</sub> < n</code>
+*   <code>board[click<sub>r</sub>][click<sub>c</sub>]</code> is either `'M'` or `'E'`.

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

@@ -0,0 +1,31 @@
+package g0501_0600.s0530_minimum_absolute_difference_in_bst
+
+import com_github_leetcode.TreeNode
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree #Binary_Search_Tree
+// #2023_01_15_Time_209_ms_(86.96%)_Space_38.5_MB_(69.57%)
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    private var ans = Int.MAX_VALUE
+    private var prev = Int.MAX_VALUE
+    fun getMinimumDifference(root: TreeNode?): Int {
+        if (root == null) {
+            return ans
+        }
+        getMinimumDifference(root.left)
+        ans = Math.min(ans, Math.abs(root.`val` - prev))
+        prev = root.`val`
+        getMinimumDifference(root.right)
+        return ans
+    }
+}

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

@@ -0,0 +1,28 @@
+530\. Minimum Absolute Difference in BST
+
+Easy
+
+Given the `root` of a Binary Search Tree (BST), return _the minimum absolute difference between the values of any two different nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst1.jpg)
+
+**Input:** root = [4,2,6,1,3]
+
+**Output:** 1
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/05/bst2.jpg)
+
+**Input:** root = [1,0,48,null,null,12,49]
+
+**Output:** 1
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[2, 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>5</sup></code>
+
+**Note:** This question is the same as 783: [https://leetcode.com/problems/minimum-distance-between-bst-nodes/](https://leetcode.com/problems/minimum-distance-between-bst-nodes/)

src/test/kotlin/g0501_0600/s0526_beautiful_arrangement/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0501_0600.s0526_beautiful_arrangement
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun countArrangement() {
+        assertThat(Solution().countArrangement(2), equalTo(2))
+    }
+
+    @Test
+    fun countArrangement2() {
+        assertThat(Solution().countArrangement(1), equalTo(1))
+    }
+}