A.Least Product(思维)

题意：

给出一个数组$a_1,a_2,...,a_n$，你可以进行若干次以下操作：

• 选择数组中的一个元素$a_i$，将这个数字修改为$0\sim a_i$之间的任意数字。

问，最少需要多少次操作可以使得$\prod _{i=1}^n{a}_i$的结果最小，并输出对应的操作。

分析：

可以将问题分成两种情况：

• 存在$a_i=0$或负数的出现次数为奇数，此时无论进行任何操作都无法使结果变得更小，输出0

• 其他情况，由于数字只能被修改到$0\sim a_i$之间，那么正负数是无法互相转换的，因此，当结果为正数时，任选一个$a_i$，将其修改为$0$，就能获得最小的结果

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;


void solve() {
    int n;
    cin >> n;
    int zero = 0, sign = 0;
    for (int i = 1; i <= n; i++) {
        int a;
        cin >> a;
        if (a == 0) {
            zero = 1;
        } else if (a < 0) {
            sign++;
        }
    }
    if (zero || sign % 2 == 1) cout << 0 << endl;
    else {
        cout << 1 << endl;
        cout << "1 0" << endl;
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.Erase First or Second Letter(思维)

题意：

给出一个长度为$n$的字符串$s$，你可以进行若干次以下操作：

• 移除第一个字符

• 移除第二个字符

问：经过若干次操作后，可以获得多少种不同的非空字符串？

分析：

将字符串划分为前后两部分，枚举两部分的分界点，每次枚举完分界点后，将后半部分视为不进行修改的部分，仅会对前半部分进行操作，那么由于每次枚举的后半部分均不同，为了保证方案的独立性，前半部分仅保留一个字符，那么此时的方案数就是前半部分中包含的不同字母的数量。

使用计数数组或set动态记录不同字符数量，每次枚举分界点后更新前半部分字符种类并记录到答案中即可。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

int vis[30];

void solve() {
    memset(vis, 0, sizeof (vis));
    int n;
    string s;
    cin >> n >> s;
    int cnt = 0, ans = 0;
    for (int i = 0; i < n; i++) {
        vis[s[i] - 'a']++;
        if (vis[s[i] - 'a'] == 1) cnt++;
        ans += cnt;
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Watering an Array(枚举)

题意：

给出一个长度为$n$的数组$a$,你将在接下来的$d$天里每天选择执行以下两个操作之一：

• 给所有的$a_1,a_2,...,a_{b_i}$加上一，其中$b_i$为题目给出的第$i$天的操作数。

• 数组$a$中$a_i=i$的数量就是你本轮获得的得分，然后将$a$数组所有元素修改为$0$

问：最多可以获得多少得分？

Tips:由于天数较多，因此$b$数组采用$b=[v_1,v_2,...,v_k,v_1,v_2,...,v_k,...]$的形式给出。

分析：

如果数组$a$开始全部为$0$，那么最优策略就是操作$1,2$轮流进行，可以获得$\lfloor \frac{d}{2}\rfloor$点得分（注意：开始时若$a_1\ge 1$，则需要使用一次操作$2$将$a_1$修改为$0$，此时得分为$(\lfloor \frac{d-1}{2}\rfloor +\text{开始时数组元素可以产生的得分}$）。

而由于初始的数组是包含初始数字的，且长度为$n$的数组最多可以产生$n$点得分，因此，只需要在$2\times n-1$的操作次数内均有可能超过循环操作获取的$n$点固定得分。

枚举第一次进行操作$2$前会进行多少次操作$1$，每次遍历数组统计得分，剩余的操作次数使用最优策略进行。记录过程中最大的得分即可。

坑点

既然获取的长度为$n$的数字最高可以产生$n$点得分，那么只枚举$n$次操作是否就够了？

反例：

原数组为$2,1,2,...,n-1$，给出的$b$数组为$[1,1,...,1,n]$，其中$b_i=n$前有$(2\times n)-4$个1，此时$d=2\times n$。

可以发现，枚举$0\sim n$次操作$1$，均无法产生额外得分，此时获得的最高总分为$\lfloor \frac{d-1}{2}\rfloor =n-1$，而依次使用$(2\times n)-3$次操作$1$，再进行操作$2$，可以获得$n-1$点得分，此时还剩下两次操作，还可以继续一次最优策略，最后得分为$n$。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL a[MAXN], b[MAXN];

void solve() {
    LL n, k, d;
    cin >> n >> k >> d;
    LL ans = 0;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 0; i < k; i++) cin >> b[i];
    for (int i = 0; i <= 2 * n && i < d; i++) {
        LL cnt = 0;
        for (int j = 1; j <= n; j++) if (a[j] == j) cnt++;
        ans = max(ans, cnt + (d - i - 1) / 2);
        for (int j = 1; j <= b[i % k]; j++) {
            if (a[j] == j) cnt--;
            a[j]++;
            if (a[j] == j) cnt++;
        }
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.Yet Another Inversions Problem(树状数组+逆序对)

题意：

给定一个由$1$到$2n-1$的奇数组成的排列$p_0,p_1,\dots ,p_{n-1}$和一个由$0$到$k-1$的整数组成的排列$q_0,q_1,\dots ,q_{k-1}$。定义长度为$nk$的数组$a_0,a_1,\dots ,a_{nk-1}$如下：对于所有$0\le i<n$和所有$0\le j<k$，有$a_{i\cdot k+j}=p_i\cdot 2^{q_j}$。例如，如果$p=[3,5,1]$且$q=[0,1]$，那么$a=[3,6,5,10,1,2]$。所有数组都是从零开始索引的。注意，数组$a$中每个元素是唯一确定的。计算数组$a$中逆序对$(i,j)(0\le i<j<nk)$的数量，结果对$998244353$取模。

分析：

对于同一个$a_i$，逆序对个数仅取决于$q$的逆序对个数。

考虑用树状数组求逆序对个数的过程。对该过程稍作修改，可以得到下面的算法：
对于$a_i$，大小在$(a_i,2a_i)$之间的数而言，$a_i\cdot 2^{p_j}$与这些数能够形成的逆序对为$(a_i\cdot 2^{p_j},a_x\cdot 2^{p_j-1})$,$(a_i\cdot 2^{p_j},a_x\cdot 2^{p_j-2})$……$(a_i\cdot 2^{p_j},a_x\cdot 2^0)$，共有$p_j$个，$a_i$与这些数所能形成的逆序对数量为$\sum _{i=0}^k{p}_i=(0+k-1)\times \frac{k}{2}$。同理对大小在$(2a_i,4a_i)$的数而言，$a_i$与这些数所能形成的逆序对数量为$\sum _{i=0}^k{p}_i=(0+k-2)\times \frac{k-1}{2}$，如此不断向上倍增求答案，直到上限。

相反的，对于大小在$(\frac{a_i}{2},a_i)$之间的数，可以按相同的方式考虑，如此不断向下除二求答案，直到下限。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod = 998244353;
const LL N = 5e5;

struct BIT {
    LL n;
    vector<LL> tr;

    BIT(LL n) : n(n), tr(n + 1, 0) {
    }

    LL lowbit(LL x) {
        return x & -x;
    }

    void modify(LL x, LL m) {
        for (LL i = x; i <= n; i += lowbit(i)) {
            tr[i] += m;
        }
    }

    void modify(LL l, LL r, LL m) {
        modify(l, m);
        modify(r + 1, -m);
    }

    LL query(LL x) {
        LL res = 0;
        for (LL i = x; i; i -= lowbit(i))
            res += tr[i];
        return res;
    }

    LL query(LL x, LL y) {
        return query(y) - query(x);
    }
};

LL tmp[N];

LL merge_sort(LL q[], LL l, LL r) {
    if (l >= r)
        return 0;

    LL mid = (l + r) >> 1;
    LL res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);
    LL i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r) {
        if (q[i] <= q[j]) tmp[k++] = q[i++];
        else {
            res += mid - i + 1;
            tmp[k++] = q[j++];
        }
    }

    while (i <= mid)
        tmp[k++] = q[i++];
    while (j <= r)
        tmp[k++] = q[j++];

    for (LL i = l, j = 0; i <= r; i++, j++)
        q[i] = tmp[j];

    return res;
}

void solve() {
    LL n, k;
    cin >> n >> k;
    BIT num(4 * n + 5), sum(k + 5);
    LL a[n], b[k];
    for (LL i = 0; i < n; i++) {
        cin >> a[i];
        num.modify(a[i], 1);
    }
    for (LL i = 0; i < k; i++) {
        cin >> b[i];
    }
    LL ans = merge_sort(b, 0, k - 1);
    ans *= n;
    ans %= mod;
    for (LL i = 0; i < n; i++) {
        LL x = a[i];
        LL cnt = 1;
        while (x < 2 * n) {
            LL t = x * 2;
            LL nn = num.query(x, t);
            if (nn == 0) {
                x = t;
                cnt++;
                continue;
            }
            LL end = max(1LL * 0, k - cnt);
            LL ns = (1 + end) * end / 2;
            ans += ns * nn;
            ans %= mod;
            x = t;
            cnt++;
        }
        x = a[i];
        cnt = 1;
        while (1) {
            if (x == 1)
                break;
            LL t = (x + 1) / 2;
            LL nn = num.query(t - 1, x - 1);
            if (nn == 0) {
                x = t;
                cnt++;
                continue;
            }
            LL st = min(k, cnt);
            LL cntt = k - st + 1;
            LL res = k - cntt;
            LL ns = k * res + (st + k) * cntt / 2;
            ans += nn * ns;
            ans %= mod;;
            x = t;
            cnt++;
        }
        num.modify(a[i], -1);
    }
    cout << ans << endl;
}

int main() {
    LL t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

E.Construct Matrix(构造)

题意：

给定一个偶数$n$和一个整数$k$。构造一个大小为$n\times n$的矩阵，由数字$0$和$1$组成，使其满足以下条件，或者输出不可能

所需满足的条件:

• 矩阵中所有数的和正好是$k$;
• 第$i$行中所有数字按位异或对每个$i$都是相同的;
• 第$j$列中所有数字按位异或对每个$j$都是相同的。

分析：

首先，因为所有列的$XOR$的$XOR$显然为$0$（因为$n$为偶），因此所有数的$XOR$也为$0$，故$k$不可能为奇数。

如果$k$是$4$的倍数，这种情况是比较简单的。易知一个$2x2$的全$1$矩阵可以在不破坏原矩阵的情况下被添加进去，那么不断添加这样的矩阵就可以了。

如果$k\equiv 2(mod4)$，不妨假设$k\le \frac{n^2}{2}$，如果不满足，令$k^{{}^{\prime }}=n^2-k$，构造完再全部取反即可。当$k=2$时，显然不存在满足条件的矩阵。当$k=6$时，可以构造出一个$3\times 3$的矩阵，如下：

1 1 0
1 0 1
0 1 1

当$k\ge 6$时，考虑将上面这个矩阵放在前$4$行$4$列的位置，然后其他位置再通过添加$2\times 2$的全$1$矩阵，即可构造满足要求的矩阵。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 1005;
int T, n, k;
bool mat[N][N];
int draw_first2block = 0;

void reset() {
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            mat[i][j] = 0;
    draw_first2block = 0;
}

void draw() {
    mat[1][1] = mat[1][2] = mat[2][1] = mat[2][3] = mat[3][2] = mat[3][3] = 1;
    draw_first2block = 1;
}

void solve(int cnt) {
    int i = 1, j = 0;
    while (cnt) {
        if (++j > n / 2) {
            ++i;
            j = 1;
        }
        if (i <= 2 && j <= 2 && draw_first2block)
            continue;
        --cnt;
        mat[i * 2][j * 2] = mat[i * 2 - 1][j * 2] = mat[i * 2][j * 2 - 1] = mat[i * 2 - 1][j * 2 - 1] = 1;
    }
}

void reverse() {
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            mat[i][j] ^= 1;
}

int main() {
    cin >> T;
    while (T--) {
        cin >> n >> k;
        if (n == 2 && k == 2) {
            cout << "Yes\n0 1\n1 0\n";
            continue;
        }
        bool check = false;
        if (k % 4 == 0) {
            check = true;
            reset();
            solve(k / 4);
        } else {
            bool reversed = false;
            if (k * 2 > n * n) {
                reversed = true;
                k = n * n - k;
            }
            if (k % 4 == 2 && k != 2) {
                check = true;
                reset();
                draw();
                solve((k - 6) / 4);
                if (reversed)
                    reverse();
            }
        }
        if (check) {
            cout << "Yes\n";
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= n; ++j)
                    cout << (mat[i][j] ? '1' : '0') << " \n"[j == n];
            }
        } else cout << "No\n";
    }
    return 0;
}

F.Construct Tree(bitset)

题意：

给定一个整数数组$l_1,l_2,\dots ,l_n$和一个整数$d$。是否能构造一棵满足以下三个条件的树:

• 该树包含$n+1$个节点。
• 第$i$条边的长度等于$l_i$。
• 该树的（加权）直径等于$d$。

分析：

考虑形式化地描述这个问题。先把$l$排序。然后相当于是否存在一个$1,2,\dots ,n$的子集S，使得$\sum _{i\in S}{l}_i=d$，$\exists T\subseteq S$，$max(l_i)\le min(\sum _{i\in T}{l}_i,\sum _{i\in S\wedge i\notin T}{l}_i)$。

注意到若$n-1\in S\wedge n\in S$，则第二个条件一定满足，让$n-1\in T$且$n\notin T$即可。所以如果$l_1,l_2\dots l_n-2$能凑出来$d-a_{n-1}-a_n$就可行。

然后依次讨论$max(i)=n-1$（$i\notin S$）或$n$的情况:

• 若$max(i)=n-1$（$i\notin S$），那么$n\in S$。若前$n-2$个元素能凑出来和为$x$和$d-x-a_n$的两个不相交集合，且$a_{n-1}\le min(x+a_n,d-x-a_n)$$就可行。
• 若$max(i)=n$（$i\notin S$），那么若前$n-1$个元素能凑出来和为$x$和$d-x$的两个不相交集合，且$a_n\le min(x,d-x)$就可行。

使用$bitset$进行优化。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int maxn = 2005;

int n, m, a[maxn];
bitset<maxn> f[maxn], g;

void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    sort(a + 1, a + n + 1);
    for (int i = 0; i <= m; ++i) {
        f[i].reset();
    }
    g.reset();
    f[0].set(0);
    g.set(0);
    for (int i = 1; i < n; ++i) {
        if (i == n - 1) {
            if (a[n - 1] + a[n] <= m && g.test(m - a[n - 1] - a[n])) {
                cout << "Yes" << endl;
                return;
            }
            for (int j = 0; j <= m - a[n]; ++j) {
                if (a[i] <= min(j + a[n], m - a[n] - j) && f[j].test(m - j - a[n])) {
                    cout << "Yes" << endl;
                    return;
                }
            }
        }
        for (int j = m; ~j; --j) {
            f[j] |= (f[j] << a[i]);
            if (j >= a[i]) {
                f[j] |= f[j - a[i]];
            }
        }
        g |= (g << a[i]);
    }
    for (int i = a[n]; i <= m - a[n]; ++i) {
        if (f[i].test(m - i)) {
            cout << "Yes" << endl;
            return;
        }
    }
    cout << "No" << endl;
}

int main() {
    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}

学习交流

以下为学习交流QQ群，群号： 546235402，每周题解完成后都会转发到群中，大家可以加群一起交流做题思路，分享做题技巧，欢迎大家的加入。