2023牛客寒假算法基础集训营1 ACDEFGHKLM

比赛链接

A

题解

知识点：模拟。

显然。

（用char输入到一半直接给答案跳出，WA了两小时，无话可说。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    string s;
    cin >> s;
    vector<int> sum(2);
    for (int i = 1;i <= 10;i++) {
        if (s[i - 1] == '1') sum[!(i & 1)]++;
        if (sum[0] > sum[1] + (10 - i + 1) / 2 || sum[1] > sum[0] + (10 - i) / 2) {
            cout << i << '\n';
            return true;
        }
    }
    return false;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

C

题解

知识点：贪心。

显然只要不是 \(0\) 的论文只要不动就会有 \(1\) 的贡献，动了也至多有 \(1\) 的贡献不如不动。因此，记录非 \(0\) 论文数量即可。

时间复杂度 \(O(n)\)

空间复杂度 \(O(n)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int a[100007];
bool solve() {
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++) cin >> a[i];
    int ans = 0;
    for (int i = 1;i <= n;i++) ans += a[i] != 0;
    cout << ans << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

D

题解

知识点：计算几何，贪心。

\((p_x,p_y)\) 会有四个位置，矩阵内、上方、右方、右上方，分别进行讨论：

1. \(p_x \leq x,p_y \leq y\) 在矩阵内部，比值最大值为 \(\dfrac{\max(px,x-px)\cdot \max(py,y-py)}{xy}\) 。
2. \(p_x > x,p_y < y\) 在矩阵右方，比值最大值为 \(\max\left(\dfrac{xp_y}{xy+(p_x-x)p_y},\dfrac{x(y-p_y)}{xy+(p_x-x)(y-p_y)}\right)\) 。
3. \(p_x < x,p_y > y\) 在矩阵上方，比值最大值为 \(\max\left(\dfrac{p_xy}{xy+p_x(p_y-y)},\dfrac{(x-p_x)y}{xy+(x-p_x)(p_y-y)}\right)\) 。
4. \(p_x \geq x,p_y \geq y\) 在矩阵右上方，比值最大值为 \(\dfrac{xy}{p_xp_y}\) ，这个需要肉眼观察法qwq。

（手残把 \(y\) 写成 \(x\) ，又瞪了半小时。。。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    int x, y, px, py;
    cin >> x >> y >> px >> py;

    if (px <= x && py <= y) {
        cout << fixed << setprecision(10) << 1.0 * max(px, x - px) * max(py, y - py) / x / y << '\n';
    }
    else if (px > x && py < y) {
        double a = 1.0 * x * py / (x * y + py * (px - x));
        double b = 1.0 * x * (y - py) / (x * y + (y - py) * (px - x));
        cout << fixed << setprecision(10) << max(a, b) << '\n';
    }
    else if (py > y && px < x) {
        double a = 1.0 * y * px / (x * y + px * (py - y));
        double b = 1.0 * y * (x - px) / (x * y + (x - px) * (py - y));
        cout << fixed << setprecision(10) << max(a, b) << '\n';
    }
    else if (px >= x && py >= y) {
        cout << fixed << setprecision(10) << 1.0 * x * y / px / py << '\n';
    }
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

E

题解

知识点：计算几何。

前两种操作是平移和旋转，并不会改变两条边的相对位置关系，而第三种操作可以通过镜像翻折改变位置关系。

先确定 \(ABC\) 和 \(DEF\) 靠左的一条边，然后比较长度，如果不同则一定用过第三种操作。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

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

using ld = long double;
const ld pi = acos(-1.0L);
const ld eps = 1e-8;
template<class T>
struct Point {
    T x, y;
    Point(const T &x = 0, const T &y = 0): x(x), y(y) {}
    Point(const Point &A, const Point &B): x(B.x - A.x), y(B.y - A.y) {}

    Point &operator+=(const Point &P) { x += P.x, y += P.y;return *this; }
    Point &operator-=(const Point &P) { x -= P.x, y -= P.y;return *this; }
    Point &operator*=(const T &k) { x *= k, y *= k;return *this; }
    Point &operator/=(const T &k) { x /= k, y /= k;return *this; }
    friend Point operator-(const Point &P) { return Point(-P.x, -P.y); }
    friend Point operator+(Point A, const Point &B) { return A += B; }
    friend Point operator-(Point A, const Point &B) { return A -= B; }
    friend Point operator*(Point P, const T &k) { return P *= k; }
    friend Point operator/(Point P, const T &k) { return P /= k; }

    bool operator==(const Point &P) const { return (abs(x - P.x) <= eps && abs(y - P.y) <= eps); }

    //点乘
    friend T operator*(const Point &A, const Point &B) { return A.x * B.x + A.y * B.y; }
    //叉乘
    friend T operator^(const Point &A, const Point &B) { return A.x * B.y - A.y * B.x; }

    //P的相对方向，逆时针为1
    int toLeft(const Point &P) const {
        T cross = (*this) ^ P;
        return (cross > eps) - (cross < -eps);
    }

    //向量长度的平方
    T len2() const { return (*this) * (*this); }
    //两点距离的平方
    friend T dist2(const Point &A, const Point &B) { return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y); }

    //*一定包含浮点的函数
    //两点距离
    friend ld dist(const Point &A, const Point &B) { return sqrt(dist2(A, B)); }
    //向量长度
    ld len()const { return sqrt(len2()); }
    //向量夹角
    friend ld ang(const Point &A, const Point &B) { return acos(max(-1.0L, min(1.0L, (A * B) / (A.len() * B.len())))); }
    //逆时针旋转rad
    Point rot(const ld rad) const { return { x * cos(rad) - y * sin(rad), x * sin(rad) + y * cos(rad) }; }
    //逆时针旋转参数
    Point rot(const ld cosr, const ld sinr) const { return { x * cosr - y * sinr, x * sinr + y * cosr }; }
};

