### 算法： 浮点数二分 讲义

#### 1. 引言

*   **问题引入**：我们都知道 √2 大约是 1.414，但这个结果是怎么算出来的？计算器按一个键就能得到答案，但它内部到底发生了什么？我们无法通过有限次的加减乘除直接得到这个无限不循环小数。这背后其实就用到了我们今天要学的思想——不断缩小范围，无限逼近。

*   **价值阐述**：浮点数二分是解决**连续函数求根**、**实数域最优解**等问题的一大利器。它在科学与工程计算中扮演着至关重要的角色：
    *   **方程求解**：求解 `sin(x) + x = 5` 这种无法直接解出的**超越方程**的根。
    *   **物理模拟**：计算物体达到特定速度或位置所需的时间。
    *   **几何计算**：在复杂图形中寻找满足特定几何属性（如面积、周长）的参数。
    它让我们能够用一种统一、简洁且高效的编程模型，来应对各种复杂的数学和工程问题。

*   **学习目标**：
    1.  理解浮点数二分与整数二分的本质区别。
    2.  掌握基于**精度控制**的循环条件和边界更新方式。
    3.  学会使用“枚举+二分”的分治策略解决复杂的多根求解问题。
    4.  能够独立编写代码求解一元三次方程的根。

#### 2. 核心思想

*   **思路铺垫：手动计算 √2**
    回到 √2 的问题。我们不求精确命中，只求去逼近它。
    
    1.  **确定范围**：我们知道 1²=1 (太小了)，2²=4 (太大了)。所以，√2 一定在 `[1.0, 2.0]` 这个区间里。
    2.  **第一次猜测**：取区间中点 `1.5`。计算 `1.5² = 2.25`。嗯，还是太大了。说明 √2 肯定比 `1.5` 小。于是，答案范围被我们缩小到了 `[1.0, 1.5]`。
    3.  **第二次猜测**：取新区间的中点 `1.25`。计算 `1.25² = 1.5625`。这次又太小了。说明 √2 比 `1.25` 大。答案范围进一步缩小到 `[1.25, 1.5]`。
    4.  **继续...**：我们不断重复“**取中点 -> 判断 -> 缩小范围**”这个过程，区间的长度会以指数级速度减小，`left` 和 `right` 将会无限逼近那个真正的 √2。
    
*   **浮点数二分与整数二分的三个核心区别**

    1.  **目标不同**
        *   **整数二分**：像是在一排有编号的格子里找东西，目标是**精确到**某个格子。
        *   **浮点数二分**：像是在一条连续的线段上找一个点，由于浮点数无限可分，我们几乎不可能精确命中。我们的目标是**无限逼近**，直到我们的左右边界把这个点“夹”得足够紧，紧到我们无法分辨它们的区别为止。

    2.  **循环条件不同：`while (r - l > eps)` vs. `while (l <= r)`**
        *   在整数世界，`l` 和 `r` 最终会“撞上”或“越过”对方，循环自然停止。
        *   在浮点数世界，`l` 和 `r` 可能永远不会完全相等。因此，我们引入一个极小值 `eps` (Epsilon，精度)，比如 `1e-8`。当区间的长度 `r - l` 已经比这个 `eps` 还要小的时候，我们就认为 `l` 和 `r` 已经“贴”在一起了，找到了答案。

    3.  **边界更新不同：`l = mid` vs. `l = mid + 1`**
        *   整数二分中，如果 `mid` 不是答案，那下一个可能的答案至少是 `mid + 1`，我们可以放心地跳一格。
        *   浮点数二分中，如果 `mid` 不是答案，真正的答案可能就藏在 `mid` 和 `mid + 0.000...01` 之间。我们绝不能跳过任何一点点空间！因此，新的边界必须是 `mid` 本身，即 `l = mid` 或 `r = mid`。

*   **浮点数二分模板**
    
    ```cpp
    double l, r;       // 答案所在的初始范围
    const double eps = 1e-8; // 精度，题目要求k位小数，eps可设为1e-(k+2)
    
    while (r - l > eps) { // 当区间长度还不够小时，继续二分
        double mid = l + (r - l) / 2; // 取中点
        if (check(mid)) { // check函数判断mid是否满足某种偏大的条件
            r = mid;      // 答案在左半边，或者mid就是答案
        } else {
            l = mid;      // 答案在右半边，或者mid就是答案
        }
    }
    // 循环结束时，l和r已经非常接近，输出任意一个均可
    cout << l << endl; 
    ```

#### 3. 实例

*   **具体案例：求解方程 `ax³+bx²+cx+d=0`**
    (B0193 / 书本例13-5)
    **问题分析**：
    这是一个一元三次方程。直接求解非常复杂。但题目给了我们几个关键的信息：
    
    1.  **根的范围已知**：`[-100, 100]`。这直接给了我们一个初始的搜索大区间。
    2.  **根的间距 ≥ 1**：它意味着，如果我们把 `[-100, 100]` 这条长长的数轴，切成 200 个长度为 1 的小区间 `[-100, -99]`, `[-99, -98]`, ..., `[99, 100]`，那么**每一个小区间里，最多只可能有一个根**。
    3.  **零点存在性定理**：`f(x₁)*f(x₂) < 0` 意味着 `f(x₁)` 和 `f(x₂)` 的函数值一个为正、一个为负。由于函数曲线是连续的，它必然会在这两者之间**穿过x轴**一次，也就是说，` (x₁, x₂) `之间必有一个根。
    
