题解 | #一元二次方程#

题目链接

题目描述

这是一个函数实现题。你需要实现一个 judgeSolutions 函数，它接受三个整数 a, b, c作为参数，代表一元二次方程 $ax^2 + bx + c = 0$ 的系数。你需要判断这个方程是否有实数解，并返回一个布尔值（true 或 false）。

平台工作模式:

你只需要在给定的函数框架内编写核心逻辑。
评测系统会自动调用你的函数并验证结果。
你不应该编写 main 函数或任何输入/输出代码。

示例:

输入: 1, 2, 2 (由平台处理)
你的函数被调用: judgeSolutions(1, 2, 2)
你的函数应返回: false (因为 $\Delta = 2^2 - 4 \cdot 1 \cdot 2 = -4 < 0$ )
输入: 0, 0, 0 (由平台处理)
你的函数被调用: judgeSolutions(0, 0, 0)
你的函数应返回: true (因为方程为 0=0，有无穷多解)

解题思路

这道题需要我们全面地分析方程的性质。关键在于要考虑所有情况，特别是 a=0 的退化情况。

Case 1: `a != 0` (标准一元二次方程)

这是最常见的情况。一个一元二次方程是否有实数解，完全由其判别式 (discriminant) $\Delta$ 的值决定。

$\Delta = b^2 - 4ac$
如果 $\Delta \geq 0$ ，方程有实数解（一个或两个）。
如果 $\Delta < 0$ ，方程没有实数解。

重要陷阱：整数溢出！ 在计算 b*b - 4*a*c 时，如果 a, b, c 是 int 类型，它们的乘积 b*b 或 4*a*c 很容易超出 int 的最大范围，导致计算错误。因此，在进行乘法运算前，必须将操作数强制类型转换为64位长整型 (long long in C++, long in Java)，以确保计算的准确性。

Case 2: `a == 0` (退化为线性方程)

当二次项系数 a 为0时，方程不再是二次方程，而退化为线性方程： $bx + c = 0$ 。

如果 b != 0: 方程变为 $x = -c/b$ 。这总是有唯一一个实数解。因此，返回 true。
如果 b == 0: 方程进一步退化为 $c = 0$ 。
- 如果 c 恰好也为 0，则方程为 $0=0$ ，这是恒成立的，意味着任意实数都是解。所以返回 true。
- 如果 c 不为 0，则方程为 c=0 (例如 $5=0$ )，这是一个矛盾式，无解。所以返回 false。

综合以上所有情况，我们就可以构建出完整的逻辑。

代码

注意：以下是你需要提交的全部内容，即在牛客网给定的模板中填写的代码。

c++
java
python

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 判断一元二次方程是否有实数解
     * @param a int整型 二次项系数
     * @param b int整型 一次项系数
     * @param c int整型 常数项
     * @return bool布尔型
     */
    bool judgeSolutions(int a, int b, int c) {
        if (a == 0) {
            // 方程退化为 bx + c = 0
            if (b != 0) {
                return true; // 线性方程，有唯一解
            } else {
                // 方程退化为 c = 0
                return c == 0; // c=0 时有无穷解，否则无解
            }
        } else {
            // 标准二次方程，计算判别式
            // 注意：必须使用 long long 防止 b*b 或 4*a*c 溢出
            long long delta = (long long)b * b - 4 * (long long)a * c;
            return delta >= 0;
        }
    }
};

import java.util.*;

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 判断一元二次方程是否有实数解
     * @param a int整型 二次项系数
     * @param b int整型 一次项系数
     * @param c int整型 常数项
     * @return bool布尔型
     */
    public boolean judgeSolutions (int a, int b, int c) {
        if (a == 0) {
            if (b != 0) {
                return true;
            } else {
                return c == 0;
            }
        } else {
            // 使用 long 计算判别式以防止溢出
            long delta = (long)b * b - 4L * a * c;
            return delta >= 0;
        }
    }
}

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 判断二元一次方程组是否有解
# @param a int整型 二次项系数
# @param b int整型 一次项系数
# @param c int整型 常数项
# @return bool布尔型
#
class Solution:
    def judgeSolutions(self, a: int, b: int, c: int) -> bool:
        if a == 0:
            if b != 0:
                return True
            else:
                return c == 0
        else:
            # Python 的 int 支持任意精度，不会溢出
            delta = b**2 - 4 * a * c
            return delta >= 0

算法及复杂度

算法: 条件判断、基本算术运算。
时间复杂度: $\mathcal{O}(1)$ 。整个过程只涉及几次比较和一次乘/减法运算，这些都是常数时间操作。
空间复杂度: $\mathcal{O}(1)$ 。没有使用额外的、与输入规模相关的存储空间。