bool solve() {
    ld xa, ya, xb, yb, xc, yc;
    cin >> xa >> ya >> xb >> yb >> xc >> yc;
    ld xd, yd, xe, ye, xf, yf;
    cin >> xd >> yd >> xe >> ye >> xf >> yf;

    Point<ld> BA({ xb,yb }, { xa,ya });
    Point<ld> BC({ xb,yb }, { xc,yc });
    Point<ld> ED({ xe,ye }, { xd,yd });
    Point<ld> EF({ xe,ye }, { xf,yf });

    if (BA.toLeft(BC) == 1) swap(BA, BC);
    if (ED.toLeft(EF) == 1) swap(ED, EF);

    if (abs(BA.len() - ED.len()) < eps) cout << "NO" << '\n';
    else cout << "YES" << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

F

题解

知识点：并查集。

注意到，即便一个点放完炸弹不能走，但因为我们能控制放炸弹的顺序，炸弹是影响不了我们的路线的。所以实际上，只要炸弹点是连通的，我们就一定可以从这个连通块的任何点开始走，并且以任何点结束，答案便是这个连通块大小的平方。

当然如果炸弹点不在一个连通块就无解。

或者，没有炸弹点，我们就可以把所有连通块大小平方加起来。

用并查集维护连通性，以及连通块大小。

时间复杂度 \(O((m+n) \log n)\)

空间复杂度 \(O(n)\)

代码

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

struct DSU {
    vector<int> fa;
    vector<int> w;

    explicit DSU(int n):fa(n + 1), w(n + 1, 1) {
        for (int i = 1;i <= n;i++)
            fa[i] = i;
    }

    void init(int n) {
        for (int i = 1;i <= n;i++)
            fa[i] = i, w[i] = 1;
    }

    int find(int x) {
        if (fa[x] == x) return x;
        fa[x] = find(fa[x]);
        return fa[x];
    }//按需修改

    bool same(int x, int y) { return find(x) == find(y); }

    bool merge(int x, int y) {
        if (same(x, y)) return false;
        int px = fa[x], py = fa[y];
        fa[px] = py;
        w[py] += w[px];
        return true;
    }//按需修改；注意方向，x合并到y
};

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    DSU dsu(n);
    for (int i = 1;i <= m;i++) {
        int u, v;
        cin >> u >> v;
        dsu.merge(u, v);
    }

    vector<int> c(n + 1);
    for (int i = 1;i <= n;i++) cin >> c[i];

    bool ok = 1;
    int rt = 0;
    for (int i = 1;i <= n;i++) {
        if (c[i]) {
            if (rt) ok &= dsu.same(i, rt);
            else rt = dsu.find(i);
        }
    }
    if (!rt) {
        ll ans = 0;
        for (int i = 1;i <= n;i++) {
            if (i == dsu.find(i)) ans += 1LL * dsu.w[i] * dsu.w[i];
        }
        cout << ans << '\n';
    }
    else if (ok) cout << 1LL * dsu.w[rt] * dsu.w[rt] << '\n';
    else cout << 0 << '\n';
    return 0;
}

