Merge pull request #394 from xirc/lib/binary-search

Add binary search library

Author: xirc

README.md

@@ -117,6 +117,7 @@ This project contains my competitive programming library, examples, and solution
 
 ### [Utilities](/lib/cpalgo/util)
 
+* [Binary Search](/lib/cpalgo/util/README.md#Binary-Search)
 * [Two Pointers](/lib/cpalgo/util/README.md#Two-Pointers)  
   "しゃくとり法" in Japanese
 * [BigInt](/lib/cpalgo/util/README.md#BigInt)

atcoder/abc034/D/main.cpp

@@ -1,5 +1,20 @@
 #include <bits/stdc++.h>
 
+inline long double binary_search_f(
+    std::function<bool(long double)> const& predicate,
+    long double ng,
+    long double ok,
+    const size_t N = 200
+) {
+    assert(!predicate(ng) && predicate(ok));
+    for (size_t i = 0; i < N; ++i) {
+        auto m = (ok + ng) / 2;
+        if (predicate(m)) ok = m;
+        else ng = m;
+    }
+    return ok;
+}
+
 using namespace std;
 using ll = int64_t;
 using lf = long double;
@@ -23,6 +38,7 @@ bool pass(lf pth) {
     return u - 1e-8 > 0;
 }
 
+
 int main() {
     ios_base::sync_with_stdio(false);
     cin.tie(0); cout.tie(0);
@@ -34,15 +50,8 @@ int main() {
     }
 
     lf ok = 0.0, ng = 200.0;
-    for (int i = 0; i < 400; ++i) {
-        lf m = (ok + ng) / 2.0;
-        if (pass(m)) {
-            ok = m;
-        } else {
-            ng = m;
-        }
-    }
-    cout << fixed << setprecision(6) << ok << endl;
+    auto ans = binary_search_f(pass, ng, ok, 400);
+    cout << fixed << setprecision(6) << ans << endl;
 
     return 0;
 }

atcoder/abc063/D/main.cpp

@@ -1,12 +1,26 @@
 #include <bits/stdc++.h>
 
+inline int64_t binary_search(
+    std::function<bool(int64_t)> const& predicate,
+    int64_t ng,
+    int64_t ok
+) {
+    assert(!predicate(ng) && predicate(ok));
+    while (abs(ok - ng) > 1) {
+        auto m = (ok + ng) / 2;
+        if (predicate(m)) ok = m;
+        else ng = m;
+    }
+    return ok;
+}
+
 using namespace std;
-using ll = long long;
+using ll = int64_t;
 
 int N, A, B;
 vector<int> H;
 
-bool is_ok(const ll M) {
+bool satisfy(const ll M) {
     int mxh = *max_element(H.begin(), H.end());
     if (mxh / B < M) return true; // prevent an overflow
     assert(B * M <= mxh);
@@ -25,17 +39,8 @@ bool is_ok(const ll M) {
 }
 
 ll solve() {
-    ll low = 0, high = 1e15;
-    assert(!is_ok(low) && is_ok(high));
-    while (high - low > 1) {
-        auto m = low + (high - low) / 2;
-        if (is_ok(m)) {
-            high = m;
-        } else {
-            low = m;
-        }
-    }
-    return high;
+    ll ng = 0, ok = 1e15;
+    return binary_search(satisfy, ng, ok);
 }
 
 int main() {

lib/cpalgo/util/README.md

@@ -14,6 +14,19 @@
 - [単調増加 - AtCoder ABC038C](https://atcoder.jp/contests/abc038/tasks/abc038_c)
 
 
+## Binary Search
+*Binary Search* is an algorithm technique that reduces solution space by half at one iteration.
+Although Binary Search often is used in which we search a specific value in a given sorted array, it is not limited.
+We can use this technique in many problems. It's a pretty powerful technique.
+
+[Binary Search (Integer) | C++ code](binary-search.hpp)
+[Binary Search (Double) | C++ code](binary-search_f.hpp)
+
+### Challenges
+- [食塩水](https://atcoder.jp/contests/abc034/tasks/abc034_d)
+- [Widespread](https://atcoder.jp/contests/abc063/tasks/arc075_b)
+
+
 ## Dice
 🚧WIP
 

lib/cpalgo/util/binary_search.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <limits>
+#include <functional>
+#include <cassert>
+
+
+// Binary Search for an integer number
+//
+// Time: O(logN)
+// Space: O(1)
+//
+// See:
+//  - https://qiita.com/drken/items/97e37dd6143e33a64c8c
+//
+// Verified:
+// - https://atcoder.jp/contests/abc063/tasks/arc075_b
+//
+inline int64_t binary_search(
+    std::function<bool(int64_t)> const& predicate,
+    int64_t ng,
+    int64_t ok
+) {
+    assert(!predicate(ng) && predicate(ok));
+    while (abs(ok - ng) > 1) {
+        auto m = (ok + ng) / 2;
+        if (predicate(m)) ok = m;
+        else ng = m;
+    }
+    return ok;
+}

lib/cpalgo/util/binary_search_f.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <limits>
+#include <functional>
+#include <cassert>
+
+
+// Binary Search for a floating point number
+//
+// Time: O(N)
+// Space: O(1)
+//
+// NOTE:
+// Use constant loop to avoid precision problems.
+// Every loop reduces solution space by half.
+// It would be better to pick a suitable loop count depending on a problem.
+//
+// Verified:
+// - https://atcoder.jp/contests/abc034/tasks/abc034_d
+//
+inline long double binary_search_f(
+    std::function<bool(long double)> const& predicate,
+    long double ng,
+    long double ok,
+    const size_t N = 200
+) {
+    assert(!predicate(ng) && predicate(ok));
+    for (size_t i = 0; i < N; ++i) {
+        auto m = (ok + ng) / 2;
+        if (predicate(m)) ok = m;
+        else ng = m;
+    }
+    return ok;
+}