1.双指针算法
核心思想：
for(int i=0,j=0;i<n;i++){
while(j<=i&&check(i,j)) j++;
res=max(res,i-j+1);
}
定义两个变量 i 和 j 用来记录数组a的位置，其中 i 记录最长连续区间的尾部，j 记录最长连续区间的开头
额外开辟一个数组用来记录每个数出现的次数 s[ ]
模拟逻辑：首先数组s先记录数组a在位置i上数字出现的次数，然后进行判断j<i并且数组s记录的数字出现次数大于1，定义一个max记录此时区间的最大长度。i继续向右移动。如果满足判断条件，j就开始移动，j按照i走过的路，消除数组s记录数组a在位置j上出现次数，直到j走到和i相同的位置。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int a[]=new int[100010];
int s[]=new int[100010];
for(int i=0;i<n;i++){
a[i]=sc.nextInt();
}
int max=0;
for(int i=0,j=0;i<n;i++){
s[a[i]]++;
while(j<i&&s[a[i]]>1){
s[a[j]]--;
j++;
}
max=Math.max(max,i-j+1);
}
System.out.println(max);
}
}2.位运算
n的二进制表示中第k位是几
步骤：
1.先把第k位移到最后一位 n>>k
2.看个位是几 x&1
综合 n>>k&1
lowbit(x):返回x的最后一位1的数(二进制表示)
lowbit(1010)=10
lowbit(1011000)=1000
x&-x=x&(~x+1) //~x是指x取反
主要思路：x每次减去自己最后一位1及其之后的数，定义变量res记录减去的次数，即为x的二进制中包含1的个数
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
while(n-->0){
int x=sc.nextInt();
int res=0;
while(x!=0){
x-=lowbit(x);
res++;
}
System.out.print(res+" ");
}
}
public static int lowbit(int x){
return x & -x;
}
}3.离散化
用于值域较大的数组
给定数组a[ ]:1 3 7 20 117 1145
开辟数组b[ ]:0 1 2 3 4 5 用于存储数组a的值
需要解决的问题：
1.a[ ]可能存在重复元素 需要去重
2.如何算出x离散化后的值（二分查找）
步骤
1.存储所有待离散化的值
2.将所有值排序
3.去掉重复的值
public static int unique(List<Integer> list){
//双指针算法：i负责遍历list j负责记录不重复元素的下标并进行替换
int j=0;
for(int i=0;i<list.size();i++){
//重复的判定：第一个数或者和前面的数不相同的数
if(i==0||list.get(i)!=list.get(i-1))
//将不重复的元素放入list当中位置为j的地方
list.set(j,list.get(i));
j++;
}
return j;
}4.二分求出x对应离散化的值（找到第一个大于等于x的位置）
public static int find(int x,List<Integer> list){
//二分查找 找到第一个大于等于x的下标
int l=0;
int r=list.size()-1;
while(l<r){
int mid=(l+r)/2;
if(list.get(mid)>=x) r=mid;
else l=mid+1;
}
return l+1;
}
区间和
题解
初始坐标均为0
集合alls用来存放数组下标 集合add存放所有的加操作 集合query存放所有的查询操作
集合alls{1,3,7,1,3,4,6,7,8} 排序之后去重 {1,3,4,6,7,8}
集合add{(1,2),(3,6),(7,5)} 集合query{(1,3),(4,6),(7,8)}
遍历集合add 数组a用于存放映射的值：a[]={0,2,0,6,0,0,0,6,……}
遍历集合query 数组s用于存放数组a的前缀和 便于求区间[ l , r ]和:s[ r ]-s[ l-1 ]
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();//n次操作
int m = sc.nextInt();//m次询问
int N = 300010;//表示需要用到的下标数量，因为一开始可能重复，所以按照最大可能开最大的数组；
int[] a = new int[N]; //用来存值,从一开始的值，因为要用到前缀和，所以0不操作；
int[] s = new int[N];//用来存前缀和，从一开始进行记录a数组；
List<Integer> alls = new ArrayList<>();//用来存所有的下标，x,l,r;
//因为可能会重复乱序，所以需要进行去重，排序；
List<Pair> add = new ArrayList<>();//用来存n次操作
List<Pair> query = new ArrayList<>();//用来存m次询问
//输入n次操作，每次操作存入add集合中，然后将下标x存入alls集合中
for(int i = 0 ; i < n ; i ++ ){
int x = sc.nextInt();
int c = sc.nextInt();
add.add(new Pair(x,c));
alls.add(x);
}
//输入m次询问，每次询问存入query集合中，因为l,r是求和的下标区间，所以l,r都存入alls集合中。
for(int i = 0 ; i < m ; i ++ ){
int l = sc.nextInt();
int r = sc.nextInt();
query.add(new Pair(l,r));
alls.add(l);
alls.add(r);
}
Collections.sort(alls); //排序，现在alls集合中存的是x，l，r所有值
int unique = unique(alls); //这一步是去重，因为l，x，r中可能有重复的数；
alls = alls.subList(0,unique); //将去重之后的alls的长度范围中的值重新赋值给alls集合中。
//增强for循环 for(元素类型 变量名 ： 数组或者集合) 缺点：无下标，简单。
for(Pair item : add){
int index = find(item.first,alls);//
a[index] += item.second;//
}
for(int i = 1 ; i <= alls.size() ; i ++ ) s[i] = s[i-1] + a[i]; //这是前缀和公式代码
for(Pair item : query){
int l = find(item.first,alls); //
int r = find(item.second,alls); //
System.out.println(s[r] - s[l-1]); //
}
}
//去重（只要符合是第一个数或者后面一个数不等于前面一个数就是不重复的数）
public static int unique(List<Integer> list){
int j = 0;
for(int i = 0 ; i <= list.size() - 1; i ++ ){
if(i == 0 || list.get(i) != list.get(i-1)){
list.set(j,list.get(i)); //将不重复之后的数一个一个重新存入list中。
j ++ ;
}
}
return j;
}
//二分查找（在集合中查找你现在的下标是在什么位置，因为需要符合我们要用的前缀和公式，要让下标不是从0输出，最低的下标是1，符合前缀和的从1开始，所以输出的值加1）
public static int find(int x ,List<Integer> list){
int l = 0;
int r = list.size() - 1;
while(l < r){
int mid = ( l + r )/ 2;
if(list.get(mid) >= x) r = mid;
else l = mid + 1;
}
return l + 1;
}
}
//这是一个Pair类，用来存操作的类
static class Pair{
int first;
int second;
public Pair(int x,int c){
this.first = x;
this.second = c;
}
}
复杂度分析
时间复杂度：O(n+2∗m)log(n+2∗m)。如果set中所有元素都不重复，那么set会存储(n+2∗m)个元素，之后排序会花掉(n+2∗m)log(n+2∗m)的时间复杂度
空间复杂度：O(n+2∗m)
4.区间合并
步骤：
1.对区间左端点进行排序
2.对可合并区间进行讨论
题解
定义一个Pair类来存储区间二元组 如需要对类中二元组排序
class Pair implements Comparable<Pair>{
int x;
int y;
public Pair(int x,int y){
this.x=x;
this.y=y;
}
public int compareTo(Pair o){
return Integer.compare(x,o.x);
}
}定义一个集合alls用来存放所有的区间二元组 并对其进行排序
排序完成后，对集合alls中每一个二元组进行合并 定义st和ed用来标识合并区间初始和最终位置
st和ed初始为负无穷 定义二元组集合res存放合并完成后的区间
对A，B两个区间（默认排好序）能否合并的判断：
第一种情况：A和B两个区间没有丝毫重合 即A的右端点小于B的左端点
第二种情况：A和B衔接 即A的右端点和B的左端点处于同一位置 可以合并
第三种情况：A和B接壤 即A的左端点大于B右端点 可以合并
上述第二和第三种情况可以合并讨论 即最后只需关注A的右端点是否小于B的左端点
如果小于 判断ed是否为负无穷 如果不是则说明上一个区间已经合并完成 加入二元组集合res
如果是 则是初始状态 更新st和ed为第一个区间的左右端点
如果大于等于 只需更新区间的右端点 即ed为当前区间的右端点
最后对临界情况判断一下 ed是否为负无穷 不是则将最后一个区间加入res
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
List<Pair> alls=new ArrayList<>();
for(int i=0;i<n;i++){
int l=sc.nextInt();
int r=sc.nextInt();
alls.add(new Pair(l,r));
}
Collections.sort(alls);
int res=merge(alls);
System.out.println(res);
}
public static int merge(List<Pair> list){
List<Pair> res=new ArrayList<>();
int st=(int)-2e9;
int ed=(int)-2e9;
for(Pair item : list){
if(ed<item.l){
if(ed!=(int)-2e9) res.add(new Pair(st,ed));
st=item.l;
ed=item.r;
}else{
ed=Math.max(ed,item.r);
}
}
if(ed!=(int)-2e9) res.add(new Pair(st,ed));
return res.size();
}
static class Pair implements Comparable<Pair>{
int l;
int r;
public Pair(int l,int r){
this.l=l;
this.r=r;
}
public int compareTo(Pair o){
return Integer.compare(l,o.l);
}
}
}补充：
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
