codeforces/CF 1850ABCDEFGH题解

A

题意

需要检查一个包含3个整数的数组,是否存在两个数之和大于等于10。

题解

主要思路是:

1. 计算数组所有元素之和sum
2. 遍历数组,检查sum减去当前元素是否>= 10
3. 如果找到满足的元素,设置found=true,退出循环
4. 根据found的值输出结果

代码

#include 

using namespace std;

int main() {

    int T;
    cin >> T;

    while(T--) {

        int a[3];
        for(int i = 0; i < 3; i++) {
            cin >> a[i]; 
        }

        bool found = false;
        int sum = accumulate(a, a + 3, 0);

        for(int i = 0; i < 3; i++) {
            if(sum - a[i] >= 10) {
                found = true;
                break;
            }
        }

        if(found) {
            cout << "YES" << endl;
        }
        else {
            cout << "NO" << endl;
        }

    }

    return 0;
}

B

题意

给出若干个(a, b)对，找出a<=10中b最大的下标

题解

1. 读入测试用例的个数T，对每个测试用例循环
2. 读入对的个数n，创建一个元组(a, b, i)的向量，其中i是对的下标
3. 使用std::partition将向量分成两部分：第一部分包含所有a<=10的元组，第二部分包含剩余的元组
4. 使用std::max_element在第一部分的向量中找到b最大的元组
5. 输出找到的元组的下标i加一（因为题目中的下标是从1开始的）

代码

#include 

typedef std::pair<int, int> pii;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        int n;
        std::cin >> n;
        std::vector<std::tuple<int, int, int>> a(n);
        int length, quality;
        for (int i = 0; i < n; i++) {
            std::cin >> length >> quality;
            a[i] = std::make_tuple(length, quality, i);
        }

        auto iter = std::partition(a.begin(), a.end(), [](auto it)
                                   { return std::get<0>(it) <= 10; });
        auto max_iter = std::max_element(a.begin(), iter, [&](const auto &a, const auto &b)
                                         { return std::get<1>(a) < std::get<1>(b); });

        std::cout << std::get<2>(*max_iter) + 1 << '\n';
    }
}

C

题意

在 8*8 的字符矩阵中有一列中存在连续小写字母存在的单词，其余皆为 *，找出其中的单词

题解

1. 读入8个字符串，表示矩阵的每一行，存储在一个向量中
2. 初始化一个空字符串res，用来存储结果
3. 遍历向量中的每个字符串和每个字符
4. 如果字符是小写字母，就把它加到res后面
5. 输出res作为答案

代码

#include 

typedef std::pair<int, int> pii;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        std::vector<std::string> s(8);
        for (auto &it : s)
            std::cin >> it;

        std::string res;
        for (auto str : s)
            for (char ch : str) 
                if(islower(ch))
                    res.push_back(ch);
        
        std::cout << res << '\n';
    }
}

D

题意

移除尽量少的元素使得数列中所有连续的元素之差小于等于 k

题解

1. 首先，对输入的数列进行排序，使得相邻的元素之差最小。
2. 然后，用一个双指针法遍历数列，找出最长的连续子序列，使得其中任意两个元素之差不超过k。
3. 最后，用数列的长度减去最长子序列的长度，就是需要移除的元素个数。

代码

#include 

typedef std::pair<int, int> pii;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        int n, k;
        std::cin >> n >> k;
        std::vector<int> a(n);
        for (auto &it : a)
            std::cin >> it;
        sort(a.begin(), a.end());

        int res = INT_MIN;
        for (int j = 0; j < n;)
        {
            int p = j;
            while (++j < n && a[j] - a[j - 1] <= k)
                ;
            res = std::max(res, j - p);
        }
        std::cout << n - res << '\n';
    }
}

E

题意

将 n 个边长为 a_i 的正方形，给每个正方形边长增加到 a_i + 2*w，使得所有正方形面积之和小于等于 c

题解

