Cinema||电影(离散化）

一、知识点介绍：离散化

离散化（Discretization），把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。例如：

原数据：1, 999, 100000, 15；处理后：1,3,4,2。
原数据：{100, 200}，{20, 50000}，{1, 400}；处理后：{3,4}，{2,6}，{1,5}。
有的时候，我们会发现对于一个序列，它的值域很大，对应算法的复杂度是 Θ(值域) 的。离散化是程序设计中一个常用的技巧，它可以有效的降低时间复杂度。其基本思想就是在众多可能的情况中，只考虑需要用的值。离散化可以改进一个低效的算法，甚至实现根本不可能实现的算法。例如，在建造线段树空间不够的情况下，可以考虑离散化。

离散化的原理和实现都很简单。为了确保不出错且尽可能地提高效率，我们希望离散化能实现以下几种功能：

1、保证离散化后的数据非负且尽可能的小

2、离散化后各数据项之间的大小关系不变，原本相等的也要保持相等。

由此，找出数据项在原序列中从小到大排第几就是离散化的关键。可以通过下面的方法以 O(n logn) 的时间复杂度完成离散化，n 为序列长度。

离散化一共有两种方法，方法一重复元素离散化后的数字相同，方法二重复元素离散化后的数字不相同。用的最多的是方法一。

---

方法一：重复元素离散化后的数字相同

例如：对于序列 [105，35，35，79，-7]，排序并去重后变为 [-7，35，79，105]，由此就得到了对应关系 -7->1, 35->2, 79->3, 105->4。

基本的步骤可以分为：

1、用一个辅助的数组把你要离散的所有数据存下来。

2、排序，排序是为了后面的二分。

3、去重，因为我们要保证相同的元素离散化后数字相同。

4、索引，再用二分把离散化后的数字放回原数组。

void discrete(){//离散化
  //排序
  sort(a+1,a+n+1);
  //去重
  for(int i=1;i<=n;i++){
    if(i==1||a[i]!=a[i-1])
        b[++m]=a[i];
  }
  
  //索引，映射
  int find(int x){
    return lower_bound(b+1,b+m+1,x)-b;
  }
}

在这段代码中，a[] 经过离散，范围就变成了 m。

数据解析
比如，这组数据：

1,23424,242,65466,242,0

排序后得到：

0,1,242,242,23424,65466

然后会去重，得到：

0,1,242,23424,65466

然后离散化的到：

1,3,2,4,2,0

注意事项

1、去重并不是把数组中的元素删去，而是重复的部分元素在数组末尾，去重之后数组的大小要减一。

2、二分的时候，注意二分的区间范围，一定是离散化后的区间。

3、如果需要多个数组同时离散化，那就把这些数组中的数都用数组存下来。

---

方法二：重复元素离散化后的数字不相同

例如：对于序列 [105，35，35，79，-7]，排序后变为 [-7，35，35，79，105]，由此就得到了对应关系 -7->1，35->2，35->3，79->4，105->5。

基本的步骤可以分为：

1、用一个辅助的数组把你要离散的所有数据存下来。

2、排序。

3、枚举着放回原数组。

对应的代码如下：

#include<algorithm>
 
struct Node {
    int data , id;
    bool operator < (const Node &a) const {
	return data < a.data;
    }
};
 
const int MAXN = 1e5+4;
Node num[MAXN];//原数组
int rank[MAXN];//离散化后数组
int n;
 
for (int i=1; i<=n; i++) {
    scanf("%d",&num[i].data);
    num[i].id = i;
}
 
sort(num+1 , num+n+1);
 
for (int i=1; i<=n; i++) {
    rank[num[i].id] = i;
}

这种方法复杂度比上面那一种要优，但不能处理重复元素。它直接用结构体存储原本的数列的元素的位置，然后排序以后将他们再重新赋值。那么 rank[] 就是结构体 num[] 离散化后的结果。

数据解析
原始数据：

data: 3 6 5 10 8
id : 1 2 3 4 5

排序以后：

data: 3 5 6 8 10
id: 1 3 2 5 4

离散化以后：

data: 3 5 6 8 10
id: 1 3 2 5 4
rank: 1 2 3 4 5

再按原来的顺序排列：

data: 3 6 5 10 8
rank: 1 3 2 5 4

---

二、题目描述

题目链接

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

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

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

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

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

他们去的电影院里一共有 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≤109
输入样例：
3
2 3 2
2
3 2
2 3
输出样例：
2

分析

m部电影和n个人最多涉及m*2+n个语言，把所有语言存入一个数组进行离散化（排序、去重、映射），记录每种语言会的人数，然后枚举每场电影选出最优的。

步骤

1、用 lang 数组收集所有语言。
2、对 lang 数组排序、去重后保存到 ans ,ans 也就是的稠密编号。
3、find 函数用于把原始的稀疏编号转变为稠密编号。（find函数就是映射）
4、cnt 数组记录每种语言的科学家数。即这门语言有多少科学家会。
5、遍历所有电影，以每部电影的语音语言为条件，在ans数组中找最大值，若有多个相同的最大值，就找字幕语言最多的。

三、AC代码

#include<iostream>
using namespace std;
#include <algorithm>
#include<stdio.h>
#include<math.h>

int n,m;
int a[200200],b[200200],c[200200];
int lang[600200],ans[600200],cnt[600200];
int k=0,v=0;

//索引
int find(int x){
  return lower_bound(ans+1,ans+v+1,x)-ans;
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++){
        cin>>a[i];
        lang[++k]=a[i];
	}
	cin>>m;
	for(int i=1;i<=m;i++){
        cin>>b[i];
        lang[++k]=b[i];
	}
	for(int i=1;i<=m;i++){
        cin>>c[i];
        lang[++k]=c[i];
	}
	//排序
	sort(lang+1,lang+1+k);
	//去重
	for(int i=1;i<=k;i++){
        if(i==1||lang[i]!=lang[i-1])
            ans[++v]=lang[i];
	}

	//记录会i语言的科学家数
	for(int i=1;i<=n;i++){cnt[find(a[i])]++;}
	//找到最佳电影；
	int ans0=0,ans1=0,ans2=0;
	for(int i=1;i<=m;i++){
        int ansx=cnt[find(b[i])],ansy=cnt[find(c[i])];
        if(ansx>ans1||(ansx==ans1&&ansy>ans2)){
            ans0=i,ans1=ansx,ans2=ansy;
        }
	}
	cout<<ans0<<endl;
}