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\n");
    else 
      printf("dasuan\n");
  }
  return 0; 
}

joker.cpp

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\n",ans[0].size()+ans[1].size());
    for (int i=0;i<ans[0].size();i++) printf("%d %d\n",ans[0][i].first,ans[0][i].second);
    for (int i=0;i<ans[1].size();i++) printf("%d %d\n",ans[1][i].first,ans[1][i].second);
    return 0;
}

swap.cpp

Problem C actor　

你有$m$种颜料，你要按照某个顺序选择颜料，每次在长度为$n$

的墙壁上刷一个区间，墙壁必须刷满，求可能刷出的墙壁方案数。

对于$100\%$的数据满足$1 \leq n\leq 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]$，此时要求$k\geq 1$

　　选择一个老颜色放在当前位置，并不终结$f[i+1][j][k]$, 此时要求$k\geq 1$

　　答案就是$\sum\limits_{i = 1}^{m} ({A_m}^i \times f[n][i][0])$

　　我们考虑到，最终的答案必然是由最多$2m$个相同颜色的块组成的，所以第一维状态可以压成和$m$有关系的了。

　　如果求出了块数为$i$的方案数$s$，那么可以通过插板法求出原来序列的答案了，即${C_{n-1}}^{i-1} \times 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] \times (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\n", sum); 
}

Actor.cpp