AtCoder Beginner Contest 343 A~F_给定一个正整数 n n。找到不超过 n n 的最大回文立方数。这里,正整数 k k 被定-优快云博客

本文链接：https://blog.youkuaiyun.com/Code_Shark/article/details/136510893

A.Wrong Answer（模拟）

题意：

给你两个整数 $A$ 和 $B$ ，它们介于 $0$ 和 $9$ 之间。

输出任何一个介于 $0$ 和 $9$ 之间且不等于 $A + B$ 的整数。

分析：

按题意判断并输出一个整数即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    for (int i = 0; i < 10; i++) {
        if (i != a + b) {
            cout << i << endl;
            break;
        }
    }
    return 0;
}

B.Adjacency Matrix（模拟）

题意：

有一个简单的无向图 $G$ ，其中有 $N$ 个顶点，顶点上标有数字 $1,2,…,N1,2,\ldots,N$ 。

给你 $G$ 的邻接矩阵 $A_{i,j})$ 。也就是说，当且仅当 $A_{i,j}=1$ 时， $G$ 有一条边连接顶点 $i$ 和 $j$ 。

对于每个 $i=1,2,…,Ni=1,2,\ldots,N$ ，按升序输出与顶点 $i$ 直接相连的顶点的编号。

当且仅当顶点 $i$ 和 $j$ 之间有一条边相连时，顶点 $i$ 和 $j$ 才被认为是直接相连的。

分析：

如果是 $1$ 代表连通，输出其索引即可。

代码：

#include<bits/stdc++.h>

using namespace std;

int main() {
    int n;
    cin >> n;
    for (int t = 1; t <= n; t++) {
        for (int i = 1; i <= n; i++) {
            int x;
            cin >> x;
            if (x)
                cout << i << ' ';
        }
        cout << endl;
    }
    return 0;
}

C.343（遍历）

题意：

给你一个正整数 $N$ 。

求一个不大于 $N$ 的最大回文立方数。

正整数 $K$ 只有在满足以下两个条件时才被定义为回文立方数：

有一个正整数 $x$ ，使得 $x^3=K$ .
$K$ 的十进制表示不含前导零，而且是一个回文数。更确切地说，如果用介于 $0$ 和 $9$ （含）之间的整数 $A0,A1,…,AL−2A_0,A_1,\ldots,A_{L-2}$ 和介于 $1$ 和 $9$ （含）之间的整数 $A_{L-1}$ 将 $K$ 表示为 $K=∑i=0L−1Ai10iK=\sum\limits_{i = 0}^{L-1}A_i10^i$ ，则所有 $i=0,1,…,L−1i=0,1,\ldots,L-1$ 都是 $A_i=A_{L-1-i}$ 。

分析：

$n$ 的范围是 $1 e 18$ , 所以只需要遍历到 $1 e 6$ 即可，枚举然后判断是否为回文数即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;

bool check(LL n) {
    string s;
    while (n) {
        s += n % 10 + '0';
        n /= 10;
    }
    int len = s.size();
    s = '$' + s;
    for (int i = 1; i <= len / 2; i++)
        if (s[i] != s[len - i + 1])
            return false;
    return true;
}

int main() {
    LL n;
    cin >> n;
    LL ans = 1;
    for (LL i = 2; i * i * i <= n; i++) {
        LL temp = i * i * i;
        if (check(temp)) {
            ans = temp;
        }
    }
    cout << ans << endl;
    return 0;
}

D.Diversity of Scores（遍历）

题意：

高桥正在举办一场有 $N$ 名选手参加的比赛，选手编号为 $1$ 至 $N$ 。选手们将争夺积分。目前，所有棋手的积分都是零。

高桥的预知能力让他知道选手们的分数将如何变化。具体来说，对于 $i=1,2,…,Ti=1,2,\dots,T$ ， $A_i$ 选手的分数将在 $i$ 秒后增加 $B_i$ 分。

高桥希望分数多样化，他想知道在每个时刻棋手的分数中会出现多少个不同的分数值。对于每个 $i=1,2,…,Ti=1,2,\dots,T$ ，求从现在起 $i + 0.5$ 秒钟后玩家分数中不同分值的数量。

