[FJOI2016]神秘数(脑洞+可持久化)

求解可重复数字集合的神秘数算法
文章描述了一种算法问题,给定一个包含重复数字的集合S和一系列区间查询,目标是找出每个查询区间内,不能表示为集合内数字子集和的最小正整数,即神秘数。提供的解决方案涉及到了对1的个数的统计,并使用了二分查找和树状数组(线段树)进行高效查询。

题目描述

一个可重复数字集合S的神秘数定义为最小的不能被S的子集的和表示的正整数。例如S={1,1,1,4,13},

1 = 1

2 = 1+1

3 = 1+1+1

4 = 4

5 = 4+1

6 = 4+1+1

7 = 4+1+1+1

8无法表示为集合S的子集的和,故集合S的神秘数为8。

现给定n个正整数a[1]..a[n],m个询问,每次询问给定一个区间l,r,求由a[l],a[l+1],…,a[r]所构成的可重复数字集合的神秘数。

题解

加入我们查询的区间为l-r。

我们先查询有几个1,然后发现有k个,那么然后我们再查询1-k+1有多少数,如果大于等于k+1的话,那么1到k+1都能表出。

重复这个过程即可,最多跳log次。

代码

#include<iostream>
#include<cstdio>
#define N 100002
using namespace std;
typedef long long ll;
const int maxn=1e9;
ll tr[N*],a[N];
int L[N*],R[N*],tot,n,m,T[N];
inline int rd(){
    int x=;char c=getchar();bool f=;
    while(!isdigit(c)){if(c=='-')f=;c=getchar();}
    while(isdigit(c)){x=(x<<)+(x<<)+(c^);c=getchar();}
    return f?-x:x;
}
void ins(int &cnt,int pre,int l,int r,ll x){
    cnt=++tot;
    tr[cnt]=tr[pre]+x;L[cnt]=L[pre];R[cnt]=R[pre];
    if(l==r)return;
    int mid=(l+r)>>;
    if(mid>=x)ins(L[cnt],L[pre],l,mid,x);
    else ins(R[cnt],R[pre],mid+,r,x);
}
ll query(int cnt,int pre,int l,int r,ll x){
//    cout<<cnt<<" "<<pre<<" "<<l<<" "<<r<<" "<<tr[cnt]<<" "<<tr[pre]<<endl;
    if(!cnt)return ;
    if(r<=x)return tr[cnt]-tr[pre];
    int mid=(l+r)>>;
    if(mid<x)return tr[L[cnt]]-tr[L[pre]]+query(R[cnt],R[pre],mid+,r,x);
    else return query(L[cnt],L[pre],l,mid,x);
}
int main(){
    n=rd();int m;
    for(int i=;i<=n;++i)a[i]=rd(),ins(T[i],T[i-],,maxn,a[i]);
    m=rd();int l,r;
    while(m--){
        l=rd();r=rd();
    //    cout<<"****"<<endl;
        ll ans=,now=;
        while(ans<=maxn){
        //    cout<<ans<<endl;
            ans=query(T[r],T[l-],,maxn,ans);
        //    cout<<ans<<" "<<now<<endl;
            if(ans<now)break;else now=ans+,ans=now;
        }
        printf("%lld\n",ans+);
    }
    return ;
}

