牛客周赛 Round 38

A.

10减去末尾数字即可，注意下本来就是0的情况即可

B.

分析：在纸上划拉两下发现，如果一个数能被9整除，那么这个数的各个位上的数相加的和也能被9整除，枚举一下即可

#include <iostream>

using namespace std;

int main()
{
    string s; cin >> s;
    
    long long sum = 0;
    int ans = 0;
    int len = s.size();
    for(int i = 0; i < len; i++)
    {
        sum += (s[i] - '0');
        if(sum%9==0) ans++;
    }
    cout << ans << endl;

    
    return 0;
}

C.

分析：我是这样想的，构造回文字符串直接选择相应数量的相同的字符即可，aaa可以贡献2+1=3个字符串，aaaa可以贡献3+2+1=6个字符串，由此可得n个相同字符可以贡献(1+(n-1))*(n-1)/2个回文字符，从a开始不断的进行循环布置字符即可，这个处理还是有一丢丢的复杂的：

#include <iostream>

using namespace std;

int main()
{
    int n, k;
    cin >> n >> k;
    
    string s = "abcdefjhigklmnopqrstuvwxyz";

    int sum = 0;
    int op = 0;//记录寻找的那个字符
    while(k > 0)
    {
        int num = 1;
        //寻找相同的字符的合适的数量
        while((num-1)*num/2 <= k) num++;//循环后num会比预定多一
        num--; //减去多的这个一
        
        for(int i = 1; i <= num; i++) cout << s[op];
        
        sum += num;
        op = (op+1)%26;//防止超过26个字母的限制
        k-=(num-1)*num/2;
    }
    op = (op+1)%26;
    for(int i = 1; i <= n-sum; i++)
    {
        cout << s[op];
        op = (op+1)%26;
    }
    
    return 0;
}

D.

分析：只需要统计每两个数字间的距离len，如果大于k就除以要求最大的平滑值，注意如果len恰好能被k整除，添加的数为商减一，其他的情况直接加上商即可，还有一件事，k有可能会大于所有的len，这时候添加一个数就行了，这可以证明出来操作一次是可行的；

#include <iostream>

using namespace std;

const int N = 1e5+10;

int a[N];

int main()
{
    int n, k; cin >> n >> k;
    
    for(int i = 1; i <= n; i++) cin >> a[i];
    
    long long ans = 0;
    int mx = 0;
    for(int i = 2; i <= n; i++)
    {
        int len = abs(a[i]-a[i-1]);
        if(len > mx) mx = len;
        
        if(len > k)
        {
            if(len % k == 0) ans += len / k - 1;
            else ans += len / k;
        }
    }
    
    if(mx < k)
    {
        cout << 1 << endl;
        return 0;
    }
    
    cout << ans << endl;
    
    return 0;
}

E.

分析：因为是等比数列，q为2时，最多也就操作15次左右，因此我们可以直接枚举100以内的数字作为公比，为什么确定是100呢，因为此时就达到10的7次方了，并且大于100最多也就3个数，所以为了不超时，大于一百的我们再分开讨论；此外，在讨论1到100的公比时，我们需要用到动态规划的思想，dp[ a[ i ] ][ j ]，代表a[ i ]能被公比 j 整除的等比数列的长度，代码如下：

#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
 
using namespace std;
 
const int N = 2e5+10;
 
int a[N];
 
int main()
{
    int n; cin >> n;
    map<int, int> mp;
    for(int i = 1; i <= n; i++) cin >> a[i], mp[a[i]]++;
     
    sort(a+1, a+1+n);
     
    vector<vector<int>> dp(N, vector<int>(101,0));
     
    int ans = 0;
    for(int i = 1; i <= n; i++)
    {
        int x = a[i];
        ans = max(ans, mp[a[i]]);//统计公比为一的时候相同元素的数量
        for(int j = 2; j <= 100; j++)
        {
            if(a[i] % j == 0)
            {
                //如果a[i]/j这个元素存在，那么就至少就有了两个数a[i]和a[i]/j
                if(mp[a[i]/j]) dp[a[i]][j] = 2;
                //如果以前出现过，那么就要在此基础上加一，并于现在的比较取最大值
                dp[a[i]][j] = max(dp[a[i]][j], dp[a[i]/j][j]+1);
                ans = max(ans, dp[a[i]][j]);
            }
        }
    }
     
    for(int i = 100; i <= N; i++)
    {
        for(int j = 1; j*i <= N; j++)
        {
            if(!mp[j]) continue;
            if(!mp[j*i]) 
            {
                ans = max(ans, 1);
                continue;
            }
            if(j*i*i > N || !mp[j*i*i]) 
            {
                ans = max(ans, 2);
                continue;
            }
            ans = max(ans, 3);
            break;
        }
         
    }
     
    cout << ans << endl;
     
    return 0;
}

F.

分析：找到一个好的数组，我们可用记录一下每个数字自己出现的位置下标，再记录一下距离这个数字最近的与他相同的数字的出现的位置，并且因为要求长度严格大于2，所以我们需要处理一下，当i >= 2时开始统计上个数字距离自己最近的相同数字的位置，这样就可以保证长度是严格大于2的，代码如下：

#include <iostream>
#include <map>

using namespace std;

const int N = 1e5+10;

int last[N];
map<int,int> mp;
int a[N];

int main()
{
    int n, q; cin >> n >> q;

    for(int i = 1; i <= n; i++) cin >> a[i];
    
    for(int i = 1; i <= n; i++)
    {
        //记录离自己最近的相同数的位置
        if(mp[a[i]]) last[i] = mp[a[i]];
        //把i的范围内的好数组赋给last[i],这样即使a[i]没形成回文数，它的范围里有回文数也可以
        last[i] = max(last[i], last[i-1]);

        if(i >= 2) mp[a[i-1]] = i-1;//记录这个数字出现的位置，选择i-1保证长度大于2
    }
    
    while(q--)
    {
        int l, r;
        cin >> l >> r;
        if(last[r] >= l) puts("YES");
        else puts("NO");
    }
    
    return 0;
}

E、F思路均来自octal_zhihao大佬，自己写一篇博客加强一下印象