两场div3 逆向思维

927div3

C

给你一个数列，和一个只含LR的操作序列s，若当前是L移除左端一个元素，若当前是R移除右端一个元素，问你每次所有元素乘积对p（p非质数）的模数。
直接进行操作肯定会爆long long 想到每次移除减去因数，这样ClogCn的复杂度 超时
可以从最后一个被移除的元素入手，每次加一个，然后乘上模完的积，倒序输出即可

F

给你m只猫，每个猫可以在[li,ri]的时间内喂食，但是每只猫只能被喂一次。
求最多能喂几只猫。
也就是说在一个有限数轴上选几个点，保证每个线段至多有一个点被选中，最多可以有几个线段被选中。
很显然oc表示一个点被多少个点覆盖，lm表示一个点若被覆盖，其最左端可以到哪
dp[i]=oc[i]+max(dp[j])(j from 0 to lm[i]-1)
oc[i]用差分数组维护，lm[i]用线段树维护。

#include <bits/stdc++.h>
using namespace std;
typedef struct dot
{
    int l, r;
} d;
#define lc p << 1
#define rc p << 1 | 1
const int maxn = 1e6 + 1;

int leftmost[maxn * 4];
void build(int p, int l, int r)
{
    leftmost[p] = maxn;
    if (l == r)
        return;
    else
    {
        int mid = (l + r) >> 1;
        build(lc, l, mid);
        build(rc, mid + 1, r);
    }
}
void pushup(int p)
{
    leftmost[p] = min(leftmost[lc], leftmost[rc]);
}
void update(int p, int l, int r, int ql, int qr, int val)
{
    if (ql > r || qr < l)
    {
        return;
    }
    if (l >= ql && r <= qr)
    {
        leftmost[p] = min(leftmost[p], val);
        return;
    }
    else
    {
        int mid = (l + r) >> 1;
        update(lc, l, mid, ql, qr, val);
        update(rc, mid + 1, r, ql, qr, val);
        return;
    }
}
int query(int p, int l, int r, int pos)
{
    if (l == r)
        return leftmost[p];
    else
    {
        int mid = (l + r) >> 1;
        int res = leftmost[p];
        if (pos <= mid)
        {
            res = min(res, query(lc, l, mid, pos));
        }
        else
        {
            res = min(res, query(rc, mid + 1, r, pos));
        }
        return res;
    }
}
int main()
{
    int tt;
    cin >> tt;
    while (tt--)
    {
        int n, m;
        cin >> n >> m;
        vector<int> dp(n + 1, 0);
        vector<int> oc(n + 1, 0);
        build(1, 1, n);
        for (int i = 0; i < m; i++)
        {
            int l, r;
            cin >> l >> r;
            update(1, 1, n, l, r, l);
            oc[l]++;
            if (r + 1 <= n)
                oc[r + 1]--;
        }
        vector<int> lm(n + 1, 0);
        for (int i = 1; i <= n; i++)
        {
            lm[i] = query(1, 1, n, i);

            oc[i] = oc[i - 1] + oc[i];
        }
        
        cout << endl;
        int maxans = 0;
        vector<int> tmpans(n + 1, 0);
        for (int i = 1; i <= n; i++)
        {
            if (lm[i] == maxn)
            {
                tmpans[i] = max(tmpans[i - 1], dp[i]);
                maxans = max(maxans, dp[i]);
            }
            else
            {
                dp[i] = oc[i] + tmpans[lm[i] - 1];
                tmpans[i] = max(tmpans[i - 1], dp[i]);
                maxans = max(maxans, dp[i]);
            }
        }
        cout << maxans << endl;
    }
}

916div3

E

给你两个弹珠序列，每次a和b可以选择一个位置，然后自己+a[i]-1或-b[i]+1。a要最大化分数，b要最小化分数。问你最后分数是多少
可以这样想 全部b取 分数就是S=sigma(-(bi-1))
然后a去取，每一次取的时候分数加上ai+bi-2，最大化S‘，b就要阻止这种操作
所以对ai+bi排序即可