1. 使用二分查找法来找出最大的满足条件的w值，即所有正方形的面积之和不超过c。
2. 定义一个check函数来判断给定的w值是否满足条件，即计算所有正方形的新面积之和，并与c进行比较。
3. 在主函数中，对数列进行排序，并初始化二分查找的左右边界和答案。
4. 在二分查找的过程中，每次取中间值作为w值，并调用check函数来判断是否满足条件，根据结果更新左右边界和答案。

代码

#include 

typedef std::pair<int, int> pii;
typedef long long LL;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        int n;
        LL s;
        std::cin >> n >> s;
        std::vector<LL> a(n);
        for (auto &it : a)
            std::cin >> it;
        int left = 1, right = 1e9 / 2, mid, ans;

        auto check = [&](LL mid) -> bool
        {
            LL res = 0;
            mid <<= 1;
            for (auto it : a)
            {
                res += (mid + it) * (mid + it);
                if (res > s)
                    return false;
            }
            return true;
        };

        while (left <= right)
        {
            mid = (left + right) >> 1;
            if (check(mid))
            {
                left = mid + 1;
                ans = mid;
            }
            else
                right = mid - 1;
        }
        std::cout << ans << '\n';
    }
}

F

题意

有 n 只青蛙，每只青蛙以 a_i 为步长不停得跳，在 [1, n] 中设置一个陷阱，捕捉尽可能多得青蛙，问做多能抓几只青蛙

题解

1. 首先，观察到如果青蛙的步长为 a，那么它只能跳到 a 的倍数的位置，所以我们可以按照步长来分组，统计每个步长有多少只青蛙。
2. 然后，对于每个位置 i，我们可以遍历它的所有因子 j，并累加对应步长为 j 的青蛙的数量，得到在位置 i 可以捕捉到的青蛙的总数。
3. 最后，我们在所有位置中找出最大的青蛙数量，就是答案。

复杂度为[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iUrS9HAN-1690212116810)(https://cdn.nlark.com/yuque/__latex/e45d75731139a9fda4a629426bf1f9ac.svg#card=math&code=n%2Alog%28n%29&id=Y0WpK)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y9BuBzYY-1690212116812)(https://cdn.nlark.com/yuque/__latex/1628a4ea7644802f0675c699b8e8320e.svg#card=math&code=%5Cfrac%7Bn%7D%7B1%7D%2B%5Cfrac%7Bn%7D%7B2%7D%2B%5Ccdots%2B%5Cfrac%7Bn%7D%7Bn%7D&id=EnBuL)] 这是著名的调和级数等于 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zoWblqHE-1690212116813)(https://cdn.nlark.com/yuque/__latex/dfbe0f7fcfb94e894b5c8502532f2797.svg#card=math&code=n%2Aln%28n%29&id=rscJV)]

代码

#include 

typedef std::pair<int, int> pii;
typedef long long LL;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        int n, x;
        std::cin >> n;
        std::vector<int> a(n + 1), c(n + 1);
        for (int i = 1; i <= n; i++)
        {
            std::cin >> x;
            if (x <= n)
                a[x]++;
        }

        for (int i = 1; i <= n; i++)
            for (int j = i; j <= n; j += i)
                c[j] += a[i];
        
        std::cout << *std::max_element(c.begin(), c.end()) << '\n';
    }
}

G

题意

有 n 个二维点，问有几个二维点对，连成的线为8个方向之一

题解

1. 首先，观察到如果两个点连成的线为8个方向之一，那么它们必须满足以下四种情况之一：
   1. 它们的横坐标相同，也就是说，它们在同一条竖直线上。
   2. 它们的纵坐标相同，也就是说，它们在同一条水平线上。
   3. 它们的横坐标和纵坐标之和相同，也就是说，它们在同一条从左下到右上的对角线上。
   4. 它们的纵坐标减去横坐标之差相同，也就是说，它们在同一条从左上到右下的对角线上。
