New Password
题意
给一个字符串,问最少几步能补到满足下列条件:
- 长度至少为7
- 至少有一个小写字母
- 至少有一个大写字母
- 至少有一个数字
- 至少有一个特殊符号
思路
先补充到满足后面4个条件,大概就是每种类型的字符没有的话就随便加一个。
现在只可能不满足长度条件,可以添加任意字符知道长度大于等于7。
AC代码
// Problem: New Password
// Contest: Google Coding Competitions - Round C 2022 - Kick Start 2022
// URL: https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb4d1/0000000000b20f15
// Memory Limit: 1024 MB
// Time Limit: 20000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
std::cout << "Case #" << Case << ": ";
int n;
std::cin >> n;
std::string s;
std::cin >> s;
{
bool flag = false;
for (char ch : s) {
if (std::islower(ch))
flag = true;
}
if (!flag)
s += 'a';
}
{
bool flag = false;
for (char ch : s) {
if (std::isupper(ch))
flag = true;
}
if (!flag)
s += 'A';
}
{
bool flag = false;
for (char ch : s) {
if (std::isdigit(ch))
flag = true;
}
if (!flag)
s += '0';
}
{
bool flag = false;
for (char ch : s) {
if (ch == '#' || ch == '@' || ch == '*' || ch == '&')
flag = true;
}
if (!flag)
s += '#';
}
while (s.size() < 7)
s += '*';
std::cout << s << "\n";
}
Range Partition
题意
给一个\(1\)到\(n\)的排列,让你将其划分为两部分,要求两部分元素和之比为\(x : y\)。
\(n\)至多为\(10^5\)。
思路
总和可以算,比例已知,可以算出来其中一部分的元素之和。
然后就是用\([1, n]\)去构造出这个元素和,经典结论,从大到小枚举,能用就用。
AC代码
// Problem: Range Partition
// Contest: Google Coding Competitions - Round C 2022 - Kick Start 2022
// URL: https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb4d1/0000000000b20deb
// Memory Limit: 1024 MB
// Time Limit: 5000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
std::cout << "Case #" << Case << ": ";
int n, x, y;
std::cin >> n >> x >> y;
int s = (1 + n) * n / 2;
if (s % (x + y) != 0) {
std::cout << "IMPOSSIBLE\n";
return;
}
i64 sa = i64(s) * x / (x + y);
std::vector<int> ans;
for (int i = n; i >= 1; --i) {
if (sa >= i) {
ans.push_back(i);
sa -= i;
}
}
std::cout << "POSSIBLE\n";
std::cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); ++i)
std::cout << ans[i] << " \n"[i + 1 == ans.size()];
}
Ants on a Stick
题意
\(n\)只蚂蚁,在长为\(L\)的树枝上运动。
所有蚂蚁的移动速率恒定为\(1\),但是方向可能不同,两只蚂蚁相遇之后会立刻翻转方向,不会产生位移。
树枝两侧都可以离开树枝,蚂蚁一旦走出树枝的范围就不会再对其他蚂蚁产生影响。
给蚂蚁的初始位置和初始运动方向,要求给出蚂蚁离开树枝范围的顺序,相同时间离开的蚂蚁按下标升序。
\(n\)至多为\(10^5\)。
思路
观察:两只蚂蚁相遇其实相当于两只蚂蚁交换初始位置和方向,然后继续运动。
由此可以推导出离开树枝的时间只和蚂蚁的初始位置和方向有关。
首先按初始位置排序,左侧的蚂蚁如果向左走那就直接离开了,记录前面向右走的蚂蚁。
假设现在遇到一只向左走的蚂蚁,观察可得:相当于把向左走的蚂蚁加入序列,然后将序列循环右移一个位置。此时最左侧的蚂蚁变成向左走的了,将其弹出序列。
这里,循环右移过程中只交换初始位置和方向,不交换标号。
模拟一遍得到最后的序列,然后就可以算出每个标号的蚂蚁离开树枝的时间,然后再排序一下就能得到答案。
\(O(n)\)模拟实现循环右移,复杂度为\(O(n^2)\),可以过前两个点。用平衡树模拟区间操作复杂度为\(O(n \log n)\),可以过所有点。
线性模拟实现
// Problem: Ants on a Stick
// Contest: Google Coding Competitions - Round C 2022 - Kick Start 2022
// URL: https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb4d1/0000000000b209bc
// Memory Limit: 1024 MB
// Time Limit: 20000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
void solve_case(int Case) {
logd(Case);
std::cout << "Case #" << Case << ": ";
int n, l;
std::cin >> n >> l;
std::vector<std::array<int, 3>> a(n);
for (int i = 0; i < n; ++i) {
int p, d;
std::cin >> p >> d;
a[i] = {p, d, i};
}
std::sort(a.begin(), a.end());
std::vector<int> q;
for (int i = 0; i < n; ++i) {
q.push_back(i);
if (a[i][1] == 0) {
logd(q);
if (!q.empty()) {
auto temp = a[q[q.size() - 1]];
for (int i = q.size() - 1; i >= 1; --i) {
a[q[i]][0] = a[q[i - 1]][0];
a[q[i]][1] = a[q[i - 1]][1];
}
a[q[0]][0] = temp[0];
a[q[0]][1] = temp[1];
q.erase(q.begin());
}
logd(a, q);
}
}
std::vector<int> t(n);
for (int i = 0; i < n; ++i) {
auto [p, d, id] = a[i];
if (d == 0)
t[id] = p;
else
t[id] = l - p;
}
logd(t);
std::vector<int> id(n);
std::iota(id.begin(), id.end(), 0);
std::sort(id.begin(), id.end(), [&t](int x, int y) {
if (t[x] == t[y])
return x < y;
return t[x] < t[y];
});
for (int i = 0; i < n; ++i)
std::cout << id[i] + 1 << " \n"[i + 1 == n];
}
平衡树模拟实现
// Problem: Ants on a Stick
// Contest: Google Coding Competitions - Round C 2022 - Kick Start 2022
// URL: https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb4d1/0000000000b209bc
// Memory Limit: 1024 MB
// Time Limit: 20000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
struct Treap {
struct node {
node *l, *r;
unsigned rnd;
T v;
int sz;
node(T _v) : l(NULL), r(NULL), rnd(rng()), sz(1), v(_v) {}
};
inline int get_size(node*& p) { return p ? p->sz : 0; }
inline void push_up(node*& p) {
if (!p)
return;
p->sz = get_size(p->l) + get_size(p->r) + 1;
}
node* root = NULL;
node* merge(node* a, node* b) {
if (!a)
return b;
if (!b)
return a;
if (a->rnd < b->rnd) {
a->r = merge(a->r, b);
push_up(a);
return a;
} else {
b->l = merge(a, b->l);
push_up(b);
return b;
}
}
void split_val(node* p, const T& k, node*& a, node*& b) {
if (!p)
a = b = NULL;
else {
if (p->v <= k) {
a = p;
split_val(p->r, k, a->r, b);
push_up(a);
} else {
b = p;
split_val(p->l, k, a, b->l);
push_up(b);
}
}
}
void split_size(node* p, int k, node*& a, node*& b) {
if (!p)
a = b = NULL;
else {
if (get_size(p->l) < k) {
a = p;
split_size(p->r, k - get_size(p->l) - 1, a->r, b);
push_up(a);
} else {
b = p;
split_size(p->l, k, a, b->l);
push_up(b);
}
}
}
void ins(int p, T val) {
node *a, *b;
split_size(root, p - 1, a, b);
a = merge(a, new node(val));
root = merge(a, b);
}
void del(T val) {
node *a, *b, *c, *d;
split_val(root, val, a, b);
split_val(a, val - 1, c, d);
node* e = d;
d = merge(d->l, d->r);
delete e;
a = merge(c, d);
root = merge(a, b);
}
T qry(int p) {
node *a, *b, *c, *d;
split_size(root, p - 1, a, b);
// logd(get_size(a), get_size(b));
split_size(b, 1, c, d);
// logd(get_size(c), get_size(d));
T result = c->v;
b = merge(c, d);
root = merge(a, b);
return result;
}
void right_rotate(int l, int r) {
node *a, *b, *c, *d;
split_size(root, l - 1, a, b);
split_size(b, r - l + 1, c, d);
{
node *e, *f;
split_size(c, r - l, e, f);
c = merge(f, e);
}
b = merge(c, d);
root = merge(a, b);
}
void debug() {
std::function<void(node*)> dfs = [&](node* p) {
if (!p)
return;
dfs(p->l);
std::cerr << to_string(p->v) << " ";
dfs(p->r);
};
dfs(root);
std::cerr << std::endl;
}
};
void solve_case(int Case) {
logd(Case);
std::cout << "Case #" << Case << ": ";
int n, L;
std::cin >> n >> L;
std::vector<std::array<int, 3>> a(n);
for (int i = 0; i < n; ++i) {
int p, d;
std::cin >> p >> d;
a[i] = {p, d, i};
}
std::sort(a.begin(), a.end());
Treap<std::pair<int, int>> T;
std::vector<int> id(n);
for (int i = 0; i < n; ++i) {
T.ins(i + 1, std::make_pair(a[i][0], a[i][1]));
// T.debug();
id[i] = a[i][2];
}
int l = 0;
for (int i = 0; i < n; ++i) {
if (a[i][1] == 0) {
T.right_rotate(l + 1, i + 1);
logd(l, i);
// T.debug();
++l;
}
}
std::vector<int> t(n);
for (int i = 0; i < n; ++i) {
logd(i);
std::pair<int, int> x = T.qry(i + 1);
logd(i, x);
auto [p, d] = x;
if (d == 0)
t[id[i]] = p;
else
t[id[i]] = L - p;
}
logd(t);
std::iota(id.begin(), id.end(), 0);
std::sort(id.begin(), id.end(), [&t](int x, int y) {
if (t[x] == t[y])
return x < y;
return t[x] < t[y];
});
for (int i = 0; i < n; ++i)
std::cout << id[i] + 1 << " \n"[i + 1 == n];
}
Palindromic Deletions
题意
给定一个字符串\(s\),其长度为\(n\)。你需要完成下面这一操作共\(n\)次,问得分的期望。
- 随机选择\(s\)一个字符,将其删去,得到一个新的\(s\)
- 如果这个新的\(s\)是回文串,得一分
思路
第一个点随便暴力就过了。
第二个点的话,观察可得:对于某个长度为\(k\)的回文子序列,他对答案的贡献为\(\frac{k! (n - k)!}{n!}\)。具体含义为先把\(n - k\)个字符删掉,共\((n - k)!\)种方案,然后这\(k\)个字符后续也要删掉,共\(k!\)种方案,因为完全随机,所以概率为\(\frac{k! (n - k)!}{n!}\)。
然后只需要求出长度为\(k\)的回文子序列有几个,再乘上概率就是期望了。可以借助DP求长度为\(k\)的回文子序列数量。
假设\(dp_{k, l, r}\)表示\(s_{l}s_{l+1}\dots s_{r}\)构成的长度为\(k\)的回文子序列数量。长度为\(0\)和长度为\(1\)的可以直接算。
对于\(k >= 2\),如果\(s_l = s_r\),那么就可以在所有由\(s_{l+1}s_{l+2}\dots s_{r-1}\)构成的回文子序列的基础上获得新的长度为\(k\)的回文子序列,数量为\(dp_{k - 2, l + 1, r - 1}\);否则没有新增的回文子序列,通过容斥可得这部分为\(dp_{k, l + 1, r} + dp_{k, l, r - 1} - dp_{k, l + 1, r - 1}\)。
然后就是\(O(n^3)\)DP跑出所有\(dp_{k, 0, n - 1}\)然后算期望了。
AC代码
// Problem: Palindromic Deletions
// Contest: Google Coding Competitions - Round C 2022 - Kick Start 2022
// URL: https://codingcompetitions.withgoogle.com/kickstart/round/00000000008cb4d1/0000000000b20d16
// Memory Limit: 1024 MB
// Time Limit: 30000 ms
//
// Powered by CP Editor (https://cpeditor.org)
#include <bits/stdc++.h>
#define CPPIO std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
#ifdef BACKLIGHT
#include "debug.h"
#else
#define logd(...) ;
#endif
using i64 = int64_t;
using u64 = uint64_t;
void solve_case(int Case);
int main(int argc, char* argv[]) {
CPPIO;
int T = 1;
std::cin >> T;
for (int t = 1; t <= T; ++t) {
solve_case(t);
}
return 0;
}
const int mod = 1e9 + 7;
int qp(int a, int b) {
int r = 1;
while (b) {
if (b & 1)
r = i64(1) * r * a % mod;
a = i64(1) * a * a % mod;
b >>= 1;
}
return r;
}
int inv(int x) {
return qp(x, mod - 2);
}
int slow(int n, std::string s) {
int ans = 0;
if (n <= 8) {
std::function<void(std::string s, int)> dfs = [&](std::string s, int p) -> void {
p = i64(1) * p * inv(s.size()) % mod;
for (int i = 0; i < s.size(); ++i) {
std::string t = s.substr(0, i) + s.substr(i + 1);
// logd(p, t);
std::string r = t;
std::reverse(r.begin(), r.end());
if (t == r) {
ans = (ans + p) % mod;
}
if (!t.empty())
dfs(t, p);
}
};
dfs(s, 1);
} else {
assert(false);
}
return ans;
}
int fast(int n, std::string s) {
int ans = 0;
std::vector<int> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = i64(1) * fact[i - 1] * i % mod;
std::vector<std::vector<std::vector<int>>> dp(
n + 1, std::vector<std::vector<int>>(n, std::vector<int>(n, 0)));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
dp[0][i][j] = 1;
dp[1][i][j] = std::max(0, j - i + 1);
}
}
for (int k = 2; k <= n; ++k) {
for (int len = 2; len <= n; ++len) {
for (int i = 0; i + len - 1 < n; ++i) {
int j = i + len - 1;
dp[k][i][j] = (dp[k][i][j] + dp[k][i + 1][j]) % mod;
dp[k][i][j] = (dp[k][i][j] + dp[k][i][j - 1]) % mod;
dp[k][i][j] = ((dp[k][i][j] - dp[k][i + 1][j - 1]) % mod + mod) % mod;
if (k >= 2 && s[i] == s[j])
dp[k][i][j] = (dp[k][i][j] + dp[k - 2][i + 1][j - 1]) % mod;
}
}
}
logd(dp);
for (int k = 0; k < n; ++k) {
ans = (ans + i64(1) * dp[k][0][n - 1] * fact[k] % mod * fact[n - k] % mod) % mod;
}
ans = i64(1) * ans * inv(fact[n]) % mod;
return ans;
}
void solve_case(int Case) {
logd(Case);
std::cout << "Case #" << Case << ": ";
int n;
std::cin >> n;
std::string s;
std::cin >> s;
int ans = fast(n, s);
std::cout << ans << "\n";
#ifdef BACKLIGHT
if (n <= 8) {
int S = slow(n, s);
logd(S, ans);
// assert(S == ans);
}
#endif
}