P1637 三元上升子序列

本文深入探讨了线段树与离散化算法在处理特定数据结构问题中的应用,通过实例讲解如何利用线段树进行高效的数据查询与更新,同时结合离散化技巧解决大数据范围的问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

标签+线段树+离散化好题。

题意:给定一个长度为n的序列a,问满足a_{i}<a_{j}<a_{k}(1\leq i<j<k\leq n)的三元组(a_{i},a_{j},a_{k})的个数。

数据范围:1\leq n\leq 30000,0\leq a_{i}\leq maxlongint

首先,我们知道求满足a_{i}<a_{j}i<j的二元组的个数的线段树做法是什么。

类比 P1198 [JSOI2008]最大数 ,假设现在有一个数组tot。我们扫一遍整个序列,扫到a_{i}tot[a[i]]+=1。此时tot_{x}数组存的是在数列a中位置下标1-i中大小为x的数字的个数。那么此时便可以得到:对于a_{i+1},在a_{1}-a_{i}中比a_{i+1}小的数字的个数cnt_{i+1}=\sum_{k=1}^{a_{i+1}-1}tot_{k}

那么对于原问题,ans=\sum_{k=2}^{n} \sum_{i=1}^{k-1,a_{i}<a_{k}}cnt_{i}。这个过程利用线段树即可完成统计。

最后注意:由于a的值域过大,所以需先离散化。

Code:

#include<cstdio>
#include<iostream>
#include<algorithm>
#define ri register int
using namespace std;

const int MAXN=30020;
int n,a[MAXN];
int l[MAXN<<2],r[MAXN<<2],add[MAXN<<2],tot[MAXN];
long long sum[MAXN<<2],ans;
struct node{
    int num,pla;
}shu[MAXN];

bool cmp(node a,node b)
{
    return a.num < b.num;
}

void build(int p,int lft,int rit)
{
    l[p]=lft,r[p]=rit;
    if(l[p]==r[p])  return;
    int mid=(lft+rit)>>1;
    build(p <<1,lft,mid);
    build(p <<1|1,mid+1,rit);
}

void pushupadd(int p)
{
    add[p]=add[p <<1]+add[p <<1|1];
}

void update1(int p,int where,int k)
{
    if(l[p]==where&&r[p]==where)
    {
        add[p]+=k;
        return;
    }
    if(where<=r[p <<1])  update1(p <<1,where,k);
    if(l[p <<1|1]<=where)  update1(p <<1|1,where,k);
    pushupadd(p);
}

int query1(int p,int lft,int rit)
{
    if(lft>rit)  return 0;
    if(lft<=l[p]&&r[p]<=rit)	return add[p];
    int anstot=0;
    if(lft<=r[p <<1])  anstot=query1(p <<1,lft,rit);
    if(l[p <<1|1]<=rit)  anstot+=query1(p <<1|1,lft,rit);
    return anstot;
}

void pushup(int p)
{
    sum[p]=sum[p <<1]+sum[p <<1|1];
}

void update2(int p,int where,long long k)
{
    if(l[p]==where&&r[p]==where)
    {
        sum[p]+=k;
        return;
    }
    if(where<=r[p <<1])  update2(p <<1,where,k);
    if(l[p <<1|1]<=where)  update2(p <<1|1,where,k);
    pushup(p);
}

long long query2(int p,int lft,int rit)
{
    if(lft>rit)  return 0;
    if(lft<=l[p]&&r[p]<=rit)	return sum[p];
    long long anstot=0;
    if(lft<=r[p <<1])  anstot=query2(p <<1,lft,rit);
    if(l[p <<1|1]<=rit)  anstot+=query2(p <<1|1,lft,rit);
    return anstot;
}

int main()
{
    scanf("%d",&n);
    for(ri i=1;i<=n;i++)
    {
        scanf("%d",&shu[i].num);
        shu[i].pla=i;
    }
    sort(shu+1,shu+n+1,cmp);
    a[shu[1].pla]=1;
    for(ri i=2;i<=n;i++)
    {
        if(shu[i-1].num==shu[i].num)  a[shu[i].pla]=a[shu[i-1].pla];
        if(shu[i-1].num<shu[i].num)  a[shu[i].pla]=a[shu[i-1].pla]+1;
    }
    build(1,1,n);
    for(ri i=2;i<=n;i++)
    {
        update1(1,a[i-1],1);
        tot[i]=query1(1,1,a[i]-1);
    }
    for(ri i=2;i<=n;i++)
    {
        update2(1,a[i-1],(long long)tot[i-1]);
        ans+=query2(1,1,a[i]-1);
    }
    cout<<ans;
    return 0;
}

 

### 关于等差子序列的算法实现 要解决生成或查找等差子序列的问题,可以采用动态规划的方法来高效处理。以下是基于引用内容以及专业知识的具体分析和解决方案。 #### 动态规划的核心思想 通过构建一个字典 `dp` 来存储以某个数值结尾的所有可能公差对应的子序列数量。具体来说,对于数组中的每一个元素 `nums[i]`,我们遍历其之前的所有元素 `nums[j] (j < i)` 并计算它们之间的差值作为潜在的公差 `d = nums[i] - nums[j]`。如果存在这样的公差,则更新当前状态并记录新的子序列数量[^3]。 下面是完整的 Python 实现代码: ```python from collections import defaultdict def numberOfArithmeticSlices(nums): total_count, dp_dict = 0, [defaultdict(int) for _ in nums] for i in range(len(nums)): for j in range(i): diff = nums[i] - nums[j] # 获取以前面索引 j 结尾且具有相同差值 d 的子序列数目 cnt_j = dp_dict[j][diff] # 更新总计数器与当前索引 i 处的状态转移方程 total_count += cnt_j dp_dict[i][diff] += cnt_j + 1 return total_count ``` 此函数接收输入列表 `nums` 并返回满足条件的不同等差子序列总数。其中利用了嵌套循环结构逐一比较每一对元素间的差异情况;借助哈希表快速定位已有符合条件路径的数量从而完成累加操作。 #### 示例运行结果 假设给定如下测试用例: ```python print(numberOfArithmeticSlices([2, 4, 6, 8, 10])) ``` 输出应为 **7** ,因为共有七个有效三元及以上长度的等差子序列组合形式分别为 `[2,4,6], [4,6,8], [6,8,10],[2,4,6,8],[4,6,8,10],[2,4,6,8,10]`. --- ### 提出进一步探讨方向
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值