Codeforces Global Round 7

A. Bad Ugly Numbers

思路

• 题意： 给我们一个k，让我们用 0～9 之间的数字构成一个 k位数a，a不能被组成a的每一位数字整除。
• 分析：首先 k等于1，无论我们怎么配都会被整除；当k > 1 的时候，a的组成位数中肯定不能有1，那么只能在 2～9，之间选择，剩下我们可以选择两个不能互相整除的数如 2、7，，我们可以让2作为第一位，剩下的位数全是7，，，，例如我们求一个k = 3 时我们构成的数a，a = 277

代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<vector>
#include<string>
using namespace std;

int main()
{
    /* freopen("A.txt","r",stdin); */
    /* freopen("Res.txt","w",stdout); */
    int t;
    scanf("%d", &t);
    while(t --)
    {
        int n;
        scanf("%d", &n);

        if(n == 1)
        {
            printf("-1\n");
            continue;
        }

        printf("2");
        for(int i = 2; i <= n; i ++)
            printf("%d", 9);
        printf("\n");
    }

    return 0;
}

• 注意：做题认真

B. Maximums（多观察）

思路

• 题意
  
  有一个序列长度为n的序列a1,a2,,,an a_1,a_2,,,a_n~a1​,a2​,,,an​  ,有给了我们另一个序列x1,x2,x3...xn x_1,x_2,x_3...x_n~x1​,x2​,x3​...xn​ ,在这个序列中xix_ixi​为序列a从1～i-1 的前缀最大值，注意：x1=0x_1 = 0x1​=0，又给了我们一个 b1,b2...bnb_1,b_2...b_nb1​,b2​...bn​,其中bi=ai−xib_i = a_i - x_ibi​=ai​−xi​, 题上给我们了 序列b的值，让我们逆向求序列a的值
• 分析：由于 xix_ixi​是前缀1~(i - 1)位置序列a最大值，而且x1=0x_1 = 0x1​=0, 我们要求的ai=bi+xia_i = b_i + x_iai​=bi​+xi​, 当i = 1，x1,b1x_1, b_1x1​,b1​均为已知值，这样我们可以求出 a1a_1a1​, 这样我们在维护 x1x_1x1​的最大值，那么相当于x1x_1x1​也是已知值，这样在不断求解每一位的时候，维护前缀最大值xix_ixi​就行了

代码

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<map>
#include<queue>
#include<vector>
#include<string>
using namespace std;

const int Len = 2e5 + 10;
int ar[Len], br[Len];

int main()
{
    /* freopen("A.txt","r",stdin); */
    /* freopen("Res.txt","w",stdout); */
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++)
        scanf("%d", &br[i]);
    int pri_mx = 0;
    for(int i = 1; i <= n; i ++)
    {
        ar[i] = br[i] + pri_mx;
        pri_mx = max(pri_mx, ar[i]);
    }
    for(int i = 1; i <= n; i ++)
        printf("%d ", ar[i]);

    return 0;
}

C. Permutation Partitions（思维）

思路

• 题意：给我们一个有1～n之间的数字组成的序列，让我们把这个序列分割成 k 段，是这k段中的最大值相加和最大，问我和的最大值是多少，并且得到这个最大值的分割方法有多少种。

• 分析：由于组成序列p是 1～n之间的数字，有很明显 和的最大值就是 n-k+1 ~ n 之间的所有数字和，这题就是难在这个分割方法，我们可以用插板法去解决这个分割方法，我们加上 前k大数字在原序列p中的位置为x1,x2...xkx_1,x_2...x_kx1​,x2​...xk​, 那么我们可以在 相邻的 两个属于前k大的数字之间进行插板，那么只需要查 k-1个板子就可解决问题了，对其中一个板子，插大位置的方案数是 x_i - x_i-1 ，那么我们把所有板子插入的位置方案数相乘就能得到ans了， ⚠️用 long long，防止相乘的时候溢出

代码

#include<iostream>
using namespace std;
typedef long long ll;
const int mod=998244353;

int n, k;
ll ans = 1, sum = 0, p = -1;   //p存储的是上一个前k大的数的位置

int main()
{
    /* freopen("A.txt","r",stdin); */
    scanf("%d %d", &n, &k);
    int x;
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d", &x);
        if(x >= n - k + 1)
        {
            sum += x;
            if(p != -1)
                ans = ans * (i - p) % mod;
            p = i;
        }
    }
    printf("%lld %lld\n", sum, ans);

    return 0;
} 

• 收获：收获的肯定是，这个“插板法”来求解分割成连续k段的思路，真实考思维啊。。。。。

D2. Prefix-Suffix Palindrome (Hard version)（马拉车）

思路

• 题意：给我们一个字符串s，让我们从这个字符串中找到一个“前缀字符a串”（从s字符串开始的第一个字符为开头的子串） 和一个“后缀字符串b”（以s最后一个字符结尾的子串），把a 、b子串拼接起来，问能组成的最大回文字符串是多长。

• 分析：首先我们从s串中前后两端进行匹配，如果前后字符相同就继续向中间匹配，这样我们的到两端已经匹配好的子串设为x，y，把匹配剩下的一个连续的子串str，我们 “马拉车”算法跑一边，去求以str中第一个字符开头的回文子串的的最大长度或者以str最后一个字符为结尾的回文子串的最大长度，得到的这个最大长度的回文子串的设为mid，那么最终答案就是 x + mid + z （把这三段拼接起来）