*   **算法策略：分治法 (枚举粗筛 + 二分精搜)**
    我们不能直接在 `[-100, 100]` 上二分，因为有三个根，天知道二分会逼近哪一个。正确的做法是：

    **第一步：枚举粗筛**
    我们用一个 `for` 循环，以 1 为步长，从 -100 扫描到 99。在每一步，我们检查 `[i, i+1]` 这个小区间。
    
    *   如果 `f(i)` 和 `f(i+1)` 的符号不同 (即 `f(i) * f(i+1) < 0`)，我们就锁定了一个藏有根的区间！
    
    **第二步：二分精搜**
    一旦我们找到了一个区间，比如 `[i, i+1]`，我们就知道这里面有且仅有一个根。现在问题变得简单了：在一个小区间内找一个唯一的根。我们立刻在这个小区间上套用浮点数二分模板，把这个根揪出来。
    
*   **流程示例**
    
    1.  **粗筛**：`for` 循环检查 `[-3,-2]`, `[-2,-1]`, `[-1,0]`...
    2.  发现 `f(-2)` 是正的，`f(-1)` 是负的。`f(-2)*f(-1) < 0`！锁定区间 `[-2, -1]`。
    3.  **精搜**：在 `[-2, -1]` 内启动浮点二分，最终逼近根 `r1`。
    4.  `for` 循环继续，又发现 `f(0)*f(1) < 0`，锁定 `[0, 1]`，二分出 `r2`。
    5.  `for` 循环继续，发现 `f(2)*f(3) < 0`，锁定 `[2, 3]`，二分出 `r3`。

#### 4. 代码实现

*   **完整代码**
    ```cpp
    #include <bits/stdc++.h>
    using namespace std;
    
    // 全局变量存储方程系数
    double a, b, c, d;
    
    // 定义方程函数 f(x)
    double f(double x) {
        return a * x * x * x + b * x * x + c * x + d;
    }
    
    int main() {
        cin >> a >> b >> c >> d;
    
        // 设置输出格式为保留两位小数
        cout << fixed << setprecision(2);
    
        // 第一步：枚举粗筛
        for (int i = -100; i < 100; ++i) {
            double x1 = i;
            double x2 = i + 1;
            double y1 = f(x1);
            double y2 = f(x2);
    
            if (y1 == 0) {
                // 如果左端点恰好是根，直接输出
                cout << x1 << " ";
            } 
            else if (y1 * y2 < 0) {
                // 如果区间内有根，启动第二步：二分精搜
                double l = x1, r = x2;
                const double eps = 1e-4; // 题目要求2位小数，1e-4的精度足够
    
                while (r - l > eps) {
                    double mid = l + (r - l) / 2;
                    // 判断根在左半边还是右半边
                    // 如果 f(mid) 和 f(l) 同号，说明根在[mid, r]
                    // 否则根在 [l, mid]
                    if (f(mid) * f(l) > 0) { 
                        l = mid;
                    } else {
                        r = mid;
                    }
                }
                cout << l << " ";
            }
        }
        return 0;
    }
    ```
    
*   **代码解读**：
    
    *   `for (int i = -100; i < 100; ++i)`: 实现了从 -100 到 99 的步长为 1 的扫描。
    *   `if (f(mid) * f(l) > 0)`: 这是判断根在哪一半区间的核心。如果 `f(mid)` 和 `f(l)` 同号（乘积为正），说明 `[l, mid]` 这个区间两端点函数值同号，根不在这里，所以根在另一半 `[mid, r]`，因此更新 `l = mid`。反之 `r = mid`。

#### 5. 验证与深化

*   **常见问题**
    1.  **为什么 `eps` 要设为 `1e-(k+2)`？**
        这是一种经验法则。二分法在最后几次迭代时，精度提升会变慢。为了确保第 `k` 位小数的正确性，我们需要计算到比它更精确几位的程度，再进行四舍五入。多算两位通常是比较保险的选择。
    2.  **二分判断条件 `if (f(mid) * f(l) > 0)` 可以换成 `if (f(mid) * f(r) > 0)` 吗？**
        可以，但逻辑要相应改变。如果 `f(mid)` 和 `f(r)` 同号，说明根在 `[l, mid]`，应更新 `r = mid`。只要保证逻辑自洽即可。
    3.  **如果题目没有“根的间距>=1”这个条件怎么办？**
        问题会变得非常复杂。一个单位区间内可能有多个根，`f(i)*f(i+1) < 0` 这个条件就可能失效（比如有两个根，穿过去又穿回来，导致两端点同号）。这时需要借助微积分中的导数来判断函数的单调区间，在每个单调区间内再进行二分。

#### 6. 总结

*   **要点回顾**：
    1.  **浮点数二分**的核心是**逼近**，而非查找。
    2.  **循环条件**由精度 `eps` 控制：`while (r - l > eps)`。
    3.  **边界更新**不加减1：`l = mid` 或 `r = mid`。
    4.  面对复杂问题，**分治思想**是关键。通过**枚举粗筛**将大问题分解为多个简单的、适合二分的小问题。
*   **思考**：
    我们今天所有 `check` 的依据都是函数值的正负号。二分思想的应用远不止于此。任何一个参数，只要它能导致结果呈现出某种“单调性”（越大越如何，或越小越如何），我们都可以对这个参数进行二分,在整数和浮点数里是完全通用的。