CSP-S模拟13
全nm构造题，我爆零了
T1.排序
我读错题了……以为这是个普通的冒泡排序。因为需要用到所有的逆序对，所以每一次操作只能减少一个逆序对。考虑从小到大归位，我们按从大到小的顺序交换，这样保证了每一次交换都是\(a\)与\(a-1\)交换，相邻的两个交换，显然不会影响剩下的逆序对数，我们不断重复此操作，直至把\(1\)位置贡献的逆序对消除，这时位置\(1\)上的数一定是\(1\)，剩下的数的相对位置不变，类似于递归处理。
代码
#define sandom signed
#include <bits/stdc++.h>
#define re register int
using namespace std; int wrt[20], TP;
const int Z = 1020;
inline int read() { int x = 0, f = 0; char c = getchar(); while (!isdigit(c)) f = c == '-', c = getchar(); while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar(); return f ? -x : x; }
inline void write(int x) { TP = 0; if (x < 0) putchar('-'), x = -x; while (x >= 10) wrt[++TP] = x % 10, x /= 10; wrt[++TP] = x; while (TP) putchar(wrt[TP--] | 48); putchar(' '); }
int n, m, a[Z];
vector <int> v[Z];
inline bool cmp(int x, int y) { return a[x] > a[y]; }
sandom main()
{
n = read();
for (re i = 1; i <= n; i++) a[i] = read();
for (re i = 1; i <= n; i++)
for (re j = i + 1; j <= n; j++)
if (a[i] > a[j]) v[i].push_back(j), ++m;
write(m), putchar('\n');
for (re i = 1; i <= n; i++)
{
sort(v[i].begin(), v[i].end(), cmp);
for (auto j : v[i]) write(i), write(j), putchar('\n');
}
return 0;
}
T2.Xorum
据说随机化分很高？但是我只有20……\(Houraisan\_Kaguya\)大佬给了一种稳定\(O(log^2n)\)的算法。小芝士：累加等价于左移。首先给定的是一个奇数，如果次低位为\(1\)，可以把它左移一位，然后与原数异或，这样最低位仍然是\(1\)，次低位为\(0\)。所以我们只对此讨论。设它为\(x\)，把\(x\)不断左移，记为\(y\)，当\(y\)的最低位的1与\(x\)的最高位的1对齐时停止，这时我们得到\(a=x+y\)，\(b=x\oplus y\)，\(c=a\oplus b\)，手磨一下发现若\(x\)的最高位为\(high\)，那么\(c=2^{high+1}\)，我们用这个不断左移，把\(y\)除了最低位上的1全部异或掉，最后的\(y=2^{high}\)，这样再\(x\oplus y\)，就把\(x\)的最高位的1清除了，我们重复此操作，最后一定只剩下\(1\)。
代码
#define sandom signed
#define fre(x, y) freopen(#x ".in", "r", stdin), freopen(#y ".out", "w", stdout);
#include <bits/stdc++.h>
#define re register int
#define int long long
using namespace std; int wrt[20], TP;
const int Z = 1e6 + 10;
inline void write(int x) { TP = 0; if (x < 0) putchar('-'), x = -x; while (x >= 10) wrt[++TP] = x % 10, x /= 10; wrt[++TP] = x; while (TP) putchar(wrt[TP--] | 48); putchar(' '); }
int n, m, x, y;
struct xorum { int op, x, y; }; vector <xorum> opt;
inline void add(int op, int x, int y) { opt.push_back({xorum{op, x, y}}); }
inline int left_move(int x, int pos) { while (pos--) add(1, x, x), x += x; return x; }
int solve(int x)
{
int high, a, b, c;
for (re i = 60; i >= 0; i--)
if (x & (1ll << i)) { high = i; break; }
int y = left_move(x, high);
add(1, x, y); a = x + y;
add(2, x, y); b = x ^ y;
add(2, a, b); c = a ^ b;
high++;
for (re i = high; i <= 60; i++)
if (y & (1ll << i))
{
c = left_move(c, i - high); high = i;
add(2, y, c); y = y ^ c;
}
add(2, x, y);
return x ^ y;
}
sandom main()
{
cin >> x;
if (x & 2)
{
add(1, x, x); y = x + x;
add(2, x, y); x = x ^ y;
}
while (x != 1) x = solve(x);
write(opt.size()), putchar('\n');
for (auto i : opt) write(i.op), write(i.x), write(i.y), putchar('\n');
return 0;
}
T3.有趣的区间问题
Special Judge中的一道良心数据结构题（但是我没切），经典套路：要么扫描线，要么CDQ分治。线段树需要跑60遍，所以我选择了CDQ。借鉴完美子图的思路即可——我们已经把左右区间单独的贡献计算完了，考虑合并：1.最大值和最小值都在左边，枚举左端点，我们只需要在右边维护一个单调指针，时刻保证右边的最大值和最小值不超过左边；2.最大值和最小值都在右边，同理；3.最大值在左边，最小值在右边，枚举左端点，在右边维护两个指针，一个是扩展指针，一个是反悔指针，只要右边的最大值不超过左边，我就一直扩展，并把贡献用桶记录下来，但是当我左移左端点时，可能会出现最小值出现在左侧的情况，这时候我们需要反悔，把这样的贡献全部从桶中清除，对于每一个左端点直接查桶就行；4.最大值在右边，最小值在左边，同理。小细节：为了去重，只需要扩展的时候一个是\(<\)，一个是\(<=\)。
代码
#define sandom signed
#define fre(x, y) freopen(#x ".in", "r", stdin), freopen(#y ".out", "w", stdout);
#include <bits/stdc++.h>
#define re register int
#define int long long
using namespace std;
const int Z = 1e6 + 10;
inline int read() { int x = 0, f = 0; char c = getchar(); while (!isdigit(c)) f = c == '-', c = getchar(); while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar(); return f ? -x : x; }
int n, m, ans;
int a[Z], b[Z];
inline int lowbit(int x) { return x & (-x); }
inline int pct(int x) { int cnt = 0; while (x) cnt++, x -= lowbit(x); return cnt; }
int Max[Z], Min[Z], rec[70];
void CDQ(int l, int r)
{
if (l == r) { ans++; return; }
int mid = l + r >> 1;
CDQ(l, mid), CDQ(mid + 1, r);
Max[mid] = Min[mid] = mid;
Max[mid + 1] = Min[mid + 1] = mid + 1;
for (re i = mid - 1; i >= l; i--) Max[i] = a[Max[i + 1]] > a[i] ? Max[i + 1] : i, Min[i] = a[Min[i + 1]] < a[i] ? Min[i + 1] : i;
for (re i = mid + 2; i <= r; i++) Max[i] = a[Max[i - 1]] > a[i] ? Max[i - 1] : i, Min[i] = a[Min[i - 1]] < a[i] ? Min[i - 1] : i;
for (re i = mid, j = mid + 1; i >= l; i--)//最大值和最小值都在左边
{
while (j <= r && a[Max[j]] < a[Max[i]] && a[Min[j]] > a[Min[i]]) j++;
if (b[Max[i]] == b[Min[i]]) ans += j - mid - 1;
}
for (re j = mid + 1, i = mid; j <= r; j++)//最大值和最小值都在右边
{
while (i >= l && a[Max[i]] <= a[Max[j]] && a[Min[i]] >= a[Min[j]]) i--;
if (b[Max[j]] == b[Min[j]]) ans += mid - i;
}
for (re i = mid, j = mid + 1, k = mid + 1; i >= l; i--)//最大值在左边，最小值在右边
{
while (j <= r && a[Max[j]] < a[Max[i]]) rec[b[Min[j]]]++, j++;
while (k < j && a[Min[k]] > a[Min[i]]) rec[b[Min[k]]]--, k++;
ans += rec[b[Max[i]]];
}
for (re t = 0; t <= 60; t++) rec[t] = 0;
for (re j = mid + 1, i = mid, k = mid; j <= r; j++)//最小值在左边，最大值在右边
{
while (i >= l && a[Max[i]] <= a[Max[j]]) rec[b[Min[i]]]++, i--;
while (k > i && a[Min[k]] >= a[Min[j]]) rec[b[Min[k]]]--, k--;
ans += rec[b[Max[j]]];
}
for (re t = 0; t <= 60; t++) rec[t] = 0;
}
sandom main()
{
n = read();
for (re i = 1; i <= n; i++) a[i] = read(), b[i] = pct(a[i]);
CDQ(1, n); cout << ans;
return 0;
}
T4.无聊的卡牌问题
赛时我与正解的差距只在读入上？？我以为他给出的序列每三个一组（没仔细看样例），所以直接存了下来……赛后改成了栈就过了……从小到大依次入栈，当栈顶三个元素是同一个人取的时，就把这个三元组拿出来。显然三元组之间是有限制关系的，考虑拓扑排序。如果一个三元组\(i\)被另一个三元组\(j\)包含，那么需要先取出\(i\)，再取出\(j\)，所以连边\(i->j\)，我是把两个人的三元组分开了，并且在拓扑时开了两个队列分别记录。每次从两个队列的队首分别取出一个元素，直接输出。tip：如果队首元素不会对其他造成限制，那么什么时候取它都可以，我们可以稍后再取它，优先取会对其他造成限制的三元组。
代码
#define sandom signed
#define fre(x, y) freopen(#x ".in", "r", stdin), freopen(#y ".out", "w", stdout);
#include <bits/stdc++.h>
#define re register int
using namespace std; int wrt[20], TP;
const int Z = 1500;
inline int read() { int x = 0, f = 0; char c = getchar(); while (!isdigit(c)) f = c == '-', c = getchar(); while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar(); return f ? -x : x; }
inline void write(int x) { TP = 0; if (x < 0) putchar('-'), x = -x; while (x >= 10) wrt[++TP] = x % 10, x /= 10; wrt[++TP] = x; while (TP) putchar(wrt[TP--] | 48); putchar(' '); }
int n, m, stk[Z], n1, n2;
bool vs[Z];
struct three//三元组
{
int x[3];
friend bool operator !=(three A, three B) { return A.x[0] < B.x[0] && A.x[2] > B.x[2]; }//A包含B
}; three f[Z], g[Z];
struct edge { int v, ne; } e[Z * Z];
int head[Z], cnt, deg[Z];
inline void add(int x, int y) { deg[y]++; e[++cnt] = edge{y, head[x]}; head[x] = cnt; }
queue <int> q1, q2;
int del(queue <int> &q)
{
int lim = q.size() + 1, u = q.front(); q.pop();
while (!head[u] && lim)
{
q.push(u); lim--;
u = q.front(), q.pop();
}
for (re i = head[u]; i; i = e[i].ne)
{
int v = e[i].v; deg[v]--;
if (!deg[v])
{
if (v <= n) q1.push(v);
else q2.push(v);
}
}
return u;
}
void VOE()//拓扑排序
{
m = n << 1;
for (re i = 0 + 1; i <= n; i++) if (!deg[i]) q1.push(i);
for (re i = n + 1; i <= m; i++) if (!deg[i]) q2.push(i);
while (!q1.empty() || !q2.empty())
{
int u = del(q1);
for (re i = 0; i < 3; i++) write(f[u].x[i]); putchar('\n');
u = del(q2);
for (re i = 0; i < 3; i++) write(g[u - n].x[i]); putchar('\n');
}
}
sandom main()
{
n = read();
for (re i = 1; i <= n; i++)
{
int x = read(), y = read(), z = read();
vs[x] = vs[y] = vs[z] = 1;
}
for (re i = 1; i <= 6 * n; i++)
{
stk[++m] = i;
if (m >= 3 && vs[stk[m]] && vs[stk[m - 1]] && vs[stk[m - 2]]) f[++n1] = three{stk[m - 2], stk[m - 1], stk[m]}, m -= 3;
if (m >= 3 && !vs[stk[m]] && !vs[stk[m - 1]] && !vs[stk[m - 2]]) g[++n2] = three{stk[m - 2], stk[m - 1], stk[m]}, m -= 3;
}
//根据包含关系建立拓扑顺序
for (re i = 1; i <= n; i++)
for (re j = 1; j <= n; j++)
if (g[j] != f[i]) add(i, j + n);
for (re i = 1; i <= n; i++)
for (re j = 1; j <= n; j++)
if (f[j] != g[i]) add(i + n, j);
VOE();
return 0;
}
