M. Stone Games(主席树) ICPC 昆明站

题目链接: Stone Games

大致题意

有n堆石子, 从1~n标号, 每堆石子有ai个.

每次询问给出一个区间 [l, r], 表示你可以选择的石子堆编号. 每次你可以选择一个子集. 子集内的石子总数加和即为所得.

问: 不能凑出的最小正整数是多少.

解题思路

大概分析

个人感觉, 这个题的难点主要还是在思维方面, 代码难度不高.

题目中的询问相当于是MEX询问, MEX是对于自然数集的询问, 而当我们一堆石子都不选的时候, 相当于就凑出了0, 即: 0是总能被满足的.

那么我们其实很容易发现, 如果对于当前询问区间,如果不存在1, 则答案一定是1.

对于存在1的情况, 我们的思路应当是由已知向未知逐步扩展. 假设区间存在k个1, 那么[0, k]的所有数字是目前的已知可被满足集合. 然后我们再对于区间去查询[0, k + 1]的所有数值之和.
至于为什么需要询问到k + 1, 因为k是当前已知集合中可以凑出的最大元素, 而k + 1和k之间是连续的, 因此可以询问到k + 1.

这样当我们会得到一个sum, 此时我们可以将已知集合右边界更新为sum. 即[0, sum]之间的所有数字我们都可以凑出.
至于为什么我们可以扩展到sum, 因为本身[0, k]我们可以扩展到, 那么对于新增加的数值, 我们都可以保证用凑出[0, k]的方式凑出[k + 1, sum], 只需要每次选择适当个k + 1即可.

至于复杂度, 最坏的情况就是每次我们都可以更新右边界的情况, 相当于序列从1~n排列, 这样每次更新大概可以扩大一倍. 也只是log级别.

具体实现

我们发现, 我们需要维护区间上的部分权值和, 可以采用静态主席树来实现. 直接在值域上动态开点即可.
这样建树的空间复杂度为O(Nlog值域), 每次查询并不会产生新的节点.

我们其实可以稍微做一点优化, 把数据离散化一下, 这样值遇可以缩小为N. 但是本题空间和时间都给的很高, 不离散化也是可以通过的.

AC代码

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E6 + 10, INF = 0x3f3f3f3f;
int w[N];
vector<int> v; //离散化数组
int find(int x) { return lower_bound(v.begin(), v.end(), x) - v.begin(); }

struct node {
    int l, r;
    ll sum;
} t[N * 20 + N]; //这应该是空间下界了, 因为根节点需要占据一层空间, 实际下标为(NlogN + N)
int root[N], ind;
int build(int a, int c, int tl, int tr, int p) {
    int x = ++ind;
    t[x] = t[p];
    t[x].sum += c;
    if (tl == tr) return x;
    
    int mid = tl + tr >> 1;
    if (a <= mid) t[x].l = build(a, c, tl, mid, t[p].l);
    else t[x].r = build(a, c, mid + 1, tr, t[p].r);
    return x;
}

ll ask(int a, int tl, int tr, int p, int op) {
    if (a >= tr) return t[op].sum - t[p].sum;
    int mid = tl + tr >> 1;
    ll res = ask(a, tl, mid, t[p].l, t[op].l);
    if (a > mid) res += ask(a, mid + 1, tr, t[p].r, t[op].r);
    return res;
}

int main()
{
    /* vector初始化说明: 由于我习惯把值遇离散化下标从1开始, 因此有-INF, 而1这个数值是否存在为我们扩展已知集合的第一步, 因此也推入. INF可推可不推, 看个人理解. */
    v.push_back(-INF), v.push_back(1), v.push_back(INF); 
    
    int n, m; cin >> n >> m;
    rep(i, n) scanf("%d", &w[i]), v.push_back(w[i]);
    sort(v.begin(), v.end()); v.erase(unique(v.begin(), v.end()), v.end());//去重离散化
    int len = v.size() - 1; //-INF不算, 因此实际区间为v.size() - 1;
    
    rep(i, n) root[i] = build(find(w[i]), w[i], 1, len, root[i - 1]); //建树(修改)
    
    ll res = 0; //记录答案
    rep(i, m) {
        int l, r; scanf("%d %d", &l, &r);
        
        //auto temp = minmax((l + res) % n + 1, (r + res) % n + 1);
        //l = temp.first, r = temp.second; 这样写就会错! 我也不知道为什么. 求大佬告知QAQ!
        l = (l + res) % n + 1, r = (r + res) % n + 1;
        if (l > r) swap(l, r);
        
        ll last = 0; //[0, k]的累加和
        while (true) {
            int target = min(last + 1, (ll)INF); //离散化前, 值域上界也只有INF, 没必要过大
            int index = find(target); //离散化后的下标
            
            if (v[index] > target) index--; //表明我们找的target不在离散化的数值中, 应向下取整.
            ll now = ask(index, 1, len, root[l - 1], root[r]);
            
            if (now == last) break; //表示已经无法再扩展.
            last = now;
        }
        res = last + 1; //答案需要+1
        printf("%lld\n", res);
    }
    return 0;
}

怎么说呢… 要不是这个minmax出了问题, 代码实现方面我感觉考察的还是很裸的. 但是感觉思维难度方面还是挺高的.

END