//hys专属水印
//方程/不等式计算器 v2.0 (支持一元一次、二元一次、一元二次、一元一次不等式组)
#include <bits/stdc++.h>
using namespace std;

// ==================== 版本信息 ====================
const string VERSION = "v2.0";
const string UPDATE_DATE = "2026-07-26";

// ==================== 颜色高亮（必须先定义） ====================
#ifdef _WIN32
    #include <windows.h>
    void setColor(int color) {
        HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(hConsole, color);
    }
    #define COLOR_RESET 7
    #define COLOR_GREEN 10
    #define COLOR_RED 12
    #define COLOR_YELLOW 14
    #define COLOR_CYAN 11
    #define COLOR_WHITE 15
#else
    #define COLOR_RESET "\033[0m"
    #define COLOR_GREEN "\033[1;32m"
    #define COLOR_RED "\033[1;31m"
    #define COLOR_YELLOW "\033[1;33m"
    #define COLOR_CYAN "\033[1;36m"
    #define COLOR_WHITE "\033[1;37m"
    void setColor(int color) {}
#endif

// 颜色输出函数（必须在 printVersionInfo 之前定义）
void printGreen(const string& s) { setColor(COLOR_GREEN); cout << s; setColor(COLOR_RESET); }
void printRed(const string& s) { setColor(COLOR_RED); cout << s; setColor(COLOR_RESET); }
void printYellow(const string& s) { setColor(COLOR_YELLOW); cout << s; setColor(COLOR_RESET); }
void printCyan(const string& s) { setColor(COLOR_CYAN); cout << s; setColor(COLOR_RESET); }
void printWhite(const string& s) { setColor(COLOR_WHITE); cout << s; setColor(COLOR_RESET); }

// ==================== 版本信息显示 ====================
void printVersionInfo() {
    cout << "\n";
    printCyan("╔═══════════════════════════════════════════════════════════════╗\n");
    printCyan("║");
    printWhite("             方程/不等式计算器 " + VERSION + " 更新说明");
    printCyan("                   ║\n");
    printCyan("╠═══════════════════════════════════════════════════════════════╣\n");
    printCyan("║");
    printGreen(" 新增功能:");
    printCyan("                                                     ║\n");
    printCyan("║   一元一次不等式组求解 (支持2-4个不等式)                      ║\n");
    printCyan("║   智能识别方程/不等式/方程组类型                              ║\n");
    printCyan("║   更完善的错误提示和边界检测                                  ║\n");
    printCyan("║                                                               ║\n");
    printCyan("║");
    printGreen(" 已有功能:");  
    printCyan("                                                     ║\n");
    printCyan("║   一元一次方程        一元一次不等式                          ║\n");
    printCyan("║   一元二次方程        二元一次方程组                          ║\n");
    printCyan("║   常数方程识别        高次项检测                              ║\n");
    printCyan("║   自定义变量名        隐式乘法支持                            ║\n");
    printCyan("║   分数形式输出        彩色高亮显示                	        ║\n");
    printCyan("║                                                               ║\n");
    printCyan("╚═══════════════════════════════════════════════════════════════╝\n");
}

// ==================== 表达式解析器 ====================
class ExpressionParser {
private:
    string expr;
    size_t pos;
    map<char, double> vars;
    double parseAddSub();
    double parseMulDiv();
    double parseFactor();
    void skipSpaces() { while (pos < expr.size() && isspace(expr[pos])) pos++; }
public:
    ExpressionParser(const string& s) : expr(s), pos(0) {}
    void setVar(char name, double value) { vars[name] = value; }
    double eval();
};

double ExpressionParser::eval() { pos = 0; return parseAddSub(); }

double ExpressionParser::parseAddSub() {
    double result = parseMulDiv();
    while (true) {
        skipSpaces();
        if (pos >= expr.size()) break;
        char op = expr[pos];
        if (op == '+' || op == '-') { pos++; double val = parseMulDiv(); result += (op == '+') ? val : -val; }
        else break;
    }
    return result;
}

double ExpressionParser::parseMulDiv() {
    double result = parseFactor();
    while (true) {
        skipSpaces();
        if (pos >= expr.size()) break;
        char op = expr[pos];
        if (op == '*' || op == '/') { pos++; double val = parseFactor(); if (op == '*') result *= val; else { if (fabs(val) < 1e-12) throw runtime_error("除以零"); result /= val; } }
        else { if (pos < expr.size() && (isalpha(expr[pos]) || expr[pos] == '(')) { double val = parseFactor(); result *= val; } else break; }
    }
    return result;
}

