宁波市多校训练（六）

A. K均值

这题卡精度，不可以使用double

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e3 + 10;
int n, m, k;

struct Point {
    ll x, y;

    Point() {}

    Point(double _x, double _y) { x = _x, y = _y; }

    void input() { scanf("%lld%lld", &x, &y); }//输入

    Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }

    Point operator*(const double &k) const { return Point(x * k, y * k); }

    double distance2(Point p) { return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y); }
};

Point p[N];
int fa[N];//标识 每个点属于哪个聚类里
Point M[N];//聚类中心点

int cnt = 100;//题目限定的迭代次数
vector<Point> son[N];//每个聚类的儿子们

void k_means() {
    cnt--;//迭代次数不超过100次

    vector<Point> newSon[m];//新儿子们

    // 求每一个点到每个聚类中心的距离

    int flag = 0;//判断聚类队伍是否发生了变动
    for (int i = 0; i < n; i++) {
        ll Min = 0x3f3f3f3f;//为防精度 没有开根号 下面的距离其实都是 距离^2
        ll Min_cnt = 1;// 距离聚类中心最近的那个聚类的个数
        int rt;//新的爸爸

        for (int j = 0; j < m; j++) {
            // 判断点到聚类中心的距离
            int sz = son[j].size();
            ll dist = (p[i] * sz).distance2(M[j]);

            //找到里面较近的距离
            if (Min * sz * sz > dist * Min_cnt * Min_cnt) {
                Min = dist;
                Min_cnt = sz;
                rt = j;
            }
        }

        if (fa[i] != rt) {
            fa[i] = rt;
            flag = 1;
        }
        newSon[rt].push_back(p[i]);
    }

    if (!flag || !cnt) return;
    // 如果发现和之前的分类一致 or 迭代太多次啦(说的是点在两个集合内变来变去 墙头草一样) 就没比较继续下去了

    int sz;
    for (int i = 0; i < m; i++) {
        sz = newSon[i].size();
        M[i] = {0, 0};// 根据新的从属关系 建立新的聚类中心
        for (int j = 0; j < sz; j++) {
            M[i] = M[i] + newSon[i][j];
        }
        son[i] = newSon[i];
    }

    k_means();
}

int main() {
    ios::sync_with_stdio(false);

    scanf("%d%d%d", &n, &m, &k);
    for (int i = 0; i < n; i++) {
        p[i].input();
        fa[i] = i;
    }

    //先给每个聚类随机(并没有)选一个作为聚类中心的点
    for (int i = 0; i < m; i++) {
        M[i] = p[i];
        son[i].push_back(p[i]);
    }

    // k均值聚类算法
    k_means();

    int a, b;
    while (k--) {
        scanf("%d%d", &a, &b);
        a--; // 因为 为了适应vector<> 统计的时候是从 0开始统计的 但是题目给出的是从1开始的
        b--;
        if (fa[a] == fa[b]) {
            puts("Yes");
        } else {
            puts("No");
        }
    }
    
    return 0;
}

---

B. llz同学的难题

---

C. 分享蛋糕（Easy）

n个人手持礼物，其中部分人会选择交换礼物，每个人只能交换一次，问有多少种交换结果

设 $F_n$ 表示n个人有多少种交换结果

当有新的人（第n+1个人）加入，这个人可以选择不交换礼物，那么就有 $F_n$ 种，即不管这个人时，前面n个人的交换结果
也可以选择和前n个人中的某一位交换礼物，剩下的 $n-1$ 个人之间进行交换，即 $n\ast F_{n-1}$

因此 $F_n=F_{n-1}+(n-1)\times F_{n-2}$

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
const int N = 1e6 + 10;
int n;
ll f[N];

int main() {
    ios::sync_with_stdio(false);

    cin >> n;
    
    // f[i]= f[i-1] + (i-1)*f[i-2]
    f[0] = 0;
    f[1] = 1;
    f[2] = 2;
    for (int i = 3; i <= n; i++) {
        f[i] = (f[i - 1] + f[i - 2] * (i - 1) % mod) % mod;
    }
    cout << f[n] << endl;
    
    return 0;
}

---

D. 分享蛋糕（Hard）

---

E. 水果忍者

#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;

int sgn(double x) {
    if (fabs(x) < eps) return 0;
    if (x < 0) return -1;
    else return 1;
}

// ---------------------- 点  ----------------------

//判断小数和0是否等于
struct Point {
    double x, y;

    Point() {}

    Point(double _x, double _y) { x = _x, y = _y; }

    void input() { scanf("%lf%lf", &x, &y); }//输入
    void output() { printf("%.2f %.2f\n", x, y); } //输出

    Point operator - (const Point &b) const { return Point(x - b.x, y - b.y); }

    Point operator + (const Point &b) const { return Point(x + b.x, y + b.y); }

    Point operator * (const double &k) const { return Point(x * k, y * k); }

    Point operator / (const double &k) const { return Point(x / k, y / k); }

    bool operator == (Point b) const { return sgn(x - b.x) == 0 && sgn(y - b.y) == 0; }

    bool operator < (Point b) const { return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x; }


