Codeforces Round #632 (Div. 2)

比赛链接：https://codeforces.com/contest/1333

比赛的时候，写D的时候用了cin,cout的优化结果还是被卡了，看来cin，cout得少用。

A - Little Artem

给你n * m的矩阵，只有B和W，相邻有其他不一样的点成为好点，让好点B的数量多于W。那么直接让左上角的一块为B其余为W即可。

#include <iostream>
#include <cstdio>
#include <bits/stdc++.h>
using namespace std;
 
const int N = 1e5 + 10;
 
int n, m;
int T;
 
int main()
{
    cin >> T;
    while(T --)
    {
        scanf("%d%d", &n, &m);
        for (int i = 1; i <= n; i ++)
        {
        
        for (int j = 1; j <= m; j ++)
        {
            if(i == 1 && j == 1)
            {
                cout << "W";
            }
            else
            cout << "B";
        }
        cout << endl;
    }
    }
}

B - Kind Anton

给定一个n，长度为n的a数组和b数组，a[i]∈{1, -1, 0}，m为任意整数，a[i]只能+a[j](j < i)，那么根据题意，从后向前模拟即可。

#include <iostream>
#include <cstdio>
#include <bits/stdc++.h>
using namespace std;
 
const int N = 1e5 + 10;
 
int n, m;
int T;
int a[N];
int b[N];
map<int, int>s;
 
int main()
{
    cin >> T;
    while(T --)
    {
        s.clear();
        scanf("%d", &n);
        for (int i = 1; i <= n; i ++)
            scanf("%d", &a[i]), s[a[i]]++;
        for (int i = 1; i <= n; i ++)
            scanf("%d", &b[i]);
        bool flag = true, flag2 = false;
        bool t1 = false;
        bool t2 = false;
        for (int i = n; i >= 1; i --)
        {
            s[a[i]] --;
            if(a[i] == b[i]) continue;
            if(a[i] < b[i])
            {
                if(!s[1])
                {
                    flag = false;
                    break;
                }
            }
            if(a[i] > b[i])
            {
                if(!s[-1])
                {
                    flag = false;
                    break;
                }
            }
        }
        if(flag)
        {
            puts("YES");
        }
        else
        {
            puts("NO");
        }
    }
    
}

C - Eugene and an array

