### 0x04 two points

There are two dichotomous ways:

int l = 0, r = n + 1; while(l < r) { mid = l + (r - l) / 2; if(a[mid] >= x) r = mid; else l = mid + 1; } while(l < r) { mid = (l + r + 1) << 1; if(a[mid] <= x) l = mid; else r = mid - 1; }

1. Cyclic condition l < R

It can be guaranteed that the final l == r at this time, the mid must fall on the correct answer

2. Change of l and r

The first is to find the lower_bound(x), the smallest number greater than or equal to X. when a [mid] > = x, the numbers after mid are certainly not satisfied, and mid may be the correct answer, so r = mid; When a [mid] < x, mid must not be the correct answer, so l = mid + 1;

The second is to find the maximum number less than or equal to X. when a [mid] < = x, the numbers before mid are certainly not satisfied, and mid may be the correct answer, so l = mid; When a [mid] > x, mid must not be the correct answer, so r = mid - 1;

3. Change of mid + [0, n+1]

Mid = L + (R - L) / 2 prevents overflow

Mid = (R + l + 1) < 1 makes mid not equal to l, so as to avoid that when r - l = 1, mid is always equal to l, and an endless loop is formed after entering the l = mid statement;

The original interval [1, n] is extended to [0, n+1] to deal with the case of no solution

##### Summary: specific analysis

1. Select the corresponding left and right half intervals according to the comparison results between a[mid] and the target value

2. According to the target value to be found, judge whether mid + 1 and mid - 1 are not the correct answer, and then select one of the two supporting half schemes: "r = mid, l = mid + 1, mid = L + (R - L) / 2" and "L = mid, r = mid - 1, mid = (L + R + 1) < < 1"

3. The termination condition is l == r, and this position is the final answer.

#### Dichotomy on real number field

1. Generally, when k decimal places are reserved, take the precision eps = 1e-(k+2)

2. while condition is L + EPS < R

while(l + eps < r) { double mid = (l + r) / 2; if(calc(mid)) l = mid; else r = mid;

3. If it is difficult to determine the accuracy, the fixed number of cycles is used for bisection, and the accuracy is often even higher

For(i, 1, 100) { double mid = (l + r) / 2; if(calc(mid)) l = mid; else r = mid; }

#### Example aw102 maximum matrix sum of pre example -- POJ1050

int main () { cin >> n; For(i, 1, n) For(j, 1, n) cin >> mat[i][j]; For(i, 1, n) { clr(s); For(j, i, n) { For(k, 1, n) s[k] += mat[j][k]; int num = 0; For(k, 1, n) { num += s[k]; if(num <= 0) num = 0; ans = max(ans, num); } } } cout << ans << endl; return 0; }

Traverse from row i to row j, and save the sum of each column from row i to row j with sum under different i conditions. After saving row j, find the maximum subarray sum once and compare it with ans, so as to change the two-dimensional into one-dimensional, and find the sum of the maximum submatrixes for all matrices in different rows, and finally get the sum of the maximum matrices

#### Example aw102 best cattle fence

Title Link: 102. Best cattle fence - AcWing question bank

Main idea: find the maximum average of all subsequences with length not less than L (sum of subsequences / length of subsequences)

Train of thought analysis: real number field dichotomy + prefix and

We can calculate the maximum average by subtracting the average from each item of the sequence to find that the sum of subsequences with length ≥ L is non negative. Since the maximum average is required, the larger the sum of non negative subsequences is, the better (because each item of the subsequence can subtract a larger average and still ensure non negative), that is, after subtracting itself from each item of the sequence, Maximum subsequence and nonnegative maximum mean

**Solution steps: 1. First use the real number field to get the average**

double l = 0, r = 1e6; double mid; double eps = 1e-5; //Keep three decimal places while(l + eps < r) //Real number field dichotomy { mid = (l + r) / 2; if(check(mid)) l = mid; else r = mid; }

2. A new sequence is generated by using the average, and the prefix sum is calculated

3. The sum of the largest subsequences of the new sequence is obtained by using the idea of prefix sum, and whether it is ≥ 0 is judged

bool check(double mid) { For(i, 1, n) s[i] = s[i-1] + a[i] - mid; //Step 2 find the prefix and of the new sequence double minn = 1e6; for(int i = 0, j = f; j <= n; j++, i++) //Using the idea of two pointers, first set the position difference of the pointer to L, and then add 1 synchronously every cycle { minn = min(minn, s[i]); //minn must be the minimum prefix sum that all S[j] can subtract, and subtracting the minimum is the sum of the maximum subsequences if(s[j] - minn >= 0) return true; //If the conditions are met, continue dichotomy to find the optimal solution } return false; }

Full Code:

//#pragma comment(linker, "/STACK:10240000000000,10240000000000") //#pragma GCC optimize(2) #include <bits/stdc++.h> #define For(i,a,b) for (int i=(a);i<=(b);++i) #define Fod(i,b,a) for (int i=(b);i>=(a);--i) #define mls multiset #define lb lower_bound #define ub upper_bound #define pb push_back #define pob pop_back #define itt iterator #define clr(x) memset(x, 0, sizeof(x)); typedef long long ll; typedef unsigned long long ull; using namespace std; const int MAXN = 0x7fffffff; int n, f; double a[100005]; double b[100005]; double s[100005]; bool check(double mid) { For(i, 1, n) s[i] = s[i-1] + a[i] - mid; double minn = 1e6; for(int i = 0, j = f; j <= n; j++, i++) { minn = min(minn, s[i]); if(s[j] - minn >= 0) return true; } return false; } int main () { cin >> n >> f; For(i, 1, n) cin >> a[i]; double l = 0, r = 1e6; double mid; double eps = 1e-5; while(l + eps < r) { mid = (l + r) / 2; if(check(mid)) l = mid; else r = mid; } cout << (int)(r*1000) << endl; return 0; }