高中代数 与 几何要点

// 求 f(x) = a*x^2 + b*x + c 在 [L, R] 上的最小值（a != 0）
double quadMin(double a, double b, double c, double L, double R) {
    double axis = -b / (2 * a);          // 对称轴
    if (a > 0) {                          // 开口向上，顶点是最小值点
        if (axis < L) return a*L*L + b*L + c;      // 单调递增，取左端点
        if (axis > R) return a*R*R + b*R + c;      // 单调递减，取右端点
        return a*axis*axis + b*axis + c;            // 顶点在区间内
    } else {                              // 开口向下，最小值必在两端点之一
        return min(a*L*L + b*L + c, a*R*R + b*R + c);
    }
}

// 把 n 拆成 m 个正整数之和，使它们的乘积最大
// 结论：各数尽量平均 —— 差不超过 1 时乘积最大（均值不等式的直接推论）
int q = n / m, r = n % m;

// 前 r 个数为 q+1，其余为 q
for (int i = 1; i <= r; i++) cout << q + 1 << " ";
for (int i = r + 1; i <= m; i++) cout << q << " ";

// 为什么？由 a+b >= 2*sqrt(ab)，和为定值时两项越接近积越大
// 多变量的推广：n 个数越平均，乘积越大（均值不等式的 n 元形式）

// 关键恒等式：1/(k(k+1)) = 1/k - 1/(k+1)
// 于是 S_n = (1/1 - 1/2) + (1/2 - 1/3) + ... + (1/n - 1/(n+1))
//           = 1 - 1/(n+1) = n/(n+1)

// 代码实现（注意：不要真的去循环，直接用公式！）
int n; cin >> n;
printf("%.6f\n", (double)n / (n + 1));

// 计算 a^b mod m，b 可达 10^18
// 核心思想：a^b = (a^(b/2))^2  (b 为偶)  或  a * (a^(b/2))^2  (b 为奇)
// 即把「b 次乘法」压缩成「log2(b) 轮平方」
long long qpow(long long a, long long b, long long m) {
    long long res = 1 % m;
    a %= m;
    while (b) {
        if (b & 1) res = res * a % m;   // 这一位是 1，就把当前的 a 乘进去
        a = a * a % m;                    // a 自己平方，对应「指数翻倍」
        b >>= 1;                          // 指数右移一位
    }
    return res;
}

const double PI = acos(-1.0);              // 高精度 π
double toDeg(double rad) { return rad * 180.0 / PI; }
double toRad(double deg) { return deg * PI / 180.0; }

// 余弦定理：由三边求角 C（返回弧度）
double angleFromSides(double a, double b, double c) {
    // c 是角 C 的对边
    double cosC = (a*a + b*b - c*c) / (2*a*b);
    cosC = max(-1.0, min(1.0, cosC));       // ★ 关键：夹紧到 [-1,1] 防 acos 出 nan
    return acos(cosC);
}

// 两边夹角求面积
double areaBySAS(double a, double b, double C) {
    return 0.5 * a * b * sin(C);
}

// 海伦公式（三边求面积）
double areaByHeron(double a, double b, double c) {
    double p = (a + b + c) / 2;
    return sqrt(p * (p - a) * (p - b) * (p - c));
}

// poly 按顺序存放 n 个顶点，返回「有向面积」的 2 倍
// 结果 > 0 表示顶点是逆时针排列，< 0 表示顺时针排列
double polygonArea2(vector<Point>& poly) {
    int n = poly.size();
    double s = 0;
    for (int i = 0; i < n; i++) {
        int j = (i + 1) % n;               // 下一个顶点（循环回到第一个）
        s += poly[i].x * poly[j].y - poly[j].x * poly[i].y;
    }
    return s;                            // 2S（带符号）
}

// 只要面积绝对值：fabs(polygonArea2(poly)) / 2.0
// 判断顶点顺序：polygonArea2(poly) > 0 ? 逆时针 : 顺时针

struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}

    // ---- 向量加减与数乘 ----
    Point operator+(const Point& p) const { return Point(x + p.x, y + p.y); }
    Point operator-(const Point& p) const { return Point(x - p.x, y - p.y); }
    Point operator*(double k) const   { return Point(x * k, y * k); }

    // ---- 点积（内积）----
    double dot(const Point& p) const { return x * p.x + y * p.y; }

    // ---- 叉积（外积）----  >0: p 在左侧; <0: 右侧; =0: 共线
    double cross(const Point& p) const { return x * p.y - y * p.x; }

    // ---- 模长与到另一点的距离 ----
    double len() const { return sqrt(x * x + y * y); }
    double dist(const Point& p) const { return (*this - p).len(); }

    // ---- 逆时针旋转 rad 弧度 ----
    Point rot(double rad) const {
        double c = cos(rad), s = sin(rad);
        return Point(x * c - y * s, x * s + y * c);
    }
};

