C

//对影成比例。a，b各自mod m等于相同的数，也就是说，
//等于（a-b）mod m==0；所以对于不同条（a1-a2）.。。（b1-b2）同余，我们要使得
//他们有公因数不等于1就可以；等于1就是代表没有一个数使得
//他们全部成立；时间复杂度O((n+logn)⋅max divisors of n)

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
    int n;
    cin>>n;
    vector<int> vc(n);
    for(int i=0;i<n;i++){
        cin>>vc[i];
    }
    ll cnt=0;
    for(int i=1;i<=n;i++){
        if(n%i==0){
            int gcd=0;
            for(int j=0;j+i<n;j++){
                gcd=__gcd(gcd,abs(vc[j]-vc[j+i]));
            }
            if(gcd!=1){
                cnt++;
            }
        }
    }
    cout<<cnt<<"\n";
}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
}

B

//找到博弈规则，a先，b后。故a要预判b的最优，b的最优就是选最大的数去*-1，并且用完
//；或者把占满，所以我们可以用*0去挤掉*-1的，而且，可以使用0~k个*0，用到必定去
//最优是挤开最大值，所以我们可以去枚举放的个数，注意不是单峰函数，所以不要用三分代码
//时间复杂度是nt级别的
#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

void solve(){
    int n, k, x;
    cin >> n >> k >> x;
    vector<int> arr(n);
    for(auto &c: arr) cin >> c;
    sort(arr.begin(), arr.end(), greater<int>());

    vector<ll> pre(n+1, 0);
    for(int i=1;i<=n;i++) pre[i] = pre[i-1] + arr[i-1];

    ll S = pre[n]; 
    int max_r = min(k, n);

    ll res = LLONG_MIN;

    for(int r=0;r<=max_r;r++){
        int f = min(x, n - r);

        ll sum_re= pre[r]; 
        ll sum_f = (r + f <=n) ? (pre[r + f] - pre[r]) : (pre[n] - pre[r]);

        ll f_sum = S - sum_re - 2 * sum_f;
        res = max(res, f_sum);
    }

    cout << res << "\n";
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin >> t;
    while(t--){
        solve();
    }
}

B

//容易想到删掉每个元素后，长度减1，每次只能删1，那么问题便转化为每个长度为k（k《=n）的种类，操作1删除第一个，操作2删除第二个，那么只经行操作1，得到n个结果，只进行2呢
//每种长度一直减会得到i-1个，但是肯定有重复，那么换种思路，固定首个，经行i-1次第二个操作得到n-1种，若首个都不同，那么字符串一定不同，如果首个相同的时候，在前面模拟删除的后续的已经被包含了
#include <bits/stdc++.h>
using namespace std;
void solve(){
    int n;
    cin>>n;
    string s;
    cin>>s;
    int cnt=n;
    map<char,int> mp;
    for(int i=0;i<n-1;i++){//ababa
        if(mp[s[i]]) continue;
        for(int j=i+1;j<n-1;j++){
            if(s[i]!=s[j]){cnt++;}
        }
        mp[s[i]]=1;
        if(s[i]!=s[n-1]) cnt++;
    }
    cout<<cnt<<"\n";

}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }

}

C

//首先容易得出答案一定是先做x次操作1.然后2，接着1，2交替着来，
//那么经行多少次1最好呢，由于n是2千以内，破链成环后*2
//那我们只需要进行线性枚举
#include <Bits/stdc++.h>
using namespace std;
void solve(){
    int n,k,d;
    cin>>n>>k>>d;
    vector<int> vc(n+1),re(k);
    int ans=(d-1)/2;    
    for(int i=1;i<=n;i++){ 
        cin>>vc[i];
        if(vc[i]==i) ans++;
    }
    for(int i=0;i<k;i++) cin>>re[i];
    for(int i=1;i<=min(n*2,d-1);i++){
        int temp=(d-i-1)/2;
        for(int j=1;j<=re[(i-1)%k];j++){
            vc[j]++;
        }
        for(int j=1;j<=n;j++){
            if(vc[j]==j) temp++;
        }
        ans=max(temp,ans);
    }
    cout<<ans<<"\n";

}
int main(){
    int t;
    cin>>t;
    while(t--){
        solve();
    }
}