double ExpressionParser::parseFactor() {
    skipSpaces();
    if (pos >= expr.size()) throw runtime_error("表达式意外结束");
    char ch = expr[pos];
    if (ch == '+' || ch == '-') { pos++; double val = parseFactor(); return (ch == '-') ? -val : val; }
    if (ch == '(') { pos++; double val = parseAddSub(); skipSpaces(); if (pos >= expr.size() || expr[pos] != ')') throw runtime_error("括号不匹配"); pos++; return val; }
    if (isalpha(ch)) { pos++; if (vars.find(ch) != vars.end()) return vars[ch]; throw runtime_error(string("未知变量: ") + ch); }
    if (isdigit(ch) || ch == '.') {
        string num;
        while (pos < expr.size() && (isdigit(expr[pos]) || expr[pos] == '.')) num += expr[pos++];
        if (pos < expr.size() && (expr[pos] == 'e' || expr[pos] == 'E')) {
            num += expr[pos++];
            if (pos < expr.size() && (expr[pos] == '+' || expr[pos] == '-')) num += expr[pos++];
            while (pos < expr.size() && isdigit(expr[pos])) num += expr[pos++];
        }
        try { return stod(num); } catch (...) { throw runtime_error(string("无效数字: ") + num); }
    }
    throw runtime_error(string("非法字符: ") + ch);
}

string removeSpaces(const string& s) { string r; for (char c : s) if (!isspace(c)) r += c; return r; }

// ==================== 方程类型检测 ====================
bool isInequality(const string& eq) {
    string s = removeSpaces(eq);
    return s.find('<') != string::npos || s.find('>') != string::npos;
}

struct InequalityInfo {
    char sign;
    size_t pos;
    string signStr;
};

InequalityInfo getInequalitySign(const string& eq) {
    string s = removeSpaces(eq);
    InequalityInfo info;
    info.pos = string::npos;
    info.sign = '=';
    info.signStr = "";
    
    if (s.find("<=") != string::npos) {
        info.pos = s.find("<=");
        info.sign = 'l';
        info.signStr = "<=";
    } else if (s.find(">=") != string::npos) {
        info.pos = s.find(">=");
        info.sign = 'g';
        info.signStr = ">=";
    } else if (s.find('<') != string::npos) {
        info.pos = s.find('<');
        info.sign = '<';
        info.signStr = "<";
    } else if (s.find('>') != string::npos) {
        info.pos = s.find('>');
        info.sign = '>';
        info.signStr = ">";
    }
    return info;
}

bool isQuadraticEquation(const string& eq) {
    string s = removeSpaces(eq);
    for (size_t i = 0; i < s.size(); i++) {
        if (s[i] == 'x' || s[i] == 'X') {
            if (i + 2 < s.size() && s[i + 1] == '^' && s[i + 2] == '2') return true;
            if (i + 2 < s.size() && s[i + 1] == '*' && (s[i + 2] == 'x' || s[i + 2] == 'X')) return true;
            if (i + 1 < s.size() && (s[i + 1] == 'x' || s[i + 1] == 'X')) return true;
        }
    }
    return false;
}

bool hasHigherDegree(const string& eq) {
    string s = removeSpaces(eq);
    for (size_t i = 0; i < s.size(); i++) {
        if ((s[i] == 'x' || s[i] == 'X') && i + 2 < s.size() && s[i + 1] == '^') {
            if (s[i + 2] >= '3' && s[i + 2] <= '9') return true;
        }
    }
    return false;
}

bool hasVariable(const string& eq) {
    string s = removeSpaces(eq);
    for (char c : s) {
        if (isalpha(c) && c != 'e' && c != 'E') return true;
    }
    return false;
}

bool isLinearEquation(const string& eq) {
    string s = removeSpaces(eq);
    size_t pos = s.find('^');
    if (pos != string::npos) {
        size_t p = pos + 1;
        while (p < s.size() && isspace(s[p])) p++;
        if (p < s.size() && s[p] == '1') {
            if (p + 1 < s.size() && isdigit(s[p + 1])) return false;
            return true;
        }
        return false;
    }
    for (size_t i = 0; i < s.size(); i++) {
        if (isalpha(s[i]) && s[i] != 'e' && s[i] != 'E') {
            if (i + 2 < s.size() && s[i + 1] == '*' && isalpha(s[i + 2]) && s[i + 2] != 'e' && s[i + 2] != 'E') return false;
            if (i + 1 < s.size() && isalpha(s[i + 1]) && s[i + 1] != 'e' && s[i + 1] != 'E') return false;
        }
    }
    return true;
}

vector<char> extractVariables(const string& eq) {
    string s = removeSpaces(eq);
    vector<char> vars;
    set<char> found;
    for (char c : s) {
        if (isalpha(c) && c != 'e' && c != 'E') found.insert(c);
    }
    for (char c : found) vars.push_back(c);
    return vars;
}

// ==================== 解析函数 ====================
long long gcdll(long long a, long long b) { a = abs(a); b = abs(b); while (b) { long long t = a % b; a = b; b = t; } return a; }