例如，如果在某一时刻球员的得分分别为 $10$ 、 $20$ 、 $30$ 和 $20$ ，那么在该时刻球员的得分中有三个不同的分值。

分析：

初始化 $0$ 为 $N$ ，开始肯定是 $1$ ，因为都是 $0$ ，可以用 $\text{值,人数} > mp$ 来储存这个值，对于每一次相加 $B, m p [W [A]]$ 就要减去一个人数到了新的地方,以此类推即可。

代码：

#include<bits/stdc++.h>

typedef long long LL;
using namespace std;
const LL N = 2e5 + 10;

map<LL, LL> mp;
LL W[N];

int main() {
    LL n, T;
    cin >> n >> T;
    mp[0] = n;
    LL ans = 1;
    for (LL i = 1; i <= T; i++) {
        LL A, B;
        cin >> A >> B;
        mp[W[A]]--;
        if (!mp[W[A]])
            ans--;
        W[A] += B;
        if (!mp[W[A]])
            ans++;
        mp[W[A]]++;
        cout << ans << endl;
    }
    return 0;
}

E.7x7x7（枚举）

题意：

在一个坐标空间中，我们想放置三个边长为 $7$ 的立方体，这样正好一个、两个、三个立方体所包含区域的体积分别为 $V_1$ 、 $V_2$ 、 $V_3$ 。

对于三个整数 $a$ 、 $b$ 、 $c$ ，让 $C (a, b, c)$ 表示由 $(a≤x≤a+7)∧(b≤y≤b+7)∧(c≤z≤c+7)(a\leq x\leq a+7)\land(b\leq y\leq b+7)\land(c\leq z\leq c+7)$ 代表的立方体区域。

判断是否有满足下列所有条件的九个整数 $a_1,b_1,c_1,a_2,b_2,c_2,a_3,b_3,c_3$ ，如果存在，请找出一个这样的元组。

$∣a1∣,∣b1∣,∣c1∣,∣a2∣,∣b2∣,∣c2∣,∣a3∣,∣b3∣,∣c3∣≤100|a_1|,|b_1|,|c_1|,|a_2|,|b_2|,|c_2|,|a_3|,|b_3|,|c_3|\leq 100$
设 $C_i=C(a_i,b_i,c_i)\ (i=1,2,3)$ 。
- 恰好包含 $C_1,C_2,C_3$ 中一个的区域的体积为 $V_1$ 。
- 恰好包含两个 $C_1,C_2,C_3$ 的区域的体积是 $V_2$ 。
- 所有 $C_1,C_2,C_3$ 所包含的区域的体积是 $V_3$ 。

分析：

假设第一个正方体的位置恒为 $(0, 0, 0)$ ，暴力枚举第二、三个正方体的位置，判断每种放置方法是否合法即可

对于枚举位置，让三个正方体离太远没有意义，只需要枚举所有能使得三个正方体相交或至少有一个面重合的最大范围即可，则可以枚举的第二个正方体的三个维度的坐标值在 $(0, 7)$ ，第三个正方体的坐标值在 $(- 7, 14)$ 。

代码：

#include<bits/stdc++.h>

using namespace std;

int get_d(int x, int tx) {
    return max(0, min(x, tx) + 7 - max(x, tx));
}

int get_d(int sx, int x, int tx) {
    return max(0, min({sx, x, tx}) + 7 - max({sx, x, tx}));
}

int fun(int ax, int ay, int az, int bx, int by, int bz) {
    int dx = get_d(ax, bx), dy = get_d(ay, by), dz = get_d(az, bz);
    return dx * dy * dz;
}

