Acwing算法基础 前缀和 差分 双指针 位运算 离散化 区间合并

前缀和与差分

AcWing 795. 前缀和

import java.util.*;
public class Main{
    public static void main(String[] args ){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        int[] arr=new int[n+1];
        arr[0]=0;
        for(int i=1;i<=n;i++) {
            arr[i]=sc.nextInt()+arr[i-1];
            // System.out.println(arr[i]);
        }
        
        while(m-- > 0) {
            int a=sc.nextInt();
            int b=sc.nextInt();
            System.out.println(arr[b]-arr[a-1]);
        }
    }
}

AcWing 796. 子矩阵的和——二阶前缀和

是点集 而不是 面积；所以要

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int q = scan.nextInt();
        int[][] a = new int[n+1][m+1];
        int[][] s = new int[n+1][m+1];
        for(int i = 1 ; i <= n  ; i ++ ){
            for(int j = 1 ;j <= m ; j ++ ){
                a[i][j] = scan.nextInt();
            }
        }
        for(int i = 1 ; i <= n  ; i ++ ){
            for(int j = 1 ;j <= m ; j ++ ){
                s[i][j] = s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
            }
        }
        while(q-->0){
            int x1=scan.nextInt();
            int y1=scan.nextInt();
            int x2=scan.nextInt();
            int y2=scan.nextInt();
            
            System.out.println(s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1]);
        }
        
    }
}

AcWing 797. 差分

差分是前缀和的逆运算；类似于 积分和微分的关系；
差分作用之一： 用O(1)的时间给 a数组的某段区间的数+c(数字)；

 

import java.util.Scanner;
public class Main{
    static int[] b = new int[100010];
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int[] a = new int[n+1];
        for(int i = 1 ; i <=n  ; i ++ ){
            a[i] = scan.nextInt();
            insert(i,i,a[i]);//b数组初始化成a数组，后面就不用再加a
        }
        
        while(m-->0){
            int l = scan.nextInt();
            int r = scan.nextInt();
            int c = scan.nextInt();
            insert(l,r,c);
        }
        for(int i = 1 ; i <= n  ; i ++ ){
            b[i]+=b[i-1];
            System.out.print(b[i]+" ");
        }
    }
    public static void insert(int l ,int r ,int c){
        b[l] += c;
        b[r+1] -= c;
    }
}

AcWing 798. 差分矩阵

构造 b[i][j] 矩阵使得，a[i][j]=双重for的 b[i][j] 之和；
二维 差分就是 给其中一个子矩阵 加 C； b[i][j]+c的效果就是这一点右下角点集全加c

import java.util.*;

public class Main{
    static int N = 1010;
    static int n, m, q;
    static int[][] b = new int[N][N];
    static int[][] a = new int[N][N];

    public static void insert(int x1, int y1, int x2, int y2, int c){
        b[x1][y1] += c;
        b[x1][y2 + 1] -= c;
        b[x2 + 1][y1] -= c;
        b[x2 + 1][y2 + 1] += c;
    }

    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        n = scan.nextInt();
        m = scan.nextInt();
        q = scan.nextInt();
        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++){
                a[i][j] = scan.nextInt();
                insert(i, j, i, j, a[i][j]);//初始化b=a数组
            }

        while (q -- > 0){
            int x1 = scan.nextInt();
            int y1 = scan.nextInt();
            int x2 = scan.nextInt();
            int y2 = scan.nextInt();
            int c = scan.nextInt();
            insert(x1, y1, x2, y2, c);
        }

        for (int i = 1; i <= n; i ++)
            for (int j = 1; j <= m; j ++)
                b[i][j] += b[i][j - 1] + b[i - 1][j] - b[i - 1][j - 1];

        for (int i = 1; i <= n; i ++){
            for (int j = 1; j <= m; j ++)
                System.out.print(b[i][j] + " ");
            System.out.println();//换行
        }
    }
}

双指针算法

AcWing 799. 最长连续不重复子序列

先写暴力，看ij单调关系，单调关系套模版

 s[]数组就是为了 判重的，因为>1就一直循环；