string doubleToFraction(double val) {
    const double EPS = 1e-9;
    if (fabs(val - round(val)) < EPS) {
        long long n = (long long)round(val);
        return to_string(n);
    }
    long long num = (long long)round(val * 1000000);
    long long den = 1000000;
    long long g = gcdll(num, den);
    num /= g; den /= g;
    if (den < 0) { num = -num; den = -den; }
    if (den == 1) return to_string(num);
    return to_string(num) + "/" + to_string(den);
}

bool parseLinearEquation(const string& eq, double& a, double& b, double& c, string& errorMsg) {
    errorMsg = "";
    string s = removeSpaces(eq);
    
    if (isInequality(eq)) {
        InequalityInfo info = getInequalitySign(s);
        if (info.sign == '=') { errorMsg = "无法识别不等号"; return false; }
        string left = s.substr(0, info.pos);
        string right = s.substr(info.pos + info.signStr.length());
        string eqStr = left + "-(" + right + ")=0";
        return parseLinearEquation(eqStr, a, b, c, errorMsg);
    }
    
    size_t eqPos = s.find('=');
    string left, right;
    if (eqPos == string::npos) { left = s; right = "0"; }
    else { left = s.substr(0, eqPos); right = s.substr(eqPos + 1); }
    
    if (left.empty()) { errorMsg = "方程左边不能为空"; return false; }
    
    vector<char> vars = extractVariables(eq);
    if (vars.empty()) {
        try {
            ExpressionParser p(left);
            double f = p.eval();
            ExpressionParser rp(right);
            double rv = rp.eval();
            a = 0; b = 0; c = rv - f;
            return true;
        } catch (const exception& e) {
            errorMsg = string("常数方程解析错误: ") + e.what();
            return false;
        }
    }
    
    char var1 = vars[0];
    char var2 = (vars.size() > 1) ? vars[1] : 'y';
    
    try {
        ExpressionParser p00(left);
        p00.setVar(var1, 0.0);
        p00.setVar(var2, 0.0);
        double f00_left = p00.eval();
        
        ExpressionParser r00(right);
        r00.setVar(var1, 0.0);
        r00.setVar(var2, 0.0);
        double f00_right = r00.eval();
        double F00 = f00_left - f00_right;
        
        ExpressionParser p10(left);
        p10.setVar(var1, 1.0);
        p10.setVar(var2, 0.0);
        double f10_left = p10.eval();
        
        ExpressionParser r10(right);
        r10.setVar(var1, 1.0);
        r10.setVar(var2, 0.0);
        double f10_right = r10.eval();
        double F10 = f10_left - f10_right;
        
        ExpressionParser p01(left);
        p01.setVar(var1, 0.0);
        p01.setVar(var2, 1.0);
        double f01_left = p01.eval();
        
        ExpressionParser r01(right);
        r01.setVar(var1, 0.0);
        r01.setVar(var2, 1.0);
        double f01_right = r01.eval();
        double F01 = f01_left - f01_right;
        
        double C = F00;
        double A = F10 - F00;
        double B = F01 - F00;
        
        a = A;
        b = B;
        c = C;
        return true;
    } catch (const exception& e) {
        errorMsg = string("表达式解析错误: ") + e.what();
        return false;
    }
}

bool parseQuadraticEquation(const string& eq, double& a, double& b, double& c, string& errorMsg) {
    errorMsg = "";
    string s = removeSpaces(eq);
    
    size_t eqPos = s.find('=');
    string left, right;
    if (eqPos == string::npos) { left = s; right = "0"; }
    else { left = s.substr(0, eqPos); right = s.substr(eqPos + 1); }
    
    if (left.empty()) { errorMsg = "方程左边不能为空"; return false; }
    
    try {
        double x0 = 0, x1 = 1, x2 = 2;
        
        ExpressionParser p0(left);
        p0.setVar('x', x0);
        double f0_left = p0.eval();
        ExpressionParser r0(right);
        r0.setVar('x', x0);
        double f0_right = r0.eval();
        double F0 = f0_left - f0_right;
        
        ExpressionParser p1(left);
        p1.setVar('x', x1);
        double f1_left = p1.eval();
        ExpressionParser r1(right);
        r1.setVar('x', x1);
        double f1_right = r1.eval();
        double F1 = f1_left - f1_right;
        
        ExpressionParser p2(left);
        p2.setVar('x', x2);
        double f2_left = p2.eval();
        ExpressionParser r2(right);
        r2.setVar('x', x2);
        double f2_right = r2.eval();
        double F2 = f2_left - f2_right;
        
        double c0 = F0;
        double A = (F2 - 2*F1 + F0) / 2;
        double B = F1 - F0 - A;
        
        a = A;
        b = B;
        c = c0;
        return true;
    } catch (const exception& e) {
        errorMsg = string("方程解析错误: ") + e.what();
        return false;
    }
}

