The 13th Zhejiang Provincial Collegiate Programming Contest 部分题解

最新推荐文章于 2025-05-25 11:48:52 发布
最新推荐文章于 2025-05-25 11:48:52 发布
阅读量567 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ZOJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Walton_/article/details/52556947
本文提供了A-Apples and Ideas、C-Defuse the Bomb、D-The Lucky Week、I-People Counting、K-Highway Project和L-Very Happy Great BG等竞赛题目的解题思路。A题涉及苹果和想法的交换；C题要求根据炸弹阶段按下对应按钮；D题通过查找周期性规律解决；I题采用标记法进行人头统计；K题为最短路径问题，利用Dijkstra算法并考虑费用；L题答案直接累加所有人即可。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

A-Apples and Ideas

签到题。相互交换苹果和想法，苹果互换，想法相加。

#include <cstdio>

int main()
{
    int t;
    scanf("%d", &t);

    while (t--) {
        int a, b, c, d;
        scanf("%d%d%d%d", &a, &b, &c, &d);
        printf("%d %d\n", c, b+d);
        printf("%d %d\n", a, b+d);
    }

    return 0;
}

C-Defuse the Bomb

一个炸弹上有一个显示器和四个按钮。显示器上显示不同的数代表不同的阶段。根据不同的阶段按下不同的按钮即可拆除炸弹。
按题目要求进行操作即可，输入每阶段四个按钮的值，留下最终按下的按钮，最后遍历一遍即可。
代码较长需仔细。

#include <cstdio>