void solve() {
    int v1, v2, v3;
    cin >> v1 >> v2 >> v3;
    for (int x = 0; x <= 7; x++) {
        for (int y = 0; y <= 7; y++) {
            for (int z = 0; z <= 7; z++) {
                for (int tx = -7; tx <= 14; tx++) {
                    for (int ty = -7; ty <= 14; ty++) {
                        for (int tz = -7; tz <= 14; tz++) {
                            int dx = get_d(0, x, tx);
                            int dy = get_d(0, y, ty);
                            int dz = get_d(0, z, tz);
                            int tv3 = dx * dy * dz;
                            if (tv3 != v3)
                                continue;
                            int tv2 = fun(0, 0, 0, x, y, z) + fun(0, 0, 0, tx, ty, tz) + fun(x, y, z, tx, ty, tz) -
                                      3 * tv3;
                            if (tv2 != v2)
                                continue;
                            int tv1 = 3 * 7 * 7 * 7 - 3 * tv3 - 2 * tv2;
                            if (tv1 != v1)
                                continue;
                            cout << "Yes" << endl;
                            cout << "0 0 0 " << x << " " << y << " " << z << " " << tx << " " << ty << " " << tz
                                 << endl;
                            return;
                        }
                    }
                }
            }
        }
    }
    cout << "No" << endl;
}

int main() {
    solve();
    return 0;
}

F.Second Largest Query（线段树）

题意：

给你一个长度为 $N$ 的序列 $A=(A1,A2,…,AN)A=(A_1,A_2,\ldots,A_N)$ 。

按照给出的顺序处理 $Q$ 个查询。每个查询属于以下两种类型之一：

类型 $1$ ：以1 p x的形式给出。将 $A_p$ 的值改为 $x$ 。
类型 $2$ ：输出 $(Al,Al+1,…,Ar)(A_l,A_{l+1},\ldots,A_r)$ 中第二大数值的出现次数。更准确地说，输出满足 $l≤i≤rl\leq i\leq r$ 的整数 $i$ 的个数，即在 $Al,Al+1,…,ArA_l,A_{l+1},\ldots,A_r$ 中正好有一个大于 $A_i$ 的不同值。

分析：

可以直接用线段树维护四个信息，每个节点维护这个区间对应的最大值、次大值、以及他们各自的出现次数，使用线段树板子加上求第二大的数即可。

代码：

#include<bits/stdc++.h>

using namespace std;

template<class Info, class Merge = std::plus<Info>>

struct SegmentTree {
    const int n;
    const Merge merge;
    vector<Info> info;

    SegmentTree(int n) : n(n), merge(Merge()), info(4 << std::__lg(n)) {}

    SegmentTree(vector<Info> init) : SegmentTree(init.size()) {

        function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };

        build(1, 0, n);
    }

    void pull(int p) {
        info[p] = merge(info[2 * p], info[2 * p + 1]);
    }

    void modify(int p, int l, int r, int x, const Info &v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;

        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }

    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }

    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;

        return merge(rangeQuery(2 * p, l, m, x, y), rangeQuery(2 * p + 1, m, r, x, y));
    }


    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
};


struct Info {
    int mx1 = -1;
    int cnt1 = 0;
    int mx2 = -2;
    int cnt2 = 0;
};


Info operator+(Info a, Info b) {
    if (a.mx1 == b.mx1) {
        if (a.mx2 < b.mx2) {
            swap(a, b);
        }
        a.cnt1 += b.cnt1;
        if (a.mx2 == b.mx2) {
            a.cnt2 += b.cnt2;
        }
        return a;
    }
    if (a.mx1 < b.mx1) {
        swap(a, b);
    }
    if (b.mx1 > a.mx2) {
        a.mx2 = b.mx1;
        a.cnt2 = b.cnt1;
    } else if (b.mx1 == a.mx2) {
        a.cnt2 += b.cnt1;
    }
    return a;
}


int main() {
    int N, Q;
    cin >> N >> Q;
    vector<int> A(N);
    for (int i = 0; i < N; i++) {
        cin >> A[i];
    }

    SegmentTree<Info> seg(N);
    for (int i = 0; i < N; i++) {
        seg.modify(i, Info{A[i], 1, -1, 0});
    }

    while (Q--) {
        int type;
        cin >> type;

        if (type == 1) {
            int p, x;
            cin >> p >> x;
            p--;
            seg.modify(p, {x, 1, -1, 0});
        } else {
            int l, r;
            cin >> l >> r;
            l--;
            cout << seg.rangeQuery(l, r).cnt2 << endl;
        }
    }
    return 0;
}