// ==================== 高亮显示 ====================
void highlightResult(const string& label, const string& value, bool isSuccess = true) {
    cout << "\n";
    printCyan("╔══════════════════════════════════════════════════════════╗\n");
    printCyan("║ ");
    printWhite("求解结果");
    printCyan("                                                 ║\n");
    printCyan("╠══════════════════════════════════════════════════════════╣\n");
    printCyan("║ ");
    cout << label;
    int padding = 56 - label.length() - value.length();
    if (padding < 0) padding = 0;
    if (isSuccess) {
        printGreen(value);
    } else {
        printRed(value);
    }
    for (int i = 0; i < padding; i++) cout << " ";
    cout << " ║\n";
    printCyan("╚══════════════════════════════════════════════════════════╝\n");
    setColor(COLOR_RESET);
}

void highlightSimple(const string& msg, bool isSuccess = true) {
    cout << "\n";
    printCyan("╔══════════════════════════════════════════════════════════╗\n");
    printCyan("║ ");
    if (isSuccess) {
        printGreen(msg);
    } else {
        printRed(msg);
    }
    int padding = 56 - msg.length();
    if (padding < 0) padding = 0;
    for (int i = 0; i < padding; i++) cout << " ";
    cout << " ║\n";
    printCyan("╚══════════════════════════════════════════════════════════╝\n");
    setColor(COLOR_RESET);
}

// ==================== 不等式组求解 ====================
struct InequalityResult {
    string var;
    double bound;
    bool isUpper;
    bool isStrict;
    bool isValid;
    string error;
};

InequalityResult solveSingleInequality(const string& ineq, char var) {
    InequalityResult result;
    result.isValid = false;
    
    string s = removeSpaces(ineq);
    InequalityInfo info = getInequalitySign(s);
    if (info.sign == '=') {
        result.error = "无法识别不等号";
        return result;
    }
    
    string left = s.substr(0, info.pos);
    string right = s.substr(info.pos + info.signStr.length());
    string eq = left + "-(" + right + ")=0";
    
    double a, b, c; string error;
    if (!parseLinearEquation(eq, a, b, c, error)) {
        result.error = error;
        return result;
    }
    
    if (fabs(a) < 1e-12) {
        bool isTrue;
        if (info.sign == '<') isTrue = (c < 0);
        else if (info.sign == 'l') isTrue = (c <= 0);
        else if (info.sign == '>') isTrue = (c > 0);
        else isTrue = (c >= 0);
        
        if (isTrue) {
            result.error = "恒成立";
        } else {
            result.error = "恒不成立";
        }
        return result;
    }
    
    double solution = -c / a;
    bool reverseSign = (a < 0);
    
    result.var = var;
    result.bound = solution;
    result.isValid = true;
    
    if (info.sign == '<') {
        result.isUpper = !reverseSign;
        result.isStrict = true;
    } else if (info.sign == 'l') {
        result.isUpper = !reverseSign;
        result.isStrict = false;
    } else if (info.sign == '>') {
        result.isUpper = reverseSign;
        result.isStrict = true;
    } else {
        result.isUpper = reverseSign;
        result.isStrict = false;
    }
    
    return result;
}

void solveInequalitySystem(const vector<string>& inequalities) {
    if (inequalities.empty()) {
        printRed("错误: 没有输入不等式\n");
        return;
    }
    
    vector<char> allVars;
    for (const string& ineq : inequalities) {
        vector<char> vars = extractVariables(ineq);
        for (char v : vars) {
            if (find(allVars.begin(), allVars.end(), v) == allVars.end()) {
                allVars.push_back(v);
            }
        }
    }
    
    if (allVars.empty()) {
        printRed("错误: 没有检测到变量\n");
        return;
    }
    
    char var = allVars[0];
    if (allVars.size() > 1) {
        printYellow("警告: 检测到多个变量，仅使用第一个变量 " + string(1, var) + "\n");
    }
    
    cout << "\n变量: " << var << "\n";
    cout << "不等式组:\n";
    for (size_t i = 0; i < inequalities.size(); i++) {
        cout << "  " << (i+1) << ". " << inequalities[i] << "\n";
    }
    cout << "\n";
    
    vector<InequalityResult> results;
    double lowerBound = -1e100, upperBound = 1e100;
    bool hasLower = false, hasUpper = false;
    bool lowerStrict = false, upperStrict = false;
    bool hasConflict = false;
    
    for (const string& ineq : inequalities) {
        InequalityResult r = solveSingleInequality(ineq, var);
        if (!r.isValid) {
            if (r.error == "恒成立") {
                cout << "  " << ineq << " 恒成立 ?\n";
                continue;
            } else if (r.error == "恒不成立") {
                cout << "  " << ineq << " 恒不成立 ?\n";
                hasConflict = true;
                break;
            } else {
                printRed("错误: " + r.error + "\n");
                return;
            }
        }
        
        results.push_back(r);
        cout << "  " << ineq << " → " << var;
        if (r.isUpper) {
            cout << (r.isStrict ? " < " : " ≤ ");
            if (r.bound < upperBound) {
                upperBound = r.bound;
                upperStrict = r.isStrict;
                hasUpper = true;
            }
        } else {
            cout << (r.isStrict ? " > " : " ≥ ");
            if (r.bound > lowerBound) {
                lowerBound = r.bound;
                lowerStrict = r.isStrict;
                hasLower = true;
            }
        }
        cout << doubleToFraction(r.bound) << "\n";
    }
    
    if (hasConflict) {
        highlightSimple("不等式组无解（存在矛盾不等式）", false);
        return;
    }
    
    if (hasLower && hasUpper) {
        if (lowerBound > upperBound || (fabs(lowerBound - upperBound) < 1e-12 && (lowerStrict || upperStrict))) {
            highlightSimple("不等式组无解（上下界矛盾）", false);
            return;
        }
    }
    
    string result;
    if (!hasLower && !hasUpper) {
        result = string(1, var) + " ∈ R （全体实数）";
    } else if (hasLower && hasUpper) {
        result = string(1, var);
        if (lowerStrict) result += " > ";
        else result += " ≥ ";
        result += doubleToFraction(lowerBound);
        result += " 且 ";
        result += string(1, var);
        if (upperStrict) result += " < ";
        else result += " ≤ ";
        result += doubleToFraction(upperBound);
    } else if (hasLower) {
        result = string(1, var);
        if (lowerStrict) result += " > ";
        else result += " ≥ ";
        result += doubleToFraction(lowerBound);
    } else {
        result = string(1, var);
        if (upperStrict) result += " < ";
        else result += " ≤ ";
        result += doubleToFraction(upperBound);
    }
    
    highlightResult("解集: ", result, true);
}

