【拼题A】2024跨年挑战赛

跨年-1 特殊的年份

请找到一个最小的公元年份，使得该年份能同时被 23、11 和 8 整除。

冷知识：只要加上足够多的限制，任何年份都可以是一个特殊的年份。

输入格式:

该题没有输入。

输出格式:

输出一行，格式为 YYYY is a special year!。

输入样例:

输出样例:

1999 is a special year!

C++代码

#include 

void solve()
{
    std::cout << "2024 is a special year!";
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-2 穿什么衣服

天_气好_冷……但你在温暖的家里，并不知道有多冷。

现在你要出门了，你发现：不知道该穿多少衣服。你决定查一查天气，根据温度决定穿多少衣服出门。

以下是妈妈给的参考清单：

温度	穿什么衣服	备注
$[15,30)$	听妈妈的（Mama）	问问妈妈穿什么吧
$[-10,15)$	羽绒服（YuRongFu）	穿件羽绒服吧
$[-100,-10)$	不出门（Zhai）	都这么冷了，还是在家待着吧

输入格式:

输出一行一个整数$C(-100\le C<30)$，表示目前的温度。

输出格式:

输出当前的温度和该穿的衣服，用空格隔开。该穿的衣服输出上面表格中括号内的部分，注意区分大小写。

输入样例:

-8

输出样例:

-8 YuRongFu

C++ 代码

#include 

void solve()
{
    int c;
    std::cin >> c;
    std::cout << c << ' ';
    if (c >= 15 && c < 30) std::cout << "Mama";
    else if (c < 15 && c >= -10) std::cout << "YuRongFu";
    else if (c >= -100 && c < -10) std::cout << "Zhai";
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-3 按比例发奖

我猜你一定知道了，今年的团体程序设计天梯赛的个人奖改为按比例发奖，具体规则是：

大于等于 175 分的选手颁发个人奖；所有符合上述规则的选手，按分数高低排名，按 1:3:6 的比例颁发个人一等奖、二等奖及三等奖。为预先准备颁奖，你需要完成一个简单的计算程序。现在给出大于等于 175 分的选手人数及若干选手的实际排名，请依次输出他们的对应奖项级别。

输入格式:

输出第一行是两个正整数 N,M ($10\le N\le 10$ 5 ,$1\le M\le 100$)，表示大于等于 175 分的选手的人数以及要询问奖项的选手人数。

接下来的 M 行，每行一个正整数 $R_i$ ($1\le R_i\le N$)，表示询问奖项选手的排名。

为方便计算，我们保证 N 是 10 的倍数。

输出格式:

对于每个选手的排名，输出 1,2,3 中的一个，表示应该获得一等奖、二等奖还是三等奖。

输入样例:

100 10
1
10
11
30
40
41
60
61
99
100

输出样例:

1
1
2
2
2
3
3
3
3
3

C++代码

#include 
#include 

int n, m, r;

void solve()
{
    std::cin >> n >> m;
    while (m--)
    {
        std::cin >> r;
        if (r >= 1 && r <= n * 0.1) std::cout << 1 << std::endl;
        else if (r > n * 0.1 && r <= n * 0.4) std::cout << 2 << std::endl;
        else if (r > n * 0.4) std::cout << 3 << std::endl;
    }
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-4 骗钱的手机游戏

某个骗钱的手机游戏里的游戏角色的稀罕度总共有 9 个级别，从常见到罕见分别是：

R、R+、SR、SR+、SSR、SSR+、UR、UR+、LR

假设所有稀罕度后面有加号（+）的都需要消耗两个同等级的角色升到下一等级（例如 SR+ 升级到 SSR 需要消耗 2 个 SR+ 的角色），而没有加号的只需要消耗 1 个同等级的角色（例如 UR 升级到 UR+ 只需要一个 UR 角色），请给出将能升级的角色都升级后，每个稀罕度分别有几个角色。

为了给没玩过这类游戏的同学更好地解释题意，我们可以将角色升级理解为“大鱼吃小鱼”。例如：

对任意两条目前稀罕度是 R 的鱼，在一次升级后，其中一条会吃掉另外一条，你会获得一条稀罕度为 R+ 的鱼，另外一条就被消耗掉了。

同理，一个稀罕度为 R+ 的角色，在消耗两个稀罕度为 R+ 的角色后，可以变身为一个稀罕度为 SR 的角色。

注意 LR 不能再升级了。

输入格式:

输入一行 9 个非负整数，分别从常见到罕见给出 9 个等级的初始角色数量。

角色数量小于等于 $10^7$ 。

输出格式:

输出一行 9 个非负整数，用空格隔开，表示升级后的角色数量。

输入样例:

1001 1002 900 899 799 700 601 501 400

输出样例:

1 2 0 0 0 1 0 0 743

C++代码

#include 

const int N = 10;

int a[N];

void solve()
{
    
    for (int i = 1; i <= 9; i++)
    {
        std::cin >> a[i];
    }
    for (int i = 1; i <= 9; i++)
    {
        // i & 1 ? a[i] += a[i - 1] / 3, a[i - 1] = a[i - 1] % 3
        //         : a[i] += a[i - 1] / 2, a[i - 1] = a[i - 1] % 2;
        if (i & 1) {
            a[i] += a[i - 1] / 3, a[i - 1] = a[i - 1] % 3;
        } else {
            a[i] += a[i - 1] / 2, a[i - 1] = a[i - 1] % 2;
        }
    }
    for (int i = 1; i <= 8; i++)
    {
        std::cout << a[i] << ' ';
    }
    std::cout << a[9];
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-5 找年兽

传统中，过春节需要打年兽。为了打败年兽，你得找到年兽。

请你在一个字符串里找到所有年兽。

输入格式:

输入在一行中给出一个字符串，只包含所有 ASCII 的可见字符，不包括回车。字符串长度不超过 $10^4$ 。

输出格式:

输出一行两个数用空格隔开，第一个数字表示年兽的个数，第二个数字表示第一个年兽出现的位置。

年兽以Nian代表，字符串的位置从 0 开始。区分大小写。如果没有找到年兽，位置输出为 -1。

输入样例:

Jin Nian Ming Nian Dou Hui Wang Wang Wang! Nian nian you yu!

输出样例:

3 4

C++代码

#include 

void solve()
{
    std::string str;
    getline(std::cin, str);
    bool flag = false;
    int cnt = 0, idx = 0;
    for (int i = 0; i < str.size(); i++)
    {
        if (str.substr(i, 4) == "Nian")
        {
            cnt++;
            if (!flag)
            {
                flag = true;
                idx = i;
            }
        }
    }
    if (!cnt) 
    {
        std::cout << "0 -1\n";
    } else 
    {
        std::cout << cnt << ' ' << idx << '\n';
    }
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-6 新年烟花

新年来临，许多地方会举行烟花庆典庆祝。小 C 也想参加庆典，但不幸的是跟他一个想法的人实在太多，活动场地全是人人人人人人人人人……

活动场地可视作一个 $N\times M$ 的矩阵，其中有一些格子是空的，另外有一些格子则被人或者建筑物占领了。烟花会在一些格子上开始燃放，一个空的格子是一个对小 C 而言的优秀的观赏位置，当且仅当这个格子能看到三个及以上不同格子上燃放的烟花。一个格子能看到一个燃放的烟花，指的是：

• 格子与烟花在同一行或同一列；
• 格子与烟花的连线上的所有格子，要不是空格子，要不格子上的任何物体的高度小于小 C 的身高。

现在给定活动场地的情况以及小 C 的身高，请找到所有对小 C 而言的优秀的观赏位置，并输出能看到最多的烟花的格子的坐标。

输入格式:

输入第一行是三个正整数 $N,M,H(1\le N,M\le 50,1\le H\le 210)$，表示活动场地矩阵大小为 $N\times M$，小 C 的身高为 $H$。

接下来的 N 行，每行 M 个整数，整数的含义如下：

• 如果是一个正整数，则表示该格子被人或建筑物占据，高度为对应的值。

• 如果是一个负整数，则表示该格子用于燃放烟花。所有燃放烟花的格子视为没有高度。

• 如果是 0，则表示该格子是空格子。 所有整数的绝对值不超过500。

输出格式:

输出第一行是一个正整数，表示对小 C 而言的优秀观赏位置有多少个。

接下来输出能看到最多的燃放烟花的格子的坐标 (X,Y)，即格子在第 X 行、第 Y 列，数字间以 1 个空格分隔。当存在多组坐标时，只输出最小的那组，即输出 X 最小的解；X 相同时输出 Y 最小的解。

矩阵左上角坐标为 (0,0) ，保证至少存在一个对小 C 而言的优秀观赏位置。

输入样例:

10 10 175
0 0 0 0 0 0 0 0 0 0
0 50 0 180 -100 180 0 70 30 0
0 30 0 0 300 0 0 0 0 0
0 250 0 0 -100 0 0 0 0 0
0 -100 174 0 0 0 0 169 -100 0
0 -100 0 0 0 0 0 0 -100 0
0 -1 0 0 170 0 0 0 0 0
0 5 0 0 300 0 0 0 0 0
0 20 0 0 -100 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

输出样例:

6
3 8

思路（模拟，算是本场最难题了）：

• 看题目范围直接枚举即可，先枚举当前所在为元素为0的位置，再找到当前行列里面所有元素小于0的元素（即燃放烟花的坐标）

• 此时再计算当前坐标与其所能看到的所有燃放烟花的坐标之间是否合乎规则（即两坐标连线上的所有格子的值data,$0<=data<=H||data<0$），若这样的坐标不少于3个，则此时当前坐标就是对小 C 而言的优秀观赏位置。

• 最后依次记录所有的优秀观赏位置，枚举完再进行遍历即可找到最优的位置。

C++代码

#include 
#include 

#define x first
#define y second

const int N = 55;

int n, m, h;
int g[N][N];

int count(int curx, int cury, std::vector<std::pair<int, int>> &vec)
{
    int ans = 0;
    for (auto c: vec)
    {
        bool flag = true;
        if (curx == c.x) //同行
        {
            int mi = std::min(c.y, cury), mx = std::max(c.y, cury);
            for (int j = mi; j <= mx; j++)
            {
                if ((g[curx][j] > 0 && g[curx][j] >= h))
                {
                    flag = false;
                    break;
                }
            }
        } else if (cury == c.y) //同列
        {
            int mi = std::min(c.x, curx), mx = std::max(c.x, curx);
            for (int i = mi; i <= mx; i++)
            {
                if ((g[i][cury] > 0 && g[i][cury] >= h))
                {
                    flag = false;
                    break;
                }
            }
        }
        if (flag) ans++;
    }
    return ans;
}

void solve()
{
    std::cin >> n >> m >> h;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            std::cin >> g[i][j];

    int maxcnt = -1;
    std::vector<std::pair<std::pair<int, int>, int>> ans;
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < m; j++)
        {
            if (g[i][j] != 0) continue;
            
            std::vector<std::pair<int, int>> vec;
            for (int k = 0; k < m; k++) 
            {
                if (g[i][k] < 0) 
                {
                    vec.emplace_back(i, k);
                }
                    
            }
                
            for (int k = 0; k < n; k++)
            {
                if (g[k][j] < 0)
                {
                    vec.emplace_back(k, j);
                }
            }
                
            int cnt = count(i, j, vec);
            if (cnt >= 3)
            {
                ans.push_back({{i, j}, cnt});
                maxcnt = std::max(cnt, maxcnt);
            }
        }
    }
    
    std::cout << ans.size() << std::endl;
    for (auto c: ans)
    {
        if (c.y == maxcnt)
        {
            std::cout << c.x.x << ' ' << c.x.y << '\n';
            break;
        }
    }
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-7 奇因子之和

一个整数的因子，就是所有可以整除这个数的数。奇数指在整数中，不能被 2 整除的数。所谓整数 Z 的奇因子，就是可以整除 Z 的奇数。
给定 N 个正整数，请你求出它们的第二大奇因子的和。当然，如果该数只有一个奇因子，就用它唯一的那个奇因子去求和。

输入格式：

输入第一行给出一个正整数 $N（\le 1000)$。随后一行给出 N 个不超过 $10^6$的正整数。

输出格式：

在一行中输出所有给定整数的第二大奇因子之和。

输入样例：

5
147 12 35 78 4

输出样例：

71

思路（枚举）：

• 正常枚举即可，枚举时记得限制已经枚举出的奇因子数量，否则会超时。

C++代码

#include 
#include 

void solve()
{
    int n, x, res = 0;
    std::cin >> n;
    for (int i = 1; i <= n; i++)
    {
        std::cin >> x;
        std::vector<int> vec;
        for (int j = 1; j <= x && vec.size() <= 2; j++)
        {
            if (x % j == 0 && (x / j) & 1)
                vec.push_back(x / j);
        }
        res += vec.size() == 1 ? vec[0] : vec[1];
    }
    std::cout << res << std::endl;
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}

跨年-8 翻箱倒柜（复刻）

翻箱倒柜找东西大概是所有人头痛的事情。大部分人类在识别物体的时候，更容易识别颜色而不是大小的差异。所以当我们想从一大堆杂乱堆放的长方体盒子中找到我们需要的盒子时，根据颜色找比根据尺寸找要容易。现在的问题是，我们只知道尺寸不知道颜色…… 所以就要请你从这些盒子的记录中快速找出需要的盒子的编号及颜色。

输入格式：

输入第一行给出一个正整数 $N（\le 10^5）$，为盒子的总数。随后 N 行，每行列出一只盒子的长、宽、高、颜色值。再后面是查询数量 $K（\le 100）$，随后 K 行，每行给出一个需要查询的盒子的长、宽、高。
这里所有尺寸都是不超过 $10^9$的正整数，颜色值按 RRR.GGG.BBB 格式给出，三个分值都在$[0,255]$ 区间内。
同一行中的数字以空格分隔。题目保证给出的 N 只盒子的尺寸都不相同，即不存在两只盒子具有相同的长、宽、高。注意：尺寸为 1、2、3 的盒子跟尺寸为 3、2、1的盒子是不同的。盒子的编号按输入顺序从 1 开始递增编号。

输出格式：

对每个查询的盒子，在一行中按输入相同的格式输出其编号及颜色。如果这个尺寸的盒子不存在，则输出 Not Found。

输入样例：

10
15 23 23 000.255.136
12 32 15 255.000.092
29 32 15 000.000.255
15 23 25 255.255.000
10 15 23 000.000.000
12 17 15 255.255.255
15 10 23 023.189.163
29 32 33 233.069.215
9 31 987 179.002.031
40 15 23 230.000.000
6
15 23 23
12 17 15
29 32 33
10 15 15
15 32 12
9 31 987

输出样例：

1 000.255.136
6 255.255.255
8 233.069.215
Not Found
Not Found
9 179.002.031

思路（水题）：

• 开map记录即可

C++代码

#include 

int n, m, h, k, x, res;

const int N = 50 + 7;

void solve()
{
    std::cin >> n;
    std::map<std::pair<int, std::pair<int, int>>, std::pair<int, std::string>> ump;
    for (int i = 1; i <= n; ++i)
    {
        int a, b, c;
        std::string str;
        std::cin >> a >> b >> c >> str;
        ump[{a, {b, c}}] = {i, str};
    }
//    for (auto [k, v]: ump)
//    {
//        std::cout << k.first << '\n';
//    }
    std::cin >> k;
    while (k--)
    {
        int a, b, c;
        std::cin >> a >> b >> c;
        if (!ump.count({a, {b, c}}))
        {
            std::cout << "Not Found\n";
        } else
        {
            std::cout << ump[{a, {b, c}}].first << ' ' << ump[{a, {b, c}}].second << '\n';
        }
    }
}

int main()
{
    int t = 1;
    std::ios::sync_with_stdio(false), std::cin.tie(nullptr), std::cout.tie(nullptr);
    //cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}