英语巨烂的我，把两个签到题读成了不可写题…感觉给我一个中文题面，有机会ak…
A. Rooms and Passages
题意：有 n + 1个点在一排，有 n 条边连接，依次求点 i 往 点 n 的方向走最多能走多远，如果当前的边权值为 x (x > 0)，且已经走过一条权值为 -x 的边，那么这条边不能走。
思路：倒着处理，标记每条正边在当前出现的最小坐标即可。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 5e5 + 10;
int vis[maxn], a[maxn];
stack<int> s;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
int pre = 0;
for (int i = n; i; i--) {
if (a[i] > 0) {
s.push(++pre);
vis[a[i]] = i;
}
else {
if (!vis[-a[i]])
pre = min(pre + 1, n - i + 1), s.push(pre);
else {
pre = min(pre + 1, vis[-a[i]] - i);
s.push(pre);
}
}
}
while (!s.empty())
printf("%d ", s.top()), s.pop();
}
B. Rearrange Columns
题意：要求交换一些列，使得 # 互相连通，签到题
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 1010;
char s[2][maxn], str[2][maxn];
int main() {
cin>>s[0]>>s[1];
int n = strlen(s[0]);
int t1 = 0, t2 = 0, t = 0;
for (int i = 0; i < n; i++) {
int f1 = 0, f2 = 0;
if (s[0][i] == '#')
f1 = 1;
if (s[1][i] == '#')
f2 = 1;
if (f1 && f2)
t++;
else if (f1)
t1++;
else if (f2)
t2++;
}
if (t1 && t2 && !t)
return puts("NO"), 0;
for (int i = 0; i < t1; i++)
str[0][i] = '#', str[1][i] = '.';
for (int i = 0; i < t; i++)
str[0][i + t1] = str[1][i + t1] = '#';
for (int i = 0; i < t2; i++)
str[0][i + t1 + t] = '.', str[1][i + t1 + t] = '#';
for (int i = t1 + t2 + t; i < n; i++)
str[0][i] = str[1][i] = '.';
if (strcmp(str[0], s[0]) == 0) {
for (int i = 0; i < t2; i++)
str[0][i] = '.', str[1][i] = '#';
for (int i = 0; i < t; i++)
str[0][i + t2] = str[1][i + t2] = '#';
for (int i = 0; i < t1; i++)
str[0][i + t2 + t] = '#', str[1][i + t2 + t] = '.';
}
puts("YES");
cout<<str[0]<<endl;
cout<<str[1]<<endl;
}
C. Jumps on a Circle
题意：有一个长度为 p 的环，你要走n次，第 i 次走 i 步，求能走多少个不同的点
思路：n很大，其实有用的n就是2 * p，因为走2 * p步肯定回到原点（等差数列求和是 p 的倍数），第 2 * p + 1其实就是第 1 步，所以我们对 n 取一个min(n , 2 * p)然后模拟走一遍就可以了
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 1e7 + 5;
bitset<maxn> a;
int main() {
int p;
ll n;
cin>>p>>n;
n = min(n, 2ll * p);
int k = 0;
for (int i = 0; i <= n; i++) {
k += i;
k %= p;
a[k] = 1;
}
printf("%d\n", a.count());
}
D. Country Division
题意：给一棵树，q次询问，每次询问把树中一些点染红色，一些点染蓝色，求是否能够断开一些边，使得所有红点联通，所有蓝点联通，且任意红点和任意蓝点不联通。
思路：我们求出所有红点lca1，所有蓝点lca2，如果所有蓝点不在lca1的子树中或者所有红点不在lca2的子树中，那么就是yes。
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
const int maxn = 2e5 + 10;
int f[maxn][20], dep[maxn], L[maxn], R[maxn], cnt;
vector<int> G[maxn], a, b;
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
L[u] = ++cnt;
f[u][0] = fa;
for (int i = 1; i < 20; i++)
f[u][i] = f[f[u][i - 1]][i - 1];
for (auto v : G[u])
if (v != fa)
dfs(v, u);
R[u] = cnt;
}
int LCA(int x, int y) {
if (dep[x] < dep[y])
swap(x, y);
for (int i = 19; i >= 0; i--)
if (dep[f[x][i]] >= dep[y])
x = f[x][i];
if (x == y)
return x;
for (int i = 19; i >= 0; i--)
if (f[x][i] != f[y][i])
x = f[x][i], y = f[y][i];
return f[x][0];
}
int ok(int u, vector<int> tmp) {
for (auto v : tmp)
if (L[v] >= L[u] && R[v] <= R[u])
return 0;
return 1;
}
int main() {
int n, u, v, q, k1, k2, x;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
G[u].pb(v);
G[v].pb(u);
}
dfs(1, 0);
scanf("%d", &q);
while (q--) {
scanf("%d%d", &k1, &k2);
a.clear();
b.clear();
int lca1 = 0, lca2 = 0, mx = 0, mn = 0;
for (int i = 1; i <= k1; i++) {
scanf("%d", &x), a.pb(x);
if (!mx || L[mx] < L[x])
mx = x;
if (!mn || L[mn] > L[x])
mn = x;
}
lca1 = LCA(mx, mn);
mx = 0, mn = 0;
for (int i = 1; i <= k2; i++) {
scanf("%d", &x), b.pb(x);
if (!mx || L[mx] < L[x])
mx = x;
if (!mn || L[mn] > L[x])
mn = x;
}
lca2 = LCA(mx, mn);
if (ok(lca1, b))
puts("YES");
else if (ok(lca2, a))
puts("YES");
else
puts("NO");
}
}
E. Third-Party Software - 2
题意：选择最少的区间，使得这些区间能够覆盖[1, m]
思路：原题，写过几次了。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
struct node{
int x, y, id;
bool operator<(const node& t) const {
if (x == t.x)
return y > t.y;
return x < t.x;
}
} a[maxn];
priority_queue<int, vector<int>, greater<int> > q;
int main()
{
int n, m, mx = 0, p = 0, t;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a[i].x, &a[i].y), a[i].id = i;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n && mx < m; i++) {
if (a[i].x > p + 1) {
if (a[i].x > mx + 1)
break;
p = mx;
q.push(t);
i--;
}
else {
if (a[i].y > mx)
mx = a[i].y, t = a[i].id;
}
if (mx >= m)
q.push(t);
}
if (mx < m)
puts("NO");
else {
puts("YES");
printf("%d\n", q.size());
while (!q.empty()) {
printf("%d ", q.top());
q.pop();
}
}
}
F. Friendly Fire
题意：有 n 个怪兽，每个怪兽有攻击力 ai 和血量 bi，你可以选择两个怪兽，如果 ai >= bj，那么怪兽 i 能打死怪兽 j，让他们同时攻击对方（有可能两只怪兽同时死亡），使得死亡的怪兽的攻击力之和最大。
思路：我们对于每只怪兽，把它的 ai 权值更新到max型线段树中的 bi 点去，枚举每只怪兽 i，我们从线段树中查找 区间[1, b[i] ]的最大值mx，如果mx存在，那么更新答案 ans = max(ans, mx)，如果mx >= b[i]，那么 ans = max(ans, mx + a[i])，但是细节挺多，有可能查到的怪兽是 i ，这样是不合法的，怎么消除这个问题，留给你深思啦（这题我代码写的巨丑）。
#include<bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, N = 1e9;
int mx[maxn * 35], cur[maxn * 35], ls[maxn * 35], rs[maxn * 35];
int a[maxn], b[maxn], cnt;
void up(int &o, int l, int r, int k, int v, int id, int opt) {
if (!o)
o = ++cnt;
if (l == r) {
if (opt)
mx[o] = v, cur[o] = id;
else if (mx[o] < v)
mx[o] = v, cur[o] = id;
return;
}
int m = (l + r) / 2;
if (k <= m)
up(ls[o], l, m, k, v, id, opt);
else
up(rs[o], m + 1, r, k, v, id, opt);
mx[o] = max(mx[ls[o]], mx[rs[o]]);
if (mx[ls[o]] == mx[o])
cur[o] = cur[ls[o]];
else
cur[o] = cur[rs[o]];
}
int qu(int o, int l, int r, int ql, int qr) { // 查询最大值下标
if (ql > qr)
return 0;
if (l >= ql && r <= qr)
return cur[o];
int m = (l + r) / 2, p = 0, tmp = 0;
if (ql <= m)
tmp = qu(ls[o], l, m, ql, qr);
if (a[tmp] > a[p])
p = tmp;
if (qr > m)
tmp = qu(rs[o], m + 1, r, ql, qr);
if (a[tmp] > a[p])
p = tmp;
return p;
}
map<int, int> mp, mp2;
struct node{
int a, b;
node (int t1, int t2) {a = t1, b = t2; }
bool operator<(const node& t)const {
return a > t.a;
}
};
vector<node> G[maxn];
int main()
{
int n, rt = 0, sz = 0;
scanf("%d", &n);
int ans = 0, t1 = 1, t2 = 2;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i], &b[i]);
if (!mp2[b[i]])
mp2[b[i]] = ++sz;
G[mp2[b[i]]].push_back(node(a[i], i));
up(rt, 1, N, b[i], a[i], i, 0);
}
for (int i = 1; i <= sz; i++)
sort(G[i].begin(), G[i].end());
for (int i = 1; i <= n; i++) {
int tmp = qu(rt, 1, N, 1, a[i]);
if (tmp == i) {
int v = 0;
int t = mp2[b[i]], ttt = 0;
if (G[t].size() > 1)
v = G[t][1].a, ttt = G[t][1].b;
up(rt, 1, N, b[i], v, ttt, 1);
}
int k = qu(rt, 1, N, 1, a[i]);
if (k) {
if (a[k] > ans)
ans = a[k], t1 = i, t2 = k;
if (a[k] >= b[i] && a[k] + a[i] > ans)
ans = a[k] + a[i], t1 = i, t2 = k;
}
if (tmp == i)
up(rt, 1, N, b[i], G[mp2[b[i]]][0].a, G[mp2[b[i]]][0].b, 1);
}
printf("%d\n%d %d\n", ans, t1, t2);
}
G. Akinator
题意：很绕，有 n 个人，有一个是小偷，要求你必须经过询问刚好 k 次，每次询问一堆人是否有小偷，找到这个小偷，同时求一个东西：如果你是第 m 次确定了第 i 个人的身份，那么这个人贡献的权值是：ai * m，我们要求最小的总的贡献sum / 总的ai，可以对ai进行排序。
思路：先对a数组排序，设d[l][r][k]为已经问了 k 次，再去确认区间 [l , r] 的人的身份的最小贡献，转移方程：dp[l][r][k] = min(d[ l ] [ i ][k + 1] + d[i + 1][ r ][k + 1]) (i <= i < r)
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n, k;
ll d[101][101][101], a[101], sum, inf = 1e18;
ll dfs(int l, int r, int step) {
if (step > k)
return inf;
if (l == r)
return a[l] * step;
if (d[l][r][step])
return d[l][r][step];
d[l][r][step] = inf;
for (int i = l; i < r; i++)
d[l][r][step] = min(d[l][r][step], dfs(l, i, step + 1) + dfs(i + 1, r, step + 1));
return d[l][r][step];
}
int main() {
cin>>n>>k;
for (int i = 1; i <= n; i++)
cin>>a[i], sum += a[i];
if (ceil(log2(n)) > k)
return puts("No solution"), 0;
sort(a + 1, a + 1 + n);
ll ans = dfs(1, n, 0);
ll tmp = __gcd(ans, sum);
printf("%lld/%lld\n", ans / tmp, sum / tmp);
}
H. Missing Number
轩少
I. Painting a Square
题意：有一个大方形，你有一个小方形刷子，问最小需要刷移动多少次，能把大方形刷满。
思路：我们发现我们每次刷，肯定是贴着大方形转圈圈的刷是最优的，每次刷一圈，大方形的边长就会缩小 2 * 小方形边长，然后就水题啦。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll dfs(ll a, ll b) {
if (a <= b)
return a;
if (a <= b * 2)
return (a - b) * 3 + b;
return (a - b) * 4 + dfs(a - 2 * b, b);
}
int main()
{
ll a, b;
cin>>a>>b;
cout<<dfs(a, b) - b;
}
J. The Power of the Dark Side - 2
轩少
K. Deck Sorting
题意：给你一个字符串s，有两个空柱子，你按顺序依次把这些字符放到两个柱子上，最后把两个柱子拼接，问是否能形成一个相同的字符必连续的目标串。
思路：因为最多只有3种字符，我们枚举目标串的排列，然后判断其是否可行，怎么判断：假设目标串排列是：RGB，我们把R放在第一个柱子，B放在第二个柱子，那么G有可能在R下面，也有可能在B上面，我们依次枚举s，如果出现了B，那么我们标记一下第二个柱子不能放G了，接下来如果出现了G，因为有了标记，那么G只能放第一个柱子，我们判断R放完了没有，如果放完了那么放第一个柱子下面，如果没放完，那么不合法。
#include<bits/stdc++.h>
using namespace std;
string s;
int ok(string targ) {
map<char, int> mp, mp2;
for (auto c : s)
mp[c]++;
for (int i = 0; i < targ.length(); i++)
mp2[targ[i]] = i + 1;
int flag = 0;
for (auto c : s) {
mp[c]--;
if (mp2[c] == 2) {
if (mp[targ[0]] && flag)
return 0;
}
else if (mp2[c] == 3) {
flag = 1;
}
}
return 1;
}
int main() {
cin>>s;
reverse(s.begin(), s.end());
if (ok("RGB") || ok("RBG") || ok("GRB") || ok("GBR") || ok("BRG") || ok("BGR"))
puts("YES");
else
puts("NO");
}
L. Inscribed Circle
轩少
M. Shlakoblock is live!
题意：有n个游戏，每个游戏有两个属性pi, vi，你可以选择一些游戏，使得vi + 1，使得所有的游戏 pi * vi 的总和除以总 vi 和最大。
思路：水题，先把游戏按照pi从大到小排序，我们从0开始选择枚举选择的游戏个数，然后把求出来的值更新到答案就行。
#include<bits/stdc++.h>
#define pi pair<int, int>
#define mk make_pair
using namespace std;
const int maxn = 1010;
struct node {
int p, v, id;
bool operator<(const node& t) const {
return p > t.p;
}
} a[maxn];
bool cmp(pi x, pi y) {
return 1ll * x.first * y.second > 1ll * y.first * x.second;
}
int main()
{
int T;
scanf("%d", &T);
while (T--) {
int n, sum = 0, res = 0, p = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].p, &a[i].v);
a[i].id = i;
sum += a[i].v;
res += a[i].p * a[i].v;
}
sort(a + 1, a + 1 + n);
pi ans = mk(res, sum);
for (int i = 1; i <= n; i++) {
res += a[i].p;
sum++;
if (cmp(mk(res, sum), ans))
ans = mk(res, sum), p = i;
}
int d = __gcd(ans.first, ans.second);
printf("%d/%d\n", ans.first / d, ans.second / d);
printf("%d\n", p);
if (!p)
puts("");
for (int i = 1; i <= p; i++)
printf("%d%c", a[i].id, i == p ? '\n' : ' ');
}
}
609
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