• ⚠️：在用马拉车求解 mid最大回文子串 的时候，有以下代码片段需要注意：

    //如果回文串从开头或者结尾出发 && 当前找到的这个回文串的长度大于 以前符合题意的回文串的长度
       if(Len[i] - 1 > mx_ans && (i - Len[i] == 0 || i + Len[i] == tot))
       {
           if(i - Len[i] == 0)
               is_front = 1;
           else
               is_front = 0;
           mx_ans = Len[i] - 1;
       }
  

代码

#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;

const int maxn = 5e6 + 5;
char ar[maxn], br[maxn], cr[maxn];
int Len[maxn];
bool is_front = 1;

int trans(int cnt)
{
    int tot = 0;
    cr[tot ++] = '@';
    for(int i = 0; i < cnt; i ++)
        cr[tot ++] = '#', cr[tot ++] = br[i];
    cr[tot ++] = '#';
    cr[tot] = '$';
    return tot;
}

int Manacher(int tot)
{
    int mid = 0, mxR = 0;
    int mx_ans = 0;
    for(int i = 1; i < tot; i ++)
    {
        if(i < mxR) Len[i] = min(mxR - i, Len[2*mid - i]);
        else Len[i] = 1;

        while(cr[i + Len[i]] == cr[i - Len[i]]) Len[i] ++;

        if(mxR < i + Len[i])
        {
            mid = i;
            mxR = i + Len[i];
        }
        //如果回文串从开头或者结尾出发 && 当前找到的这个回文串的长度大于 以前符合题意的回文串的长度
        if(Len[i] - 1 > mx_ans && (i - Len[i] == 0 || i + Len[i] == tot))
        {
            if(i - Len[i] == 0)
                is_front = 1;
            else
                is_front = 0;
            mx_ans = Len[i] - 1;
        }
    }
    return mx_ans;
}

int main()
{
    /* freopen("A.txt","r",stdin); */
    /* freopen("Res.txt","w",stdout); */
    int t;
    scanf("%d", &t);
    while(t --)
    {
        is_front = 1;
        scanf("%s", ar + 1);
        int n = strlen(ar + 1);
        int len1 = 0;
        int cnt = 0;
        for(int i = 1, j = n; i <= j; i ++, j --)
        {
            if(ar[i] == ar[j] && i != j)
                len1 ++;
            else
            {
                while(i <= j)
                {
                    br[cnt ++] = ar[i];
                    i ++;
                }
                break;
            }
        }
        int len2 = Manacher(trans(cnt));

        for(int i = 1; i <= len1; i ++)
            printf("%c", ar[i]);
        if(is_front)
        {
            for(int i = 0; i < len2; i ++)
                printf("%c", br[i]);
        }
        else
        {
            for(int i = cnt - len2; i < cnt; i ++)
                printf("%c", br[i]);
        }
        for(int i = n - len1 + 1; i <= n; i ++)
            printf("%c", ar[i]);
        printf("\n");
    }

    return 0;
}

*收获：“马拉车”，这个神奇的以O(n)求回文的子串的算法。其次还是要好好读好题，把题意理解正确

E. Bombs（真思维 + 线段树）

思路

• 题意及分析：请看这位大佬的讲解

代码

#include<iostream>
using namespace std;

#define rl rt << 1
#define rr rt << 1 | 1
#define ms m = (tre[rt].l + tre[rt].r) >> 1
const int maxn = 300005;
struct Node
{
    int l, r, mn, lazy;
} tre[maxn << 2];

int p[maxn];

void Push_up(int rt)
{
    tre[rt].mn = min(tre[rl].mn, tre[rr].mn);
}
void Push_down(int rt)
{
    int ly = tre[rt].lazy;
    if(ly)    //如果 lazy 不等于0，我们要下推标记
    {
        tre[rl].lazy += ly;
        tre[rl].mn += ly;
        tre[rr].lazy += ly;
        tre[rr].mn += ly;
        tre[rt].lazy = 0;   //解除标记
    }
}

void Build(int rt, int l, int r)
{
    tre[rt].l = l, tre[rt].r = r;
    tre[rt].mn = tre[rt].lazy = 0;
    if(l == r) return;
    int m = (l + r) >> 1;
    Build(rl, l, m);
    Build(rr, m + 1, r);
}

void Update(int rt, int s, int e, int val)
{
    if(s <= tre[rt].l && tre[rt].r <= e)
    {
        tre[rt].mn += val;
        tre[rt].lazy += val;
        return;
    }

    Push_down(rt);
    int ms;
    if(s <= m) Update(rl, s, e, val);
    if(e >  m) Update(rr, s, e, val);
    Push_up(rt);
}

int main()
{
    /* freopen("A.txt","r",stdin); */
    /* freopen("Ans.txt","w",stdout); */
    int n;
    scanf("%d", &n);
    int x;
    for(int i = 1; i <= n; i ++)
        scanf("%d", &x), p[x] = i;          //存储x这个值所在的位置为 i
    Build(1, 1, n);
    int ans = n + 1;
    int q;
    for(int i = 1; i <= n; i ++)
    {
        scanf("%d", &q);
        while(tre[1].mn >= 0)       //当tre[1].mn 小于0的时候我们可以确定当前最大值ans没有被没有被当前位置之前的所有炸弹炸掉，所以 最大值还是ans，直接输出就行了；
                                    //如果tre[1].mn >= 0 这个时候 ans 这个序列中的最大值已经被 炸弹炸掉了，所以我们需要 while循环，找符合题意的ans使tre[rt].mn再次小于0，然后再次输出ans
        {
            ans --;
            Update(1, 1, p[ans], -1);
        }
        Update(1, 1, q, 1);
        printf("%d ", ans);
    }

    return 0;
}