The 18th Zhejiang Provincial Collegiate Programming Contest

最新推荐文章于 2024-07-17 20:43:45 发布

木木警官

最新推荐文章于 2024-07-17 20:43:45 发布

阅读量1.3k

点赞数 33

文章标签： c++

本文链接：https://blog.csdn.net/zjdysq/article/details/135962106

版权

文章目录

A. League of Legends
M. Game Theory
C. Cube
J. Grammy and Jewelry
L. String Freshman
F. Fair Distribution
G. Wall Game
I. Grammy and Ropes

A. League of Legends

求出 $B$ 和 $A$ 队员的 $H P$ 总和，比较大小输出答案

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n = 0, m = 0;
    for(int i = 1;i <= 5;i++)
    {
        int tt;
        cin >> tt;
        n += tt;
    }
    for(int i = 1;i <= 5;i++)
    {
        int tt;
        cin >> tt;
        m += tt;
    }
    if(n >= m)
    cout << "Blue" << '\n';
    else
    cout << "Red" << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

M. Game Theory

每个学生都相对独立，由于选择每个数字的概率相同，且加分等于减分，所以最终期望为 $0$

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    cout << "0" << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

C. Cube

计算出各个点之间的距离，和各个距离的数量，如果距离的平方之比为 $1 : 2 : 3$ 且个数之比为 $12 : 12 : 4$ 则可以组成一个正立方体

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n = 8;
    int x[10], y[10], z[10];
    map<int, int> m;
    for(int i = 1;i <= n;i++)
    cin >> x[i] >> y[i] >> z[i];
    for(int i = 1;i <= n;i++)
    {
        for(int j = i + 1;j <= n;j++)
        {
            int dis = (x[j] - x[i]) * (x[j] - x[i]) + (y[j] - y[i]) * (y[j] - y[i]) + (z[j] - z[i]) * (z[j] - z[i]);
            m[dis]++;
        }
    }
    int sum = 0;
    vector<int> a, b;
    for(auto i : m)
    {
        a.push_back(i.first);
        b.push_back(i.second);
    }
    if(a.size() != 3)
    cout << NO << '\n';
    else
    {
        sort(a.begin(), a.end());
        sort(b.begin(), b.end());
        if(a[0] * 2 == a[1] && a[0] * 3 == a[2] && b[0] * 3 == b[1] && b[0] * 3 == b[2])
        cout << YES << '\n';
        else
        cout << NO << '\n';
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

J. Grammy and Jewelry

通过 $b f s$ 计算得每个点距离 $1$ 的最短距离，记作 $w [i]$ ，每个点的珠宝价值记作 $v [i]$ ，由于珠宝可以无限拿，所以最后可以转化为完全背包问题

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
int v[5005], vis[5005], w[5005], dp[5005];
vector<int> G[5005];
void bfs()
{
	queue<pii>que;
	que.push({1, 0});
	while (!que.empty()) {
		int u = que.front().first;
        int dis = que.front().second;
		que.pop();
		for (auto it : G[u]) 
        {
			if (!vis[it]) 
            {
				vis[it] = 1;
				w[it] = dis + 2;
				que.push({it, dis + 2});
			}
		}
	}
}
void solve()
{
    int n, m, k;
    cin >> n >> m >> k;
    for(int i = 2;i <= n;i++)
    {
        cin >> v[i];
        w[i] = INF;
    }
    for(int i = 1;i <= m;i++)
    {
        int a, b;
        cin >> a >> b;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    vis[1] = 1;
    bfs();
    // for(int i = 2;i <= n;i++)
    // cout << w[i] << " " << v[i] << '\n';
    for(int i = 1;i <= n;i++)
    {
        for(int j = w[i]; j <= k;j++)
        dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
    }
    for(int i = 1;i <= k;i++)
    cout << dp[i] << " ";
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

L. String Freshman

题目给出一个假的 $K MP$ 算法，当匹配失败时它并没有像 $K MP$ 算法那样跳到 $n e x$ 继续匹配，而是变成从头匹配，这样会导致计数错误

为了 $ha c k$ 这段代码，我们只需要查找字符串中是否有字符与第一个字符相同，若有，则 $ha c k$ 成功

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n;
    cin >> n;
    string s;
    cin >> s;
    for(int i = 1;i < n;i++)
    {
        if(s[i] == s[0])
        {
            cout << "Wrong Answer" << '\n';
            return;
        }
    }
    cout << "Correct" << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

F. Fair Distribution

假设最后剩下 $x$ 个机器人，那最后剩下能量棒个数为 $\lceil \frac{m}{x} \rceil *x$

$\lceil \frac{m}{x} \rceil *x - m$
$\lfloor \frac{m + x - 1}{x} \rfloor * x - m$
$(\lfloor \frac{m - 1}{x} \rfloor - 1 + 1) * x + n - m$
$\lfloor \frac{m - 1}{x} \rfloor * x + n - m$

由于 $\lfloor \frac{m - 1}{x} \rfloor$ 的值可以分块维护，所以我们可以在时间复杂度 $O (n l o g m)$ 求得答案

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
void solve()
{
    int n, m;
    cin >> n >> m;
    if(m <= n)
    cout << n - m << '\n';
    else
    {
        int mn = INF;
        for(int l = 1, r;l <= n;l = r + 1)
        {
            r = (m - 1) / ((m - 1) / l);
            mn = min(mn, (m - 1) / l * l);
            //cout << l << " " << r << '\n';
        }
        cout << mn + n - m << '\n';
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

G. Wall Game

首先，我们可以将坐标化成点存储在 $ma p$ 中，由图可知，每个蜂巢相邻着六个蜂巢，所以每次加入蜂巢后，我们可以遍历它周围的六个蜂巢，如果之前的蜂巢出现过，则通过并查集的方式把出现过的蜂巢块加到当前蜂巢下，同时记录当前蜂巢块内有多少个蜂巢和重复的蜂巢个数

查询时，如果当前蜂巢没出现过，则它的六条边都没被占用，则输出 $6$ ，如果当前蜂巢出现过，则通过并查集找到它的祖先，输出 $6 *$ 蜂巢个数 $- 2 *$ 重复蜂巢个数

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
int xx[6] = {0, 1, 1, 0, -1, -1};
int yy[6] = {1, 0, -1, -1, 0, 1};
int fa[N], num[N], cf[N];
int findfa(int x)
{
    if(fa[x]!=x)
        fa[x] = findfa(fa[x]);
    return fa[x];
}
void solve()
{
    int n;
    cin >> n;
    map<pii, int> m;
    int cnt = 0;
    for(int i = 1;i <= n;i++) fa[i] = i;
    for(int i = 1;i <= n;i++)
    {
        int op, x, y;
        cin >> op >> x >> y;
        if(op == 1)
        {
            num[++cnt] = 1;
            m[{x, y}] = cnt;
            for(int j = 0;j < 6;j++)
            {
                int t1 = x + xx[j];
                int t2 = y + yy[j];
                if(m[{t1, t2}])
                {
                    int tt = findfa(m[{t1, t2}]);
                    if(tt != cnt)
                    {
                        fa[tt] = cnt;
                        num[cnt] += num[tt];
                        cf[cnt] += cf[tt] + 2;
                    }
                    else
                    cf[cnt] += 2;
                }
            }
        }
        else
        {
            if(!m[{x, y}])
            cout << "6" << '\n';
            else
            {
                int p = findfa(m[{x, y}]);
                if(num[p] == 1)
                cout << "6" << '\n';
                else
                cout << num[p] * 6 - cf[p] << '\n';
            }
        }
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

I. Grammy and Ropes

由图可知：
$1$ 和 $2$ 圆相交与点 $1$ 和 $4$
$1$ 和 $3$ 圆相交与点 $2$ 和 $5$
$2$ 和 $3$ 圆相交与点 $3$ 和 $6$

设 $s u m$ 为两个圆中的冲突个数（例如 $1$ 和 $2$ 圆,如果在点 $1$ 是圆 $1$ 在圆 $2$ 上但是在点 $4$ 是圆 $2$ 在圆 $1$ 上，我们认为这两个圆有冲突）

如果 $s u m = 0$ ，不会出现圆与圆之间相互嵌套的情况，即至少剪掉一个圆后所有的圆都能拿走。为什么说至少呢，因为存在形如 $1 > 2, 2 > 3, 3 > 1$ 等情况，我们必须要剪掉其中一个圆才能使这个“死循环”解放出来，所以一个都不剪是不行的，这种情况输出 $7$ 。如果没有出现这种死循环，说明即使一个圆也不剪掉，也有一个圆在最上方，可以直接被拿走，这种情况输出 $8$

$s u m > 0$ 时，先来看至少剪掉两个圆的情况，这种情况下最多只会剩下一个圆，所以无论如何也能成功拿走所有的圆， $an s$ 的初始值就为 $4$ ，那如何和 $s u m$ 联系在一起呢，如果两个圆之间没有冲突，那我们可以剪掉另外一个圆使得剩下这两个没有冲突的圆可以被直接拿走，所以最后 $an s = 4 + s u m$ ，输出 $an s$ 即可

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e16;
const ll mod = 1e9 + 7;
const int base = 13331;
int a[10];
void solve()
{
    for(int i = 1;i <= 6;i++)
    {
        string s;
        cin >> s;
        if(s[0] == 't')
        a[i] = 1;
        else
        a[i] = 0;
    }
    int sum = 0;
    for(int i = 1;i <= 3;i++)
    {
        if(a[i] == a[i + 3])
        sum++;
    }
    if(sum == 3)
    {
        if(a[1] == 0 && a[2] == 0 || a[2] == 1 && a[3] == 1 || a[1] == 1 && a[3] == 0) // 有一个绳子在最上面
        cout << "8" << '\n';
        else
        cout << "7" << '\n';
    }
    else
    cout << 4 + sum << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

木木警官

关注

33
点赞
踩
25

收藏

觉得还不错? 一键收藏
1
评论
The 18th Zhejiang Provincial Collegiate Programming Contest

中，由图可知，每个蜂巢相邻着六个蜂巢，所以每次加入蜂巢后，我们可以遍历它周围的六个蜂巢，如果之前的蜂巢出现过，则通过并查集的方式把出现过的蜂巢块加到当前蜂巢下，同时记录当前蜂巢块内有多少个蜂巢和重复的蜂巢个数。联系在一起呢，如果两个圆之间没有冲突，那我们可以剪掉另外一个圆使得剩下这两个没有冲突的圆可以被直接拿走，所以最后。，不会出现圆与圆之间相互嵌套的情况，即至少剪掉一个圆后所有的圆都能拿走。时，先来看至少剪掉两个圆的情况，这种情况下最多只会剩下一个圆，所以无论如何也能成功拿走所有的圆，
复制链接

扫一扫