G

题解

知识点：线段树，数学。

众所周知，分数是不会一直涨的qwq，所以 \(x_{i+1} = round(10\sqrt {x_i})\) 在 \(x = 0,99,100\) 时会不变，这些点称为不动点。同时，其他点也会快速收敛到 \(99\) 或者 \(100\) ，也就是说每个点最多修改几次就不用改了。

因此，可以写一个伪区间修改的线段树，即单点修改但套一个区间修改的壳子。然后再加一个区间值都为 \(99,100\) 时的优化，可以用最大值和最小值夹逼实现。单点修改时也是同样的，修改到 \(99,100\) 就可以结束了。

特判 \(a_i = 0\) 的情况，为了判断统一可以把这个节点的 \(max\) 和 \(min\) 的信息修改为 \(100\) ，而 \(val\) 还是 \(0\) ，不影响求和。

因为每个点最多修改几次可以看作常数，所以对单点修改次数是 $O(n) $ ，所以复杂度也是 \(O(n\log n)\) 。

时间复杂度 \(O(n \log n)\)

空间复杂度 \(O(n)\)

代码

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

struct T {
    ll val;
    int mi, mx;
    static T e() { return T{ 0,0x3f3f3f3f,0 }; }
    friend T operator+(const T &a, const T &b) { return { a.val + b.val,min(a.mi,b.mi),max(a.mx,b.mx) }; }
};
///节点元封装类，定义单位元"e"、合并"+"
struct F {
    int k;
    T operator()(const T &x) {
        int val = x.val;
        for (int i = 1;i <= k && val != 99 && val != 100;i++) {
            val = sqrt(val) * 10 + 0.5;
        }
        return T{ val,val,val };
    }
};
///修改元封装类，定义映射"()"
class SegmentTree {
    const int n;
    vector<T> node;
    void update(int rt, int l, int r, int L, int R, F f) {
        if (node[rt].mi >= 99 && node[rt].mx <= 100) return;
        if (r < L || l > R) return;
        if (l == r) {
            node[rt] = f(node[rt]);
            return;
        }
        int mid = l + r >> 1;
        update(rt << 1, l, mid, L, R, f);
        update(rt << 1 | 1, mid + 1, r, L, R, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    }
    T query(int rt, int l, int r, int x, int y) {
        if (l > y || r < x) return T::e();
        if (x <= l && r <= y) return node[rt];
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    }

public:
    SegmentTree(int _n):n(_n), node(_n << 2, T::e()) {}
    SegmentTree(int _n, vector<T> &src):n(_n), node(_n << 2, T::e()) {
        function<void(int, int, int)> build = [&](int rt, int l, int r) {
            if (l == r) {
                node[rt] = src[l];
                return;
            }
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        };
        build(1, 1, n);
    }

    void update(int L, int R, F f) {
        update(1, 1, n, L, R, f);
    }

    T query(int x, int y) {
        return query(1, 1, n, x, y);
    }
};
///线段树，建树O(nlogn)、修改查询O(logn)，单点修改、区间查询

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    vector<T> src(n + 1);
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        if (x) src[i] = { x,x,x };
        else src[i] = { 0,100,100 };
    }
    SegmentTree sgt(n, src);
    while (m--) {
        int op;
        cin >> op;
        if (op == 1) {
            int l, r, k;
            cin >> l >> r >> k;
            sgt.update(l, r, { k });
        }
        else {
            cout << sgt.query(1, n).val << '\n';
        }
    }
    return 0;
}

H

题解

知识点：数学。

因为面积总和不变，记录 \(n^2-1\) 多了或少了几个半圆，一定会出现在最后一块上，直接算即可。

时间复杂度 \(O(n^2)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

bool solve() {
    int n;
    cin >> n;
    int ans = 10;
    for (int i = 1;i <= n * n - 1;i++) {
        for (int j = 1;j <= 4;j++) {
            char x;
            cin >> x;
            if (x == '1') ans++;
            else if (x == '2') ans--;
        }
    }
    cout << ans << '\n';
    return true;
}

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--) {
        if (!solve()) cout << -1 << '\n';
    }
    return 0;
}

