离散化 AcWing103.电影 + 用map做

https://www.acwing.com/problem/content/105/

莫斯科正在举办一个大型国际会议，有n个来自不同国家的科学家参会。

每个科学家都只懂得一种语言。

为了方便起见，我们把世界上的所有语言用1到10^9之间的整数编号。

在会议结束后，所有的科学家决定一起去看场电影放松一下。

他们去的电影院里一共有m部电影正在上映，每部电影的语音和字幕都采用不同的语言。

对于观影的科学家来说，如果能听懂电影的语音，他就会很开心；如果能看懂字幕，他就会比较开心；如果全都不懂，他就会不开心。

现在科学家们决定大家看同一场电影。

请你帮忙选择一部电影，可以让观影很开心的人最多。

如果有多部电影满足条件，则在这些电影中挑选观影比较开心的人最多的那一部。

输入格式

第一行输入一个整数n，代表科学家的数量。

第二行输入n个整数a1,a2…an,其中ai表示第i个科学家懂得的语言的编号。

第三行输入一个整数m，代表电影的数量。

第四行输入m个整数b1,b2…bm,其中bi表示第i部电影的语音采用的语言的编号。

第五行输入m个整数c1,c2…cm,其中ci表示第i部电影的字幕采用的语言的编号。

请注意对于同一部电影来说，bi≠ci。

同一行内数字用空格隔开。

输出格式

输出一个整数，代表最终选择的电影的编号。

如果答案不唯一，输出任意一个均可。

数据范围

1≤n,m≤200000,
1≤ai,bi,ci≤10^9

输入样例：

3
2 3 2
2
3 2
2 3

输出样例：

2

 

 

我们只需要计算出懂某种语言的人的数量有多少，然后枚举每个电影就能找出最好的电影。

然而语言的范围有1e9，超过了允许的储存空间，但是语言的种类不会超过n<=2e5种，所以我们可以使用离散化的技巧。

离散化：

（《算法竞赛进阶指南》）

 

 

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
typedef long long ll;
using namespace std;

const int N=2e5+5;

int a[N],b[N],c[N];
int d[N];
int know[N];
int n,m,cnt=0;

void discrete() {
    sort(a+1,a+n+1);
    for(int i=1;i<=n;i++) {
        if(i==1||a[i]!=a[i-1]) {
            d[++cnt]=a[i];
        }
    }
}

int query(int x) {
    int find=lower_bound(d+1,d+cnt+1,x)-d;
    if(d[find]!=x) return 0;
    return find;
}

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        scanf("%d",&a[i]);
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++) {
        scanf("%d",&b[i]);
    }
    for(int i=1;i<=m;i++) {
        scanf("%d",&c[i]);
    }
    discrete();
    for(int i=1;i<=n;i++) {
        know[query(a[i])]++;
    }
    int MAX1=-1,MAX2=-1,maxn;
    for(int i=1;i<=m;i++) {
        int x=query(b[i]),y=query(c[i]);
        if(MAX1<know[x]||(MAX1==know[x]&&MAX2<know[y])) {
            MAX1=know[x];
            MAX2=know[y];
            maxn=i;
        }
    }
    printf("%d\n",maxn);
    return 0;
}

 

离散化可以压缩空间复杂度，同时也保留了数据之间的大小关系，但我们可以发现这题对元素之间的大小关系并没有要求，所以可以用另外的方法比如用map来做，这种方法的好处在于增加或删除元素十分方便，只需O(logN)的时间复杂度，而如果用离散化的话只能重新排序或者从中间插入元素，时间复杂度为O(N*logN)，所以这种方法十分有价值。

代码：（这题对常数的要求较高，提交这段代码会TLE，不过时间复杂度是一样的，没啥毛病）

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <map> 
typedef long long ll;
using namespace std;

const int N=2e5+5;

map <int,int> discrete;

int a[N],b[N],c[N];
int know[N];
int n,m,cnt=0;

int main() {
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        scanf("%d",&a[i]);
        int tmp=discrete[a[i]];
        if(!tmp) {
            discrete[a[i]]=++cnt;
            know[cnt]++;
        }else {
            know[tmp]++;
        }
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++) {
        scanf("%d",&b[i]);
    }
    for(int i=1;i<=m;i++) {
        scanf("%d",&c[i]);
    }
    int MAX1=-1,MAX2=-1,maxn;
    for(int i=1;i<=m;i++) {
        int x=discrete[b[i]],y=discrete[c[i]];
        if(MAX1<know[x]||(MAX1==know[x]&&MAX2<know[y])) {
            MAX1=know[x];
            MAX2=know[y];
            maxn=i;
        }
    }
    printf("%d\n",maxn);
    return 0;
}