【团队赛组】2021-2022年度第三届全国大学生算法设计与编程挑战赛（赛氪）（秋季赛）【D分配颜色】【I排队队】

D分配颜色

分析:
首先，很容易看出来，对某一行或列操作奇数次是有效的，操作偶数次妹用，故我们可以枚举被操作了奇数次的行数i和被操作了偶数次的列数j，i，j，n，m，t之间有着一定的约束关系，也很容易看出来是i*(m-j) + j*(n-i) == t，由此我们可以枚举i和j，之后的问题就是对于每一对合法的i，j他们对答案的贡献是多少。
我们先需要确定这i行是哪i行，所以自然需要c(n, i)， 对着i行我们都认为是进行了1次操作，那么还剩p-i次操作，这时我们需要判断p-i的奇偶性，因为如果p-i是奇数，那么这p-i次操作结束之后，进行了奇数次操作的行数一定不是i了，那么怎么办呢，为了防止这个行数i发生变化，很简单我们把剩下的p-i次操作两次看成一次即可，那怎么分配呢？我们设第i行在这之后还会被操作xi次，那么满足x1 + x2 + x3 + ... + xn = (p - i) / 2，同时xi满足大于等于0，那么对这个式子两边都加一个n，我们可以理解为x1 + x2 + ... + xn = n + (p-i)/2，xi满足大于等于1,那接下来的操作就相当于一个隔板法分配了，直接c(n + (p-i)/2 - 1, n-1)即可。
比赛的时候，这部分当n^((p-i)/2)算wa到死惹，就还有(p-i)/2次操作，每次操作可以选择n行中的任意一行嘛，但其实是不对的，每次操作是相同的，这样的话其实是认为每次操作不同了，举个例子，还有3次操作，假设有一种是操作第1，1，2行，另一种是操作2，1，1行，这两种是操作其实是相同的，而我们认为它是不同的。
AC代码：

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;
typedef long long ll;
const int maxn=4000;
ll C[maxn][maxn];

const ll mod=555555555;
void init()
{
    for(int i=0;i<maxn;i++)
    {
        for(int j=0;j<=i;j++)
        {
            if(j==0)
                C[i][j]=1;
            else
                C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
        }
    }
}

int n, m, p, q, t;
ll ans, ans1, ans2;
ll sum;

int main()
{
    init();
    sum = 0;
    scanf("%d%d%d%d%d", &n, &m, &p, &q, &t);
    //cout << n << ' ' << m << ' ' << p << ' ' << q << ' ' << t << '\n';
    for(int i = 1; i <= min(p, n); ++i)
    {
        for(int j = 1; j <= min(q, m); ++j)
        {
            if(i * (m - j) + j * (n - i) == t)
            {
                //cout << i << ' ' << j << '\n';
                if((p - i) % 2 == 0 && (q - j) % 2 == 0)
                {
                    //cout << i << ' ' << j << ' ' << ans1 << ' ' << ans2 << '\n';
                    ans1 = (C[n][i] * C[(p - i)/2 + n - 1][n - 1]) % mod;
                    ans2 = (C[m][j] * C[(q - j)/2 + m - 1][m - 1]) % mod;
                    ans = (ans1 * ans2) % mod;
                    sum = (sum + ans) % mod;
                }
            }
        }
    }
    printf("%lld\n", sum);
    return 0;
}

I排队队

分析：

是一个单峰函数，所以对于每一种如果我们都取到它的峰值的话，那就是最大的呗。但是问题在于有的种类取不到它的峰值，但是即便有这种情况，那也最多只有一种。比如某一种取峰值时对应mx端，而除去这一种剩下的所有种类取峰值时段数和为sum，sum小于mx-1，那么是不符合的。这是一种特殊情况，需要特别处理一下，处理的办法是比较让剩下的加一段对答案的贡献为正还是为负，为正则加，为负直接break（因为是排过序的这个为负，后面的更负
具体操作用到vector和优先队列，实现起来有点麻烦的）
然后那个峰值对应的段数其实就是每种有多少个q-p>=0的学生
还有就是每种都最少是一段的
AC代码：

#include <bits/stdc++.h>

using namespace std;

int n;
struct node
{
    int a, p, q, cx;//性格，p，q，q - p
    bool operator < (const node &b) const
    {
        return cx > b.cx;
    }
} now;
vector<node> v[500050];//存每种的学生按照cx排序后的
priority_queue<node> q;//除了段数最多的那个，把剩下的所有的学生都放进来（只在特殊情况下会用到）
int kk[500050];//记录每种的峰值对应的段数
int sum, mx, mx_id, ans;//段数和，最大的段数，最大的编号
bool boo[500050];//是否存在第i种学生
int cnt;//一共出现的多少种学生

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)//把每一种放到对应的vector中
    {
        scanf("%d%d%d", &now.a, &now.p, &now.q);
        if(!boo[now.a])
        {
            boo[now.a] = true;
            ++cnt;
        }
        now.cx = now.q - now.p;
        ans += now.p;
        v[now.a].push_back(now);
    }
    for(int i = 1; i <= n; ++i)//排序，并算出每种峰值对应的段数
    {
        if(!boo[i]) continue;
        sort(v[i].begin(), v[i].end());//按照q-p从大到小排序，重载运算符了
        for(int j = 0; j < v[i].size(); ++j)
        {
            if(v[i][j].cx < 0)
            {
                kk[i] = max(1, j);
                sum += kk[i];
                if(mx < kk[i])
                {
                    mx = kk[i];
                    mx_id = i;
                }
                break;
            }
        }
        if(!kk[i])
        {
            kk[i] = v[i].size();
            sum += kk[i];
            if(mx < kk[i])
            {
                mx = kk[i];
                mx_id = i;
            }
        }
    }
    if(mx - 1 >= sum - mx)//是否是特殊情况
    {
        for(int i = 1; i <= n; ++i)//每种最少一段的，加上，剩下的放到优先队列里    {
            if(!boo[i]) continue;
            if(i != mx_id)
            {
                ans += v[i][0].cx;
                for(int j = 1; j < v[i].size(); ++j) q.push(v[i][j]);
            }
        }
        for(int i = 0; i < cnt; ++i) ans += v[mx_id][i].cx;
        for(int i = cnt; i < mx; ++i)//开始比较剩下的再加一段是都对答案有正的贡献
        {
            if(q.top().cx >= 0)
            {
                ans += q.top().cx;
                q.pop();
                ans += v[mx_id][i].cx;
            }
            else if(q.top().cx + v[mx_id][i].cx > 0)
            {
                ans += (q.top().cx + v[mx_id][i].cx);
                q.pop();
            }
            else break;
        }
    }
    else
    {
        for(int i = 1; i <= n; ++i)
        {
            if(!boo[i]) continue;
            for(int j = 0; j < kk[i]; ++j)
            {
                ans += v[i][j].cx;
            }
        }
    }
    printf("%d\n", ans);
    //cout << cnt << ' ' << mx << ' ' << mx_id << '\n';
    return 0;
}