为什么会从第三个点开始TLE? # P8868 [NOIP2022] 比赛 ## 题目描述 小 N 和小 O 会在 2022 年 11 月参加一场盛大的程序设计大赛 NOIP!小 P 会作为裁判主持竞赛。小 N 和小 O 各自率领了一支 $n$ 个人的队伍,选手在每支队伍内都是从 $1$ 到 $n$ 编号。每一个选手都有相应的程序设计水平。具体的,小 N 率领的队伍中,编号为 $i$($1 \leq i \leq n$)的选手的程序设计水平为 $a _ i$;小 O 率领的队伍中,编号为 $i$($1 \leq i \leq n$)的选手的程序设计水平为 $b _ i$。特别地,$\{a _ i\}$ 和 $\{b _ i\}$ 还分别构成了从 $1$ 到 $n$ 的排列。 每场比赛前,考虑到路途距离,选手连续参加比赛等因素,小 P 会选择两个参 $l, r$($1 \leq l \leq r \leq n$),表示这一场比赛会邀请两队中编号属于 $[l, r]$ 的所有选手来到现场准备比赛。在比赛现场,小 N 和小 O 会以掷骰子的方式挑选出参 $p, q$($l \leq p \leq q \leq r$),只有编号属于 $[p, q]$ 的选手才能参赛。为了给观众以最精彩的比赛,两队都会派出编号在 $[p, q]$ 内的、程序设计水平值最大的选手参加比赛。假定小 N 派出的选手水平为 $m _ a$,小 O 派出的选手水平为 $m _ b$,则比赛的精彩程度为 $m _ a \times m _ b$。 NOIP 总共有 $Q$ 场比赛,每场比赛的参 $l, r$ 都已经确定,但是 $p, q$ 还没有抽取。小 P 想知道,对于每一场比赛,在其所有可能的 $p, q$($l \leq p \leq q \leq r$)参下的比赛的精彩程度之和。由于答案可能非常之大,你只需要对每一场答案输出结果对 $2 ^ {64}$ 取模的结果即可。 ## 输入格式 第一行包含两个正整 $T, n$,分别表示测试点编号和参赛人。如果据为样例则保证 $T = 0$。 第二行包含 $n$ 个正整,第 $i$ 个正整为 $a _ i$,表示小 N 队伍中编号为 $i$ 的选手的程序设计水平。 第三行包含 $n$ 个正整,第 $i$ 个正整为 $b _ i$,表示小 O 队伍中编号为 $i$ 的选手的程序设计水平。 第四行包含一个正整 $Q$,表示比赛场。 接下来的 $Q$ 行,第 $i$ 行包含两个正整 $l _ i, r _ i$,表示第 $i$ 场比赛的参 $l, r$。 ## 输出格式 输出 $Q$ 行,第 $i$ 行包含一个非负整,表示第 $i$ 场比赛中所有可能的比赛的精彩程度之和对 $2 ^ {64}$ 取模的结果。 ## 输入输出样例 #1 ### 输入 #1 ``` 0 2 2 1 1 2 1 1 2 ``` ### 输出 #1 ``` 8 ``` ## 输入输出样例 #2 ### 输入 #2 ``` 见附件下的 match/match2.in。 ``` ### 输出 #2 ``` 见附件下的 match/match2.ans。 ``` ## 输入输出样例 #3 ### 输入 #3 ``` 见附件下的 match/match3.in。 ``` ### 输出 #3 ``` 见附件下的 match/match3.ans。 ``` ## 说明/提示 **【样例 1 解释】** 当 $p = 1, q = 2$ 的时候,小 N 会派出 $1$ 号选手,小 O 会派出 $2$ 号选手,比赛精彩程度为 $2 \times 2 = 4$。 当 $p = 1, q = 1$ 的时候,小 N 会派出 $1$ 号选手,小 O 会派出 $1$ 号选手,比赛精彩程度为 $2 \times 1 = 2$。 当 $p = 2, q = 2$ 的时候,小 N 会派出 $2$ 号选手,小 O 会派出 $2$ 号选手,比赛精彩程度为 $1 \times 2 = 2$。 **【样例 2】** 该样例满足测试点 $1 \sim 2$ 的限制。 **【样例 3】** 该样例满足测试点 $3 \sim 5$ 的限制。 **【据范围】** 对于所有据,保证:$1 \leq n, Q \leq 2.5 \times 10 ^ 5$,$1 \leq l _ i \leq r _ i \leq n$,$1 \leq a _ i, b _ i \leq n$ 且 $\{a _ i\}$ 和 $\{b _ i\}$ 分别构成了从 $1$ 到 $n$ 的排列。 ::cute-table{tuack} | 测试点 | $n$ | $Q$ | 特殊性质 A | 特殊性质 B | | :----------: | :----------: | :----------: | :----------: | :----------: | | $1, 2$ | $\leq 30$ | $\leq 30$ | 是 | 是 | | $3, 4, 5$ | $\leq 3,000$ | $\leq 3,000$ | ^ | ^ | | $6, 7$ | $\leq 10 ^ 5$ | $\leq 5$ | ^ | ^ | | $8, 9$ | $\leq 2.5 \times 10 ^ 5$ | ^ | ^ | ^ | | $10, 11$ | $\leq 10 ^ 5$ | ^ | 否 | 否 | | $12, 13$ | $\leq 2.5 \times 10 ^ 5$ | ^ | ^ | ^ | | $14, 15$ | $\leq 10 ^ 5$ | $\leq 10 ^ 5$ | 是 | 是 | | $16, 17$ | $\leq 2.5 \times 10 ^ 5$ | $\leq 2.5 \times 10 ^ 5$ | ^ | ^ | | $18, 19$ | $\leq 10 ^ 5$ | $\leq 10 ^ 5$ | ^ | 否 | | $20, 21$ | $\leq 2.5 \times 10 ^ 5$ | $\leq 2.5 \times 10 ^ 5$ | ^ | ^ | | $22, 23$ | $\leq 10 ^ 5$ | $\leq 10 ^ 5$ | 否 | ^ | | $24, 25$ | $\leq 2.5 \times 10 ^ 5$ | $\leq 2.5 \times 10 ^ 5$ | ^ | ^ | 特殊性质 A:保证 $a$ 是均匀随机生成的 $1 \sim n$ 的排列。 特殊性质 B:保证 $b$ 是均匀随机生成的 $1 \sim n$ 的排列。 #include<bits/stdc++.h> using namespace std; int a[250005],b[250005]; struct node{ int l,r; int maxn; }; node ta[250005*4]; node tb[250005*4]; void builda(int i,int le,int ri){ ta[i].l=le; ta[i].r=ri; if(le==ri){ ta[i].maxn=a[le]; return; } int mid=(ri-le)/2+le; builda(i*2,le,mid); builda(i*2+1,mid+1,ri); ta[i].maxn=max(ta[i*2].maxn,ta[i*2+1].maxn); } void buildb(int i,int le,int ri){ tb[i].l=le; tb[i].r=ri; if(le==ri){ tb[i].maxn=b[le]; return; } int mid=(ri-le)/2+le; buildb(i*2,le,mid); buildb(i*2+1,mid+1,ri); tb[i].maxn=max(tb[i*2].maxn,tb[i*2+1].maxn); } long long querya(int i, int le, int ri){ if(ta[i].l>=le&&ta[i].r<=ri){ return ta[i].maxn; } int mid=(ta[i].l+ta[i].r)/2; if(ri<=mid){ return querya(i*2,le,ri); } else if(le>mid){ return querya(i*2+1,le,ri); } else{ return max(querya(i*2,le,ri),querya(i*2+1,le,ri)); } } long long queryb(int i, int le, int ri){ if(tb[i].l>=le&&tb[i].r<=ri){ return tb[i].maxn; } int mid=(tb[i].l+tb[i].r)/2; if(ri<=mid){ return queryb(i*2,le,ri); } else if(le>mid){ return queryb(i*2+1,le,ri); } else{ return max(queryb(i*2,le,ri),queryb(i*2+1,le,ri)); } } int main(){ int t,n; cin>>t>>n; for(int i=1;i<=n;i++){ cin>>a[i]; } for(int i=1;i<=n;i++){ cin>>b[i]; } builda(1,1,n); buildb(1,1,n); int q; cin>>q; while(q--){ int l,r; cin>>l>>r; long long ans=0; for(int i=l;i<=r;i++){ for(int j=i;j<=r;j++){ long long ma=querya(1,i,j); long long mb=queryb(1,i,j); ans=(ans+ma*mb); } } cout<<ans<<endl; } return 0; }
最新发布
11-27
你的代码在 **小据(如测试点 1~5)上可以通过**,但在 **第 6 个测试点及之后开始 TLE(超时)** 是完全合理的。下面我将详细解释:**为什么从第三个点以后会 TLE?** --- ## ✅ 题目要求回顾 - 组长度 $ n \leq 2.5 \times 10^5 $ - 查询次 $ Q \leq 2.5 \times 10^5 $ - 每次查询区间 $[l, r]$,需要计算: $$ \sum_{p=l}^{r} \sum_{q=p}^{r} \left( \max_{i=p}^{q} a[i] \times \max_{j=p}^{q} b[j] \right) $$ 即所有子区间 $[p,q] \subseteq [l,r]$ 的 `a` 最大值 × `b` 最大值 的总和。 --- ## ❌ 当前算法的时间复杂度分析 你使用的是: ```cpp for (int i = l; i <= r; i++) { for (int j = i; j <= r; j++) { ma = querya(1, i, j); // O(log n) mb = queryb(1, i, j); // O(log n) ans += ma * mb; } } ``` ### 时间复杂度为: - 外层循环枚举子区间量:对于一个长度为 $ L = r-l+1 $ 的区间,共有 $ O(L^2) $ 个子区间。 - 每次查询最值是 $ O(\log n) $ - 所以单次查询时间复杂度是: $$ O(L^2 \log n) $$ ### 最坏情况举例: - 若一次查询是 $[1, n]$,且 $n = 10^5$,则子区间约为: $$ \frac{n(n+1)}{2} \approx 5 \times 10^9 \text{ 个子区间} $$ - 即使每个子区间只花 1ns,也需要 **5 秒以上**,而实际还有线段树递归开销,可能达几十秒。 > 而题目允许的总时间通常是 1~2 秒! --- ## 📉 不同测试点的据规模与你能通过的原因 | 测试点 | $n, Q$ 规模 | 是否可通过暴力 | |--------|--------------|----------------| | 1~2 | ≤ 30 | ✅ 可通过(最多 435 子区间) | | 3~5 | ≤ 3000 | ❌ 暴力不可行($L=3000$ → $4.5 \times 10^6$ 子区间/查询) | | 6~7 | $n \leq 10^5$, $Q \leq 5$ | ⚠️ 若每次查询都是整个组,则 $5 \times O(n^2 \log n) \to > 10^{10}$ 操作,TLE | | 8~25 | $n, Q \leq 2.5 \times 10^5$ | ❌ 完全不可能用 $O(n^2)$ 暴力 | 所以: > 💥 **你之所以从第 3 个测试点开始 TLE,是因为据规模变大了,而你的算法是 $O(n^2 \log n)$ 每次查询,无法承受大据量。** --- ## ✅ 正确做法应该怎么做? 我们需要把“所有子区间的最大值乘积之和”这个问题优化到 **接近线性或离线处理**。 ### 🔧 核心思想:贡献法 + 单调栈 + 分治 #### 思路概述: 我们不枚举每个子区间,而是考虑每个值对答案的**贡献**。 由于 $a$ 和 $b$ 都是排列,我们可以利用这一性质。 但注意:我们要算的是: $$ \sum_{[p,q]} \max_a(p,q) \times \max_b(p,q) = \sum_{[p,q]} \max_a \cdot \max_b \neq \left( \sum \max_a \right) \cdot \left( \sum \max_b \right) $$ ⚠️ 不能拆开!因为是乘积后再求和,不是独立的。 所以我们不能分别计算 $\sum \max_a$ 和 $\sum \max_b$。 --- ### ✅ 推荐解法(适用于本题) 这是 NOIP2022 真题,标准解法如下: #### ✔️ 解法一:离线 + 单调栈 + 线段树 / 差分(推荐) ##### 步骤: 1. **预处理每个元素作为最大值的影响区间** - 对组 $a$ 使用单调栈,得到每个位置 $i$ 的: - `L_a[i]`: 左边第一个大于 $a[i]$ 的位置 +1 - `R_a[i]`: 右边第一个大于等于 $a[i]$ 的位置 -1 - 同理处理 $b$ 2. **按最大值从小到大枚举子区间的影响** - 因为最大值由大决定,可以考虑从大到小加入元素,维护当前连通段内的合法子区间。 3. **使用并查集或扫描线维护当前可扩展的区间** - 经典技巧:“笛卡尔树遍历” 或 “Governing Max” 方法 4. **离线处理所有询问:莫队?不行!太慢。** - 更好的方法是:**离线 + 扫描右端点 + 线段树维护左端点的答案** --- ### ✅ 实际高效解法(简略版思路) 一种已被验证的 $O((n + Q) \log n)$ 解法: #### 步骤: 1. 将所有三元组 $(a_i, b_i, i)$ 按 $\max(a_i, b_i)$ 降序排序。 2. 初始时所有位置未激活。 3. 依次激活每个位置,并维护: - 当前已激活的连续段(可用并查集合并) - 在这些段中,统计有多少子区间满足其最大值由当前这个值主导 4. 利用这样一个事实: > 当我们按最大值从大到小插入时,一旦某个子区间被覆盖,它的 $\max_a$ 和 $\max_b$ 就已经被确定。 但这仍然非常复杂。 --- ### ✅ 更可行的做法(适合竞赛选手) 参考官方题解和 AC 代码,常见做法是: > 使用 **分治(类似启发式合并)** + **单调栈预处理边界** + **离线处理询问** #### 具体步骤(高级): ```text 定义 solve(l, r) 表示处理所有完全包含于 [l,r] 的子区间, 并且我们知道该区间的 min_len, max_val 等信息。 取 mid = (l+r)/2,分为三种情况: 1. 完全在左边 2. 完全在右边 3. 跨越中点 重点处理第 3 类:跨越中点的区间。 我们可以: - 从 mid 向左扫,维护左侧 a 和 b 的最大值 - 从 mid+1 向右扫,维护右侧的最大值 - 枚举左端点 i ∈ [l, mid],右端点 j ∈ [mid+1, r] - 利用归并的思想,分成若干段,使得 max 值不变,批量处理 这样每层分治处理跨越部分是 O(len),总复杂度 O(n log n) 然后对所有询问离线,按区间存储到分治结构中,在递归过程中回答。 ``` 这就是所谓的 **分治 + 归并思想处理最值卷积类问题**,经典题如「历史研究」、「FJOI 区间最值和」等。 --- ## ✅ 如何修复你的程序? 你目前的暴力只能过前 2~3 个点。 要通过全部据,必须重写为: ```cpp // 伪代码示意 struct Query { int l, r, id; }; vector<Query> queries[N]; void solve(int l, int r) { if (l == r) { ans[queries[l][r]] += a[l] * b[l]; return; } int mid = (l + r) >> 1; // 先递归左右 solve(l, mid); solve(mid + 1, r); // 处理跨越 mid 的区间 process_crossing(l, mid, r); } ``` 其中 `process_crossing` 是关键,需双指针 + 分段处理。 --- ## ✅ 修复建议(过渡方案) 如果你暂时不会高级算法,可以用以下方式判断是否应放弃暴力: ```cpp if (r - l + 1 > 5000) { // 使用近似或快速退出策略(仅调试) cout << "0\n"; continue; } // 否则暴力 ``` 但这显然不能拿高分。 --- ## ✅ 总结:为什么会 TLE? | 原因 | 说明 | |------|------| | ✅ 算法复杂度太高 | 每次查询 $O(L^2 \log n)$,当 $L=10^4$ 时已有 $10^8 \sim 10^9$ 操作 | | ✅ 据规模上升 | 测试点 3 开始 $n > 1000$,暴力不可接受 | | ✅ 线段树查询常大 | 每次 `querya` 都有函调用、分支判断,远慢于组访问 | | ✅ 缺少优化手段 | 没有预处理、没有离线、没有贡献法思想 | --- ## ✅ 如何改进? 你需要学习以下知识点来解决此类问题:
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lmr廖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值