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

news2025/1/11 2:25:32

前缀和与差分

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. 区间合并

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/750537.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

【从零开始学CSS | 第二篇】伪类选择器

目录 前言&#xff1a; 伪类选择器&#xff1a; 常见的伪类选择器&#xff1a; 举例&#xff1a; 小窍门&#xff1a; 总结: 前言&#xff1a; 上一篇文章我们详细的为大家介绍了一些常见的选择器&#xff0c;这几篇我们将再次介绍CSS中的一个常见选择器——伪类选择器&am…

flutter开发实战-css的linear-gradient的值转换成LinearGradient

flutter开发实战-css的linear-gradient的值转换成LinearGradient 在开发中遇到了参照前端的css的属性值&#xff0c;需要将css的linear-gradient值转换成LinearGradient&#xff0c;这样可以直接设置相应的值。这里暂时不涉及到&#xff0c;颜色值名称、color-stop1&#xff0…

第6章 NVMe 介绍 6.1-6.3

6.1 AHCI 到 NVMe AHCI协议。NVMe协议。 HDD 和早期的 SSD 绝大多数都是使用SATA接口&#xff0c;跑的是AHCI&#xff0c;它是一种系统接口标准。 后来&#xff0c;AHCI 和 SATA 不能满足高性能和低时延 SSD 的需求&#xff0c;SSD 需要更快、更高效的协议和接口。因此 NVMe 出…

webug4.0靶场通关笔记

文章目录 注入显错注入布尔注入延时注入post注入过滤注入宽字节注入xxe注入csv注入万能密码登陆 XSS反射型xss存储型xssDOM型xss过滤xss链接注入 任意文件下载任意文件下载mysql配置文件下载 上传漏洞文件上传(前端拦截)文件上传(解析漏洞)文件上传(畸形文件)文件上传(截断上传…

layui中laydate日期组件闪动打不开问题解决

在laydate.render里配置trigger:click’就可以了&#xff08;已解决&#xff09;

路径规划算法:基于人工蜂鸟优化的路径规划算法- 附代码

路径规划算法&#xff1a;基于人工蜂鸟优化的路径规划算法- 附代码 文章目录 路径规划算法&#xff1a;基于人工蜂鸟优化的路径规划算法- 附代码1.算法原理1.1 环境设定1.2 约束条件1.3 适应度函数 2.算法结果3.MATLAB代码4.参考文献 摘要&#xff1a;本文主要介绍利用智能优化…

Leetcode-每日一题【83.删除排序链表中的重复元素】

题目 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2]输出&#xff1a;[1,2] 示例 2&#xff1a; 输入&#xff1a;head [1,1,2,3,3]输出&#x…

Docker 安装与基本使用

一、简介 Docker 官方文档、Docker 中文文档&#xff0c;更新会落后于官方文档 什么是 Docker ? Docker 是一个应用打包、分发、部署的工具&#xff0c;也可以把它理解为一个轻量的虚拟机&#xff0c;它只虚拟软件需要的运行环境&#xff0c;多余的一点都不要&#xff0c;而普…

jinkens编译问题

可以看到是NapaMedia 编译有问题 往上面查看 再在gerrit上看提交的这个文件。。打开看下是不是有冲突 果然有冲突 有冲突在gerrit上直接解决冲突 然后保存 updatechanges再publish edit 然后点进编译

Gym - 101652

A - Odd Palindrome 题意&#xff1a;给你一个字符串如果它的所有回文子串长度为奇数&#xff0c;输出Odd.否则输出Or not. 思路&#xff1a;其实只要判断是否有两个相连的字符就可以了 #include <bits/stdc.h> using namespace std; #define pi 3.1415926 #define X f…

STM32初识---概念了解(下)

复位和时钟控制&#xff08;RCC) 系统复位 当发生以下任一事件时&#xff0c;产生一个系统复位&#xff1a; 1. NRST引脚上的低电平(外部复位) 2. 窗口看门狗计数终止(WWDG复位) 3. 独立看门狗计数终止(IWDG复位) 4. 软件复位(SW复位) 5. 低功耗管理复位 电源复位 当以下事件中…

XML文档详解

目录 XML文档 一、XML文件 二、Dom4J解析XML文件 三、Sax解析XML文件 四、使用Dom4j的XPath解析XML文件 4.1XPath语法 4.2 获取sys-config.xml文件的配置信息 4.3 获取server.xml文件的配置信息 4.4 获取bookstore.xml文件的配置信息 XML文档 一、XML文件 1.1 学习重…

s3fs安装使用

s3fs安装使用 前言 最近在预研将对象存储桶挂载到本地文件系统的需求&#xff0c;查阅了一些相关的资料&#xff0c;找到s3fs-fuse开源组件&#xff0c;可以满足需求&#xff0c;本文主要记录一下s3fs的部署以及使用。 s3fs简介 s3fs 是一个 C 开发的开源工具&#xff0c;可…

Amplify-Shader-Pack下载

ASE相关效果资源https://download.csdn.net/download/mayzhengxi/87915649?spm1001.2014.3001.5503

[linux] ebtables技术

Linux系统中使用ebtables技术 ebtables就是以太网桥防火墙&#xff0c;以太网桥工作在数据链路层&#xff08;MAC层&#xff09;&#xff0c;ebtables主要过滤数据链路层数据包&#xff0c;ebtables能过滤桥接流量。ebtables每个阶段的过滤时机都比iptables早。 ebtables的配置…

centos7.9修改ssh默认的端口号

多开几个ssh&#xff0c;防止配置文件错误&#xff0c;将自己关在服务器外面了 netstat -ntlp|grep ssh # ssh对应的端口号 修改sshd_config配置文件 /etc/ssh/sshd_config&#xff0c;重启sshd服务 #Port 22 Port 10011 # 端口号自己定义&#xff0c;不能超过65535&#xf…

基于Java+Swing+Mysql影院购票系统

基于JavaSwingMysql影院购票系统 一、系统介绍二、功能展示1.用户登陆2.用户订票管理3.电影售票中心4.电影上映管理4.退票记录查询 三、数据库四、其他系统实现五、获取源码 一、系统介绍 该系统实现了查看管理员登陆、用户订票管理、电影上映管理、电影售票中心、退票记录查询…

重定义/自定义printf到串口输出实现的三种方法(cubeide)

重定义/自定义printf到串口输出实现的三种方法&#xff08;cubeide) 文章目录 重定义/自定义printf到串口输出实现的三种方法&#xff08;cubeide)1.重写_write函数2.重定义PUTCHAR_PROTOTYPE宏3.va_list自定义printf总结&#xff1a; 1.重写_write函数 注释掉syscalls.c文件中…

Java中Map使用增强for循环和迭代器获取key和value

加油&#xff0c;新时代打工人&#xff01; java中List集合三种获取集合元素方式 本文运行代码使用 jdk1.8 for 语句比较简单&#xff0c;用于循环数据。 Java迭代器&#xff08;Iterator&#xff09;是 Java 集合框架中的一种机制&#xff0c;是一种用于遍历集合&#xff08…

非线程安全问题

目录 实例变量共享导致的“非线程安全问题” 如何解决这个问题&#xff1f; i--与System.out.println()出现引起的“非线程安全问题” 非线程安全主要是指多个线程对同一个对象中的同一个实例变量进行操作时会出现值被更改、值不同步的情况&#xff0c;进而影响程序的执行流…