import java.util.*;
public class Main{
    static int[] s=new int[100010];
    public  static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[] a=new int[n];
        int res=0;
        for(int i=0;i<n;i++) a[i]=sc.nextInt();
        for(int i=0,j=0;i<n;i++) {
            s[a[i]]++;
            while(s[a[i]]>1){//存在重复元素
                s[a[j]]--;//j需要移动到 重复元素位置才能跳出循环
                j++;
            }
            res=Math.max(res,i-j+1);
        }
        System.out.println(res);
    }
}

AcWing 800. 数组元素的目标和

这道题如果不仔细思考
i变大的时候，和不变，一个变大另一个变小， j必须从大往前走 会超时；
而且和>的时候就改跳出while了

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int m = scan.nextInt();
        int targe  = scan.nextInt();
        int[] a = new int[n];
        int[] b = new int[m];
        for(int i = 0 ; i < n ; i ++ ){a[i] = scan.nextInt();}
        for(int i = 0 ; i < m ; i ++ ){b[i] = scan.nextInt();}

        for(int i = 0,j=m-1 ; i < n ; i ++ ){
            while(a[i]+b[j]>targe &&j>=0){
                j--;
            }
            if(a[i]+b[j]==targe){
            System.out.println(i+" "+j);
            return ;//因为题目说了只有一组，否则应该break;
            }
        }
    }
}

AcWing 2816. 判断子序列

位运算

求n的第k位数字：n＞＞k＆1

返回n的最后一位1：lowbit（n）＝n＆-n；lowbit是树状数组的基本操作

AcWing 801. 二进制中1的个数 lowbit

离散化

a数组是存的数 s是前缀和 vector是存的要离散化的值

去重函数unique

AcWing 802. 区间和

局域1e9很大，但是数很稀疏1e5；n读1e5，m读左右端点 两个1e5；一共3e5；
在存储add数据时不要用HashMap！！！
在存储query数据时不要用LinkedHashMap或TreeMap！！！
Map集合在存储数据时会底层根据键的值来计算数据的哈希值从而确定数据的存放位置，如果当前要存储的数据的键和已经存进去的某个数据的键一样或者计算出来的哈希值一样时（哈希碰撞），那么当前数据不会被存入Map集合中，而是被直接丢弃！！！
所以大家还是老老实实地定义一个Pair类来存储数据吧

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();//n次操作
        int m = scan.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 = scan.nextInt();
            int c = scan.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 = scan.nextInt();
            int r = scan.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类，用来存操作的类
   class Pair{
        int first;
        int second;
        public Pair(int x,int c){
            this.first = x;
            this.second = c;
        }
    }

区间合并

AcWing 803. 区间合并

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        List<PIIs> alls = new ArrayList<>();//用来存一开始的数

        for(int i = 0 ; i < n ; i  ++ ){
            int l = scan.nextInt();
            int r = scan.nextInt();
            alls.add(new PIIs(l,r));
        }
        Collections.sort(alls);//排序
        int res = qu(alls);
        System.out.println(res);
    }
    public static int qu(List<PIIs> list){
        List<PIIs> res = new ArrayList<>();//用来存区间和之后的数
        int st = (int)-2e9;
        int ed = (int)-2e9;
        for(PIIs item : list){
            if(ed < item.x){//找到了一个新区间
                //不是初始区间就把上一个维护好的放到结果
                if(st != (int)-2e9) res.add(new PIIs(st,ed));
                st = item.x;ed = item.y;//重新标记 要维护的 新区间的 首尾
            }else //当前这个区间 和 我们维护的区间 有交集，求两个区间的 并集
                ed = Math.max(ed,item.y);
        }
        //最后的判断，防止输入数组为空，没有任何区间
        if(ed != (int)-2e9) res.add(new PIIs(st,ed));

        return res.size();
    }
}
class PIIs implements Comparable<PIIs>{
    int x,y;
    public PIIs(int x,int y){
        this.x = x;
        this.y = y;
    }
    public int compareTo(PIIs o){
        return Integer.compare(x,o.x);
    }
}