目录
正文
Problem - A - Codeforces
题意:
没读懂,说的比较绕
思路:
赛场时没多长时间大家就疯狂过这题,大佬队友猜了个结论 % 998244353直接过了,666!
代码:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
ll n, ans = 1;
cin >> n;
for (int i = 1; i <= n - 1; i++) {
ans = (ans << 1) % 998244353;
}
cout << ans << "\n";
return 0;
}
Problem - F - Codeforces
题意:
给你n-1个数,每一个代表当前位置 i 的父文件夹是谁。你每次操作可以更换一个文件夹的父文件夹(参照样例解读),问你最少多少次可以让这些文件夹变成:满足每个文件夹只有至多一个子文件夹(就是1->2->3->....->n这种)
出题人解读如下:
文件夹显然是一棵树的结构,原题相当于把一个树的其中一个子树切下来,接到另 一个节点上,问最少进行几次操作使得树变成一个链。
思路:
当时读完样例发现,似乎只需要让这n - 1个数变成不同的,就能满足题目中的要求。也就是说最少只需要n - 1 - (这n - 1个数中不同数的个数)
所以我们直接开个set记一下共有多少种不同的,再用n - 1 - set.size(),就可以得到答案
出题人解读如下:
而每一次操作,显然可以且至多减少一个叶子,故只需要数原始树的叶子结点个数, 答案即为叶子结点个数减一。
代码:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
set<int> st;
for (int i = 1; i <= n - 1; i++) {
int x;
cin >> x;
st.insert(x);
}
cout << n - 1 - int(st.size()) << "\n";
return 0;
}
Problem - E - Codeforces
题意:
个人理解:现在有长度为n的序列A:1~n,长度为n的空序列B。正常情况下我们按顺序依次把A中对应的数放在B中(就是Ai=Bi这种)。
但是我们在保持上述条件的前提下,添加两条限制如下:
1、对于前k个数(原题题干为m,不过我喜欢用k)我们是随机插入B中非空位置(A1~Ak随便插入B中不空的位置)
2、对于后n - k个数,为了方便我们给这个数起名字叫Ax,如果能Ax插入对应位置(即要求Bx为空)就插入,否则随机插入B中非空位置
我们进行加了这两条限制的操作,会产生若干个(即ALL个)序列B,现在我们求ALL中满足Bn=n的序列(即ANS个)占序列总数ALL的比率
综上所求为:ANS / ALL
思路:
根据数据范围1≤n≤10可以发现,这个题其实是非常简单一个模拟,DFS乱跑一下就行(毕竟10的全排列才10! = 3628800),不过我当时占用机子很长时间(45min+)都没写出来,耽误了队友大佬A题QAQ,所以在说完思路的时候我会说一下我踩到坑点:
1、dfs把前k个数插入
2、在dfs插入好前k个数的基础上,进行dfs1按顺序继续插后n-k个(在dfs终止条件那开始进行dfs1),
3、在达到n个数的时候ALL++,如果还满足a[n] == n那么ANS++
4、输出ANS / ALL
坑点1:按顺序处理每个数,按顺序处理每个数!!!我当时对于第二点限制,以为是扫一遍后n-k个数把能放进原有位置的直接放进去,再去安排剩下的,这样是不对的,因为这n-k个数中,也会互相影响、占用
比如:n = 4, k = 2的情况,一种可能的变化为1_2_ -> 1_23 -> 1423,可以发现如果我们前k个随机插好后,如果把后n-k个能放进去的先全部放进去,就会漏掉类似这种的情况!!!
坑点2:忘记恢复vis[]为0!!!我是fw呜呜呜
代码:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int vis[15], a[15];
int n, k, all, ans;
void dfs1(int now, int sum) {
if (sum == n - k) {
all ++;
if (a[n] == n) ans ++;
return;
}
// can insert to its own pos
if (!vis[now]) {
vis[now] = 1;
a[now] = now;
dfs1(now + 1, sum + 1);
vis[now] = 0; // 这里要恢复的原因是,别的地方可能会用到这个vis[xxx]
a[now] = 0;
} else {
// can't
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = 1;
a[i] = now;
dfs1(now + 1, sum + 1);
vis[i] = 0; // 这里要恢复的原因是,别的地方可能会用到这个vis[xxx]
a[i] = 0;
}
}
}
}
void dfs(int now, int sum) {
if (sum == k) {
dfs1(k + 1, 0);
return;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vis[i] = 1;
a[i] = now;
dfs(now + 1, sum + 1);
a[i] = 0;
vis[i] = 0;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(9);
cin >> n >> k;
dfs(1, 0);
cout << 1. * ans / all << "\n";
return 0;
}
Problem - G - Codeforces
题意:
n个平面上的点,分成两堆,取各自的中心为A、B,问你怎么样分能让三角形OAB面积最大
思路:
显然各自的重心在知道如何划分两堆的情况下可求,那么我们如果知道了重心,面积式子用向量表示就是我们考虑如何化简这个式子
1、由a叉乘b=(a+b)叉乘b,替换上式子的对应部分,化简成为继续化简
也就是说我们想要让面积S最大,那就让ALL叉乘B最大,也可以说让ALL叉乘B中的每个子向量(我自己瞎起的名字)最大即可。
2、我们设置B包含的向量数为|B|个,所以其实我们可以对向量集合以ALL叉乘vi进行排序,然后找前|B|大的向量放入B集合即可。
注意:这个题会卡精度(可能不叫卡精度?),我的写法:sum[i] / (1. * (2 * (n - i) * i)) 正确写法:sum[i] / (2.0 * (n - i) * i)
代码:
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using Real = i64;
using Point = complex<Real>;
Real cross(const Point &a, const Point &b) {
return (conj(a) * b).imag();
}
Real dot(const Point &a, const Point &b) {
return (conj(a) * b).real();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
Point S(0, 0);
vector<Point> a(n + 1);
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
a[i] = Point(x, y);
S += a[i];
}
vector<double> b(n + 1);
for (int i = 1; i <= n; i++) {
b[i] = cross(S, a[i]);
}
sort(b.begin() + 1, b.end(), greater());
double sum = 0, ans = 0;
for (int i = 1; i <= n - 1; i ++) {
sum += b[i];
ans = max(ans, sum / (2.0 * (n - i) * i));
// WA sum[i] / (1. * (2 * (n - i) * i))
// AC sum[i] / (2.0 * (n - i) * i)
}
cout << fixed << setprecision(12) << ans << "\n";
return 0;
}
Problem - I - Codeforces
题意:
n个俱乐部,m个奖牌,每个俱乐部可以拿这m个奖牌之一作为该俱乐部游戏的奖励。现在有一些人来参加游戏,游戏终止条件是所有奖牌都被收集,问你最小游戏次数的期望值是多少
思路:
警告:本人概率菜鸡,以下内容大概率有错误之处OVO
赛场压根没读懂这题,个人感觉这题干很多槽点。
1、我们可以发现在n个俱乐部均分m块奖牌的时候,会让游戏次数最小(为什么发现我也不知道)
2、但肯定有不能均分的,这时候我们就把所有的奖牌分为两个大类A:能够被n个俱乐部均分的,B:不能被n个俱乐部均分的
3、首先对于每一类,我们分别计算他们有多少种不同的奖牌,下面的式子我有点不懂...
int A = (n - 1) % m + 1; // A类包含的不同奖牌的种数
int B = m - A; // B类包含的不同奖牌的种数
4、为了计算期望(需要概率),我们需要分别求出A类、B类种各自含有多少块奖牌,顺便把最开始的概率p,q求出来(p:选A类中之前没选过的一种奖牌的概率,q:选B类中之前没选过的一种奖牌的概率)
int each = (n + m - 1) / m; // 上取整的意思
int Sum_A = each / n; // A类奖牌总数
int Sum_B = (each - 1) / n; // B类奖牌总数
double p = (1. * each) / n;
double q = (1. * (each - 1)) / n;
5、到这里我们可以写出期望dp的含义为:dp[i][j],表示从当前状态(A类差i个没选,B类差j个没选),到游戏结束(全部选完)还需要进行的游戏次数的期望。并且转移方程如下,并对其进行化简
这里我有个不懂的点,为什么pi = p*i, qj = q*j ,似乎是因为分别是独立事件?不懂,概率论学的太垃圾了...
1、dp[i][j] = (1 − pi − qj) * dp[i][j] + pi * dp[i-1][j] + qj * dp[i][j-1] + 1 // 初始式子
->
2、dp[i][j] = 1. / (p * i + q * j) + p * i / (p * i + q * j) * dp[i - 1][j] + q * j / (p * i + q * j) * dp[i][j - 1]; // 这个是化简后的,但还需要分情况
->
3、
if (i || j) dp[i][j] += 1. / (p * i + q * j); // ALL
if (i) dp[i][j] += p * i / (p * i + q * j) * dp[i - 1][j]; // i - 1 >= 0
if (j) dp[i][j] += q * j / (p * i + q * j) * dp[i][j - 1]; // j - 1 >= 0
代码:
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
int A = (n - 1) % m + 1;
int B = m - A;
int each = (n + m - 1) / m;
double p = (1. * each) / n;
double q = (1. * (each - 1)) / n;
vector<vector<double> > dp(A + 1, vector<double>(B + 1, 0));
for (int i = 0; i <= A; i++) {
for (int j = 0; j <= B; j++) {
if (i || j)
dp[i][j] += 1. / (p * i + q * j);
if (i)
dp[i][j] += p * i / (p * i + q * j) * dp[i - 1][j];
if (j)
dp[i][j] += q * j / (p * i + q * j) * dp[i][j - 1];
}
}
cout << fixed << setprecision(12) << dp[A][B] << "\n";
return 0;
}
后记
还有几个题没补,这些先发上来吧。其实是我这几天一直在摸鱼摆烂没复习考试啥的,搭了个博客想测试一下博客界面的效果,才写了这个补题报告,AND博客的域名在备案,过段时间更新个人博客链接@。@