// ==================== 各类求解函数 ====================
void solveInequality(const string& ineq) {
    string s = removeSpaces(ineq);
    cout << "输入不等式: " << ineq << "\n";
    
    InequalityInfo info = getInequalitySign(s);
    if (info.sign == '=') {
        cout << "这不是不等式，请使用方程求解\n";
        return;
    }
    
    string left = s.substr(0, info.pos);
    string right = s.substr(info.pos + info.signStr.length());
    string eq = left + "-(" + right + ")=0";
    
    double a, b, c; string error;
    if (!parseLinearEquation(eq, a, b, c, error)) {
        printRed("错误: " + error + "\n");
        return;
    }
    
    vector<char> vars = extractVariables(ineq);
    char var = (vars.empty()) ? 'x' : vars[0];
    
    if (vars.empty()) {
        bool isTrue;
        if (info.sign == '<') isTrue = (c < 0);
        else if (info.sign == 'l') isTrue = (c <= 0);
        else if (info.sign == '>') isTrue = (c > 0);
        else isTrue = (c >= 0);
        if (isTrue) highlightSimple("不等式恒成立", true);
        else highlightSimple("不等式恒不成立", false);
        return;
    }
    
    if (fabs(a) < 1e-12) {
        bool isTrue;
        if (info.sign == '<') isTrue = (c < 0);
        else if (info.sign == 'l') isTrue = (c <= 0);
        else if (info.sign == '>') isTrue = (c > 0);
        else isTrue = (c >= 0);
        if (isTrue) highlightSimple("不等式恒成立", true);
        else highlightSimple("不等式恒不成立", false);
        return;
    }
    
    double solution = -c / a;
    string solStr = doubleToFraction(solution);
    string result;
    bool reverseSign = (a < 0);
    
    if (info.sign == '<') result = string(1, var) + (reverseSign ? " > " : " < ") + solStr;
    else if (info.sign == 'l') result = string(1, var) + (reverseSign ? " ≥ " : " ≤ ") + solStr;
    else if (info.sign == '>') result = string(1, var) + (reverseSign ? " < " : " > ") + solStr;
    else result = string(1, var) + (reverseSign ? " ≤ " : " ≥ ") + solStr;
    
    cout << "化简为: " << a << var << " + " << c << " " << info.signStr << " 0\n";
    cout << "解集: ";
    highlightResult("", result, true);
}

