Divide by Zero 2021 and Codeforces Round #714 (Div. 2) 总结与A-E题解

思考与总结：
①赛后观察他人代码，发现一个题目有更多简单且易于实现的写法，自己的代码有时候显得冗余了，且可能容易出错，需要改进实现方式。
②这场比赛一共WA了五发，其中三发没开long long,一发dp数组开小了。细节考虑清楚能减少debug时间和罚时，规避掉小错误这场就进前三百了。不确定的情况下直接开long long，边界条件考虑的要更清楚一点。

---

A. Array and Peaks
大意：找到一个长度为n的全排列，其中包含k个峰值。峰值定义为$a_i>a_{i-1},a_i>a_{i+1},(1<i<n)$
思路：一个递增的全排列，每有一个k就从尾部取一个数放到前面的两个数中间。若无法进行该操作，则没有合法序列。

inline void Solve()
{
    /*write your code down here*/
    int n,k;
    In(n),In(k);
    vector<int>v;
    int cur = n;
    int tot = n;
    for(int i = 1;i <= k;i++)
    {
        if(v.size() == 0)
        {
            if(cur < 3)
            {
                puts("-1");
                return;
            }
            cur -= 3;
            v.push_back(tot--);
        }
        else{
            if(cur < 2)
            {
                puts("-1");
                return;
            }
            cur -= 2;
            v.push_back(tot--);
        }
    }
    int aaa = 0;
    for(int i = 1;i <= tot;i++)
    {
        cout<<i<<" ";
        if(aaa < v.size())
        {
            cout<<v[aaa++]<<" ";
        }
    }
    cout<<'\n';
}

B. AND Sequences
大意：给一个长度为n的数字，找到一个排列顺序，使得对于所有的1<i<n,满足
$a_1\&a_2\&\dots \&a_i=a_{i+1}\&a_{i+2}\&\dots \&a_n$
统计排列的数量
思路：与操作是只减不增操作，因此若想满足题意，那么要找到两个$a_1和a_n$，使得两端固定后，中间的值与他们相与不会发成改变即可。
$a_1和a_n$将整个数组与一遍就能找到唯一答案，然后进行全排列。

LL A(LL m,LL n)//排列数
{
    if(m < n || n < 0)return 0;
    return 1ll * f[m] * Finv[m - n] % kMod;
}
inline void Solve()
{
    /*write your code down here*/
    int n;
    In(n);
    vector<LL>v(n);
    for(auto &it:v)In(it);
    LL tmp = -1;
    for(auto it:v)
    {
        if(tmp == -1)
            tmp = it;
        else tmp &= it;
    }
    int tot = 0;
    for(auto it:v)if(it == tmp)tot++;
    if(tot <= 1){
        puts("0");
        return;
    }
    LL sum = A(tot,2)%kMod;
    for(int i = 1;i <= n-2;i++)
        sum = (sum*i)%kMod;
    cout<<sum%kMod<<'\n';
}

C. Add One
大意：将n的每一位数都加1，重复进行m次之后n有几位数。
思路：观察到一个数从第0位走十步之后会分裂成两个数，分别到第0位和第1位。那么dp[i]的含义就是数从第0位走i步之后会产生多少贡献。
同时，若有些数不在第0位，那把他们向左移到第0位，步数相应增加左移的位数即可。
状态转移方程$dp[i]=dp[i-10]+dp[i-9]$

LL dp[kMax];
int num[20];
inline void Solve()
{
    /*write your code down here*/
    LL n,m;
    In(n),In(m);
    LL sum = 0;
    memset(num,0,sizeof(num));
    while(n)
    {
        num[n%10]++;
        n /= 10;
    }
    for(int i = 0;i <= 9;i++)
    {
        sum = (sum + (num[i]*dp[m+i])%kMod)%kMod;
    }
    cout<<sum<<'\n';
}
void init()
{
    for(int i = 0;i <= 2e5+100;i++)
    {
        if(i <= 9)dp[i] = 1;
        else dp[i] = (dp[i-9] + dp[i-10])%kMod;
    }
}

D. GCD and MST