int main()
{
    int t;
    int b[6][5];
    scanf("%d", &t);

    for (int i = 0; i < t; i++) {
        for (int j = 1; j <= 5; j++) {
            int d;
            scanf("%d", &d);
            for (int k = 1; k <= 4; k++)
                scanf("%d", &b[j][k]);
            //stage 1
            if (j == 1) {
                if (d == 1) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 2)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 2) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 2)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 3) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 3)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 4)
                            continue;
                        b[j][k] = 0;
                    }
                }
            }
            //stage 2
            else if (j == 2) {
                if (d == 1) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[j][k] == 4)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 2) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[1][k] != 0)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 3) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 1)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else {
                    for (int k = 1; k <= 4; k++) {
                        if (b[1][k] != 0)
                            continue;
                        b[j][k] = 0;
                    }
                }
            }
            //stage 3
            else if (j == 3) {
                if (d == 1) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[2][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[2][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
                else if (d == 2) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[1][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[1][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
                else if (d == 3) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 3)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else {
                    for (int k = 1; k <= 4; k++) {
                        if (b[j][k] == 4)
                            continue;
                        b[j][k] = 0;
                    }
                }
            }
            //stage 4
            else if (j == 4) {
                if (d == 1) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[1][k] != 0)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 2) {
                    for (int k = 1; k <= 4; k++) {
                        if (k == 1)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else if (d == 3) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[2][k] != 0)
                            continue;
                        b[j][k] = 0;
                    }
                }
                else {
                    for (int k = 1; k <= 4; k++) {
                        if (b[2][k] != 0)
                            continue;
                        b[j][k] = 0;
                    }
                }
            }
            //stage 5
            else {
                if (d == 1) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[1][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[1][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
                else if (d == 2) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[2][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[2][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
                else if (d == 3) {
                    for (int k = 1; k <= 4; k++) {
                        if (b[4][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[4][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
                else {
                    for (int k = 1; k <= 4; k++) {
                        if (b[3][k] != 0) {
                            for (int l = 1; l <= 4; l++) {
                                if (b[j][l] == b[3][k])
                                    continue;
                                b[j][l] = 0;
                            }
                        }
                    }
                }
            }
        }

        for (int j = 1; j <= 5; j++) {
            for (int k = 1; k <= 4; k++) {
                if (b[j][k]) {
                    printf("%d %d\n", k, b[j][k]);
                }
            }
        }
    }

    return 0;
}

D-The Lucky Week

由于所要求的n的数字范围实在太多，用简单粗暴的方法显然会超时。
每四个世纪星期就重复一次，因此只需要遇事不决打个表。
用蔡勒公式找到400年内的Lucky Week，再将第一个Lucky Week转化成在该区间内的时间，往后找到第n个日期即可。
找到后要转换年份。

#include <cstdio>
#include <vector>
#include <map>

using namespace std;

struct day
{
    int year, month, day;
};

vector<day> v;
map<int, int> mp;

int Zeller(int y, int m, int d)
{
    if (m < 3) {
        y -= 1;
        m += 12;
    }
    int c = y / 100;
    y %= 100;
    int w = (c / 4 - 2 * c + y + y / 4 + 13 * (m+1) / 5 + d - 1);
    w = ((w % 7) + 7) % 7;
    return w;
}

void list()
{
    for (int y = 1753; y <= 1753 + 399; y++) {
        for (int m = 1; m <= 12; m++) {
            day tmp;
            tmp.year = y;
            tmp.month = m;
            int num = y * 10000 + m * 100;

            if (Zeller(y, m, 1) == 1) {
                tmp.day = 1;
                v.push_back(tmp);
                num += tmp.day;
                mp[num] = (int)(v.size() - 1);
            }
            else if (Zeller(y, m, 11) == 1) {
                tmp.day = 11;
                v.push_back(tmp);
                num += tmp.day;
                mp[num] = (int)(v.size() - 1);
            }
            else if (Zeller(y, m, 21) == 1) {
                tmp.day = 21;
                v.push_back(tmp);
                num += tmp.day;
                mp[num] = (int)(v.size() - 1);
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d", &t);

    list();

    while (t--) {
        int y, m, d, n;
        scanf("%d%d%d%d", &y, &m, &d, &n);

        n--;
        int yy = (y - 1753) % 400 + 1753;
        int num = yy * 10000 + m * 100 + d;
        int pos = mp[num];
        int mod = (pos + n) % v.size();
        int ny = (pos + n) / v.size();

        printf("%d %d %d\n", y + v[mod].year + ny * 400 - v[pos].year, v[mod].month, v[mod].day);
    }

    return 0;
}

I-People Counting

简单搜索题，只要将每个人的各部分进行标记即可。
由于遍历的顺序决定只需标记这个人后面的部分即可。

#include <cstdio>
#include <cstring>

const int MAXN = 100;

char photo[MAXN+2][MAXN+2];
bool vis[MAXN+2][MAXN+2];

int h, w;
int cnt = 0;

void check(int x, int y)
{
    vis[x][y] = true;
    if (photo[x][y] == 'O') {
        cnt++;
        if (x + 1 < h) {
            if (y - 1 >= 0 && vis[x+1][y-1] == false && photo[x+1][y-1] == '/')
                vis[x+1][y-1] = true;
            if (vis[x+1][y] == false && photo[x+1][y] == '|')
                vis[x+1][y] = true;
            if (y + 1 < w && vis[x+1][y+1] == false && photo[x+1][y+1] == '\\')
                vis[x+1][y+1] = true;
        }
        if (x + 2 < h) {
            if (y - 1 >= 0 && vis[x+2][y-1] == false && photo[x+2][y-1] == '(')
                vis[x+2][y-1] = true;
            if (y + 1 < w && vis[x+2][y+1] == false && photo[x+2][y+1] == ')')
                vis[x+2][y+1] = true;
        }
    }
    else if (photo[x][y] == '/') {
        cnt++;
        if (y + 1 < w && vis[x][y+1] == false && photo[x][y+1] == '|')
            vis[x][y+1] = true;
        if (y + 2 < w && vis[x][y+2] == false && photo[x][y+2] == '\\')
            vis[x][y+2] = true;
        if (x + 1 < h) {
            if (vis[x+1][y] == false && photo[x+1][y] == '(')
                vis[x+1][y] = true;
            if (y + 2 < w && vis[x+1][y+2] == false && photo[x+1][y+2] == ')')
                vis[x+1][y+2] = true;
        }
    }
    else if (photo[x][y] == '|') {
        cnt++;
        if (y + 1 < w && vis[x][y+1] == false && photo[x][y+1] == '\\')
            vis[x][y+1] = true;
        if (x + 1 < h) {
            if (y - 1 < w && vis[x+1][y-1] == false && photo[x+1][y-1] == '(')
                vis[x+1][y-1] = true;
            if (y + 1 < w && vis[x+1][y+1] == false && photo[x+1][y+1] == ')')
                vis[x+1][y+1] = true;
        }
    }
    else if (photo[x][y] == '\\') {
        cnt++;
        if (x + 1 < h) {
            if (y - 2 >= 0 && vis[x+1][y-2] == false && photo[x+1][y-2] == '(')
                vis[x+1][y-2] = true;
            if (vis[x+1][y] == false && photo[x+1][y] == ')')
                vis[x+1][y] = true;
        }
    }
    else if (photo[x][y] == '(') {
        cnt++;
        if (y + 2 < w && vis[x][y+2] == false && photo[x][y+2] == ')')
            vis[x][y+2] = true;
    }
    else if (photo[x][y] == ')')
        cnt++;
}

int main()
{
    int t;
    scanf("%d", &t);

    while (t--) {
        scanf("%d%d", &h, &w);
        getchar();

        for (int i = 0; i < h; i++)
            gets(photo[i]);

        cnt = 0;
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                if (vis[i][j] == false) {
                    check(i, j);
                }
            }
        }
        printf("%d\n", cnt);

        memset(photo, '\0', sizeof(photo));
        memset(vis, false, sizeof(vis));
    }

    return 0;
}

K-Highway Project

以时间为第一关键字，花费为第二关键字的最短路问题。
使用Dijkstra结合优先队列进行找出最短路，在最短路相同的情况下用花费最少的方案。
为避免重复计算铁路发费，纪录每段铁路的花费，最后相加即可。
注意这题要用long long，并且INF要足够大，起码10e10以上！！
一定要用long long！！
INF也是！！

#include <cstdio>
#include <queue>
#include <algorithm>

using namespace std;

const int MAXN = 10e5+20;
const long long INF = 10e10;

struct edge
{
    int to;
    int cost;
    int time;
};

typedef pair<int, int> P;

vector<edge> G[MAXN];
long long d[MAXN];
long long c[MAXN];

void Dijkstra(int s, int n)
{
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d, d + n, INF);
    fill(c, c + n, INF);
    d[s] = c[s] = 0;
    que.push(P (0, s));

    while (!que.empty()) {
        P p = que.top();
        que.pop();
        int v = p.second;
        if (d[v] < p.first) {
            continue;
        }
        for (int i = 0; i < G[v].size(); i++) {
            edge e = G[v][i];
            if (d[e.to] > d[v] + e.time) {
                d[e.to] = d[v] + e.time;
                c[e.to] = e.cost;
                que.push(P (d[e.to], e.to));
            }
            else if (d[e.to] == d[v] + e.time) {
                c[e.to] = c[e.to] > e.cost ? e.cost : c[e.to];
            }
        }
    }
}

int main()
{
    int t;
    scanf("%d", &t);

    while (t--) {
        int n, m;
        scanf("%d%d", &n, &m);
        for (int i = 0; i < m; i++) {
            int x, y, c, d;
            edge e, l;
            scanf("%d%d%d%d", &x, &y, &c, &d);
            e.to = x;
            l.to = y;
            e.time = l.time = c;
            e.cost = l.cost = d;
            G[x].push_back(l);
            G[y].push_back(e);
        }

        Dijkstra(0, n);

        long long mt, mc;
        mt = mc = 0;
        for (int i = 0; i < n; i++) {
            mt += d[i];
            mc += c[i];
            G[i].clear();
        }
        printf("%lld %lld\n", mt, mc);
    }

    return 0;
}

L-Very Happy Great BG

这个题算是安慰题了。
把所有人都加起来就好了。

#include <cstdio>

int main()
{
    int t;
    scanf("%d", &t);

    while (t--) {
        int n;
        scanf("%d", &n);
        int ans = n;
        while (n--) {
            int fri;
            scanf("%d", &fri);
            ans += fri;
        }
        printf("%d\n", ans);
    }

    return 0;
}
2021 Shandong Provincial Collegiate Programming Contest 个人训练题解
m0_46527476的博客
06-10 1477
题目链接 目录 B Build Roads 题意 给定n(1≤n≤2⋅105)n(1\leq n\leq2\cdot10^5)n(1≤n≤2⋅105)个点的完全图，每个点有一个权值为ai(1≤ai≤2⋅105)a_i(1\leq a_i\leq2\cdot10^5)ai​(1≤ai​≤2⋅105)，两个点iii和jjj之间的边权为gcd(ai,aj)gcd(a_i,a_j)gcd(ai​,aj​)。题目给定点权aia_iai​随机生成的程序、范围以及随机种子，要求该图的最小生成树。 题解 首先如果点权范围L
星期五13：游戏高清壁纸。「Friday the 13th: The Game HD Wallpapers.」-crx插件
03-16
获取新的背景主题与星期五13日游戏的每个粉丝高清壁纸。 每天，在新标签页的背景下，您都会看到漂亮的新墙纸。 每天根据自己的心情进行更改，您的日子将永远不会灰暗！ 13日星期五：“游戏高清壁纸”新标签页可帮助...
The 13th Zhejiang Provincial Collegiate Programming Contest
梦载代码
04-24 742
Apples and Ideas Time Limit: 2 Seconds      Memory Limit: 65536 KB A 简单题 "If you have an apple and I have an apple and we exchange these apples then you and I will still each have one appl
ZOJ 146 - The 13th Zhejiang Provincial Collegiate Programming Contest - C Defuse the Bomb
不想宅的冷同学
04-23 996
Defuse the Bomb Time Limit: 2 Seconds      Memory Limit: 65536 KB The bomb is about to explode! Please defuse it as soon as possible! There is a display showing a number from 1 to 4 on the bomb
The 13th Shaanxi Provincial Collegiate Programming Contest 部分题题解
最新发布
m0_74707185的博客
05-25 347
用map容器会导致超时。用map<char,vector<double> >存我们对应符号的vector导致超时。所以较少的vector能不用map，就不用map。
The 13th Zhejiang Provincial Collegiate Programming Contest （杂谈）
小时的枫的博客
04-21 1058
明天就要和大家一起出发去杭州了。此刻心情是 不安 。 第一次参加如此正式的比赛。 算起来，在优快云写博客也差不多快一个月了。这一个月也算是有很大的进步吧。 在一个月前，自己还是连STL甚至是一些如strcmp函数都还不知道的菜鸟（虽然现在也是菜鸟。。）。 一个月前自己可能也为自己能写出一些小小的辣鸡程序而洋洋得意。现在看来，颇有一丝井底蛙的感觉。 盗用某人的话：要是我没加ACM，也许还
The 13th Zhejiang Provincial Collegiate Programming Contest - I People Counting
Turne的博客
04-23 814
People Counting Time Limit: 2 Seconds      Memory Limit: 65536 KB In a BG (dinner gathering) for ZJU ICPC team, the coaches wanted to count the number of people present at the BG. They did that
Zoj-5704题 People Counting (带注释) The 13th ZhejiangProvincial Collegiate Programming Contest – I
ai_64的博客
04-24 3123
题目http://acm.zju.edu.cn/onlinejudge/showContestProblem.do?problemId=5704 Zoj-5704题 People CountingThe 13th ZhejiangProvincial Collegiate Programming Contest – I In a BG (dinner gathering) for ...
Distributed Autonomous Robotic Systems The 13th International Symposium epub
04-18
Distributed Autonomous Robotic Systems The 13th International Symposium 英文epub 第13版 本资源转载自网络，如有侵权，请联系上传者或csdn删除 查看此书详细信息请在美国亚马逊官网搜索此书
Friday The 13th: The Game New Tab Theme-crx插件
03-13
13日星期五：“游戏”新标签页扩展程序为您的Chrome浏览器带来了新外观。 安装13号星期五：游戏的新标签页主题，并欣赏13号星期五：游戏的精选高清图像。 它带有一些很酷的属性，这些属性可以改善您的“新标签页”...
Distributed Autonomous Robotic Systems The 13th International Symposium 无水印原版pdf
04-18
Distributed Autonomous Robotic Systems The 13th International Symposium 英文无水印原版pdf 第13版 pdf所有页面使用FoxitReader、PDF-XChangeViewer、SumatraPDF和Firefox测试都可以打开 本资源转载自网络，...
2016 浙江省赛 The 13th Zhejiang Provincial Collegiate Programming Contest K题 SPFA
Cross
04-23 515
链接：戳这里 Highway Project Time Limit: 2 Seconds      Memory Limit: 65536 KB Edward, the emperor of the Marjar Empire, wants to build some bidirectional highways so that he can reach other citi
【ZOJ3946 The 13th Zhejiang Provincial Collegiate Programming ContestK】【最短路+贪心 or 最小树形图】Highway Proje
snowy_smile的博客
04-26 714
Highway Project Time Limit: 2 Seconds      Memory Limit: 65536 KB Edward, the emperor of the Marjar Empire, wants to build some bidirectional highways so that he can reach other cities from
The 13th Zhejiang Provincial Collegiate Programming Contest - K Highway Project（dij）
weixin_33694620的博客
04-23 82
题意：N个点（0-n-1）M条边，每条边有一个花费的时间和花费的钱， 问你从0到任意节点所需的最小时间和还有该状态下建造的最小花费 /* *********************************************** Author :devil Created Time :2016/4/23 14:58:56 *********************...
2016 浙江省赛 The 13th Zhejiang Provincial Collegiate Programming Contest I题
Cross
04-23 654
链接：戳这里 People Counting Time Limit: 2 Seconds      Memory Limit: 65536 KB In a BG (dinner gathering) for ZJU ICPC team, the coaches wanted to count the number of people present at the BG. Th
The 13th Shandong ICPC Provincial Collegiate Programming Contest B. Building Company
qq_73887470的博客
10-15 306
The 13th Shandong ICPC Provincial Collegiate Programming Contest B. Building Company
The 13th Shandong ICPC Provincial Collegiate Programming Contest
maisui12138的博客
05-16 1092
一个队员可以背着另一个队员，i背j，若j的体重小于i，则对i的速度没有影响，否则i的速度vi - (wj - wi)，若i的速度为负，则i无法背j；二分团队最小速度，在check函数里将速度慢的人按照重量从大到小存取，然后将符合条件的人按照速度+重量从大到小进行存取，遍历当前不符合条件的人是否都能有人能背并且整体速度符合最小速度。题意：在n*n的白色正方形矩阵中，有一个黑色方块，现在需要将除了黑色方块外的所有白色方块用L形覆盖；$ 找出一个匹配项，使匹配项中所有边的权重之和最大，并输出这个最大值。
2023年第13届山东省大学生程序设计竞赛题解
Texcavator的博客
04-27 3971
所以我们只需要枚举相同的前缀和长度：i 从 v 开始，每次找到最末尾的一个0并将其替换为1（即加上lowbit），假设路径按位与之后的前缀和长这样，我们需要判断有没有这样的路径可以满足条件。很容易发现，先进行一次操作1再进行一次操作2之后，前面进行过的操作1会被抵消，所以操作1永远不会在操作2前面进行，因此操作顺序是：先进行完所有的操作2，再进行所有的操作1。怎么消去呢，左边的可以利用以左上角为顶点和以右下角为顶点的方式消去，上边的可以利用以左上角为顶点和以右上角为顶点的方式消去。
个性化Chrome新标签页：Friday The 13th主题壁纸与工具
资源摘要信息:"该文件提供了一个名为“Friday The 13th Wallpapers and New Tab”的扩展程序，专为Google Chrome浏览器设计。该扩展允许用户更改默认的新标签页，为其添加星期五第十三张壁纸，从而为用户提供一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值