Updates leetcode/binary-search/528-random-pick-with-weight.md

Auto commit by GitBook Editor

Author: just4once

SUMMARY.md

@@ -251,6 +251,7 @@
     * [475-Heaters](leetcode/binary-search/475-heaters.md)
     * [483-Smallest Good Base](leetcode/binary-search/483-smallest-good-base.md)
     * [497-Random Point in Non-overlapping Rectangles](leetcode/binary-search/497-random-point-in-non-overlapping-rectangles.md)
+    * [528-Random Pick with Weight](leetcode/binary-search/528-random-pick-with-weight.md)
     * [644-Maximum Average Subarray II](leetcode/binary-search/644-maximum-average-subarray-ii.md)
     * [658-Find K Closest Elements](leetcode/binary-search/658-find-k-closest-elements.md)
     * [668-Kth Smallest Number in Multiplication Table](leetcode/binary-search/668-kth-smallest-number-in-multiplication-table.md)

leetcode/binary-search/528-random-pick-with-weight.md

@@ -0,0 +1,83 @@
+### Question {#question}
+
+[https://leetcode.com/problems/random-pick-with-weight/description/](https://leetcode.com/problems/random-pick-with-weight/description/)
+
+Given an array w of positive integers, where w\[i\] describes the weight of index i, write a function pickIndex which randomly picks an index in proportion to its weight.
+
+**Note:  
+**
+
+1. 1 <= w.length <= 10000
+2. 1 <= w\[i\] <= 10^5
+3. pickIndex will be called at most 10000 times.
+
+**Example 1:**
+
+```
+Input: 
+["Solution","pickIndex"]
+[[[1]],[]]
+Output: [null,0]
+```
+
+**Example 2:**
+
+```
+Input: 
+["Solution","pickIndex","pickIndex","pickIndex","pickIndex","pickIndex"]
+[[[1,3]],[],[],[],[],[]]
+Output: [null,0,1,1,1,0]
+```
+
+**Explanation of Input Syntax:  
+**
+
+The input is two lists: the subroutines called and their arguments. Solution's constructor has one argument, the array w. pickIndex has no arguments. Arguments are always wrapped with a list, even if there aren't any.
+
+### Thought Process {#thought-process}
+
+1. Binary Search
+   1. Since every integer is weighted, we need to get the total sum before we pick a point
+   2. The total sum does not exceed the integer max value, so we can use a int to store the sum
+   3. After creating accumulated sum array, we generate a random point, r, between \[0, sum\) and perform binary search on this accumulated array
+   4. Time complexity O\(n\)
+   5. Space complexity O\(n\)
+2. TreeMap
+   1. 
+3. asd
+
+### Solution
+
+```java
+class Solution {
+    private int[] presum;
+    private int n;
+    private Random rand;
+
+    public Solution(int[] w) {
+        n = w.length;
+        presum = new int[n];
+        rand = new Random();
+        presum[0] = w[0];
+        for (int i = 1; i < n; i++) presum[i] = presum[i - 1] + w[i];
+    }
+
+    public int pickIndex() {
+        int r = rand.nextInt(presum[n - 1]) + 1;
+        int i = Arrays.binarySearch(presum, r);
+        if (i < 0) i = -(i + 1);
+        return i;
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * Solution obj = new Solution(w);
+ * int param_1 = obj.pickIndex();
+ */
+```
+
+### Additional {#additional}
+
+
+