递增三元组问题

递增三元组问题

问题详情

给定三个整数数组

A=[A1,A2,…AN]

B=[B1,B2,…BN]

C=[C1,C2,…CN]

请你统计有多少个三元组 (i,j,k)
满足：

1≤i,j,k≤N
Ai<Bj<Ck
输入格式
第一行包含一个整数 N

第二行包含 N 个整数 A1,A2,…AN
第三行包含 N整数 B1,B2,…BN
第四行包含 N 个整数 C1,C2,…CN

输出格式
一个整数表示答案。

数据范围
1≤N≤105

0≤Ai,Bi,Ci≤105
输入样例：
3
1 1 1
2 2 2
3 3 3
输出样例：
27

问题分析

1、预处理

Ai<Bj<Ck

我们需要将 a , b , c 数组分别进行递增排序，以便后续计算寻找目标

2、选取分析对象

为了方便分析，我们要先在 a , b , c 数组选择一个进行分析，假设我们先选 a 数组分析，很明显，我们会将a 数组遍历，选取每一个数 a [ i ] 作为对象 ，找到 a[ i ] 在 b 中的位置 ， 再对 b 中符合条件的数进行遍历 选取对象 b [ j ] , 接着在 c 中找到合适的位置后遍历 c 的元素，如此一来实在是太过复杂
假设我们选取 B 数组作为最开始的遍历对象呢？
推导如下：
选取 b [ i ] 作为中间值 ，找到 b [ i ] 在 a 数组中应有的位置 x，再找到 b[ i ] 在 c 数组当中应有的位置 y ， 【当然这里的数组 a b c 都是预处理好的】 , 进行计算就是 ==x * ( n - y + 1) == 。

知识预备

1.lower_bound

lower_bound函数是C++ STL中的一个函数，用于在有序序列中查找第一个大于或等于给定值的元素的位置。

lower_bound函数的返回值是一个迭代器，指向序列中第一个大于或等于给定值的元素的位置。

如果找到了符合条件的元素，则返回指向该元素的迭代器；如果没有找到符合条件的元素，则返回指向序列中第一个大于给定值的元素的迭代器。

需要注意的是，lower_bound函数要求序列是有序的，否则结果是未定义的。

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int target = 6;

    auto it = std::lower_bound(nums.begin(), nums.end(), target);
    
    if (it != nums.end()) {
        std::cout << "找到了目标值：" << *it << std::endl;
    } else {
        std::cout << "未找到目标值" << std::endl;
    }

    return 0;
}

2.upper_bound

#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> arr = {1, 2, 3, 4, 4, 4, 5, 6, 7};
    int target = 4;

    auto upperBound = std::upper_bound(arr.begin(), arr.end(), target);
    int index = std::distance(arr.begin(), upperBound);

    std::cout << "Upper bound of " << target << " is at index " << index << std::endl;

    return 0;
}

上述代码中，我们使用了C++标准库中的upper_bound函数来查找目标元素4的上界。upper_bound函数接受两个迭代器参数，表示查找的范围，以及一个目标元素。它返回一个迭代器，指向第一个大于目标元素的位置。

在上述代码中，我们将有序数组存储在std::vector容器中，并调用upper_bound函数来查找目标元素4的上界。然后，使用std::distance函数计算迭代器的距离，得到目标元素的上界在数组中的索引。最后，将结果打印出来。

运行这段代码，将会输出：

Upper bound of 4 is at index 6

这与之前使用自定义的up_bound函数得到的结果相同。

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+7;
int a[N],b[N],c[N],n;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++) cin>>b[i];
    sort(b+1,b+n+1);
    for(int i=1;i<=n;i++) cin>>c[i];
    sort(c+1,c+n+1);
    long long ans=0;
    for(int i=1;i<=n;i++){
        int target=b[i];
        int left= lower_bound(a+1,a+1+n,target)-a-1;
        //由于 lower_bound 函数返回的是迭代器，所以需要减去a代表的&a[0];
        int right=upper_bound(c+1,c+n+1,target)-c;
        if(left>=1 && right<=n) ans+=(long long )(n-right+1)*left;
        //为了防止数据过大，我们在这里用 long long去储存，同时+=计算的时候
        //也要使用 long long ，防止数据溢出
    }
    cout<<ans<<endl;
    return 0;
}

优化的代码（利用双指针去找到上述代码 left、right的位置）

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+7;
int a[N],b[N],c[N],n;
int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++) cin>>b[i];
    sort(b+1,b+n+1);
    for(int i=1;i<=n;i++) cin>>c[i];
    sort(c+1,c+n+1);
    long long ans=0;
    int left =1,right=1;
    for(int i=1;i<=n;i++){
        int target=b[i];
        while(a[left]< target && left<=n) left++;
        while(c[target]<=left && left<=n) right++;
        ans+=(long long)(n-right+1)*(left-1);
        //这里的 left 其实应该从 0 开始【假如是为了此处的计算】
        //但是考虑到 数组 a 下标是从1 开始，我们的左值偏移了1 ，为了
        //计算，我们将其-1处理
    }
    cout<<ans<<endl;
    return 0;
}