4408: [Fjoi 2016]神秘数

本文介绍了一道关于主席树的数据结构题目,通过分析数学原理,实现了对于特定区间内元素求和的功能。使用C++实现了一个高效的算法解决方案。

主席树水题...

首先由小学数学知道...

如果有[1,x]区间可以取到,那么对于另外一个数y,我此时能构成区间[1+y,x+y];

那么我考虑当前最小可能的答案为ans,那么[1,ans - 1]这个区间一定可以取到,

考虑令num=∑(x <= ans)x, 则[1,num]为我此时能确定一定能取到的区间,

因为我已经确定[1,ans - 1]这个区间一定可以取到,那么我令p = ∑[1,lst - 1]

令q = num - p,则q由选[1,ans - 1]可以不选的数组合而来,且组成q的数一定不超过ans

那么我的[1,num]就可以从[1,ans-1]与q中某些数相加得到。

搞定

c++代码如下:

#include<bits/stdc++.h>
#define rep(i,x,y) for(register int i = x;i <= y; ++ i)
#define repd(i,x,y) for(register int i = x;i >= y; -- i)
using namespace std;
typedef long long ll;
template<typename T>inline void read(T&x)
{
	x = 0;char c;int sign = 1;
	do { c = getchar(); if(c == '-') sign = -1; }while(!isdigit(c));
	do { x = x * 10 + c - '0'; c = getchar(); }while(isdigit(c));
	x *= sign;
}

const int M = 1e7+500,N = 1e5+500;
int root[N],ls[M],rs[M],sum[M],sz;
int n,m;

void insert(int&id,int idx,int l,int r,int x)
{
	id = ++ sz;
	sum[id] = sum[idx] + x; 
	if(l == r) return ;
	ls[id] = ls[idx]; rs[id] = rs[idx];
	int mid = l + r >> 1;
	if(x <= mid) insert(ls[id],ls[idx],l,mid,x);
	else insert(rs[id],rs[idx],mid + 1,r,x);
}

int query(int rt1,int rt2,int l,int r,int x)
{
	if(r <= x) return sum[rt1] - sum[rt2];
	int mid = l + r >> 1;
	if(x > mid) return query(ls[rt1],ls[rt2],l,mid,x) + query(rs[rt1],rs[rt2],mid + 1,r,x);
	else return query(ls[rt1],ls[rt2],l,mid,x);
}

int main()
{
	read(n);
	rep(i,1,n)
	{
		int x;
		read(x);
		insert(root[i],root[i - 1],1,1e9,x);
	}
	read(m);
	rep(i,1,m)
	{
		int l,r;
		read(l); read(r);
		int ans = 1,k;
		while((k = query(root[r],root[l - 1],1,1e9,ans)) >= ans)
			ans = k + 1;
		printf("%d\n",ans);
	}
	return 0;
}

为什么会从第三个点开始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
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值