文远知行杯广东工业大学第十六届程序设计竞赛

A-区间最大值

定义 a[i] = n % i，给定L, R，求区间LR中，数组a的最大值。n <= 1e8.
做法：
如果n <= 1e6，可以建st表查询。注意到询问的次数才1e4，可以考虑下整除分块。本地打表分块，输出一个块内所有n % i的值，发现块内的左端点的n % i的值是最大的。
从L开始到R进行整除分块的操作，不断更新最大值就好了。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
void solve()
{
    int n, m;
    cin >> n >> m;
    while(m--)
    {
        int L, R;
        scanf("%lld%lld", &L, &R);
        int ma = 0;
        for (int l = L, r; l <= R; l = r + 1)
        {
            r = n / (n / l);
            if (L <= l && r <= R) ma = max(ma, n % l);
        }
        ma = max(ma, n % L);
        ma = max(ma, n % max ((n / (n / R + 1) + 1), L ) ) ;
        printf("%lld\n", ma);
    }
}
signed main()
{
    int tt;
    // cin >> tt;
    tt = 1;
    while (tt--) solve();
    return 0;
}

I-V字钩爪

每次在数组中取出两个数a[i]与a[i+k]，k是定值，取出后就没这个数了。求取出的数的和的最大值。
做法：
由于k是定值，则下标i + s * k 可以连成一条链，如果这条链上节点是偶数，那么可以两两一组；如果是奇数，那就必须舍弃某个节点，通过草稿纸画画可以发现（没发现还可以用dp求解），舍弃的节点一定是个奇数节点，所以求奇数节点中的最小值，舍弃他即可。
关于dp求解链上的最大值：
f[i][0]表示不选，f[i][1]表示选。

for (int j = 2; j <= cnt; j++) {
        f[j][0] = max(f[j - 1][0], f[j - 1][1]);
        f[j][1] = f[j - 1][0] + b[j] + b[j - 1];
 }

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
int a[N];
bool f[N];
void solve()
{
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        int cnt = 0;
        int mi = 1e18;
        if (f[i]) continue;
        for (int j = i, p = 1; j <= n; j += k, p++) {
            cnt++;
            ans += a[j];
            f[j] = 1;
            if (p & 1)
                mi = min(mi, a[j]);
        }
        if (cnt & 1)
            ans -= mi;
    }
    cout << ans;
}
signed main()
{
    int tt;
    // cin >> tt;
    tt = 1;
    while (tt--) solve();
    return 0;
}

F-一个很大的数

给定数x质因数分解的结果，求x的因数中有多少因子互质。这里认为（i，j）与（j，i）是不同的对。
做法：
不同质因子之间可能有各种各样的组合，都能形成互质的因子。可以想象一个n位的二进制数，为1的数位与为0的数位代表了因子之间的组合情况。1分成一组，0分成一组。
一个质因子p[i]有（c[i] + 1）种可能性去组合。
规定1这一组的质因子只有c[i]种可能性去组合，即忽略了指数为0的情况，因为指数为0，那就相当于没有选上这个数；为0这一组的质因子有（c[i] + 1）种可能性。可以举个例子，如果p[i]在1这一组，然后他指数选择0，其他的数选好乘完后得到（x，y）这么一对，因为p[i]指数是0，那么如果p[i]分配到0那一组去，仍然能得到（x，y）这么一对，就重复计数了。

============我是手动分界线 ===============

化繁为简，合法的一对是（x，y），对于一个质因子，他有三种选择，去左边的x，去右边的y，或者哪里都不去。那这不裸的dp计数了：

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
int p[N], c[N];
int f[N][3];
void solve()
{
    int n;
    cin >> n;
    f[0][0] = 1;
    for (int i = 1; i <= n; i++) {
        scanf("%lld%lld", &p[i], &c[i]);
        f[i][0] = (f[i - 1][0] + f[i - 1][1] + f[i - 1][2]) % mod;
        f[i][1] = (f[i - 1][0] + f[i - 1][1] + f[i - 1][2]) * c[i] % mod;
        f[i][2] = (f[i - 1][0] + f[i - 1][1] + f[i - 1][2]) * c[i] % mod;
    }
    cout << (f[n][0] + f[n][1] + f[n][2]) % mod << "\n";
}
signed main()
{
    int tt;
    cin >> tt;
    // tt = 1;
    while (tt--) solve();
    return 0;
}

E-爬塔

给定L,R，玩家可以从区间任意一个点开始出发。初始血量为1，如果遇见1，血量+1,；遇见0，血量-1。玩家要求结束的时候血量也为1，求在区间LR内最多能走几步。题目保证不管从哪个点开始出发，最多走的步数不会超过10.
做法：枚举每个点开始最多走10步，记录走j步是否能结束时血量为1。对于查询，st表就可以做到。