void solveQuadratic(const string& eq) {
    double a, b, c; string error;
    cout << "输入方程: " << eq << "\n";
    
    if (!parseQuadraticEquation(eq, a, b, c, error)) {
        printRed("错误: " + error + "\n");
        return;
    }
    
    if (!hasVariable(eq)) {
        if (fabs(c) < 1e-12) {
            cout << "化简为: 0 = 0 (常数方程)\n";
            highlightSimple("方程恒成立，任意 x 都是解", true);
        } else {
            cout << "化简为: 0 = " << c << " (常数方程)\n";
            highlightSimple("方程恒不成立，无解", false);
        }
        return;
    }
    
    string eqStr = "";
    if (fabs(a) > 1e-12) {
        if (fabs(a - 1) < 1e-12) eqStr += "x^2";
        else if (fabs(a + 1) < 1e-12) eqStr += "-x^2";
        else eqStr += doubleToFraction(a) + "x^2";
    }
    if (fabs(b) > 1e-12) {
        if (!eqStr.empty() && b > 0) eqStr += " + ";
        else if (!eqStr.empty() && b < 0) eqStr += " - ";
        else if (b < 0) eqStr += "-";
        if (fabs(fabs(b) - 1) > 1e-12) eqStr += doubleToFraction(fabs(b));
        eqStr += "x";
    }
    if (fabs(c) > 1e-12) {
        if (!eqStr.empty() && c > 0) eqStr += " + ";
        else if (!eqStr.empty() && c < 0) eqStr += " - ";
        else if (c < 0) eqStr += "-";
        eqStr += doubleToFraction(fabs(c));
    }
    if (eqStr.empty()) eqStr = "0";
    eqStr += " = 0";
    
    cout << "化简为: " << eqStr << "\n";
    
    const double EPS = 1e-12;
    if (fabs(a) < EPS) {
        if (fabs(b) < EPS) {
            if (fabs(c) < EPS) highlightSimple("方程有无数解 (0 = 0)", true);
            else highlightSimple("方程无解 (常数项不为0)", false);
        } else {
            double x = -c / b;
            string result = "x = " + doubleToFraction(x);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        }
        return;
    }
    
    double discriminant = b * b - 4 * a * c;
    
    if (fabs(discriminant) < EPS) {
        double x = -b / (2 * a);
        string result = "x = " + doubleToFraction(x) + " (重根)";
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << setprecision(12) << x << "\n";
    } else if (discriminant > 0) {
        double sqrtD = sqrt(discriminant);
        double x1 = (-b + sqrtD) / (2 * a);
        double x2 = (-b - sqrtD) / (2 * a);
        string result = "x? = " + doubleToFraction(x1) + ", x? = " + doubleToFraction(x2);
        highlightResult("解: ", result, true);
        cout << "  小数形式: x? = " << setprecision(12) << x1 << ", x? = " << setprecision(12) << x2 << "\n";
    } else {
        double realPart = -b / (2 * a);
        double imagPart = sqrt(-discriminant) / (2 * a);
        string realStr = doubleToFraction(realPart);
        string imagStr = doubleToFraction(imagPart);
        if (realStr == "0") realStr = "0";
        if (imagStr == "1") imagStr = "";
        else if (imagStr == "-1") imagStr = "-";
        string result = "x? = " + realStr + " + " + imagStr + "i, x? = " + realStr + " - " + imagStr + "i";
        highlightResult("解: ", result, true);
        cout << "  小数形式: x? = " << setprecision(12) << realPart << " + " << imagPart << "i, "
             << "x? = " << realPart << " - " << imagPart << "i\n";
    }
}

void solveLinear(const string& eq) {
    double a, b, c; string error;
    cout << "输入方程: " << eq << "\n";
    if (!parseLinearEquation(eq, a, b, c, error)) {
        printRed("错误: " + error + "\n");
        return;
    }
    
    vector<char> vars = extractVariables(eq);
    char var = (vars.empty()) ? 'x' : vars[0];
    
    if (vars.empty()) {
        if (fabs(c) < 1e-12) {
            cout << "化简为: 0 = 0 (常数方程)\n";
            highlightSimple("方程恒成立，任意 " + string(1, var) + " 都是解", true);
        } else {
            cout << "化简为: 0 = " << c << " (常数方程)\n";
            highlightSimple("方程恒不成立，无解", false);
        }
        return;
    }
    
    if (fabs(b) > 1e-9 && vars.size() > 1) {
        cout << "警告: 此方程包含多个变量 (" << vars[0];
        if (vars.size() > 1) cout << ", " << vars[1];
        cout << ")，将忽略其他变量，仅解 " << var << "。\n";
    }
    
    cout << "化简为: " << a << var << " + " << c << " = 0\n";
    cout << "即: " << a << var << " = " << -c << "\n";
    const double EPS = 1e-12;
    if (fabs(a) < EPS) {
        if (fabs(c) < EPS) highlightSimple("方程有无数解 (0 = 0)", true);
        else highlightSimple("方程无解 (0 = " + to_string(-c) + ")", false);
    } else {
        double x = -c / a;
        string result = string(1, var) + " = " + doubleToFraction(x);
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << setprecision(12) << x << "\n";
    }
}

