leet-code/Java/Maximum Average Subarray II.java at master · awangdev/leet-code · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
R
1521096472
tags: Array, BinarySearch, PreSum

给int[] nums和windowminsizek. windowsize可以大于K. 找最大的连续数列averagevalue.

- BinarySearch的思想, 用在所要找的这个averagesum上面. 大小是在[min, max]之中
- 找k的时候, 是>=k都可以, 巧用一个min(preSum)的概念.
- 找k的时候, 画图, 可以看出来, 其实要的是kwindow里面的sum [x, i], 所以要用sum[0, i] - sum[0, x]

需要仔细去读下面的notes.

```

/*
Given an array consisting of n integers, find the contiguous subarray
whose length is greater than or equal to k that has the maximum average value.
And you need to output the maximum average value.

Example 1:
Input: [1,12,-5,-6,50,3], k = 4
Output: 12.75
Explanation:
when length is 5, maximum average value is 10.8,
when length is 6, maximum average value is 9.16667.
Thus return 12.75.
Note:
1 <= k <= n <= 10,000.
Elements of the given array will be in range [-10,000, 10,000].
The answer with the calculation error less than 10-5 will be accepted.

*/

/*
Thoughts:
If trying brutly, it'll be O(n^2). How about O(nLogN)?

Try binary serach on the final result: the average number, which will range from [min, max] of nums.
Should recognize that when seeing '1e-15'
http://bookshadow.com/weblog/2017/07/16/leetcode-maximum-average-subarray-ii/

Key idea:
0. start=mid, end=max.
1. Give the midAvg[min, max] as the arbitrary avg, see if we can find possible k [k ~ n], that gives average sum >= midAvg
2. If it does exist, maybe we can find larger midAvg? so set start=midAvg
3. If not exist, we should set end=midAvg

Problem:
How to effectively check we can beat given midAvg? Simply sum up k items => sum, then check sum/k >= midAvg.
Well, a bit more to it:
1. If using nums[0, k], it's easy: sum[0, k] / k will be it.
2. If using [x, i], where i - x = k. The sum will be sum[0, i] - preSum[0, x].
 Here is the core triky part: we don't have to try O(n^2) here to check all possible k in [k ~ n]
 Rather, we record preSum as the minimal value of all possible preSum as k moves.
 `sum[x, i] = sum[0 ~ i] - min(preSum's) >= 0` basically tells: for all possible k's, is there a split where preSum is smallest and makes the sum[x, i] greater than 0?
 That's the beauty to the problem: no need to calculate all possible k's: just need 1 valid solution, and we don't care which k that will be.
*/
classSolution {
publicdoublefindMaxAverage(int[] nums, intk) {
if (nums == null || nums.length == 0) {
return0;
 }
intn = nums.length;
doublemin = Integer.MAX_VALUE;
doublemax = Integer.MIN_VALUE;
for (inti = 0; i < n; i++) {
min = Math.min(nums[i], min);
max = Math.max(nums[i], max);
 }

doublestart = min;
doubleend = max;
doublemidAvg = max;
while (end - start > 1e-5) {
midAvg = start + (end - start) / 2.0;
if (check(nums, k, midAvg)) {
start = midAvg;
 } else {
end = midAvg;
 }
 }
returnmidAvg;
 }

/**
 Return true, if there is a window with size >= k,
 such that the average sum will >= given midAvg.
 */
privatebooleancheck(int[] nums, intk, doublemidAvg) {
doublepreSum = 0;
doublesum = 0;
doubleminPreSum = 0;
for (inti = 0; i < k; i++) {
sum += nums[i] - midAvg;
 }
if (sum >= 0) {
returntrue;
 }
for (inti = k; i < nums.length; i++) {
sum += nums[i] - midAvg;
preSum += nums[i - k] - midAvg;
minPreSum = Math.min(preSum, minPreSum);
if (sum >= minPreSum) {
returntrue;
 }
 }
returnfalse;
 }
}


```