Codeforces Round #564 (Div. 2)

 

传送门

 

参考资料

　　[1]: the Chinese Editoria

 

A. Nauuo and Votes

•题意

　　x个人投赞同票，y人投反对票，z人不确定；

　　这 z 个人由你来决定是投赞同票还是反对票；

　　判断 x 与 y 的相对大小是否确定？

•题解

　　如果 x == y && z == 0，输出 '0'；

　　如果 x-y > z，输出 '+'；

　　如果 y-x > z，输出 '-'；

　　反之，输出 '?'；

•Code

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define memF(a,b,n) for(int i=0;i <= n;a[i++]=b);
const int maxn=1e3+50;

int x,y,z;

char *Solve()
{
    if(x == y && z == 0)
        return "0";
    if(x-y > z)
        return "+";
    if(y-x > z)
        return "-";
    return "?";
}
int main()
{
//    freopen("C:\\Users\\hyacinthLJP\\Desktop\\in&&out\\contest","r",stdin);
    scanf("%d%d%d",&x,&y,&z);
    puts(Solve());

    return 0;
}

 

---

B.Nauuo and Chess（构造）

•题意

　　给你 n 个棋子，求满足 "for all pairs of pieces i and j, |r_i−r_j|+|c_i−c_j| ≥ |i−j|."的最小的方形棋盘的列；

　　方形棋盘的右下角(m,m)与左上角(1,1)的距离为 2×(m-1)；

•题解

　　①找到 2×(m-1) ≥ n-1 的最小的 m；

　　②将 1~n-1 个棋子从第一行开始填充，第一行填充完，填充最后一列；

•Code

#include<bits/stdc++.h>
using namespace std;
#define memF(a,b,n) for(int i=0;i <= n;a[i++]=b);
#define INF 0x3f3f3f3f
const int maxn=2e5+50;

int n;

void Solve()
{
    int m=(n+2)/2;
    printf("%d\n",m);
    int x=1,y=1;
    for(int i=1;i < n;++i)
    {
        printf("%d %d\n",x,y);
        if(y < m)///先填充第一行
            y++;
        else
            x++;
    }
    printf("%d %d\n",m,m);
}
int main()
{
    scanf("%d",&n);
    Solve();

    return 0;
}

 

---

C. Nauuo and Cards（贪心）

•题意

　　有 2n 张牌，其中 n 张标号 1~n，其余 n 中为空牌；

　　从这 2n 张牌中拿出 n 张放在手中，剩余的 n 张摞在桌子上（牌堆）；

　　你可以进行如下操作：

　　　　将手中的任意一张牌插入到牌堆的底部，并将牌堆顶端的牌放入手中；

　　求最少的操作，使得摞在桌子上的 n 张牌从顶端到底端为 1,2,....,n；

•题解

　　

　　第一句话很好理解，主要是 “答案为 max(...)”这句话不太好理解，下面说说我的进一步理解：

　　最终结果就是 1~n 摞在桌子上，并且有序；

　　那么，存在牌k，在经过操作后，使得[1,2,...,k]在牌堆的底端，并且接下来的操作只用标号为[k+1,....,n]的牌，将其依次插入牌堆的底端；

　　那么，这种情况下，答案就为 p[k]+1+n-k；

　　其中 p[k]+1 是将牌 k 插入牌堆底端需要的最小操作，n-k是将[k+1,....,n]依次插入牌堆的最小操作；

•Code

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn=2e5+50;

int n;
int a[maxn];
int b[maxn];
int p[maxn];///p[i]:第i张牌在b中的位置，如果在a中，那么p[i]=0;