2. 然后，我们可以用四个数组来分别存储每个点的横坐标、纵坐标、横纵坐标之和、横纵坐标之差，并对每个数组进行排序。
3. 接着，我们可以用一个函数来计算每个数组中有多少对相同的元素，也就是说，有多少对点满足其中一种情况。这个函数的思路是：
   1. 遍历数组中的每个元素，并用一个变量来记录当前元素出现的次数。
   2. 如果遇到不同的元素，就计算当前元素出现次数的二项式系数，也就是从中选两个的组合数，并累加到结果中。
   3. 如果遍历到数组的末尾，也要计算最后一个元素出现次数的二项式系数，并累加到结果中。
4. 最后，我们把四个数组分别调用这个函数得到的结果相加，就是答案。

代码

#include 

typedef std::pair<int, int> pii;
typedef long long LL;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        auto cal = [](std::vector<int> vec) -> LL
        {
            std::sort(vec.begin(), vec.end());

            int n = (int)vec.size();
            LL res = 0;
            for (int j = 0; j < n;)
            {
                int p = j;
                while (++j < n && vec[j] == vec[j - 1])
                    ;

                LL len = j - p;
                res += len * (len - 1);
            }
            return res;
        };

        int n;
        std::cin >> n;
        std::vector<pii> points(n);
        for (auto &point : points)
            std::cin >> point.first >> point.second;

        std::vector<int> x, y, xplusy, ysubx;
        std::transform(points.begin(), points.end(), std::back_inserter(x), [](const pii &point)
                       { return point.first; });
        std::transform(points.begin(), points.end(), std::back_inserter(y), [](const pii &point)
                       { return point.second; });
        std::transform(points.begin(), points.end(), std::back_inserter(xplusy), [](const pii &point)
                       { return point.first + point.second; });
        std::transform(points.begin(), points.end(), std::back_inserter(ysubx), [](const pii &point)
                       { return point.second - point.first; });

        LL res = cal(x) + cal(y) + cal(xplusy) + cal(ysubx);
        std::cout << res << '\n';
    }
}

H

题意

已知 n 个横坐标轴上点 a_i，和 m 个约束
每个约束 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UWSk2lAa-1690212116814)(https://cdn.nlark.com/yuque/__latex/6dc3974d55cff8726ef9c61a7a825894.svg#card=math&code=a_x%20-%20a_y%20%3D%20d&id=KU9og)], 问是否存在 n 个点满足所有约束

题解

1. 首先，把每个约束看作一条有向边，从点 x 指向点 y，边的权值为 d，表示 a_x - a_y = d。这样就可以把问题转化为一个图论问题，即判断这个图是否存在环，并且环上的边权之和是否为0。
2. 然后，我们可以用一个深度优先搜索（DFS）算法来遍历这个图，同时记录每个点的距离（即 a_i 的值），并检查是否有矛盾的情况出现。具体地，我们可以用一个数组 vis 来标记每个点是否被访问过，用一个数组 dis 来存储每个点的距离，用一个函数 dfs 来实现DFS算法。

代码

#include 

typedef std::pair<int, int> pii;
typedef long long LL;

int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    int T;
    std::cin >> T;

    while (T--)
    {
        int n, m;
        std::cin >> n >> m;
        std::vector<std::vector<pii>> E(n + 1);
        for (int i = 1; i <= m; i++)
        {
            int u, v, d;
            std::cin >> u >> v >> d;
            E[u].push_back(std::make_pair(v, d));
            E[v].push_back(std::make_pair(u, -d));
        }

        bool flag = true;
        std::vector<bool> vis(n + 1);
        std::vector<LL> dis(n + 1);
        std::function<void(int, LL)> dfs;
        dfs = [&](int now, LL w)
        {
            vis[now] = true;
            dis[now] = w;
            for (auto item : E[now])
            {
                int &v = item.first;
                int &d = item.second;
                if (!vis[v])
                    dfs(v, w + d);
                else
                {
                    if (dis[v] - dis[now] != d)
                        flag = false;
                }
            }
        };

        for (int i = 1; i <= n; i++)
            if (!vis[i])
                dfs(i, 0);

        std::cout << (flag ? "YES\n" : "NO\n");
    }
}