第九届蓝桥杯C语言B组递增三元组

标题：递增三元组

给定三个整数数组
A = [A1, A2, ... AN],
B = [B1, B2, ... BN],
C = [C1, C2, ... CN]，
请你统计有多少个三元组(i, j, k) 满足：
1. 1 <= i, j, k <= N
2. Ai < Bj < Ck

【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, ... AN。
第三行包含N个整数B1, B2, ... BN。
第四行包含N个整数C1, C2, ... CN。

对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000

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

【样例输入】
3
1 1 1
2 2 2
3 3 3

【样例输出】
27

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

注意：
main函数需要返回0;
只使用ANSI C/ANSI C++ 标准;
不要调用依赖于编译环境或操作系统的特殊函数。
所有依赖的函数必须明确地在源文件中 #include <xxx>
不能通过工程设置而省略常用头文件。

提交程序时，注意选择所期望的语言类型和编译器类型。

前面瞎搞把时间浪费了，考试的时候直接写了三重循环拿一些分。

最近又拿出来重新写，自己笨笨的脑袋只想出了一个两重循环的解法，后受某大佬启发后写了更简单的方法。

解法：

1.对每一个B数组的元素进行一个操作，这个操作是求出比对应B元素大的C数组元素个数，存入临时数组BT。

2.对每一个A数组的元素进行下一个操作，这个操作是把比对应A元素大的B元素对应的临时数组BT的数据全部加起来。存到临时数组AT中。

3.对临时数组AT求和。

最终是二重循环，应该过不了全部数据。

而改进是将3个数组进行排序后在进行上面操作。

设下列为排好序的B,C数组

B C

9 17
8 14
7 7
6 5
5 2

用i j 分别指向B、C数组的顶部。

然后比较Bi, Cj 。

若 Bi < Cj, j--, BT[i]++。

否则, i--，BT[i] = BT[i+1] //BT[i] 是比 BT[i+1] 小的，因此直接继承BT[i+1]的值。

循环终止条件为i， j任一到达底部。

描述如下：

i = 5, j = 5, 9 < 17, j-- ,BT[i]++。记下一个比其小,并向下滑动

i = 5, j = 4, 9 < 14, j--, BT[i]++。已经有2个比17小了。

i = 5, j = 4，9 > 7, i--, BT[i] = BT[i+1]。继承上一元素。

循环结束后，如果j先到底部，那么i 下面的BT值都是BT[i]。

AB操作类似，只是将BT[i]++,换成AT[i]+=BT[j]

代码

#include<bits/stdc++.h>

using namespace std;

#define SIZE 100001

int A[SIZE]; 
int B[SIZE]; 
int C[SIZE];

int BT[SIZE];
int AT[SIZE];

int main(){
    
    int N;
    scanf("%d", &N);
    for(int i = 1; i <= N; i++){
        scanf("%d", &A[i]);    
    }
    for(int i = 1; i <= N; i++){
        scanf("%d", &B[i]);    
    }        
    for(int i = 1; i <= N; i++){
        scanf("%d", &C[i]);    
    }
    
    sort(A+1, A+N+1);
    sort(B+1, B+N+1);
    sort(C+1, C+N+1);
    memset(BT, 0, sizeof(int) * SIZE);
    memset(AT, 0, sizeof(int) * SIZE);
    long long int total = 0;
    
     int i = N, j = N;
     while(i >= 1&&j >= 1){
         
         if(B[i] < C[j]){
             BT[i]++;
             j--;
         }else{
             i--;
             BT[i] = BT[i+1];
         }
     }
    if(i > 1){
        for(int k = i-1; k >= 1; k--)
            BT[k] = BT[i];
    }
    
    i = N, j = N;
    while(i >= 1&&j >= 1){
        if(A[i] < B[j]){
            AT[i] += BT[j];  
            j--;
        }else{
            i--;
            AT[i] = AT[i+1];
        }
    }
    if(i > 1){
        for(int k = i-1; k >= 1; k--)
            AT[k] = AT[i];
    }
    
    for(int i = 1; i <= N; i++){
        //printf("[%d %d]\n", AT[i], BT[i]);
        total+=AT[i]; 
    }
    
    printf("%lld", total);
    
    return 0;
}

未排序优化的解法 //便于先理解

#include<stdio.h>
#include<string.h>

int A[100001];
int AT[100001]; 
int B[100001];
int BT[100001]; 
int C[100001];


int main (){
    
    int N;
    scanf("%d", &N);
    for(int i = 1; i <= N; i++){
        scanf("%d", &A[i]);    
    }
    for(int i = 1; i <= N; i++){
        scanf("%d", &B[i]);    
    }        
    for(int i = 1; i <= N; i++){
        scanf("%d", &C[i]);    
    }    
    
    int total = 0;
    memset(BT, 0, sizeof(int)*100001);
    
    for(int i = 1; i <= N; i++) {
        for(int j = 1; j <= N; j++){
            if(B[i] < C[j]) BT[i]++;
        }
    } 
    
    for(int i = 1; i <= N; i++) {
        for(int j = 1; j <= N; j++){
            if(A[i] < B[j]){
                AT[i] += BT[j];
            }
        }
        total += AT[i];
    } 
    printf("%d", total);
    
    
    return 0;
}

参考

https://blog.csdn.net/qq_40727946/article/details/79871230

第九届蓝桥杯C语言B组 递增三元组

猜你喜欢

第九届蓝桥杯C语言B组递增三元组