K

题解

知识点：线性dp。

\(n\leq 2\) 特判为 \(0\) 。

设 \(dp[i][j][k]\) 表示为考虑了前 \(i\) 个位置，有 \(j\) 个 \(1\) ，最后两个位置的状态是 \(k\) （00,10,01,11 四种状态）。

初值设置：

if (m >= 0) dp[3][0][0] = 0;
if (m >= 1) dp[3][1][0] = dp[3][1][1] = dp[3][1][2] = 0;
if (m >= 2) dp[3][2][1] = dp[3][2][2] = dp[3][2][3] = 1;
if (m >= 3) dp[3][3][3] = 1;

转移方程：

dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]);
dp[i][j][1] = min(dp[i - 1][j][2], dp[i - 1][j][3] + 1);
if (j >= 1) dp[i][j][2] = min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1] + 1);
if (j >= 2) dp[i][j][3] = min(dp[i - 1][j - 1][2] + 1, dp[i - 1][j - 1][3] + 1);

本题实际可以贪心 \(O(n)\) 过，加点推公式可以 \(O(1)\) 过。

（公式写挂了，没考虑填填满前的几个 \(1\) 的情况不符合规律要特判，于是用dp硬碾过去了qwq。

时间复杂度 \(O(nm)\)

空间复杂度 \(O(nm)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int dp[1007][1007][4];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    if (n <= 2) {
        cout << 0 << '\n';
        return 0;
    }
    memset(dp, 0x3f3f3f3f, sizeof dp);
    if (m >= 0) dp[3][0][0] = 0;
    if (m >= 1) dp[3][1][0] = dp[3][1][1] = dp[3][1][2] = 0;
    if (m >= 2) dp[3][2][1] = dp[3][2][2] = dp[3][2][3] = 1;
    if (m >= 3) dp[3][3][3] = 1;
    for (int i = 4;i <= n;i++) {
        for (int j = 0;j <= min(i, m);j++) {
            dp[i][j][0] = min(dp[i - 1][j][0], dp[i - 1][j][1]);
            dp[i][j][1] = min(dp[i - 1][j][2], dp[i - 1][j][3] + 1);
            if (j >= 1) dp[i][j][2] = min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1] + 1);
            if (j >= 2) dp[i][j][3] = min(dp[i - 1][j - 1][2] + 1, dp[i - 1][j - 1][3] + 1);
        }
    }
    cout << min({ dp[n][m][0],dp[n][m][1],dp[n][m][2],dp[n][m][3] }) << '\n';
    return 0;
}

L

题解

知识点：数学。

先团队，再个人，选择是独立的可以分开来算加起来。

团队选 \(1,2,3,4,5\) 次选到的概率都是 \(\dfrac{1}{5}\) ，特别地 \(5\) 才能选中次只选 \(4\) 次就可以结束了，期望 \(\dfrac{1+2+3+4+4}{5}\) 。

个人同理，期望为 \(\dfrac{1+2+3+3}{4}\) 。

总和为 \(5.05\) ，选 \(32\) 。

（傻不拉几的真信了运气题，题都没看直接抽卡，抽了十几发。。

时间复杂度 \(O(1)\)

空间复杂度 \(O(1)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

    cout << 32 << '\n';
    return 0;
}

M

题解

知识点：线性dp。

设 \(dp[i][j]\) 表示为考虑到倒数第 \(i\) 个人，还剩下 \(j\) 个仙贝。

初始状态 \(dp[0][0] = 0\) 。

枚举给了倒数第 \(i\) 个人 \(k\) 个仙贝的情况转移即可。

（傻不拉几的真信了找规律题，找了1小时屁都没发现。。。

时间复杂度 \(O(nm^2)\)

空间复杂度 \(O(nm)\)

代码

#include <bits/stdc++.h>
#define ll long long

using namespace std;

double dp[507][507];
int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1;i <= n;i++) {
        for (int j = 0;j <= m;j++) {
            dp[i][j] = dp[i - 1][j];
            for (int k = 1;k <= j;k++) {
                dp[i][j] = max(dp[i][j], dp[i - 1][j - k] + 1.0 * k / j);
            }
        }
    }
    cout << fixed << setprecision(10) << dp[n][m] << '\n';
    return 0;
}