// ---- 三角形有向面积的两倍（符号表示 C 在 AB 的哪一侧）----
double cross2(Point A, Point B, Point C) {
    return (B - A).cross(C - A);
}

// ---- 判断三点是否共线（利用 inSegment 前先判共线）----
bool collinear(Point A, Point B, Point C, double eps = 1e-8) {
    return fabs(cross2(A, B, C)) < eps;
}

const double PI  = acos(-1.0);      // 高精度 π
const double eps = 1e-8;            // 通用误差限

int sgn(double x) {                    // 三态符号函数：-1 / 0 / 1
    if (x >  eps) return 1;
    if (x < -eps) return -1;
    return 0;
}
bool eq(double a, double b) { return fabs(a - b) < eps; }

// ---- 二分实数：用固定迭代次数，而不是 while (r - l > eps) ----
double lo = 0, hi = 1e9;
for (int it = 0; it < 100; it++) {   // 100 次迭代，精度足以到 1e-30
    double mid = (lo + hi) / 2;
    if (check(mid)) lo = mid; else hi = mid;
}
printf("%.6f\n", lo);                // 按题目要求输出位数

#include <bits/stdc++.h>
using namespace std;

int main() {
    long long L; cin >> L;

    // 方法一：二次函数顶点公式   x = L/4
    double x1 = L / 4.0;
    double s1 = x1 * (L - 2 * x1);

    // 方法二：均值不等式   S_max = L^2/8，取等时 x = L/4
    double x2 = L / 4.0;
    double s2 = (double)L * L / 8.0;

    printf("%.2f\n%.2f\n%.2f\n", s2, x2, (double)L - 2 * x2);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const double PI = acos(-1.0);

int main() {
    double ax, ay, bx, by, cx, cy;
    cin >> ax >> ay >> bx >> by >> cx >> cy;

    // ---- 构造两个从 A 出发的向量 ----
    double ux = bx - ax, uy = by - ay;      // 向量 AB
    double vx = cx - ax, vy = cy - ay;      // 向量 AC

    // ---- 点积与模长 ----
    double dotUV = ux * vx + uy * vy;
    double lenU = sqrt(ux * ux + uy * uy);
    double lenV = sqrt(vx * vx + vy * vy);

    // ---- 求角 A ----
    double cosA = dotUV / (lenU * lenV);
    cosA = max(-1.0, min(1.0, cosA));    // ★ 关键：夹紧到 [-1,1]
    double angleA = acos(cosA) * 180.0 / PI;

    // ---- 用叉积求面积：2S = |AB × AC| ----
    double crossUV = ux * vy - uy * vx;
    double area = fabs(crossUV) / 2.0;

    printf("%.4f\n%.4f\n", angleA, area);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const double eps = 1e-8;

struct Point { double x, y; };

// 有向面积的两倍：>0 表示 P 在 AB 左侧，<0 表示右侧，=0 表示共线
double cross(Point A, Point B, Point P) {
    return (B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x);
}

// 三态符号：-1 / 0 / 1
int sgn(double v) {
    if (v >  eps) return 1;
    if (v < -eps) return -1;
    return 0;
}

int main() {
    Point A, B, C, P;
    cin >> A.x >> A.y >> B.x >> B.y >> C.x >> C.y >> P.x >> P.y;

    int s1 = sgn(cross(A, B, P));   // 相对于边 AB
    int s2 = sgn(cross(B, C, P));   // 相对于边 BC
    int s3 = sgn(cross(C, A, P));   // 相对于边 CA

    // ---- 判断位置关系：三个符号是否同号 ----
    bool allNonNeg = (s1 >= 0 && s2 >= 0 && s3 >= 0);
    bool allNonPos = (s1 <= 0 && s2 <= 0 && s3 <= 0);

    if (allNonNeg || allNonPos) {
        if (s1 == 0 || s2 == 0 || s3 == 0) cout << "ON\n";
        else cout << "IN\n";
    } else {
        cout << "OUT\n";
    }
    cout << s1 << " " << s2 << " " << s3 << "\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

double a, b, c, d;
const double eps = 1e-8;

double f(double x) {              // 计算 f(x) = a*x^3 + b*x^2 + c*x + d
    return a*x*x*x + b*x*x + c*x + d;
}

int main() {
    cin >> a >> b >> c >> d;

    for (int k = -100; k < 100; k++) {       // 扫描 200 个单位区间
        double l = k, r = k + 1;
        double fl = f(l), fr = f(r);

        if (fabs(fl) < eps) {               // 左端点恰是根
            printf("%.2f ", l);
            continue;
        }
        if (fl * fr < 0) {                // 区间内恰有一个根
            for (int it = 0; it < 60; it++) {  // 固定次数二分
                double mid = (l + r) / 2;
                if (f(mid) * fl < 0) r = mid;    // 根在左半
                else l = mid;                      // 根在右半
            }
            printf("%.2f ", (l + r) / 2);
        }
    }
    printf("\n");
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

int n;
double x[105], y[105];

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];

    double s2 = 0;                        // 有向面积的两倍
    for (int i = 1; i <= n; i++) {
        int j = (i == n) ? 1 : i + 1;       // 下一个顶点，最后一个接回第一个
        s2 += x[i] * y[j] - x[j] * y[i];  // 累加叉积
    }

    printf("%.1f\n", fabs(s2) / 2.0);
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const double eps = 1e-8;
struct Point {
    double x, y;
    bool operator<(const Point& p) const {
        return fabs(x - p.x) < eps ? y < p.y : x < p.x;
    }
    Point operator-(const Point& p) const { return {x - p.x, y - p.y}; }
};
double cross(Point O, Point A, Point B) {      // (A-O) × (B-O)
    return (A.x - O.x) * (B.y - O.y) - (A.y - O.y) * (B.x - O.x);
}
double dist(Point A, Point B) {
    return sqrt((A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y));
}

Point p[10005], hull[20005];

int main() {
    int n; scanf("%d", &n);
    for (int i = 1; i <= n; i++) scanf("%lf %lf", &p[i].x, &p[i].y);
    sort(p + 1, p + n + 1);

    int k = 0;
    // ---- 下凸壳：从左到右 ----
    for (int i = 1; i <= n; i++) {
        while (k >= 2 && cross(hull[k - 1], hull[k], p[i]) <= eps) k--;
        hull[++k] = p[i];
    }
    // ---- 上凸壳：从右到左 ----
    int lower = k;
    for (int i = n - 1; i >= 1; i--) {
        while (k > lower && cross(hull[k - 1], hull[k], p[i]) <= eps) k--;
        hull[++k] = p[i];
    }
    k--;                                   // 最后一个点与第一个点重复，去掉

    double ans = 0;
    for (int i = 1; i <= k; i++) {
        int j = (i == k) ? 1 : i + 1;
        ans += dist(hull[i], hull[j]);     // 累加相邻顶点的距离
    }
    printf("%.2f\n", ans);
    return 0;
}

// ============ 计算几何基础模板（CSP-S / NOIP 通用） ============
#include <bits/stdc++.h>
using namespace std;

const double PI  = acos(-1.0);   // 3.141592653589793
const double eps = 1e-8;         // 误差容忍度，看题给精度调整

// ---- 符号函数与相等判断：任何「等于」都要用它 ----
int sgn(double x) {                 // x>0 返回 1，x<0 返回 -1，≈0 返回 0
    if (x >  eps) return  1;
    if (x < -eps) return -1;
    return 0;
}
bool eq(double a, double b) { return sgn(a - b) == 0; }
bool lt(double a, double b) { return sgn(a - b) <  0; }
bool le(double a, double b) { return sgn(a - b) <= 0; }
double clamp1(double x) {            // 把值夹进 [-1,1]，保护 acos
    return max(-1.0, min(1.0, x));
}

// ---- 点 / 向量：二维统一用 Point 表示 ----
struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
    // 向量加、减、数乘
    Point operator+(const Point &o) const { return Point(x + o.x, y + o.y); }
    Point operator-(const Point &o) const { return Point(x - o.x, y - o.y); }
    Point operator*(double k)        const { return Point(x * k, y * k); }
    // 点积：判垂直、求夹角、求投影
    double dot(const Point &o)   const { return x * o.x + y * o.y; }
    // 叉积：判左右、求面积、判共线
    double cross(const Point &o) const { return x * o.y - y * o.x; }
    // 模长与两点距离
    double len() const { return sqrt(x * x + y * y); }
    double dist(const Point &o) const { return (*this - o).len(); }
    // 逆时针旋转 90°：(x,y) -> (-y,x)
    Point rot90() const { return Point(-y, x); }
};

// ---- 三点方向：1 左转（逆时针），-1 右转（顺时针），0 共线 ----
int orient(const Point &O, const Point &A, const Point &B) {
    return sgn((A - O).cross(B - O));
}
bool collinear(const Point &A, const Point &B, const Point &C) {
    return orient(A, B, C) == 0;
}

// ---- 三角形面积（叉积的一半，带符号）----
double triArea2(const Point &A, const Point &B, const Point &C) {
    return (B - A).cross(C - A);        // 两倍有向面积
}

// ---- 三点夹角（弧度）：先解余弦，再反余弦，最后夹紧 ----
double angleAt(const Point &A, const Point &B, const Point &C) {
    Point u = A - B, v = C - B;          // 以 B 为顶点
    return acos(clamp1(u.dot(v) / (u.len() * v.len())));
}

// ---- 点 P 是否在三角形 ABC 内（含边界）----
bool inTriangle(const Point &A, const Point &B,
                const Point &C, const Point &P) {
    int d1 = orient(A, B, P);
    int d2 = orient(B, C, P);
    int d3 = orient(C, A, P);
    bool hasNeg = (d1 < 0) || (d2 < 0) || (d3 < 0);
    bool hasPos = (d1 > 0) || (d2 > 0) || (d3 > 0);
    return !(hasNeg && hasPos);        // 没有「既有正又有负」= 三者同号
}

// ---- 二分求零点：固定 100 次，精度无忧 ----
double binaryZero(double l, double r,
                  function<double(double)> f) {
    for (int i = 0; i < 100; i++) {
        double mid = (l + r) / 2;
        if (sgn(f(l)) * sgn(f(mid)) <= 0) r = mid;
        else l = mid;
    }
    return (l + r) / 2;
}

#include <bits/stdc++.h>
using namespace std;

const double eps = 1e-10;

double f(double x) { return -x*x + 6*x - 5; }

double ternarySearch(double l, double r) {
    while (r - l > eps) {
        double m1 = l + (r - l) / 3;     // 左三等分点
        double m2 = r - (r - l) / 3;     // 右三等分点
        if (f(m1) < f(m2)) l = m1;         // 峰在右侧
        else               r = m2;         // 峰在左侧
    }
    return (l + r) / 2;
}

int main() {
    double x = ternarySearch(0, 10);
    printf("x = %.4f, f(x) = %.4f\n", x, f(x));
    printf("理论值：x = 3.0000, f(x) = 4.0000\n");
    return 0;
}

#include <bits/stdc++.h>
using namespace std;

const double eps = 1e-8;
int sgn(double x) { return x > eps ? 1 : (x < -eps ? -1 : 0); }

struct Point {
    double x, y;
    Point(double x = 0, double y = 0) : x(x), y(y) {}
    Point operator-(const Point &o) const { return Point(x - o.x, y - o.y); }
    double cross(const Point &o) const { return x * o.y - y * o.x; }
    double dot(const Point &o)   const { return x * o.x + y * o.y; }
};
// 叉积符号：O-A-B 的方向
int orient(const Point &O, const Point &A, const Point &B) {
    return sgn((A - O).cross(B - O));
}
// 「P 在线段 AB 上」：共线 + 投影落在 AB 之间
bool onSegment(const Point &A, const Point &B, const Point &P) {
    if (orient(A, B, P) != 0) return false;              // 不共线，直接否决
    return min(A.x, B.x) - eps <= P.x && P.x <= max(A.x, B.x) + eps
        && min(A.y, B.y) - eps <= P.y && P.y <= max(A.y, B.y) + eps;
}
// 线段 AB 与 CD 是否相交
bool segIntersect(const Point &A, const Point &B,
                  const Point &C, const Point &D) {
    int d1 = orient(A, B, C), d2 = orient(A, B, D);
    int d3 = orient(C, D, A), d4 = orient(C, D, B);

    // ① 正常跨立：两个方向的叉积都异号
    if (d1 * d2 < 0 && d3 * d4 < 0) return true;

    // ② 共线特判：某个端点落在另一条线段上
    if (d1 == 0 && onSegment(A, B, C)) return true;
    if (d2 == 0 && onSegment(A, B, D)) return true;
    if (d3 == 0 && onSegment(C, D, A)) return true;
    if (d4 == 0 && onSegment(C, D, B)) return true;

    return false;
}

int main() {
    // 测试 1：标准的 X 型交叉
    printf("测试1 (0,0)-(4,4) 与 (0,4)-(4,0)：%s\n",
           segIntersect({0,0}, {4,4}, {0,4}, {4,0}) ? "相交 ✅" : "不相交");
    // 测试 2：只在一个方向上「跨立」，但线段本身不相交
    printf("测试2 (0,0)-(1,0) 与 (2,-1)-(2,1)：%s\n",
           segIntersect({0,0}, {1,0}, {2,-1}, {2,1}) ? "相交" : "不相交 ✅");
    // 测试 3：共线重叠
    printf("测试3 (0,0)-(6,0) 与 (2,0)-(8,0)：%s\n",
           segIntersect({0,0}, {6,0}, {2,0}, {8,0}) ? "相交 ✅" : "不相交");
    // 测试 4：共线但分离
    printf("测试4 (0,0)-(2,0) 与 (5,0)-(8,0)：%s\n",
           segIntersect({0,0}, {2,0}, {5,0}, {8,0}) ? "相交" : "不相交 ✅");
    // 测试 5：端点接触
    printf("测试5 (0,0)-(3,3) 与 (3,3)-(6,0)：%s\n",
           segIntersect({0,0}, {3,3}, {3,3}, {6,0}) ? "相交 ✅" : "不相交");
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

struct P {
    ll x, y;
    P(ll x = 0, ll y = 0) : x(x), y(y) {}
    P operator-(const P &o) const { return P(x - o.x, y - o.y); }
    ll  operator^(const P &o) const { return x * o.y - y * o.x; }  // 叉积
    bool operator<(const P &o) const { return x != o.x ? x < o.x : y < o.y; }
    bool operator==(const P &o) const { return x == o.x && y == o.y; }
};
ll dist2(const P &a, const P &b) {          // 距离的平方：整数运算，零误差
    ll dx = a.x - b.x, dy = a.y - b.y;
    return dx * dx + dy * dy;
}

int n;
vector<P> p, hull;

void convexHull() {                        // Andrew 单调链，不保留共线点
    sort(p.begin(), p.end());
    n = unique(p.begin(), p.end()) - p.begin();   // 去重是必须的！
    p.resize(n);
    hull.clear();
    if (n <= 1) { hull = p; return; }
    for (int i = 0; i < n; i++) {
        while (hull.size() >= 2 &&
               ((hull[hull.size()-1] - hull[hull.size()-2]) ^
                (p[i] - hull[hull.size()-2])) <= 0)
            hull.pop_back();
        hull.push_back(p[i]);
    }
    int lower = hull.size();
    for (int i = n - 2; i >= 0; i--) {
        while ((int)hull.size() > lower &&
               ((hull[hull.size()-1] - hull[hull.size()-2]) ^
                (p[i] - hull[hull.size()-2])) <= 0)
            hull.pop_back();
        hull.push_back(p[i]);
    }
    hull.pop_back();                        // 首尾重复，去掉一个
}

ll rotatingCalipers() {
    int m = hull.size();
    if (m == 1) return 0;
    if (m == 2) return dist2(hull[0], hull[1]);

    int j = 2;                                // 对踵点指针，从第 3 个顶点开始
    ll ans = 0;
    for (int i = 0; i < m; i++) {
        int ni = (i + 1) % m;
        // 面积法：把 j 推到「离边 i->ni 最远」的位置
        while (true) {
            int nj = (j + 1) % m;
            ll cur = llabs((hull[ni] - hull[i]) ^ (hull[j]  - hull[i]));
            ll nxt = llabs((hull[ni] - hull[i]) ^ (hull[nj] - hull[i]));
            if (nxt > cur) j = nj; else break;
        }
        ans = max(ans, dist2(hull[i],  hull[j]));
        ans = max(ans, dist2(hull[ni], hull[j]));
    }
    return ans;
}

int main() {
    scanf("%d", &n);
    p.resize(n);
    for (int i = 0; i < n; i++) scanf("%lld%lld", &p[i].x, &p[i].y);
    convexHull();
    printf("%lld\n", rotatingCalipers());
    return 0;
}