题意如图
思路：考虑贪心，每次取出权值最小的点向左右进行路径优化，直到取出来点的权值已经比默认的p大，那么就不可能继续优化了。
证明：因为gcd具有传递性，因此只能向连续的一段区间进行优化。若碰到了一个不可能优化的点（gcd != a[i])，那么这个区间就断开了，不能继续优化了。
剪枝：假如从点3向右优化了4,5,6，那么4,5是不可能再被优化了，因为他们已经被最小且能够到达的点优化过了。但是6仍有可能向外延伸，所以不能直接剪掉。

LL a[kMax];
pair<LL,LL>pa[kMax];
bool vis[kMax];
inline void Solve()
{
    /*write your code down here*/
    LL n,p;
    In(n),In(p);
    for(int i = 1;i <= n;i++)
        vis[i] = false;
    LL sum = (n-1)*p;
    for(int i = 1;i <= n;i++){
        In(a[i]);
        pa[i].first = a[i],pa[i].second = i;
    }
    sort(pa+1,pa+1+n);
    int cnt = 1;
    while(1)
    {
        if(cnt > n)break;
        LL val = pa[cnt].first,pos = pa[cnt].second;
        if(vis[pos]){cnt++;continue;}
        vis[pos] = true;
        if(val >= p)break;
        int tx = pos-1;
        int last = -1;
        for(int i = pos-1;i >= 1;i--)
        {
            if(vis[i])break;
            if(__gcd(a[i],val) == val)
            {
                vis[i] = true;
                last = i;
                sum -= p;
                sum += val;
            }
            else break;
        }
        if(last != -1)
        vis[last] = false;
        last = -1;
        for(int i = pos+1;i <= n;i++)
        {
            if(vis[i])break;
            if(__gcd(a[i],val) == val)
            {
                vis[i] = true;
                last = i;
                sum -= p;
                sum += val;
            }
            else break;
        }
        if(last != -1)
        vis[last] = false;
        cnt++;
    }
    cout<<sum<<'\n';
}

E. Cost Equilibrium
题意如链接
思路：每个数的最终状态是$sum/n$。由于每个数加减操作只能进行一次，因此一定是大于$sum/n$的数放在一边，小于的数放另外一边，可以是左边或右边。否则会有二义性，也就是代价不一定一样。
只有一个sourse或link的时候随便放，否则因为上述原因，答案由三部分组成：sourse的摆放，Link的摆放和其余数的摆放。注意这个答案要乘2，因为sourse可以在Link的左边，也可以在link的右边。

LL f[kMax],Finv[kMax],invv[kMax];
void init(){
    f[0] = Finv[0] = 1;
    invv[1] = 1;
    for(int i = 2;i < kMax;i++)
    {
        invv[i] = (kMod -  kMod / i) * invv[kMod % i] % kMod;
	}
    for (int i = 1; i < kMax;i++)
    {
        f[i] = f[i - 1] * i % kMod;
        Finv[i] = Finv[i - 1] * invv[i] % kMod;
    }
}
LL C(LL m,LL n)//组合数
{
    if(m < n || n < 0)return 0;
    return 1ll*f[m]*Finv[n]%kMod*Finv[m-n]%kMod;
}
inline void Solve()
{
    /*write your code down here*/
    LL n;
    LL sum = 0;
    In(n);
    map<LL,LL>sr,si;
    LL srr,sii;srr = sii = 0;
    vector<LL>v(n);
    for(auto &it:v){In(it);sum += it;}
    if(sum%n){puts("0");return;}
    for(auto it:v){
        if(it > sum/n){sr[it]++,srr++;}
        if(it < sum/n){si[it]++,sii++;}
    }
    if(srr == 0&&sii == 0){puts("1");return;}
    if(srr == 1||sii == 1)
    {
        LL res = f[n];
        for(auto it:sr)res = (res*__inv(f[it.second],kMod))%kMod;
        for(auto it:si)res = (res*__inv(f[it.second],kMod))%kMod;
        res = (res*__inv(f[n-srr-sii],kMod))%kMod;
        cout<<res<<'\n';
        return;
    }
    LL res = (1LL*2*f[srr]*f[sii])%kMod;
    for(auto it:sr)res = (res*__inv(f[it.second],kMod))%kMod;
    for(auto it:si)res = (res*__inv(f[it.second],kMod))%kMod;
    res = (res*C(n,n-(sii+srr)))%kMod;
    cout<<res<<'\n';
    return;
}