给定长度为n的序列，定义序列a为“好的”，当且仅当，a的子段中不存在sum值为0。那么根据题意，若sum[a[i]]在i前面存在，那么这样的序列只能最后一次取到sum[a[i]]的下标k以后，数量为i - k。

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
const int N = 2e5+10;
ll a[N];
map<ll, ll>mp;
int main()
{
    ll n;
    scanf("%lld", &n);
    for(int i = 1; i <= n; i++)
    scanf("%lld", &a[i]);
    ll sum = 0, res = 0, last = 0;
    mp[0] = 1;
    for(int i = 1; i <= n; i++)
    {
        sum += a[i];
        if(mp[sum]) last = max(last, mp[sum]);
        res += i - last;
        mp[sum] = i+1;
 
    }
    printf("%lld
", res);
}

D - Challenges in school №41

有一个n个箭头箭头序列，只能是L（左箭头）或者R（右箭头），每次操作可以选一对相邻的相对的箭头变成相背的箭头。每秒操作至少1次，求能够恰好k秒把整个箭头序列变成没有任何相对的箭头。

那么最后的序列肯定是LLLL...LLRRR....R这样，那么可以暴力算出每一轮能移多少并且至少移几轮。因为n只有3000，最坏情况下o(n²),满足条件。

当出现RL的时候就把R的下标保存。当RLL的时候要移俩轮，所以每次有RL存在，i++。

那么假设算出x轮，一共需要移y次。那么存在有解的情况的一定是x <= k && k <= y的。然后去贪心分配轮的次数，实现具体看代码。

#include<bits/stdc++.h> 
using namespace std;
typedef long long ll;
const int N = 3e3+10;
char s[N];
int n, k;
vector<int>a[N];
 
int main()
{
    scanf("%d%d", &n, &k);
    scanf("%s", s + 1);
    int cnt  = 0;
    while(1)
    {
        cnt ++;
        bool flag = true;
        for (int i = 1; i < n; i ++)
        {
            if(s[i] == 'R' && s[i + 1] == 'L')
            {
                flag = false;
                a[cnt].push_back(i);
                swap(s[i], s[i + 1]);
                i ++;
            }
        }
        if(flag)
        {
            break;
        }
    }
    cnt --;
    if(cnt == 0)
    {
        puts("-1");
        return 0;
    }
    ll res = 0;
    for (int i = 1; i <= cnt; i ++)
    {
        res += a[i].size();
    }
    if(res < k || cnt > k)
    {
        puts("-1");
        return 0;
    }
    ll tmp = k - cnt;
    for (int i = 1; i <= n; i ++)
    {
        int t = a[i].size();
        if(tmp >= t - 1)
        {
            for (int j = 0; j < t; j ++)
            {
                printf("1 %d
", a[i][j]);
            }
            tmp -= t - 1;
        }
        else
        {
            if(tmp)
            {
                for (int j = 0; j < tmp; j  ++)
                {
                        printf("1 %d
", a[i][j]);
 
                }
                printf("%d ", t - tmp);
                for (int j = tmp; j < t; j ++)
                {
                    printf("%d ", a[i][j]);
                }
                puts("");
                tmp = 0;
            }
            else
            {
            
                
                printf("%d ", t);
                for (int j = 0; j <t; j ++)
                {
                printf("%d ", a[i][j]);
                }
                puts("");
            
            }
        }
    }
}

E - Road to 1600

定义车和皇后都从1出发每次到可以到达的最小的位置，如果无法通行，则花费1到未到达的最小位置。给定一个n找到皇后的花费比车多的n * n的矩阵。

首先1和2肯定不行，然后写个暴力程序，发现n = 3的时候就有满足的情况。再考虑n变大以后，因为车和皇后的x轴y轴的方向是一样的，所以可以让其路径相同，直到最后一个3 * 3矩阵，让皇后的花费多余车。

#include <bits/stdc++.h>

using namespace std;

int n;
int ma[510][510];

int main()
{
    scanf("%d", &n);
    if(n <= 2)
    {
        puts("-1");
        return 0;
    }
    int tmp = 0;
    if(n == 3)
    {
        ma[n - 1][n - 1] = ++ tmp;
        ma[n - 1][n] = ++ tmp;
        ma[n][n] = ++ tmp;
        ma[n][n - 2] = ++ tmp;
        ma[n - 1][n - 2] = ++ tmp;
        ma[n - 2][n] = ++ tmp;
        ma[n - 2][n - 1] = ++ tmp;
        ma[n - 2][n - 2] = ++ tmp;
        ma[n][n - 1] = ++ tmp;
    }
    else
    {
        if(n % 2)
        {
            for (int i = 1; i <= n - 3; i ++)
            {
                if(i % 2)
                {
                    for (int j = 1; j <= n; j ++)
                    {
                        ma[i][j] = ++ tmp;    
                    }            
                }
                else
                {
                    for (int j = n; j >= 1; j --)
                        ma[i][j] = ++ tmp;
                }
            }
            for (int i = 1; i <= n - 4; i ++)
            {
                if(i % 2)
                {
                    for (int j = n - 2; j <= n; j ++)
                    {
                        ma[j][i] = ++ tmp;
                    }
                }
                else
                {
                    for (int j = n; j >= n - 2; j --)
                    {
                        ma[j][i] = ++ tmp;
                    }
                }
            }
            ma[n][n - 3] = ++ tmp;
            ma[n - 2][n - 3] = ++ tmp;
            ma[n - 1][n - 3] = ++ tmp;
        }
        else
        {
        
            for (int i = 1; i <= n - 3; i ++)
            {
                if((i % 2) != 1)
                {
                    for (int j = 1; j <= n; j ++)
                    {
                        ma[i][j] = ++ tmp;    
                    }            
                }
                else
                {
                    for (int j = n; j >= 1; j --)
                        ma[i][j] = ++ tmp;
                }
            }
            for (int i = 1; i <= n - 4; i ++)
            {
                if(i % 2 != 1)
                {
                    for (int j = n - 2; j <= n; j ++)
                    {
                        ma[j][i] = ++ tmp;
                    }
                }
                else
                {
                    for (int j = n; j >= n - 2; j --)
                    {
                        ma[j][i] = ++ tmp;
                    }
                }
            }
                ma[n - 2][n - 3] = ++ tmp;
            ma[n][n - 3] = ++ tmp;
            ma[n - 1][n - 3] = ++ tmp;
        }
            ma[n - 1][n - 1] = ++ tmp;
            ma[n - 1][n] = ++ tmp;
            ma[n][n] = ++ tmp;
            ma[n][n - 2] = ++ tmp;
            ma[n - 1][n - 2] = ++ tmp;
            ma[n - 2][n] = ++ tmp;
            ma[n - 2][n - 1] = ++ tmp;
            ma[n - 2][n - 2] = ++ tmp;
            ma[n][n - 1] = ++ tmp;
    }
    for (int i = 1; i <= n; i ++)
    { 
        for (int j = 1; j <= n; j ++)
        {
            printf("%d ", ma[i][j]);
            }
            puts("");
    } 
}

F - Kate and imperfection

 给[1,n]的连续自然数。对[2,n]的每个k，都枚举所有大小恰好为k的子集，然后定义一个值为f，其遍历集合中所有的二元组，求出二元组的gcd，然后取这些gcd里面的最大值，求f的最小值。

第一眼看到这个东西的时候一点思路都没有，后来看了大佬们的思路，发现是真的很神奇，对于每一个数（无论质数合数）x，都有一个最小质因子*一个数，那么我们就贪心，给n个数排序，肯定是让最小质因子慢慢增大（1，1， 1， 2, 2，...3,），才会让f的最大值最小。

那么根据欧拉筛每个合子都是被其最小质因子筛的。就可以在o(n) + o(nlogn)的情况下得到答案。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<set>
 
using namespace std;
 
int read() 
{
    char c;
    while (c = getchar(), c != '-' && (c < '0' || c > '9'));
    bool flag = (c == '-');
    if (flag)
        c = getchar();
    int x = 0;
    while (c >= '0' && c <= '9') {
        x = x * 10 + c - '0';
        c = getchar();
    }
    return flag ? -x : x;
}
 
const int MAXN = 500000;
 
bool flag[MAXN + 1];
int prime[MAXN], x[MAXN + 1];


int main() {
    int n = read();
    int total = 0;
    x[1] = 1;
    for (int i = 2; i <= n; i++) 
    {
        if (!flag[i]) 
        { 
            prime[total++] = i;
            x[i] = 1;
        }
        for (int j = 0; j < total && i * prime[j] <= n; j++) {
            int k = i * prime[j];
            flag[k] = true;
            x[k] = i;
            if (!(i % prime[j]))
                break;
        }
    }
    sort(x + 1, x + (n + 1));
    for (int i = 2; i <= n; i++)
        printf("%d%c", x[i], (i == n) ? '
' : ' ');
    return 0;
}