离散化思想

 引入

先来看看离散化的百度解释吧：离散化，把无限空间中有限的个体映射到有限的空间中去。

①原数据:1,999,100000,15;处理后:1,3,4,2;

②原数据:{100,200}，{20,50000}，{1,400};处理后:{3,4}，{2,6}，{1,5};

一个很好的解释：把数据离散的点重新标号

小前提：先想出朴素的算法，再把离散化思想带入^_^

使用

设数组a[i],1<=i<=n。

一般情况下，当a[i]本身特别大，n比较小，那么我们就可以利用离散化思想把下标重定义，一般的就是排序。//以下代码的unique可不加，手动struct+去重效率会更高

#include<cstring>
#include<algorithm>//unique()返回去重后末尾下标、lower_bound返回地址
#include<cstdio>
using namespace std;
const int nn=105;
int a[nn],new[nn],b[nn];
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){scanf("%d",&a[i]);}
    memcpy(b,a,sizeof(b));
    sort(b+1,b+n+1)//默认升序
    int m=unique(b+1,b+n+1)-b;//先排序后去重养成习惯^_^
    for(int i=1;i<=m;i++){
        for(int j=1;j<=n;j++){//这里选用最笨的方法，由于unique加struct本人不会用
            if(a[j]==b[i])new[j]=i;//重标号
        }
    }
    /*for(int i=1; i<=n; i++)
	    a[i]=lower_bound(b+1,b+m+1,a[i])-b;
    lower_bound>=,,,,,,,upper_bound>
    二分放回，本人用的不熟*/
    work();//你要解决的问题
    return 0;
}

例题

题目：【离散思想】矩形面积

---

题目描述

　桌面上放了N个矩形，这N个矩形可能有互相覆盖的部分，求它们组成的图形的面积。

输入输出格式

输入格式：

　　输入第一行为一个数N（1≤N≤100），表示矩形的数量。下面N行，每行四个整数，分别表示每个矩形的左下角和右上角的坐标，坐标范围为–10^8到10^8之间的整数。

输出格式：

　　输出只有一行，一个整数，表示图形的面积。

输入输出样例

输入样例#1：

3 1 1 4 3 2 -1 3 2 4 0 5 2

输出样例#1：

10

提示信息

【说明】这道题的第4个数据出现了给出左上角坐标和右下角坐标的情况，写程序时忽略这些不合法矩形就行了。

左边是朴素算法，右边是离散化的优化，对比可发现该效率的提升。

代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int nn=105*2,mm=999999999;
struct aty{
	long long x1,y1,x2,y2;
}a[nn];
struct bty{
	int N;
	long long xy;
}b[nn],c[nn];
bool mp[nn][nn];
long long xx[nn],yy[nn];
bool cmp(bty p,bty q){return p.xy<q.xy;}
int main(){
	int n;long long ans=0,x1,x2,y1,y2;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld%lld%lld%lld",&x1,&y1,&x2,&y2);
		if(x1>=x2||y1>=y2)continue;
		b[i]=(bty){i,x1};b[i+n]=(bty){i,x2};
		c[i]=(bty){i,y1};c[i+n]=(bty){i,y2};
	}
	for(int i=1;i<=n;i++)a[i]=(aty){mm,mm,mm,mm};
	sort(b+1,b+2*n+1,cmp);
	sort(c+1,c+2*n+1,cmp);
	int ex=mm,ey=mm,xn=0,yn=0;//example
	for(int i=1;i<=2*n;i++){//重新标号
		if(ex!=b[i].xy){ex=b[i].xy;xx[++xn]=b[i].xy;}
		if(a[b[i].N].x1==mm)a[b[i].N].x1=xn;
		else a[b[i].N].x2=xn;// 
		if(ey!=c[i].xy){ey=c[i].xy;yy[++yn]=c[i].xy;}
		if(a[c[i].N].y1==mm)a[c[i].N].y1=yn;
		else a[c[i].N].y2=yn;
	}
	for(int i=1;i<=n;i++)
		for(int j=a[i].x1+1;j<=a[i].x2;j++)
			for(int k=a[i].y1+1;k<=a[i].y2;k++) 
				mp[j][k]=true;
	for(int i=2;i<=xn;i++)
		for(int j=2;j<=yn;j++)
			if(mp[i][j]){
				ans+=(xx[i]-xx[i-1])*(yy[j]-yy[j-1]);
			}
	printf("%lld",ans);
	return 0;
}

学术不精，这只是离散化最浅显的思想，会不断更新，有更好的想法欢迎在评论区讨论！