Problem A Joker
老虎和蒜头是好朋友。
夏天过去了，凉爽的秋天来临，老虎和蒜头又有了新的娱乐项目。
老虎有一个远房表亲是西伯利亚虎，那里流行着一个纸牌游戏：两位玩家参与游戏，道具是一副54张的扑克牌，52 张基本牌和两张Joker，也称为王牌。这两张王分别是红色和黑色的。这52 张基本牌又分为黑桃、红桃、梅花、方片四种花色，每种花色均有13 张牌，这13 张牌会有一个等级顺序，依次分别是2 3 4 5 6 7 8 9 10 J Q K A，其中2 是最低的等级，A 是最高的等级。所有的红桃和方片都被认为是红色的，而所有的黑桃和梅花都被认为是黑色的。有一种花色会被硬点，我们称这种花色的牌为庄家牌。
一局游戏开始前，两名玩家手上都有六张牌，剩余的42 张牌组成牌堆。一局游戏由多轮游戏组成，在每一轮开始前，两名玩家手上均有若干张牌，一名玩家先手，另一名玩家后手。先手的玩家应在桌上放若干张等级相同的牌，注意先手玩家在任意时刻都不允许放置王牌，且放置的牌的张数不能超过后手玩家手上拥有牌的总数。后手玩家可以选择一些自己的牌分别叠在先手玩家的牌上，一张牌可以叠在另一张牌上当且仅当以下条件中至少有一条满足：
1. 这张牌和被叠的牌花色相同，且有着更高的等级。
2. 这张牌为庄家牌，而被叠的牌不是。
3. 这张牌是王牌，且和被叠的牌颜色相同。
4. 这张牌是王牌，并且它的颜色和为庄家牌的颜色相同。在所有桌上的牌都被叠后，先手者还可以在桌面上再放置若干张牌，但这些牌的等级一定要和桌上的任意一张牌的等级相同(无论是否被叠)，而后手的玩家仍然可以选择一些自己的牌叠在先手玩家的牌上。注意，先手玩家仍然不能在桌上放置比后手玩家的手牌数更多的牌。
一轮游戏结束，当且仅当以下两种情况之一发生：后手玩家不能或不想叠桌面上的牌、或是先手玩家不能或不想放置更多的牌。在第一种情况下，当后手玩家认为不必继续这一轮游戏时，先手玩家仍然有一次继续放置非王牌的扑克牌的机会，而放置的牌的等级仍要和桌面上已有的任一张牌等级相同，且桌面上未被叠的牌的总数不能超过后手玩家手上牌的总数。在此之后，后手玩家输掉了这一轮，并将桌面上的所有牌加入自己的手牌。在下一轮游戏中，先手玩家和后手玩家的角色不变。
在第二种情况下，后手玩家赢得了这一轮。桌面上的所有牌将被移走(并不移入牌堆)，而在下一轮中先手和后手玩家的角色将会互换，即先手玩家变为后手玩家，后手玩家变为先手玩家。
在轮与轮之间，如果上一轮的先手玩家的手牌不超过6 张，他会从牌堆顶部开始一张一张取入手牌，直到手牌恰好有6 张或是牌堆中所有牌均已被取走。
如果在一轮游戏开始前，一名玩家已经没有手牌，而另一位玩家仍有手牌，那么无手牌的玩家赢得了这一局游戏。如果两位玩家都没有了手牌，那么本局游戏以平局收场。在两名玩家都有至少一张手牌，但先手玩家的手牌只有王牌——他不能做任何行动——的情况下，我们认为后手玩家取得本局游戏的胜利。
老虎和蒜头正在进行这样的游戏，我们给定牌堆的情况、两人手中的手牌以及特殊牌的花色，你的目标是确定在最优策略下这局游戏的胜者是谁。注意：牌堆的信息对两人来说都是公开的。西伯利亚虎是老虎的朋友，因此蒜头决定每局游戏中让老虎先手。
老虎认为这个游戏太复杂了，因此在每一局游戏进行前老虎会先从所有牌中去掉某些等级的牌，但老虎保证至少剩下3 个等级的牌，即至少有14 张牌以使得游戏能顺利进行。
Solution ：
还好本题在知乎上看到过原题，这是tourist出的神仙题。
无用信息对于$95\%$，个人认为本题没有什么价值。
只要后手没有两张王，那么就后手必胜，否则先手必胜。
最优策略下，后手只需要一直不出然后让先手将牌堆摸遍就好了。
是一个Trick题
#include <bits/stdc++.h> using namespace std; const int N = 1005; string s1, s2, s3, c, level; int main() { int T; cin >> T; char ch; cin >> ch; while (T--) { int flg = 0; getline(cin, level); getline(cin, s1); getline(cin, s2); for (int i = 0; i < (int) s2.size(); i++) { if (s2[i] == 'R' && s2[i + 1] == 'J') flg++; if (s2[i] == 'B' && s2[i + 1] == 'J') flg++; } getline(cin, s3); getline(cin, c); if (flg == 2) printf("laohu "); else printf("dasuan "); } return 0; }
Problem B swap
给出两个长度为$n$的排列$a,b$，每一次操作可以将$a$中的一段$[L,R]$拿出，将其最大值和最小值交换顺序。
在$345678$次操作之内，将$a$变成$b$.
对于$100\%$的数据保证，$1 leq n leq 4096$
Solution ：
之前有出过类似的题目，仍然考虑归并排序套快速排序的思想。
如果我们可以将一个$a$数组排序，其操作序列为$S$,将$b$数组排序，其操作序列为$T$
那么由于操作可逆，所以我们只需要正序输出$S$，然后倒序输出$T$即可。
利用归并排序，问题可以转化为，如何合并两个递增有序的序列。
这个事情，我们需要使用一个分治做法来完成。
设当前需要合并的区间为$[l0,r0]$和$[l1,r1]$
设要合并的线段是$[l0,r0]$,$[l1,r1]$，找到一个最小的长度$pt$,使得$[r0-pt+1,r0]$的数的大小都比$[l1,l1+pt-1]$的数的大小大。
这个时候，我们需要将$[r0-pt+1,l1+pt-1]$区间的数有序，所以我们需要依次做三个$update$操作。
即翻转区间$[r0,pt+1,r0]$，翻转区间$[l1,l1+pt-1]$，翻转区间$[r0-pt+1,l1+pt-1]$
此时问题就转化为两个子问题: 将$[l0,l0-pt]$和$[r0-pt+1,r0]$合并; 将$[l1,l1+pt-1]$和$[l1+pt,r1]$合并。
这样的分治，每一次将会将线段均分成两段，时间复杂度为$O(log_2 l)$，其中$l$表示处理线段长度。
所以，外套一个归并排序，本题的最终时间复杂度为$O(n {log_2}^2 n)$
# include<bits/stdc++.h> using namespace std; const int N=1e5+10; int n,a[N]; vector< pair<int,int> >ans[2]; void update(int op,int l,int r) { for (int i=0;i<(r-l+1)/2;i++) { ans[op].push_back(make_pair(l+i,r-i)),swap(a[l+i],a[r-i]); } } void merge(int op,int l0,int r0,int l1,int r1) { if (l0>r0 || l1>r1) return; int l=min(r0-l0,r1-l1),pt=0; while (pt<=l) if (a[r0-pt]>=a[l1+pt]) pt++; else break; if (!pt) return; update(op,r0-pt+1,r0); update(op,l1,l1+pt-1); update(op,r0-pt+1,l1+pt-1); merge(op,l0,r0-pt,r0-pt+1,r0); merge(op,l1,l1+pt-1,l1+pt,r1); } void solve(int op,int l,int r) { if (l >= r) return; int mid = (l+r)>>1; solve(op,l,mid); solve(op,mid+1,r); merge(op,l,mid,mid+1,r); } int main() { scanf("%d",&n); for (int i=1;i<=n;i++) scanf("%d",&a[i]); solve(0,1,n); for (int i=1;i<=n;i++) scanf("%d",&a[i]); solve(1,1,n); reverse(ans[1].begin(),ans[1].end()); printf("%d ",ans[0].size()+ans[1].size()); for (int i=0;i<ans[0].size();i++) printf("%d %d ",ans[0][i].first,ans[0][i].second); for (int i=0;i<ans[1].size();i++) printf("%d %d ",ans[1][i].first,ans[1][i].second); return 0; }
Problem C actor
你有$m$种颜料，你要按照某个顺序选择颜料，每次在长度为$n$
的墙壁上刷一个区间，墙壁必须刷满，求可能刷出的墙壁方案数。
对于$100\%$的数据满足$1 leq nleq 10^6, m leq 300$
Solution :
我们会首先考虑一个$O(mn^2)$的暴力$dp$.
设$f[i][j][k]$表示当前涂到第$i$个格子，使用了$j$个颜色，而有$k$个颜色一定会在后来的涂色中涂到。
那么$f[0][0][0] = 1$,采用刷表法转移。
考虑$f[i][j][k]$可以转移到
新放一个在之后将不会再刷到这个颜色： $f[i+1][j+1][k]$
新放一个在之后还会刷到这个颜色：$f[i+1][j+1][k+1]$
选择一个老颜色放在当前位置，并终结$f[i+1][j][k-1]$，此时要求$kgeq 1$
选择一个老颜色放在当前位置，并不终结$f[i+1][j][k]$, 此时要求$kgeq 1$
答案就是$sumlimits_{i = 1}^{m} ({A_m}^i imes f[n][i][0])$
我们考虑到，最终的答案必然是由最多$2m$个相同颜色的块组成的，所以第一维状态可以压成和$m$有关系的了。
如果求出了块数为$i$的方案数$s$，那么可以通过插板法求出原来序列的答案了，即${C_{n-1}}^{i-1} imes s$
将状态改为$f[i][j][k]$表示当前考虑到$i$块，已经使用$j$个颜色，该块和该块之后最多能放置的已经放过的颜色的数目为$k$。
那么，$f[i+1][j][k] = f[i][j][k+1]+f[i][j][k+2] + ...$ ，此时只要在第$i+1$放一个已经放过的颜色就能实现。
若考虑新放置一个$j+1$的颜色，其有$(m-j)$种元素好挑，所以转移方程为$f[i+1][j+1][k+1] += f[i][j][k] imes (m-j)$
答案按照上述方法统计即可。
时间复杂度为$O(m^3)$
#include <stdio.h> typedef unsigned long long u64; const int N = 305, P = 1e9 + 7; int n, m, f[N << 1][N][N], c[N << 1], inv[N << 1], sum; void inc(int &x, int y){ (x += y) < P ?: x -= P; } void inc(int &x, u64 y){ x = (x + y) % P; } int main(){ // freopen("actor.in", "r", stdin); // freopen("actor.out", "w", stdout); int i, j, k, s; scanf("%d%d", &n, &m); f[1][1][1] = m, c[1] = inv[1] = 1; for (i = 2; i <= m << 1; ++i) { inv[i] = P - (u64)(P / i) * inv[P % i] % P; c[i] = (u64)c[i - 1] * inv[i - 1] % P * (n - i + 1) % P; } for (i = 1; i <= m << 1; ++i) { for (j = 1; j <= m; ++j) { for (k = j, s = 0; k >= 1; --k) { inc(f[i + 1][j][k], s); inc(f[i + 1][j + 1][k + 1], (u64)f[i][j][k] * (m - j)); inc(s, f[i][j][k]); } inc(sum, (u64)s * c[i]); } } printf("%d ", sum); }