AtCoder Beginner Contest 266 A-G
abc
AtCoder Beginner Contest 266 A-G
https://atcoder.jp/contests/abc266
A - Middle Letter
输出字符串最中间的那个字母
#include <bits/stdc++.h>
using namespace std;
int main () {
string s;
cin >> s;
cout << s[(s.size()+1)/2-1];
}
B - Modulo Number
题意：\(N\in [-10^{18}, 10^{18}], x\in [0, 998244352]\), 给定 \(N\), 求 \(x\),使得 \((N-x) \%\,998244353=0\)
分析：不难发现就是要找到一个和 \(N\) 同余的 \(x\)
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int mod = 998244353;
int n;
int MOD (int x) {
while (x < 0) x += mod;
return x % mod;
}
signed main () {
cin >> n;
cout << MOD (n);
}
//倍数
//N与x同余
C - Convex Quadrilateral
题意：给四个点的坐标，问构成的图形是否为凸多边形
注：给的点满足不重合，不共线，不相邻的边一定没有公共点，也就是保证四个点一定构成四边形
分析：高中知识，分别判断两条对角线是否都能把两个点隔开（不在同一边），判断的方式就是————
设对角线 \(AC\) 方程为 \(Ax+By+C=0\), 若 \((Ax_b+By_b+C)*(Ax_d+By_d+C)<0\), 则 \(B,D\) 在对角线 \(AC\) 的两边；同理再判断一下对角线 \(BD\) 能否把 \(A,C\) 划分到两边即可。
至于直线方程怎么写，相信也不难，两点式一般式之类的都能解出来，我手算的结果是：
\(A = y_1-y_2, B = x_2-x_1, C = x_1*y_2 - x_2*y_1;\)
#include<bits/stdc++.h>
#define int long long
using namespace std;
int x[5], y[5];
signed main () {
for (int i = 1; i <= 4; i++) cin >> x[i] >> y[i];
//判两条对角线
int A, B, C, X, Y;
A = y[1] - y[3], B = x[3] - x[1], C = x[1]*y[3] - x[3]*y[1];
X = A*x[2] + B*y[2] + C, Y = A*x[4] + B*y[4] + C;
//cout << X << ' ' << Y << endl;
if (X * Y > 0) {
cout << "No\n";
return 0;
}
A = y[2] - y[4], B = x[4] - x[2], C = x[2]*y[4] - x[4]*y[2];
X = A*x[1] + B*y[1] + C, Y = A*x[3] + B*y[3] + C;
if (X * Y > 0) {
cout << "No\n";
return 0;
}
cout << "Yes";
}
//判断是否为凸多边形
//判断点是否在直线的两边
//Ax+By+C < 0
//A = y1-y2, B = x2-x1, C = x1y2 - x2y1;
D - Snuke Panic (1D)
这一道题和 \(kuangbin\) 专题里的免费馅饼十分相似
题意：\(t_i\) 时刻在 \(x_i\) 处会出现价值为 \(a_i\) 的东西。人一开始在 \(0\) 的位置，每次只能向右或向左移动一格，且花费一单位时间。人与物品的坐标取值只可能为 \(0,1,2,3,4\)。问人能得到的最大价值为多少
分析：定义 \(dp\) 数组\(f_{i,j}\)表示第 \(i\) 秒时在位置 \(j\) 时所能得到的最大价值，然后逆推转移即可。
#include <bits/stdc++.h>
#define endl "\n"
#define int long long
using namespace std;
typedef pair<int, int> pii;
const int N = 1e5 + 5;
int n, m;
int f[N][7]; //第i秒时在位置j
int dx[] = {-1, 0, 1};
signed main () {
ios::sync_with_stdio (0);cin.tie(0);cout.tie(0);
memset (f, 0, sizeof f);
cin >> n;
for (int i = 0; i < n; i++) {
int ti, xi, ai;
cin >> ti >> xi >> ai;
f[ti][xi] = ai;
m = max (m, ti);
}
//cout << "m=" << m << endl;
for (int t = m-1; t >= 0; t--) {
f[t][0] += max (f[t+1][0], f[t+1][1]);
for (int x = 1; x < 4; x++) {
f[t][x] += max (f[t+1][x], max (f[t+1][x+1], f[t+1][x-1]));
}
f[t][4] += max (f[t+1][4], f[t+1][3]);
cout << endl;
}
cout << f[0][0] << endl;
}
E - Throwing the Die
题意：\(n\) 轮游戏，每次可以丢一枚骰子，每次丢完可以选择结束游戏或者继续。
结束游戏时的分数为最终得分，如果一直按照最优策略来投，求 \(n\) 轮游戏的期望得分。
分析：最开始没读懂题，不知道什么时候结束为最优。
其实就是：如果下一轮投的点数比当前的期望更高，那么继续投下去就可以增加期望，所以会选择继续投
然后就可以直接 \(dp\) 了
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
double f[N];
int main () {
int n;
cin >> n;
f[1] = 3.5;
for (int i = 2; i <= n; i++) {
for (double j = 1.0; j <= 6.0; j++) {
if (j >= f[i-1]) f[i] += j;
else f[i] += f[i-1];
}
f[i] /= 6;
}
cout << fixed << setprecision (8) << f[n] << endl;
}
//f[i]表示第i轮的期望,点数比期望大就继续投
F - Well-defined Path Queries on a Namori
题意
给定一个有 \(n\) 个点，\(n\) 条边的无向图，\(q\) 次查询两点 \(u_i,v_i\) 之间是否只存在一条简单路径(每条边只走一次)
分析
观察样例：
\(n\) 个点 \(n\) 条边，不难得出图上必定有且仅有一个环，那么这就是一个基环树。
相当于是一个环把树劈开，然后环上每一点都连着一条链。
可以以环上的每一点作为根节点，它连着的那条树上的所有点的根都是这个在环上的点。
则只需判断待查询的 \(u,v\) 点的根是否相同。
相同则 \(Yes\)，因为不会进入环，有且仅有一条简单路径；
不同则 \(No\), 因为会进入环，不止一条简单路径。
Code
\(topsort+dfs\)
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, M = N*2;
int n, q;
int h[N], e[M], ne[M], idx;
int fa[N], d[N];
void add (int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void topsort () {
queue <int> q;
for (int i = 1; i <= n; i++) {
if (d[i] == 1) q.push (i);
}
while (!q.empty()) {
int t = q.front();
q.pop ();
fa[t] = -1; //无环
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (--d[j] == 1) q.push (j);
}
}
}
void dfs (int u, int v) {
fa[u] = v;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (fa[j] == -1) dfs (j, v);
}
}
int main () {
memset (h, -1, sizeof h);
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
add (a, b), add (b, a);
d[a] ++, d[b] ++;
}
//topsort找环
topsort ();
for (int i = 1; i <= n; i++) {
if (fa[i] == 0) dfs (i, i);
}
cin >> q;
while (q --) {
int u, v;
cin >> u >> v;
if (fa[u] == fa[v]) cout << "Yes\n";
else cout << "No\n";
}
}
//dfs合并到环上
G - Yet Another RGB Sequence
题意
输入 \(R,G,B,K\)，要求构造字符串（只由 \(R,G,B\) 构成），满足：\(R\) 出现 \(R\) 次，\(G\) 出现 \(G\) 次，\(B\) 出现 \(B\) 次，\(RG\) 出现 \(K\) 次。问可以构造出多少种这样的串。
分析
首先考虑 \(G,B\) 的分配（不会影响到 \(RG\)），方案数为 \(C_{G+B}^G\)；
然后在排好的 \(GB\) 串中选 \(K\) 个 \(G\)，插入 \(R\), 变成 \(RG\)，方案数为 \(C_G^K\)；
最后还剩 \(R-K\) 个 \(R\)，放进去不能产生新的 \(RG\)，所以只能填在 \(B\) 前或 \(R\) 前，方案数为 \(C_{R-K+B+K}^{R-K}=C_{R+B}^{R-K}\)
故答案为 \(C_{G+B}^G *C_G^K *C_{R+B}^{R-K}\)
Code
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int P = 998244353, N = 3e6 + 5;
int R, G, B, K;
using i64 = long long;
// assume -P <= x < 2P
int norm(int x) {
if (x < 0) {
x += P;
}
if (x >= P) {
x -= P;
}
return x;
}
template<class T>
T power(T a, i64 b) {
T res = 1;
for (; b; b /= 2, a *= a) {
if (b % 2) {
res *= a;
}
}
return res;
}
struct Z {
int x;
Z(int x = 0) : x(norm(x)) {}
Z(i64 x) : x(norm(x % P)) {}
int val() const {
return x;
}
Z operator-() const {
return Z(norm(P - x));
}
Z inv() const {
assert(x != 0);
return power(*this, P - 2);
}
Z &operator*=(const Z &rhs) {
x = i64(x) * rhs.x % P;
return *this;
}
Z &operator+=(const Z &rhs) {
x = norm(x + rhs.x);
return *this;
}
Z &operator-=(const Z &rhs) {
x = norm(x - rhs.x);
return *this;
}
Z &operator/=(const Z &rhs) {
return *this *= rhs.inv();
}
friend Z operator*(const Z &lhs, const Z &rhs) {
Z res = lhs;
res *= rhs;
return res;
}
friend Z operator+(const Z &lhs, const Z &rhs) {
Z res = lhs;
res += rhs;
return res;
}
friend Z operator-(const Z &lhs, const Z &rhs) {
Z res = lhs;
res -= rhs;
return res;
}
friend Z operator/(const Z &lhs, const Z &rhs) {
Z res = lhs;
res /= rhs;
return res;
}
friend std::istream &operator>>(std::istream &is, Z &a) {
i64 v;
is >> v;
a = Z(v);
return is;
}
friend std::ostream &operator<<(std::ostream &os, const Z &a) {
return os << a.val();
}
};
Z fac[N], inv[N];
Z C(int x,int y){
return fac[x] * inv[y] * inv[x-y];
}
signed main () {
cin >> R >> G >> B >> K;
int N = R + G + B;
fac[0] = 1;
for (int i = 1; i <= N; i++) fac[i] = fac[i-1] * i;
inv[N] = fac[N].inv();
for (int i = N; i; i--) inv[i-1] = inv[i] * i;
Z ans = C(G+B, G) * C(G, K) * C(B+R, R-K);
cout << ans;
}
Ex - Snuke Panic (2D)
题意
同 \(D\), 不同的是二维坐标，初始在 \((0,0)\), 且坐标范围变为 \(0\leq X_i,Y_i\leq 10^9\)，规则变为沿 \(x\) 轴方向一次走一格，沿 \(y\)方向一次走一格，\(x\) 轴方向正负方向都能走， \(y\) 轴方向只能沿 正半轴方向走
二位偏序，学了再写
小菜鸟上了个色