void solveSystem(const string& eq1, const string& eq2) {
    double a1, b1, c1, a2, b2, c2; string error;
    
    vector<char> vars1 = extractVariables(eq1);
    vector<char> vars2 = extractVariables(eq2);
    
    set<char> allVars;
    for (char c : vars1) allVars.insert(c);
    for (char c : vars2) allVars.insert(c);
    
    vector<char> varList(allVars.begin(), allVars.end());
    if (varList.size() == 0) {
        printRed("错误: 方程中没有变量\n");
        return;
    }
    
    char var1 = varList[0];
    char var2 = (varList.size() > 1) ? varList[1] : 'y';
    
    cout << "变量: " << var1;
    if (varList.size() > 1) cout << ", " << var2;
    cout << "\n";
    
    cout << "方程1: " << eq1 << "\n";
    if (!parseLinearEquation(eq1, a1, b1, c1, error)) {
        printRed("错误 (方程1): " + error + "\n");
        return;
    }
    
    cout << "方程2: " << eq2 << "\n";
    if (!parseLinearEquation(eq2, a2, b2, c2, error)) {
        printRed("错误 (方程2): " + error + "\n");
        return;
    }
    
    cout << "\n解析结果:\n";
    cout << "  方程1: " << a1 << var1 << " + " << b1 << var2 << " + " << c1 << " = 0\n";
    cout << "  方程2: " << a2 << var1 << " + " << b2 << var2 << " + " << c2 << " = 0\n";
    
    const double EPS = 1e-12;
    double D = a1 * b2 - a2 * b1;
    double Dx = (-c1) * b2 - (-c2) * b1;
    double Dy = a1 * (-c2) - a2 * (-c1);
    
    bool const1 = (fabs(a1) < EPS && fabs(b1) < EPS), const2 = (fabs(a2) < EPS && fabs(b2) < EPS);
    
    if (const1 && const2) {
        if (fabs(c1 - c2) < EPS) highlightSimple("方程组有无数解 (两个常数方程相同)", true);
        else highlightSimple("方程组无解 (两个常数方程矛盾)", false);
        return;
    }
    
    if (const1) {
        if (fabs(c1) > EPS) {
            highlightSimple("方程组无解 (方程1矛盾: 0 = " + to_string(-c1) + ")", false);
            return;
        }
        if (fabs(a2) < EPS && fabs(b2) < EPS) {
            if (fabs(c2) < EPS) highlightSimple("方程组有无数解", true);
            else highlightSimple("方程组无解", false);
            return;
        }
        if (fabs(a2) < EPS) {
            double y = -c2 / b2;
            string result = string(1, var1) + " 任意, " + string(1, var2) + " = " + doubleToFraction(y);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << y << "\n";
        } else if (fabs(b2) < EPS) {
            double x = -c2 / a2;
            string result = string(1, var1) + " = " + doubleToFraction(x) + ", " + string(1, var2) + " 任意";
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        } else {
            string msg = "方程组有无数解 (一个方程约束)\n  关系: " + to_string(a2) + string(1, var1) + " + " + to_string(b2) + string(1, var2) + " + " + to_string(c2) + " = 0";
            highlightSimple(msg, true);
        }
        return;
    }
    
    if (const2) {
        if (fabs(c2) > EPS) {
            highlightSimple("方程组无解 (方程2矛盾: 0 = " + to_string(-c2) + ")", false);
            return;
        }
        if (fabs(a1) < EPS && fabs(b1) < EPS) {
            if (fabs(c1) < EPS) highlightSimple("方程组有无数解", true);
            else highlightSimple("方程组无解", false);
            return;
        }
        if (fabs(a1) < EPS) {
            double y = -c1 / b1;
            string result = string(1, var1) + " 任意, " + string(1, var2) + " = " + doubleToFraction(y);
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << y << "\n";
        } else if (fabs(b1) < EPS) {
            double x = -c1 / a1;
            string result = string(1, var1) + " = " + doubleToFraction(x) + ", " + string(1, var2) + " 任意";
            highlightResult("解: ", result, true);
            cout << "  小数形式: " << setprecision(12) << x << "\n";
        } else {
            string msg = "方程组有无数解 (一个方程约束)\n  关系: " + to_string(a1) + string(1, var1) + " + " + to_string(b1) + string(1, var2) + " + " + to_string(c1) + " = 0";
            highlightSimple(msg, true);
        }
        return;
    }
    
    if (fabs(D) < EPS) {
        if (fabs(Dx) < EPS && fabs(Dy) < EPS) {
            bool proportional = true;
            if (fabs(a1) > EPS && fabs(a2) > EPS) {
                double ratio = a1 / a2;
                if (fabs(b1 - b2 * ratio) > EPS * 100 || fabs(c1 - c2 * ratio) > EPS * 100) proportional = false;
            } else if (fabs(b1) > EPS && fabs(b2) > EPS) {
                double ratio = b1 / b2;
                if (fabs(a1 - a2 * ratio) > EPS * 100 || fabs(c1 - c2 * ratio) > EPS * 100) proportional = false;
            } else proportional = true;
            if (proportional) {
                string msg = "方程组有无数解 (两个方程成比例)\n  关系: " + to_string(a1) + string(1, var1) + " + " + to_string(b1) + string(1, var2) + " + " + to_string(c1) + " = 0";
                highlightSimple(msg, true);
            } else {
                highlightSimple("方程组有无数解 (方程线性相关)", true);
            }
        } else {
            highlightSimple("方程组无解 (矛盾)", false);
        }
    } else {
        double x = Dx / D, y = Dy / D;
        string result = string(1, var1) + " = " + doubleToFraction(x) + ", " +
                       string(1, var2) + " = " + doubleToFraction(y);
        highlightResult("解: ", result, true);
        cout << "  小数形式: " << var1 << " = " << setprecision(12) << x << ", " << var2 << " = " << setprecision(12) << y << "\n";
        
        double v1 = a1 * x + b1 * y + c1, v2 = a2 * x + b2 * y + c2;
        cout << "验证: " << v1 << " = 0, " << v2 << " = 0\n";
    }
}

