2019.9.21模拟赛
2019.9.21模拟赛
T1：奇怪的队列
类似蓝书《算法竞赛进阶指南》上树状数组一节中的一道例题。
不难想到先把所有人按身高排序，这样问题会变得容易下手。
身高按升序排序，然后依次为每个人在队列中安排位置。这样，假设我们已经安排到第x个人，他的身高和记住的数字分别是\(a_x\)、\(b_x\)，现在队列中所有空余的位置上的人的身高都大于\(a_x\)，已经安排好的x-1个位置上的人的身高都小于\(a_x\)。
问题转化为：找一个位置，满足该位置没有被占用，且该位置之前或之后恰有\(b_x\)个空位。一个位置有没有被占用可以用0/1表示，1表示空位（没有被占用），0表示已经被占用。这样就可以用前/后缀和表示，若第x个人的位置\(pos_x\)之前恰有\(b_x\)个空位，且\(pos_x\)本身也是空位，那么该位置前缀和\(sum_x=b_x+1\)，同理可用后缀和表示\(pos_x\)之后恰有\(b_x\)个空位的情况。但同时维护前后缀和比较麻烦，于是我们尝试用前缀和表示\(pos_x\)之后恰有\(b_x\)个空位的情况：前x-1个人已经安排好位置，现在还有n-x+1个空位，\(pos_x\)之后有\(b_x\)个空位，那么该位置的前缀和就是\(sum_x=n-x+1-b_x\)。
01序列前缀和单调不减，于是我们可以二分找到满足要求的\(pos_x\)位置，分\(pos_x\)前/后有\(b_x\)个人两种情况，题目要求字典序最小，我们又是按升序排序，所以当两个位置都可以的时候选择靠前的位置即可。
注意我们每次安排好第x个人的位置，都会改变\(pos_x\)位置的0/1情况，即要求动态维护01序列的前缀和。我选择了用树状数组维护，每次需要二分\(pos_x\)，对每次二分到的值在树状数组上查询前缀和，总复杂度\(O(nlog^2n)\)。
标程是用线段树维护01序列，利用线段树结构可直接在线段树上二分，类似平衡树查第k大元素的写法，这样复杂度为\(O(nlogn)\)。
Code：
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
const int N = 2e5 + 5, inf = 0x3f3f3f3f;
int n, q[N], c[N];
pii p[N];
void add(int p, int v) {
for(; p <= n; p += p & -p) c[p] += v;
}
int ask(int p) {
int ans = 0;
for(; p; p ^= p & -p) ans += c[p];
return ans;
}
int calc(int v) {
int l = 1, r = n, ans = n;
while(l <= r) {
int mid = (l + r) >> 1, res = ask(mid);
if(res >= v) ans = min(ans, mid), r = mid - 1;
else l = mid + 1;
}
return ask(ans) == v ? ans : inf;
}
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; ++i) {
scanf("%d%d", &p[i].first, &p[i].second);
add(i, 1);
}
sort(p + 1, p + n + 1);
for(int i = 1; i <= n; ++i) {
int pos = min(calc(p[i].second + 1), calc(n - i + 1 - p[i].second));
if(pos == inf) return puts("impossible"), 0;
q[pos] = p[i].first;
add(pos, -1);
}
for(int i = 1; i <= n; ++i) printf("%d ", q[i]);
return 0;
}
T2：质数
首先考虑单组询问的情况
注意到询问上界R=1e7，可以直接用bool数组标记符合要求的数。质数可以直接\(O(n)\)线性筛求出，对于两个质数的乘积，可以在求出的质数数组中两两枚举相乘进行标记。分析复杂度：看似两重循环，实际上内层循环在两数乘积大于R就break，所有枚举到的乘积都是合法的，且每两个质数的乘积只会被枚举一次。所以复杂度不会超过\(O(n)\)。
对于多组询问，对bool数组\(O(n)\)求出前缀和数组，每次\(O(1)\)回答即可。
Code：
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
int T, n, tot, l[N], r[N], p[N], sum[N];
bool mark[N], vis[N];
void prime() {
for(int i = 2; i <= n; ++i) {
if(!vis[i]) p[++tot] = i;
for(int j = 1; j <= tot && i * p[j] <= n; ++j) {
vis[i * p[j]] = true;
if(i % p[j] == 0) break;
}
}
}
int main() {
scanf("%d", &T);
for(int i = 1; i <= T; ++i) {
scanf("%d%d", &l[i], &r[i]);
n = max(n, r[i]);
}
prime();
for(int i = 1; i <= tot; ++i) {
mark[p[i]] = true;
for(int j = i; j <= tot; ++j) {
if(1ll * p[i] * p[j] > n) break;
mark[p[i] * p[j]] = true;
}
}
for(int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + mark[i];
for(int i = 1; i <= T; ++i) printf("%d\n", sum[r[i]] - sum[l[i] - 1]);
return 0;
}
T3：好文章
字符串算法基本忘光了，只好打hash了。
思路很简单，对整个串hash，之后把每m个字符的hash值塞入set中，最后输出set的size，复杂度\(O(nlogn)\)。
数据较大，且可能经过构造，自然溢出会被卡。可以用双模数hash，选两个大质数和底数分别hash，最后比较pair类型。
最初写的时候函数传入参数是bool类型区分两个模数，结果传参时写成1和2，相当于单模数hash，WA了一整页...
Code：
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
const int N = 8e6 + 5;
const ll mod1 = 1e9 + 7, mod2 = 1e9 + 9, base1 = 131, base2 = 31;
int n, m;
ll hash1[N], hash2[N], fac_mod1[N], fac_mod2[N];
char s[N];
set<pll> U;
ll ask(int l, int r, bool op) {
if(op == 1) return ((hash1[r] - hash1[l - 1] * fac_mod1[r - l + 1] % mod1) % mod1 + mod1) % mod1;
else return ((hash2[r] - hash2[l - 1] * fac_mod2[r - l + 1] % mod2) % mod2 + mod2) % mod2;
}
int main() {
scanf("%d%d%s", &n, &m, s + 1);
fac_mod1[0] = fac_mod2[0] = 1;
for(int i = 1; i <= n; ++i) {
fac_mod1[i] = fac_mod1[i - 1] * base1 % mod1;
fac_mod2[i] = fac_mod2[i - 1] * base2 % mod2;
}
for(int i = 1; i <= n; ++i) {
hash1[i] = (hash1[i - 1] * base1 % mod1 + s[i] - 'a' + 1) % mod1;
hash2[i] = (hash2[i - 1] * base2 % mod2 + s[i] - 'a' + 1) % mod2;
}
for(int i = 1; i + m - 1 <= n; ++i)
U.insert(make_pair(ask(i, i + m - 1, 1), ask(i, i + m - 1, 0)));
cout << U.size();
return 0;
}