int F()///判断是否可以只将标号牌插入牌堆的底端使得最终状态满足条件
{
    if(!p[1])
        return INF;
    int cur=2;
    for(;p[cur] == p[1]+cur-1;cur++);
    if(p[cur-1] == n)///[1,2,...,cur-1]在b中最后的位置
    {
        int k=cur;
        /**
            在依次将第k(k∈[cur,n])张牌插入底部的时候要确保k在手上
            如何确保k在手上呢？
            假设[cur,k-1]成功插入到底部；
            那么，这k-cur牌的插入势必会使得b中的前k-cur张牌拿到手中；
            那么，只要b中前k-cur张牌含有k就行；
            也就是p[k]<=k-cur;
        */
        for(;k <= n && p[k] <= k-cur;k++);
        if(k > n)///如果k=n+1,那么只操作[cur,n]便可满足条件
            return n-(cur-1);
    }
    return INF;
}
int G()
{
    /**
        ①如果[1,..,i]中标号为x的牌，x在b中的位置在i之后
         也就是说 x<i,p[x]>p[i];
         那么 p[x]+1+n-x > p[i]+1+n-i；
         对于这种情况，ans只会取x对应的操作次数
        ②如果经过p[i]+1次操作后使得[1,...i]插入牌堆的底端
         但是，i之后存在标号为x,y的牌，x<y,p[x]>p[y]
         那么，[i+1,...,n]是没法依次插入牌堆的
         但，答案会是p[i]+1+n-i吗？
         易得p[x] >= p[i]+2
         第i张牌的操作次数为 p[i]+1+n-i;
         第x张牌的操作次数为 p[x]+1+n-x;
         两者做差得 p[x]+1+n-x-(p[i]+1+n-i)=p[x]-p[i]+i > 0
         所以，ans只会取x对应的操作次数，而不会取i对应的操作次数
    */
    int ans=0;
    for(int i=1;i <= n;++i)
        ans=max(ans,p[i]+1+n-i);
    return ans;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
    {
        scanf("%d",a+i);
        p[a[i]]=0;
    }
    for(int i=1;i <= n;++i)
    {
        scanf("%d",b+i);
        p[b[i]]=i;
    }
    printf("%d\n",min(F(),G()));
    
    return 0;
}

 

•二次理解2019.10.21

　　因为明天要帮老师讲有关贪心的实验课，今天就将之前做的贪心的题复习了一下；

　　对这道题有了新的理解；

　　将所有操作分为两类：

　　　　（1）牌面为 1 的牌从手中打到桌子上

　　　　（2）牌面为 1 的牌在桌子上，并且在不打空白牌的情况下就可以完成

　　首先判断（2）是否满足，如果满足，那此时的解肯定是最优解；

　　如果不满足（2），如何快速求解（1）对应的最优解呢？

　　定义 $f_i$ 表示将牌放入手中所需的最小操作；

　　因为要使得桌子上的牌连续，所以，在打出 1 这张牌后，紧接着要打 2 这张牌，接着是 3,......

　　也就是说，$f_2 \leq f_1+1\ ,\ f_3 \leq f_1+2\ ,\cdots \ ,\ f_n \leq f_1+n-1$；

　　所以说，要在 $max_{i=1}^{n} \ \ (f_i-(i-1))$ 后打出牌 1 才能确保接下来打出的牌依次为 2,3,4,....,n；

　　所以，（1）的最优解为 $max_{i=1}^{n}\ (f_i-(i-1)) + n$；

•Code

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+50;

int n;
int a[maxn];
int b[maxn];
int f[maxn];

int Calc()
{
    if(f[1] == 0)
        return -1;
    for(int i=f[1]+1;i <= n;++i)
        if(b[i] != b[i-1]+1)
            return -1;

    int ans=0;
    int k=0;
    for(int i=b[n]+1;i <= n;++i)
    {
        if(f[i] > k)
            return -1;
        ans++;
        k++;
    }
    return ans;
}
int Solve()
{
    int ans=Calc();
    if(ans != -1)
        return ans;

    ans=f[1];
    for(int i=2;i <= n;++i)
        ans=max(ans,f[i]-(i-1));
    return ans+n;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i <= n;++i)
    {
        scanf("%d",a+i);
        f[a[i]]=0;
    }
    for(int i=1;i <= n;++i)
    {
        scanf("%d",b+i);
        f[b[i]]=i;
    }
    printf("%d\n",Solve());

    return 0;
}