HGOI 20191105 题解

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

 

 

posted @ 2019-11-05 18:49  ljc20020730  阅读(244)  评论(0编辑  收藏  举报