离散化算法思路

离散化

在不改变数据相对大小的条件下，对数据进行相应的缩小，对应映射，把不规则的数据变规则

洛谷 P1966 [NOIP2013 提高组] 火柴排队
#include<bits/stdc++.h>
using namespace std;

const int N=1e5+10,MOD=99999997;
int number,x[N],p[N],ans;
struct comb
{
	int h;
	int num;
}a[N],b[N];

bool cmp(comb cmb1,comb cmb2)
{
	return cmb1.h<cmb2.h;
}
void msort(int s,int t);//归并排序

int main()
{
	cin>>number;
	for(int i=0;i<number;i++)//这里使用索引就用了离散化，先求索引序再对应
	{
		cin>>a[i].h;
		a[i].num=i+1;
	}
	for(int i=0;i<number;i++)
	{
		cin>>b[i].h;
		b[i].num=i+1;
	}
	sort(a,a+number,cmp);
	sort(b,b+number,cmp);
	for(int i=0;i<number;i++)
	{
		x[b[i].num-1]=a[i].num;
	}
	msort(0,number-1);
	printf("%lld",ans);
  return 0;
}

洛谷 P1496 火烧赤壁
#include <iostream>
#include <algorithm>
using namespace std;
const int N=2e4+5;
int n;
int b[N*2];
int map[N*2],sum[N*2];
struct items{//用结构体记录离散化的对应，用数组b进行排序和离散化
	int l;//左。
	int nl;//l离散化后的位置。
	int r;//右。
	int nr;//r离散化后的位置。
}len[N];
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>len[i].l>>len[i].r;//读入每个区间的l,r。
		b[i]=len[i].l,b[n+i]=len[i].r;//读入一个数组进行离散化操作，b[i]记录从离散化后转到离散化前的对应，前转后二分查找，后转前直接数组索引
	}
	sort(b+1,b+1+2*n);//由于unique需要在一个有序的数组下进行去重，所以我们需要排序。
	auto k=unique(b+1,b+1+2*n);//去重操作，不过这道题去不去重无所谓
	for(int i=1;i<=n;i++){
		len[i].nl=lower_bound(b+1, k, len[i].l)-b;//通过lower_bound来查询每个l离散化后的位置，并存储在len[i].nl。
		len[i].nr=lower_bound(b+1, k, len[i].r)-b;//通过lower_bound来查询每个r离散化后的位置，并存储在len[i].nr。
	}
	for(int i=1;i<=n;i++)map[len[i].nl+1]++,map[len[i].nr+1]--;//差分。
	for(int i=1;i<=(k-b-1);i++)sum[i]+=sum[i-1]+map[i];//（k-b-1）为元素个数。
	int l,r;//不为0的区间的左端点和右端点。
	long long ans=0;
	for(int i=1;i<=(k-b-1);i++){
		if(sum[i]!=0&&sum[i-1]==0)l=i-1;
		if(sum[i]!=0&&sum[i+1]==0){
			r=i;
			ans+=b[r]-b[l];//由于这是离散化后的区间长度，并不是真正的区间长度，所以我们要找到原来的l与r，将他们相减，就是原来的区间长度。
		}
	}
	cout<<ans<<endl;
	return 0;
}