    double operator ^ (const Point &b) const { return x * b.y - y * b.x; }
    //叉积

    double operator * (const Point &b) const { return x * b.x + y * b.y; }
    //点积

    double distance(Point p) { return hypot(x - p.x, y - p.y); }
    //两点之间的距离

    Point rotLeft() { return Point(-y, x); }
    //逆时针旋转90°

};

typedef Point Vector;
typedef Point point;

// ---------------------- 直线  ----------------------

struct Line {
    Point s, e;

    Line() {}
    Line(Point _s, Point _e) {
        s = _s;
        e = _e;
    }

    bool operator == (Line v) { return (s == v.s) && (e == v.e); }

    void input() {
        s.input();
        e.input();
    }//输入

    double length() { return s.distance(e); }
    //求线段长度

    int relation(Point p) {
        int c = sgn((p - s) ^ (e - s));
        if (c < 0) return 1; //点在直线的左侧
        else if (c > 0) return 2;//点在直线的右侧
        else return 3;//点在直线上
    }//判断点与直线的关系

    int seg_cross_seg(Line v) {
        int d1 = sgn((e - s) ^ (v.s - s));
        int d2 = sgn((e - s) ^ (v.e - s));
        int d3 = sgn((v.e - v.s) ^ (s - v.s));
        int d4 = sgn((v.e - v.s) ^ (e - v.s));
        if ((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2; //规范相交
        return (d1 == 0 && sgn((v.s - s) * (v.s - e)) <= 0) ||
               (d2 == 0 && sgn((v.e - s) * (v.e - e)) <= 0) ||
               (d3 == 0 && sgn((s - v.s) * (s - v.e)) <= 0) ||
               (d4 == 0 && sgn((e - v.s) * (e - v.e)) <= 0); //返回 1 非规范相交 0 不相交
    }


    Point cross_point(Line v) {
        double a1 = (v.e - v.s) ^(s - v.s);
        double a2 = (v.e - v.s) ^(e - v.s);
        return Point((s.x * a2 - e.x * a1) / (a2 - a1), (s.y * a2 - e.y * a1) / (a2 - a1));
    }//求两直线的交点 前提：要保证直线不平行或重合

    double dis_point_to_line(Point p) {
        return fabs((p - s) ^ (e - s)) / length();
    }//点到直线的距离

    double dis_point_to_seg(Point p) {
        if (sgn((p - s) * (e - s)) < 0 || sgn((p - e) * (s - e)) < 0)
            return min(p.distance(s), p.distance(e));
        return dis_point_to_line(p);
    }//点到线段的距离

};

typedef Line Seg;

//  ---------------------- 圆 ----------------------
struct circle {
    Point p;//圆心
    double r;//半径
    circle() {}

    circle(Point _p, double _r) {
        p = _p;
        r = _r;
    }

    circle(double x, double y, double _r) {
        p = Point(x, y);
        r = _r;
    }

    void input() {
        p.input();
        scanf("%lf", &r);
    }//输入
    void output() { printf("%.2lf %.2lf %.2lf\n", p.x, p.y, r); }//输出

    bool operator == (circle v) { return (p == v.p) && sgn(r - v.r) == 0; }

    bool operator < (circle v) const { return ((p < v.p) || ((p == v.p) && sgn(r - v.r) < 0)); }

    int relation_seg(Line v) {
        double dst = v.dis_point_to_seg(p);
        if (sgn(dst - r) < 0)
            return 2;//相交
        else if (sgn(dst - r) == 0)
            return 1;//相切
        return 0;//相离
    }//线段和圆的关系 比较的是圆心到线段距离的

};

Seg S;//刀
vector<vector<point>> F;//水果
vector<circle> B;//炸弹

int cal() {
    int res = 0;
    //先看看有没有切到炸弹
    int sz = B.size();
    for (int i = 0; i < sz; i++) {
        if (B[i].relation_seg(S) == 2) {
            return 0;
        }
    }

    //然后看看有没有切完水果
    sz = F.size();

    Point u, v;
    for (int i = 0; i < sz; i++) {

        int l = 0, r = 0;
        int F_sz = F[i].size();

        for (int j = 0; j < F_sz; j++) {
            u = F[i][j];
            v = F[i][(j + 1) % F_sz];

            int pu = S.relation(u);//判断线段与点的关系
            if (pu == 1)l = 1;
            else if (pu == 2) r = 1;

            int pv = S.relation(v);
            if (pv == 1)l = 1;
            else if (pv == 2) r = 1;

            // 下面说的异侧 可能会有 这么几种情况
            // 1：两点分布线段两侧
            // 2: 一个点在线段左侧 一个点在线段上
            // 3: 一个点在线段右侧 一个点在线段上
            // 要确保存在两个点 分布在线段两侧的
            if (pu != pv) {
                Seg L = {u, v};
                if (S.seg_cross_seg(L) == 0) {
                    //异侧的两个点形成的线 与线段不相交 说明没有切割成两部分
                    l = r = 0;
                    break;
                }
            }
        }
        if (l && r) res++; //存在异侧的两个点

    }
    return res;
}


int n, m, T;
char s[20];
circle b;

int main() {
    ios::sync_with_stdio(false);

    int cs;
    scanf("%d", &cs);
    while (cs--) {
    
        int res = 0;
        scanf("%d", &T);//t秒

        for (int i = 1; i <= T; i++) {
            scanf("%d", &n);

            // n个炸弹or水果
            for (int j = 1; j <= n; j++) {
                scanf("%s", s);

                if (s[0] == 'F') {//水果
                    scanf("%d", &m);
                    vector<point> f(m);
                    for (int k = 0; k < m; k++) {
                        f[k].input();
                    }
                    F.push_back(f);

                } else {//炸弹
                    b.input();
                    B.push_back(b);
                }
            }

            S.input();

            res += cal();

            F.clear();
            B.clear();
        }
        printf("%d\n", res);
    }
    return 0;
}

---

天天天天想女装

一道类似的题目：牛客 - 队伍配置

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int N = 105;
int n, m, k;
int a[N], b[N], c[N], d[N];
ll f[N][N][N];

int main() {
    ios::sync_with_stdio(false);
    
    scanf("%d%d%d", &k, &n, &m);
    
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
    
    for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
    for (int i = 1; i <= m; i++) scanf("%d", &d[i]);
    

    ll res = -INF;
    memset(f, -INF, sizeof f);


    f[0][0][0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = k; j >= a[i]; j--) {
            for (int l = 1; l <= i; l++) { //枚举上衣的数量 这个时候 裙子还没有被统计 所以是0
                f[j][l][0] = max(f[j][l][0], f[j - a[i]][l - 1][0] + b[i]);
            }
        }
    }

    for (int i = 1; i <= m; i++) {
        for (int j = k; j >= c[i]; j--) {
        
            for (int t = 1; t <= i; t++) { // 枚举裙子的数量
                for (int l = 1; l <= n; l++) { // 枚举上衣的数量
                    f[j][l][t] = max(f[j][l][t], f[j - c[i]][l][t - 1] + d[i]);

                    if (l >= 2 && t >= 2) {
                        res = max(res, f[j][l][t]);
                    }
                }
            }
        }
    }
    if (res < 0) {
        printf("NO\n");
    } else {
        printf("YES\n%lld\n", res);
    }
    return 0;
}

---

猩球崛起

板子题 - 康拓展开

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

int n, q;

namespace CantorExpansion { // 康拓展开板子
    const int N = 20;
    ll fac[N];

