- 离散化1: 包含重复元素,并且相同元素离散化后也要相同
public class Discretization {
public static int lower_bound(int[] arr,int target){
int l=0;
int r=arr.length;
while (l<r){
int mid=l+(r-l)/2;
if(arr[mid]>=target){
r=mid;
}else{
l=mid+1;
}
}
return l==arr.length?-1:l;
}
public static int[] solve(int[] array){
SortedSet<Integer> set=new TreeSet<Integer>();
for(int i=0;i<array.length;++i){
set.add(array[i]);
}
int[] b=new int[set.size()];
int ct=0;
for(int cur:set){
b[ct++]=cur;
}
for(int i=0;i<array.length;++i){
array[i]=lower_bound(b,array[i])+1;
}
return array;
}
public static void main(String[] args) {
int[] a={10000000,2,2,123123213};
solve(a);
}
}
- 离散化二: 1.包含重复元素,并且相同元素离散化后不相同,2.不包含重复元素,并且不同元素离散化后不同
public class Discretization {
static class Node implements Comparable<Node>{
int rt;
int idx;
public Node(int rt, int idx) {
this.rt = rt;
this.idx = idx;
}
@Override
public int compareTo(Node node) {
return rt-node.rt;
}
}
public static void work(int[] array){
int[] rank=new int[array.length];
Node[] nodes=new Node[array.length];
for(int i=0;i<array.length;++i){
nodes[i]=new Node(array[i],i);
}
java.util.Arrays.sort(nodes);
for(int i=0;i<array.length;++i){
rank[nodes[i].idx]=i;
}
for(int i=0;i<array.length;++i){
array[i]=rank[i]+1;
}
}
public static void main(String[] args) {
int[] a={10000000,2,2,123123213};
work(a);
}
}