void solveEquation(const string& eq) {
    string s = removeSpaces(eq);
    
    if (isInequality(eq)) {
        solveInequality(eq);
        return;
    }
    
    if (hasHigherDegree(s)) {
        printRed("错误: 此方程包含超过2次的高次项，本程序暂不支持\n");
        return;
    }
    
    if (isQuadraticEquation(eq)) {
        vector<char> vars = extractVariables(eq);
        if (vars.size() == 1 && (vars[0] == 'x' || vars[0] == 'X')) {
            solveQuadratic(eq);
            return;
        } else {
            printRed("错误: 一元二次方程只能包含一个变量 x\n");
            return;
        }
    }
    
    if (isLinearEquation(s)) {
        vector<char> vars = extractVariables(eq);
        if (vars.size() <= 1) {
            solveLinear(eq);
        } else {
            printRed("错误: 检测到多个变量，请使用二元方程组模式(选项2)\n");
        }
        return;
    }
    
    printRed("错误: 无法识别的方程类型\n");
}

// ==================== 主程序 ====================
int main() {
    int choice;
    string input;
    vector<string> inequalities;
    
    #ifdef _WIN32
        system("color 0F");
    #endif
    
    cout << "==============================================\n";
    printCyan("    方程/不等式计算器 " + VERSION);
    cout << "\n";
    printYellow("    " + UPDATE_DATE + " 更新");
    cout << "\n";
    cout << "==============================================\n";
    
    // 首次运行显示版本信息
    static bool firstRun = true;
    if (firstRun) {
        printVersionInfo();
        firstRun = false;
    }
    
    cout << "\n支持格式:\n";
    cout << "  - 一元一次\n";
    cout << "  - 一元二次 x^2/xx/x*x\n";
    cout << "  - 一元一次不等式 <,<=,>,>=\n";
    cout << "  - 一元一次不等式组: 多个不等式用 ; 分隔\n";
    cout << "  - 二元一次方程组\n";
    cout << "  - 常数方程 (恒等式/矛盾式)\n";
    cout << "==============================================\n";
    
    while (true) {
        cout << "\n请选择:\n";
        cout << "  1. 解一元方程/不等式 (自动识别)\n";
        cout << "  2. 解一元一次不等式组 (用 ; 分隔)\n";
        cout << "  3. 解二元一次方程组\n";
        cout << "  4. 显示版本更新说明\n";
        cout << "  5. 退出\n";
        cout << "选择 (1/2/3/4/5): ";
        cin >> choice;
        if (cin.fail()) { cin.clear(); cin.ignore(10000, '\n'); cout << "输入无效，请输入数字 1-5。\n"; continue; }
        cin.ignore(10000, '\n');
        
        switch (choice) {
            case 1:
                cout << "请输入一元方程或不等式: ";
                getline(cin, input);
                if (input.empty()) cout << "输入不能为空。\n";
                else solveEquation(input);
                break;
                
            case 2: {
                cout << "请输入不等式组 (多个不等式用 ; 分隔): ";
                getline(cin, input);
                if (input.empty()) { cout << "输入不能为空。\n"; break; }
                
                inequalities.clear();
                stringstream ss(input);
                string ineq;
                while (getline(ss, ineq, ';')) {
                    string trimmed = removeSpaces(ineq);
                    if (!trimmed.empty()) {
                        inequalities.push_back(trimmed);
                    }
                }
                
                if (inequalities.empty()) {
                    cout << "没有检测到有效的不等式。\n";
                } else if (inequalities.size() < 2) {
                    cout << "至少需要2个不等式组成不等式组。\n";
                } else {
                    solveInequalitySystem(inequalities);
                }
                break;
            }
                
            case 3: {
                string eq1, eq2;
                cout << "请输入第一个方程: ";
                getline(cin, eq1);
                if (eq1.empty()) { cout << "方程不能为空。\n"; break; }
                cout << "请输入第二个方程: ";
                getline(cin, eq2);
                if (eq2.empty()) { cout << "方程不能为空。\n"; break; }
                solveSystem(eq1, eq2);
                break;
            }
                
            case 4:
                printVersionInfo();
                break;
                
            case 5:
                cout << "感谢使用，再见！\n";
                return 0;
                
            default:
                cout << "无效选择，请输入 1, 2, 3, 4 或 5。\n";
        }
    }
    return 0;
}