    // 计算全排列 n!
    void initFac(int n) {
        fac[0] = 1;
        for (int i = 1; i <= n; i++) {
            fac[i] = fac[i - 1] * i;
        }
    }


    //康拓展开
    // res= cnt[1]*(n-1)! + cnt[2]*(n-2)! +...+ cnt[n]*0!
    // 根据原数组推断在全排列中的位置
    // vector<int> a - 原数组 由 0~n-1组成
    // n - 全排列范围 0~n-1
    ll Cantor(vector<int> a) {
        ll res = 0;

        int n = a.size();
        for (int i = 0; i < n - 1; i++) {
            int cnt = 0;
            //统计 已经遍历到第i个位置时 当前还没有出现的 比a[i]还小的数 的个数
            // 或者说 当i>j时 a[i]>a[j]的个数
            for (int j = i + 1; j < n; j++) {
                if (a[i] > a[j])
                    cnt++;
            }
            res += fac[(n - 1) - i] * cnt;
        }
        res++;//让排列序号从1开始
        return res;
    }

    // 逆康拓展开
    // 根据在全排列中的位置推断出数组
    vector<int> deCantor(ll x, int n) {
        //初始化vis数组
        vector<int> vis(n + 1, false);
        vector<int> res(n);
        int k;
        x--;//如果x的编号是从0开始的 就不需要这一步了 如果是1就得还原
        for (int i = 0; i < n; i++) {
            ll Min = x / fac[(n - 1) - i];//说明比a[i]小的数有Min个
            x = x % fac[(n - 1) - i];
            k = 0; // 如果全排列范围是1~n 修改这里 k=1
            for (int j = 0; j <= Min; k++) {
                if (!vis[k]) {
                    j++;
                }
            }
            k--;
            res[i] = k;
            vis[k] = true;
        }
        return res;
    }

    //输出排列
    void output(vector<int> a) {
        for (int i = 0, sz = a.size(); i < sz; i++) {
            printf("%d%c", a[i] , (i == sz - 1 ? '\n' : ' '));
        }
    }

}
using namespace CantorExpansion;

string s;

int main() {
    ios::sync_with_stdio(false);

    initFac(16);

    cin >> n >> q;
    cin >> s;

    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        a[i] = (s[i] - 'a' + 1);
    }

    ll u, v;
    u = Cantor(a);
    
    int op;
    while (q--) {
        cin >> op;
        if (op == 1) {
            cin >> s;
            for (int i = 0; i < n; i++) {
                a[i] = (s[i] - 'a' + 1);
            }
            v = Cantor(a);
            cout << abs(u - v) << endl;

        } else {
            cin >> v;
            u += v;
            output(deCantor(u, n));

        }
    }
    return 0;
}