CF #632 (Div. 2)A-D、F_cf632div2-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_43803508/article/details/105438361

A. Little Artem

题目大意：构造一个 $n \times m$ 的矩阵：1、只有黑白两种颜色；2、要满足 $B = W + 1$ （B表示黑色单元格的个数，并且这些单元格周围至少有一个白色单元格，W类似）
思路：在左上角的一个单元格涂上白色（与它相邻的单元格刚好只有两个），其他全涂黑色

#include <iostream>
#include <stdio.h>
#include <algorithm>
//#define int long long
using namespace std;
const int INF=0x3f3f3f3f;
const int manx=1e5+10;
void black(int n)
{
    for(int i=0;i<n;i++)
        printf("B");
    printf("\n");
}
void white(int n)
{
    for(int i=0;i<n;i++)
        printf("W");
}
int main()
{
    int t,n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        white(1);
        black(m-1);
        for(int i=1;i<n;i++)
            black(m);
    }
    return 0;
}

B. Kind Anton

题目大意：给定长度均为n的两个数列 $a 、 b$ ， $a [i]$ 只能是 $1, 0, - 1$ 中的一个数，问是否能执行若干次操作 $： a [j] + = a [i] （ 1 \leq i < j \leq n ）$ 使数列 $a$ 与数列 $b$ 相等
因为只能将前面的数累加到后面，所以当 $a [i] < b [i]$ 时，只用看 $a [1]$ 到 $a [i - 1]$ 中有没有1； $a [i] > b [i]$ 时，就看前面有没有-1（有的人想着想着就忘了i<j ：)……

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
const int INF=0x3f3f3f3f;
const int manx=1e5+10;
int main()
{
    int t,n,a[manx],b;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int f_1=0,f1=0,ans=1;
        for(int i=0;i<n;i++)
            scanf("%d",&a[i]);
        for(int i=0;i<n;i++)
        {
            scanf("%d",&b);
            if(ans&&a[i]>b&&f_1==0)
                ans=0;
            if(ans&&a[i]<b&&f1==0)
                ans=0;
            if(a[i]==-1)
                f_1=1;
            else if(a[i]==1)
                f1=1;
        }
        if(ans)
            printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

C. Eugene and an array

题目大意：给定一个长度为n的序列 $(1 \leq n \leq 2 e 5)$ ，定义good array 为不含有和为0的连续子序列，问这个序列中有多少个good array
思路：我们可以求一次前缀和，如果某两个前缀和相等 $s u m [i] = = s u m [j]$ ，就说明 $[i + 1, j]$ 这段子序列和为0。因为我们找的这些子序列中 $“$ 不能含有某段和为0的连续子序列 $”$ ，所以，我们可以记录这些序列的左端点的最大值为p，处理到第i位时，以i结尾的good array 个数就等于 $i - (p + 1)$

//为了避免讨论不存在相等前缀和和其他特殊情况情况，所以在序列前面加了一个0
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <map>
#define int long long
using namespace std;
const int INF=0x3f3f3f3f;
const int manx=2e5+10;
map<int,int>mp;
signed main()
{
    int n,a,ans=0,psum=0,p=0;
    scanf("%lld",&n);
    mp[0]=1;
    for(int i=2;i<=n+1;i++)
    {
        scanf("%lld",&a);
        psum+=a;
        p=max(p,mp[psum]);
        ans+=i-p-1;
        mp[psum]=i;
    }
    printf("%lld",ans);
    return 0;
}

D. Challenges in school №41

题目大意：n个人站成一排，要么朝向左边，要么朝向右边。如果两个人相邻且 looking at each other ，那么他们两个人可以在1s以内转向和原来相反的方向。问：是否存在一种步骤，使他们在k秒后不存在相邻且对视的情况。（多解）
思路：在1s内，可能不止一对人满足可以同时转向另一面的条件，但是他们之间是互不影响的，比如“RLRL”中第三个人肯定是和第四个人同时转向，而不会是1、2两个人转向后，2、3两个人也能满足同时转向的条件（感觉说不太清楚地样子）。所以我们可以先处理出最短的时间，即在每1s内能够转向的都转向，一直重复这个步骤，直到不存在相邻且对视的情况（ps:题目有保证说转向次数不会超过n²次，且n<3e3）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <vector>
//#define int long long
using namespace std;
const int INF=0x3f3f3f3f;
const int manx=3e3+10;
char str[manx];
int a[manx][manx],n,k,cou=0,sum=0;
int main()
{
    scanf("%d%d",&n,&k);
    scanf("%s",str+1);
    for(int i=0;i<=n;i++)
        a[i][0]=0;
    while(1)
    {
        for(int i=1;i<n;i++)
        {
            if(str[i]=='R'&&str[i+1]=='L')
            {
                a[cou][0]++;
                a[cou][a[cou][0]]=i;
                str[i]='L';
                str[i+1]='R';
                i++;
            }
        }
        if(!a[cou][0])break;
        sum+=a[cou][0];
        cou++;
    }
    if(sum<k||cou>k)
    {
        printf("-1\n");
        return 0;
    }
    for(int i=0;i<cou;)
    {
        if(cou-i==k)
        {
            printf("%d",a[i][0]);
            for(int j=1;j<=a[i][0];j++)
                printf(" %d",a[i][j]);
            printf("\n");
            i++;
            k--;
        }
        else
        {
            printf("1 %d\n",a[i][a[i][0]]);
            a[i][0]--;
            if(!a[i][0])
                i++;
            k--;
        }
    }
    return 0;
}

F. Kate and imperfection

题目大意：一个包含n个数：1、2、3……n的集合S，（一个集合中存在最大的 $_\_gcd()$ 值）求S的k个元素的子集中，最小的 $最大\_\_gcd()”$ ，k=2、3、4……n.
思路：首先k=n时，最小的 $最大\_\_gcd()”$ 很容易求出（因为n个元素的子集只有一个）；要使k=n-1时， $最大\_\_gcd()”$ 最小，就应该删去n个元素中产生 $最大\_\_gcd()”$ 的数。因为是连续的n个数，所以每个数能产生的最大__gcd()值就是它的最大因子（不含本身），将这些最大因子排序，逐个输出就可以了
O(nlogn)：也可以用素数打表里面的线性筛，因为线性筛里面每个数只被它的最小因子筛选一次，所以就能够很容易得到它的最大因子

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#include <map>
//#define int long long
using namespace std;
const int INF=0x3f3f3f3f;
const int manx=5e5+10;
int a[manx];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int flag=1;
        for(int j=2;j*j<=n;j++)
        {
            if(i%j==0)
            {
                flag=i/j;
                break;
            }
        }
        a[i]=flag;
    }
    sort(a+1,a+n+1);
    for(int i=2;i<=n;i++)
        printf("%d ",a[i]);
    printf("\n");
    return 0;
}