2022 China Collegiate Programming Contest (CCPC) Mianyang Onsite
A - Ban or Pick, What’s the Trick
题目描述：
有A和B两支队伍，每个队伍可以从n个英雄中选择最多k个英雄，每个英雄有对应的分值。A队先手，可以选择一个自己英雄池中的英雄或禁用对方的英雄，之后轮到B队。这个过程持续n个回合。
解题思路：
显然，每轮需要对双方队伍中分值最大的英雄进行操作，要么选择自己分值最高的英雄，要么ban掉对方的最高分英雄。动态规划可以很好地解决这个问题，关键在于如何追踪分值最高的英雄坐标，尤其是在已经选了若干英雄的情况下。还需注意的是，B队在最后一轮可能无英雄可选，此时只能禁用对方英雄。
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
const int N = 1e5 + 10;
const int K = 12;
int dp[2 * N][15][15];
int cmp(int x, int y)
{
return x > y;
}
void solved()
{
int n, k;
cin >> n >> k;
vector<int> arr[2];
arr[0].push_back(0);
arr[1].push_back(0);
for (int i = 1; i <= n; i++)
{
int v;
cin >> v;
arr[0].push_back(v);
}
for (int i = 1; i <= n; i++)
{
int v;
cin >> v;
arr[1].push_back(v);
}
sort(arr[0].begin() + 1, arr[0].end(), cmp);
sort(arr[1].begin() + 1, arr[1].end(), cmp);
memset(dp, 0, sizeof(dp));
for (int i = 2 * n - 1; i >= 0; i--)
{
if (i % 2 == 0)
{
for (int l = 0; l + 1 <= min((i + 2) / 2, k); l++)
{
for (int r = 0; r <= min((i + 1) / 2, k); r++)
{
int id = l + 1 + (i + 1) / 2 - r;
dp[i][l][r] = max(dp[i + 1][l][r], dp[i + 1][l + 1][r] + arr[0][id]);
}
}
for (int j = 0; j <= min((i + 1) / 2, k); j++)
{
dp[i][min((i + 2) / 2, k)][j] = dp[i + 1][min((i + 2) / 2, k)][j];
}
}
else
{
for (int l = 0; l + 1 <= min((i + 1) / 2, k); l++)
{
for (int r = 0; r <= min((i + 1) / 2, k); r++)
{
int id = l + 1 + (i + 1) / 2 - r;
if (id > n)
{
dp[i][r][l] = min(dp[i + 1][r][l], dp[i + 1][r][l + 1] - 0);
}
else
{
dp[i][r][l] = min(dp[i + 1][r][l], dp[i + 1][r][l + 1] - arr[1][id]);
}
}
}
for (int j = 0; j <= min((i + 1) / 2, k); j++)
{
dp[i][j][min((i + 1) / 2, k)] = dp[i + 1][j][min((i + 1) / 2, k)];
}
}
}
cout << dp[0][0][0] << endl;
}
signed main()
{
close;
solved();
return 0;
}
C - Catch You Catch Me
题目描述：
给定一棵包含n个节点的树，节点1为根节点。除了1号节点外，每个节点都有一只蝴蝶。蝴蝶每过一单位时间，都会向根节点移动一个单位，直到到达根节点并飞走。Bobo需要尽可能少次地抓住所有蝴蝶，问他至少需要抓多少次。
解题思路：
当深度为1的节点在下一时刻将飞走时，必须在第0时刻将这些节点的蝴蝶抓住。接着，采用贪心策略，当深度增加时，节点的分支也会变大。最佳方法是在同一高度的所有节点到达深度为1时再抓住它们。这是最优化的抓取策略。
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
const int N = 1e5 + 10;
int n;
int dep[N];
vector<int> edg[N];
int vis[N];
int fath[N];
int fi[N];
void dfs(int id, int fa, int firstFa)
{
fath[id] = fa;
fi[id] = firstFa;
for (auto i : edg[id])
{
if (i == fa)
continue;
if (!vis[i])
{
vis[i] = 1;
dep[i] = dep[id] + 1;
dfs(i, id, firstFa);
}
}
}
void input()
{
cin >> n;
for (int i = 1; i <= n - 1; i++)
{
int u, v;
cin >> u >> v;
edg[u].push_back(v);
edg[v].push_back(u);
}
vis[1] = 1;
dep[1] = 0;
for (auto ne : edg[1])
{
if (!vis[ne])
{
vis[ne] = 1;
dep[ne] = 1;
fath[ne] = 1;
fi[ne] = ne;
dfs(ne, 1, ne);
}
}
}
signed main()
{
close;
input();
int ans = 0;
set<pair<int, int>> uniquePairs;
for (int i = 2; i <= n; i++)
{
if (uniquePairs.insert({dep[i], fi[i]}).second)
{
++ans;
}
}
cout << ans << endl;
}
D - Gambler’s Ruin
题目描述：
有n个赌徒，每个赌徒有一个概率p和下注数量c。赌徒会根据p决定是否下注给BU或BC，其中x和y分别是BU和BC的赔率。目标是设计x和y的值，以便在最坏情况下获得最大利润。
解题思路：
x和y必须是>=1的正整数，否则赌徒可以对双方下注，确保获利。通过确定一个x值后，使用三分法寻找最优的y值。
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
using namespace std;
const int N = 1000001;
const int mod = 1000000007;
struct asdf
{
long double p;
int c;
bool operator<(const asdf a) const
{
return p < a.p;
}
} a[N];
int n;
long double sum[N];
inline long double getans(int i, int j)
{
long double leftSum = sum[i];
long double rightSum = sum[n] - sum[j - 1];
long double leftValue = leftSum * (1.0 / (1 - a[i].p));
long double rightValue = rightSum * (1.0 / a[j].p);
return sum[i] + sum[n] - sum[j - 1] - max(leftValue, rightValue);
}
int solve()
{
cin >> n;
for (int i = 1; i <= n; ++i)
{
cin >> a[i].p >> a[i].c;
}
sort(a + 1, a + 1 + n);
int tot = 1;
for (int i = 2; i <= n; ++i)
{
if (a[i].p != a[i - 1].p)
a[++tot] = a[i];
else
a[tot].c += a[i].c;
}
n = tot;
for (int i = 1; i <= n; ++i)
{
sum[i] = sum[i - 1] + a[i].c;
}
sum[n + 1] = sum[n];
long double ans = 0;
for (int i = 1; i <= n; ++i)
{
int l = i, r = n;
while (r - l > 2)
{
int mid1 = l + (r - l) / 3;
int mid2 = r - (r - l) / 3;
long double val1 = getans(i, mid1);
long double val2 = getans(i, mid2);
if (val1 < val2)
{
l = mid1;
}
else
{
r = mid2;
}
}
for (int j = l; j <= r; ++j)
{
ans = max(ans, getans(i, j));
}
}
cout << ans << endl;
return 0;
}
signed main()
{
int T = 1;
while (T--)
solve();
return 0;
}
问题描述：
给定n个村庄，每个村庄有ai个人，m条双向道路，过路时有花费w。同时有q次打击事件，每次打击发生在编号为bi的村庄，村民可以提前通过道路转移到其他村庄，求最小的转移花费。
解题思路：
由于打击事件的发生需要动态规划处理，且暴力枚举所有路径的复杂度过高，因此我们采用分治的思想。对于度数小于临界值B的村庄，直接暴力枚举并更新相关村庄的状态；对于度数大于B的村庄，提前处理好数据并更新与其相关的村庄信息。
G - Let Them Eat Cake](https://mirror.codeforces.com/group/3nTbOxulYa/contest/554468/problem/G)
问题描述：
国王给n个人吃蛋糕，每个人都有一个值。当队伍中有一个人的时候当然就分给他，不然的话当他小于他左边相邻的人或者小于右边相邻的人的时候，蛋糕就给他，问需要多少轮数才能结束。
解题思路：
一个模拟题，把题目要求的内容用代码完成就行。
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
const int N = 1e5 + 10;
void solved()
{
int n;
cin >> n;
vector<int> s(n + 1);
for (int i = 1; i <= n; i++)
cin >> s[i];
set<pair<int, int>> st;
st.insert({0, 0}), st.insert({n + 1, 0});
for (int i = 1; i <= n; i++)
st.insert({i, s[i]});
int ans = 0;
while (st.size() > 3)
{
++ans;
vector<pair<int, int>> del;
for (set<pair<int, int>>::iterator it = st.begin(); it != st.end(); it++)
{
if ((*it).first == 0 or (*it).first == n + 1)
continue;
else
{
set<pair<int, int>>::iterator be = prev(it);
set<pair<int, int>>::iterator af = st.upper_bound(*it);
if ((*be).second > (*it).second or (*af).second > (*it).second)
del.push_back(*(it));
}
}
for (auto i : del)
st.erase(i);
}
cout << ans << endl;
}
signed main()
{
close;
solved();
return 0;
}
H - Life is Hard and Undecidable, but…
题目描述：
一个细胞有下面几种状态。
一：出生在t时刻当且仅当在t-1时刻他的8个邻居中有3个是活着的
二：在t+1时刻死亡，当且仅当他有大于等于4个邻居在t时刻是活着的时候
三：在t+1时刻死亡，当且仅当他在t时刻有0个或1个邻居活着
四：除了上述情况外细胞在t+1时刻存活
给定一个轮数k，要求你构造初始0时刻细胞的位置，使得k轮之后场上没有细胞存活。
解题思路：
如果考虑有细胞重生，这题目有点难做，因为你没有构造出来的细胞都可以视为在t=0时刻死亡，所以我们要避免这种情况产生，所以我们可以考虑斜着放，因为k最大是100，给定x和y最大是300，斜着放空间完全足够。
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
void solved()
{
int n;
cin >> n;
cout << 2 * n - 1 << endl;
for (int i = 1; i <= 2 * n - 1; i++)
{
cout << i << " " << i << endl;
}
}
signed main()
{
close;
solved();
return 0;
}
M - Rock-Paper-Scissors Pyramid
题目描述：
一个经典的石头剪刀布游戏，给定一个字符串，每个字符代表出的是剪刀，石头还是布，我们需要输出最后的赢家是剪刀，石头，还是布。
解题思路：
这题可以通过一个栈来描述，因为前面的赢家可以影响到后面的状态，所以我们可以用栈来实现，最后的赢家就是栈底的那个元素。
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define close ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
map<char, char> win;
void solved()
{
string s;
cin >> s;
stack<char> st;
int len = s.length();
for (int i = 0; i < len;i++)
{
while(!st.empty()&&win[st.top()]==s[i])
{
st.pop();
}
st.push(s[i]);
}
while(st.size()>1)
{
st.pop();
}
cout << st.top()<<endl;
st.pop();
}
signed main()
{
close;
win['R'] = 'P', win['S'] = 'R', win['P'] = 'S';
int T;
cin >> T;
while(T--)
{
solved();
}
return 0;
}
扫一扫
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