#include <bits/stdc++.h>
// #define int long long
using namespace std;
const int N = 100000 + 5, mod = 1e9 + 7;
char s[N];
int ma[N][11][22];
int f[N][11];
int lo[N];
int n;
int ws(int n)
{
    int ret = 0;
    while(n){
        ret++;
        n >>= 1;
    }
    return ret - 1;
}
void init()
{
    for (int i = 1; i <= n; i++) {
        for (int p = 1; p <= 10; p++) ma[i][p][0] = f[i][p];
        lo[i] = ws(i);
    }
    int t = lo[n] + 1;
    for (int j = 1; j < t; j++){
        for (int p = 1; p <= 10; p++)
        for (int i = 1; i <= n - (1 << j) + 1; i++) {
            ma[i][p][j] = max(ma[i][p][j - 1], ma[i + (1 << (j - 1))][p][j - 1]);
        }
    }
}
int que(int l, int r, int p)
{
    int k = lo[r - l + 1];
    return max(ma[l][p][k], ma[r - (1 << k) + 1][p][k]);
}
void solve()
{
    cin >> n;
    scanf("%s", s + 1);
    for (int i = 1; i <= n; i++) {
        int sum = 1;
        for (int j = 1; j <= 10; j++) {
            if (i + j - 1 > n) break;
            if (s[i + j - 1] == '1') sum++;
            else sum--;
            if (sum == 0) break;
            if (sum == 1) f[i][j] = 1;
        }
    }
    // cout << f[1][6] << "\n";
    init();
    int q;
    cin >> q;
    while(q--)
    {
        int l, r;
        scanf("%d%d", &l, &r);
        int ans = 0;
        if (r - 10 + 1 >= l) {
            for (int i = 1; i <= 10; i++) {
                int ret = que(l, r - 10 + 1, i);
                if (ret) ans = max(ans, i);
            }
        }
        for (int i = max(l, r - 10 + 1); i <= r; i++) {
            int len = r - i + 1;
            // printf("len = %d\n", len);
            for (int j = 1; j <= len; j++) {
                if (f[i][j]) ans = max(ans, j);
            }
        }
        printf("%d\n", ans);
    }
}
signed main()
{
    int tt;
    // cin >> tt;
    tt = 1;
    while (tt--) solve();
    return 0;
}

H-变换01串

有两个操作：前缀取反，后缀取反。有q次询问，opt = 1，回答区间LR的01串最小清零操作次数；opt = 2，将区间LR取反。
做法：草稿纸画一画，发现一个01串清零最小操作次数是连续的0和连续的1的块数-1。这个信息的修改和查询都可以用线段树来实现，所以直接上线段树。
对于两段区间01块数的合并，如果左区间的右端点与右区间的左端点相同，那么合并块数 = 左块数+右块数-1，否则合并块数 = 左块数+右块数。
查询：与合并操作类似。
修改：重点是懒标记，add ^= 1即可，如果碰到add = 1，那就懒标记下传，左右端点取反，区间的块数是不受影响的。

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e6 + 5, mod = 1e9 + 7;
char s[N];
struct node{
    int l, r;
    int left, right, val;//val为总段数
    int add;
    #define l(x) tree[x].l
    #define r(x) tree[x].r
} tree[N * 4];
void build(int p, int l, int r)
{
    tree[p].l = l, tree[p].r = r;
    if (l >= r) {
        tree[p].val = 1;
        if (s[l] == '1')
            tree[p].left = tree[p].right =  1;
        else
            tree[p].left = tree[p].right =  0;
        return;
    }
    int mid = (l + r) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    build(chl, l, mid);
    build(chr, mid + 1, r);


    tree[p].left = tree[chl].left;
    tree[p].right = tree[chr].right;
    if (tree[chl].right == tree[chr].left)
        tree[p].val = tree[chl].val + tree[chr].val - 1;
    else 
        tree[p].val = tree[chl].val + tree[chr].val;
}
void pushdown(int p)
{
    if (tree[p].add) {
        int chl = p * 2, chr = p * 2 + 1;
        tree[chl].add ^= 1;
        tree[chr].add ^= 1;
        // tree[chl].val += tree[p].add * (r(chl) - l(chl) + 1);
        // tree[chr].val += tree[p].add * (r(chr) - l(chr) + 1);
        tree[chl].left ^= 1, tree[chl].right ^= 1;
        tree[chr].left ^= 1, tree[chr].right ^= 1;
        tree[p].add = 0;
    }
}
void up(int p, int l, int r, int x)
{   
    if (l <= l(p) && r >= r(p)) {
        // tree[p].val += x * (r(p) - l(p) + 1);
        tree[p].left ^= 1;
        tree[p].right ^= 1;
        tree[p].add ^= 1;
        return;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    if (l <= mid) up(chl, l, r, x);
    if (mid < r) up(chr, l, r, x);


    tree[p].left = tree[chl].left;
    tree[p].right = tree[chr].right;
    if (tree[chl].right == tree[chr].left)
        tree[p].val = tree[chl].val + tree[chr].val - 1;
    else 
        tree[p].val = tree[chl].val + tree[chr].val;
}
int que(int p, int l, int r)
{
    if (l <= l(p) && r >= r(p)) {
        return tree[p].val;
    }
    pushdown(p);
    int mid = (l(p) + r(p)) >> 1;
    int chl = p * 2, chr = p * 2 + 1;
    int ret = 0;
    int ret1 = 0, ret2 = 0;
    if (l <= mid) {
        ret1 = que(chl, l, r);
        ret = ret1;
    }
    if (mid < r) {
        ret2 = que(chr, l, r);
        if (ret1 != 0) {

            if (tree[chl].right == tree[chr].left)
                ret += ret2 - 1;
            else
                ret += ret2;
        }
        else
            ret = ret2;
    }
    return ret;
}
void solve()
{
    int n, m;
    cin >> n >> m;
    scanf("%s", s + 1);
    build(1, 1, n);
    while(m--)
    {
        int op, l, r;
        scanf("%lld%lld%lld", &op, &l, &r);
        if (op == 1) {
            printf("%lld\n", que(1, l, r) - 1);
        }
        else{
            up(1, l, r, 1);
        }
    }
}
signed main()
{
    int tt;
    // cin >> tt;
    tt = 1;
    while (tt--) solve();
    return 0;
}