Minjie's Blog

SSI 中的VC撤销与 DID 注销

Mon, 30 Mar 2026 14:01:58 +0800

本文是对 IEEE Access 2026 综述论文《A Survey on Credential Revocation and DID Deactivation in Self-Sovereign Identity Systems》的系统性解析笔记。论文提出 SSI 撤销机制的四大类分类框架（列表式、密码学累加器、正向确认、治理感知），并独立分析 DID 注销层。笔记按原文结构展开，重点覆盖各类机制的技术细节、隐私分析、可扩展性对比以及开放挑战。

V'CER: 约束网络中的高效证书验证

Sat, 28 Mar 2026 15:06:30 +0800

no description

Crset Private Vc Revocation

Thu, 26 Mar 2026 19:25:03 +0800

本文是对论文《CRSet: Private Non-Interactive Verifiable Credential Revocation》的详细阅读笔记。论文识别了现有 SSI 撤销机制（如 Bitstring Status List、AnonCreds）在签发方活动隐私上的根本缺陷，提出并形式化证明了「选择计数不可区分性」这一隐私定义，并设计实现了满足该定义的 CRSet 机制，每个以太坊 Blob 可支持约 17 万张凭证的撤销数据。

EVOKE：面向物联网的高效可验证凭证吊销机制

Thu, 26 Mar 2026 12:30:54 +0800

EVOKE 针对 IoT 环境下 VC 吊销机制在存储、连通性与可扩展性方面的不足，提出一种基于密码学累加器的高效撤销方案。相比传统 PKI 吊销方法（OCSP、CRL）及 W3C Revocation List 2020，EVOKE 通过 ECC 正向累加器将有效凭证集合压缩为常数大小，并结合 witness 实现本地可验证性，从而避免在线查询需求；同时借助 DAG 分布式账本实现吊销信息的高效传播与离线同步。实验结果表明，该方案在资源受限设备上具有较低的计算开销，并在大规模网络中表现出优良的同步性能，体现了在低存储、离线验证与批量吊销之间的良好权衡。

去中心化标识符（DID）与可验证凭证（VC）综述

Sun, 22 Mar 2026 15:00:06 +0800

系统梳理 IEEE 2025 年综述论文《A Survey on Decentralized Identifiers and Verifiable Credentials》的核心内容，包括数字身份演进历史、DID/VC 技术架构、安全威胁与缓解策略、五大主流实现框架对比、跨领域应用案例（智能交通/医疗/工业/教育等）、全球监管项目动态，以及标准化、可扩展性、隐私合规等关键挑战与未来研究方向。

Decentralized Identity Systems: Architecture, Challenges, Solutions and Future Directions

Fri, 20 Mar 2026 14:12:28 +0800

本文对数字身份管理系统进行了全面综述，重点分析基于区块链的去中心化身份（SSI）范式——包括其架构、组件、生命周期与工作流程，并依据自主主权身份的十项原则对现有解决方案进行评估，最后讨论了阻碍去中心化身份全面落地的技术与非技术挑战。

Books 2026

Wed, 04 Mar 2026 22:14:00 +0800

这是我在2026年里的书单，以及相应的思考和学习笔记大杂烩

常俞吉他｜学习笔记

Fri, 30 Jan 2026 19:01:57 +0800

记录常俞吉他课程的完整学习过程，涵盖基础概念、指法练习、练琴要点与个人理解，用于长期复盘与持续进阶的吉他学习笔记。

zkLogin: 基于现有凭证的隐私保护区块链认证

Wed, 21 Jan 2026 21:20:09 +0800

zkLogin 是一种创新的区块链认证方案,允许用户使用 Google、Facebook 等现有 OpenID 账户进行区块链交易认证,通过零知识证明技术保护隐私,无需管理私钥

数学基础——数学篇作业集

Mon, 29 Dec 2025 13:25:26 +0800

本作业集包含四次数学基础作业的完整解答，涵盖：矩阵范数理论、特征值与特征多项式、正交投影、 LU分解、Cholesky分解、QR分解、SVD奇异值分解、最小二乘法、图像处理应用（旋转与压缩）、以及 kNN 分类器的实现。每道题目都配有详细的数学推导过程和部分编程实现代码。

xRWA: 真实世界资产的跨链互操作性框架

Thu, 25 Dec 2025 03:52:02 +0800

2025年预印本论文解读:随着RWA代币化市场从2025年初的86亿美元激增至230亿美元(增长260%),Citibank预测2030年将达到4万亿美元规模。xRWA框架通过创新性地结合DID/VC身份管理、SPV跨链认证和无需关闭的跨链通道,首次系统性地解决了RWA在异构区块链间的互操作性挑战。本文详细解析了RWA复合凭证(RWA-CC)的四模块设计、SPV认证协议如何避免重复验证、跨链通道如何实现批量结算,以及在房地产、稳定币、私募信贷等场景的应用价值。

Web3.0 身份认证系统综述：中心化与去中心化方案对比分析

Wed, 24 Dec 2025 15:03:41 +0800

基于 Future Internet 2025 年发表的综述论文，系统分析传统中心化身份管理系统与新兴去中心化方案在可扩展性、安全性、可靠性、适应性和成本方面的对比，为 Web3.0 身份认证研究提供全面参考

数学基础算法篇

Sun, 21 Dec 2025 15:50:54 +0800

金老师主讲的研究生课程《数学基础算法篇》完整笔记，从算法分析基础开始，系统介绍相似度搜索、概率不等式、流式数据处理、分布式计算、哈希技术、优化算法、图算法等内容，理论与实践相结合，为解决大规模数据处理问题提供数学和算法基础。

黑马点评项目笔记

Wed, 17 Dec 2025 21:01:53 +0800

"记录黑马点评项目的学习过程，包括 Redis 的多种应用场景、缓存穿透/击穿/雪崩解决方案、分布式锁实现、UV 统计、好友关注等功能的技术实现细节"

机器学习习题集

Sat, 13 Dec 2025 20:26:19 +0800

这是胡老师出的考题集，涵盖机器学习课程的28道经典问题详解，包括：基础理论（梯度下降、交叉熵损失、最大似然估计）、判别模型（Logistic回归、GDA、SVM对偶优化）、深度学习（Transformer架构、RoPE、KV Cache、门控注意力）、强化学习（多臂老虎机、MDP Bellman方程、最优策略）、大模型优化（XGBoost二阶泰勒展开、Roofline模型、AI Agent特性）。每道题配有完整数学证明和算法原理解析。

四川麻将指南

Sat, 13 Dec 2025 12:16:13 +0800

详细介绍四川麻将的规则、技巧和进阶策略，让你快速从新手成长为高手

常用命令行指令参考

Wed, 10 Dec 2025 11:28:47 +0800

一份完整的开发者命令行速查表，涵盖 Windows PowerShell、Linux/Unix 终端、Git 版本控制和 GitHub CLI 工具的常用指令、参数说明|和实际使用场景示例

MySQL 语句速查笔记

Wed, 10 Dec 2025 08:45:19 +0800

MySQL 常用语句全面速查手册，涵盖基础到高级的所有常用操作

zkBID: 区块链账户与Web 3.0去中心化身份

Mon, 08 Dec 2025 10:50:12 +0800

WWW 2025论文解读：zkBID是首个同时实现身份匿名性和可信性的Web 3.0去中心化身份系统。通过结合zkSNARK零知识证明和MLSAGS可链接环签名，在完全去中心化的前提下，将区块链灵魂账户与真实用户建立一对一可验证映射，同时保护用户隐私。本文详细解析了三阶段IVAC流程的技术设计、安全性证明、以太坊测试网性能评估，以及在社交网络、DAO治理、DeFi等场景的应用价值。

算法刷题必备：Java集合与算法模板

Sun, 07 Dec 2025 16:33:25 +0800

Java 集合框架完整使用手册 + 常用算法模板

Hugo 常用指令与 Markdown 配置指南

Sat, 06 Dec 2025 17:43:45 +0800

一份完整的 Hugo 和 Markdown 使用手册，包含常用命令、配置说明和最佳实践

Mon, 01 Jan 0001 00:00:00 +0000

==⚠ Switch to EXCALIDRAW VIEW in the MORE OPTIONS menu of this document. ⚠== You can decompress Drawing data with the command palette: ‘Decompress current Excalidraw file’. For more info check in plugin settings under ‘Saving’

Excalidraw Data

Text Elements

Drawing

N4KAkARALgngDgUwgLgAQQQDwMYEMA2AlgCYBOuA7hADTgQBuCpAzoQPYB2KqATLZMzYBXUtiRoIACyhQ4zZAHoFAc0JRJQgEYA6bGwC2CgF7N6hbEcK4OCtptbErHALRY8RMpWdx8Q1TdIEfARcZgRmBShcZQUebR4ABm0ANho6IIR9BA4oZm4AbXAwUDBSiBJuCAAhAEcAZQBNAGl8AEYAJTTSyFhESsdcfU5iLrLMbmceAA4AVn4ymAmAZiWA

FniAdjWljbmiyAoSdW4eHfnISQRCZWluVtnziGtlYO4Ex+YoUjYAawQAYTY+DYpEqAGJWghIZDRpBNLhsD9lN8hBxiIDgaCJF9rMw4LhAjlYRAAGaEfD4OqwV4SQQeYmfb5/ADqR0kJw+X1+CCpMBp6DpFUeKJuHHCeTQrUebHx2DUi0lCXe+wgyOEcAAksQJah8gBdR4k8hZLXcDhCCmPQhorCVXAJYkotFi5g6krdaDwcS8fYAXw+CAQI0VyVa

PBmU1ayWVHsYLHYXDQ00ecdYnAAcpwxCcEjsEgBOHjJVZW5gAEQyUCD3C+QgQj00wjRAFFglkcjrzZaVUI4MRcFXg6hWhsNkWllGeKsw8lHkQOD8zRb8HO2Ijq2gSQQwkV/UV3ZAKhJJAApACKJI2zdWADVib1vRgKYQ5EhHuM0M4w1KVQrUJNVimTZtl2R5DmIY5JTOFVLmuW40FWPgVWefkYzKRluQxEFwWhKE3xVeFETVVF0SBbDsXIDg8QJb

IoGJMkKV5fkIEFEZOSZBBWQg9kk3Y7kmMfVjHWEUVxTuaVZXlO4lUeYjNW1AoDRVI1BgQU00C7FcVWtYhbQkXBWmEkiXTdfYei9E4/QDDdhxmVZVi2QtAJTJg00TYdZxVVME0zDhszQfMR3sjYEimKZSwrYJBxrUg6wbJtiFbTJaM7ZdHl7ftoslUdx0nHh8qQj150XDS0pVYF1yHLd8B3UpfXAJTIFwOA4CpAdvXdaBLiySoiBuOj5gYQgEAoKo

ESRJ1SMxcESVmubRggbAREJKANSrfQqQ4rCsXQCE8JhQaltIFa1syMaiMm7bKhxKj8RWhajpO9aADFyUpalBKBIUikW5baNOjauRZNkOR+x7/vWzb+I+yohMOv6cgB9oRMkEzxLBhHVvWgB5STYGktDfuOiHMmezgoGewZyT/PYynBxGXvJupCCMb1Enh4mGcyAAVLAoAAQT69yIGCEkBoxzmscyNrSAF462AoS5cCHTSOaezJmzRfn5cVkIhyeH

WHsxgHte+ChuYsiRJqNyWAee40EGR/lVZ+5hsG+CkAA1uGSaD0PdoF8AabhVnzfNtDHZIZmScNBqMNgDG4A8GAIOs7l3NWSf0ZHjLEq2EoW5ESGZ1mc0GoviCpBA4G4WnIArgBZNhdM13BNGCKrt3rH6K6utBk6qIF9dIZR4QACh4EdqF4KeZ42aekhmABKYl2gQZQLQJSoR/H053l4JZ973hftGXiAM4llaob+XGoATVLuzKFSsjXm1SGtZQk5V

bI247mK4pVNgIgNc0C1m7h6Dgql/7gLKMIKA85vRgMePoAkfxSDpigaA2KMDIAoNIGg1u7cbJgIvrAzQAArBA2Bch1EgXAJuLdIFEM7jVGBTxqGEEYNzBO+Av4egfLDDIHDODEiWp8AwFs+ilUfmUCqfwWFhENN8DaQi74iM3F3OcoQBYcK4TwpcFJSGQEcMwX+AJyZ8wbtkIQ3Bqq1T3JABi4Qk71V9EAA=

Mon, 01 Jan 0001 00:00:00 +0000

Drawing

N4IgLgngDgpiBcIYA8DGBDANgSwCYCd0B3EAGhADcZ8BnbAewDsEAmcm+gV31TkQAswYKDXgB6MQHNsYfpwBGAOlT0AtmIBeNCtlQbs6RmPry6uA4wC0KDDgLFLUTJ2lH8MTDHQ0YNMWHRJMRZFFgAGRQA2MiRPVRhGMBoEAG0AXXJ0KCgAZQCwPlBJfDwc7A0+Rk5MTHIdGCIAIXRUAGtirkZcAGF6THp8BBAAYgAzcYmQAF8poA===

Mon, 01 Jan 0001 00:00:00 +0000

SQL基础

NOSQL和SQL的区别

NOSQL: 非关系型数据库，更加宽松的模型BASE, 即基本可用，软状态和最终一致性
SQL：关系型数据库，支持ACID，原子性、一致性、隔离性、持续性

数据库三大范式

第一：原子项
第二：非码属性完全依赖于候选码，而不是单独某一个部分（部分函数依赖）
第三：消除了传递依赖

联表查询

Mon, 01 Jan 0001 00:00:00 +0000

小林code

Mon, 01 Jan 0001 00:00:00 +0000

图解redis redis常见面试题

认识redis

什么是redis

基于内存的数据库，因此读写速度非常快
提供多种数据类型支持不同的业务场景

redis和Memcached有什么区别

共同点：
- 都是基于内存的数据库
- 都有过期策略
- 两者性能都非常高
不同点：
- Redis支持的数据类型更加丰富
- 支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载使用，而Memcached没有持久功能，数据全在内存中
- Redis原生支持集群模式，Memcached没有原生的集群模式，需要依赖客户端来实现集群中分片
- Redis还支持订阅模型，Lua脚本，事务等功能

为什么用redis作为MySQL的缓存

高性能

Mon, 01 Jan 0001 00:00:00 +0000

小林code

Spring

说一说你对Spring的理解

spring的核心思想你是如何理解的

Spring IoC和AOP介绍一下

Spring的aop介绍一下

IoC和AOP是通过什么机制来实现的

怎么理解Spring Ioc

依赖倒置、依赖注入、控制反转分别是什么

依赖注入了解吗，怎么实现依赖注入的

如果让你设计一个SpringIoc,你觉得会从哪些方面考虑这个设计

SpringAOP主要想解决什么问题

AOP在spring中的应用，你知道哪些

谈谈你对Spring IoC的了解程度

SpringAOP的原理了解吗

动态代理是什么

动态代理和静态代理的区别

能使用静态代理的方式实现AOP吗

AOP实现有哪些注解

什么是反射，有哪些应用场景

spring是如何解决循环依赖的

Spring三级缓存的数据结构是什么

Spring框架中都用到了哪些设计模式

Spring常用注解有什么

Spring的事务什么情况下会失效

Spring的事务，使用this调用是否生效

Bean的生命周期说一下

Bean是否单例

Bean的单例和非单例，生命周期是否一样

Spring Bean的作用域有哪些

Spring容器里存的是什么

Spring中，在bean加载/销毁前后，如果想实现某些逻辑，可以怎么做

Spring给我们提供了很多扩展点，这些有了解吗

SpringMVC

MVC分层介绍一下

了解SpringMVC的处理流程

Handlermapping和Handlereadapter有了解吗

SpringBoot

为什么使用Springboot

SpringBoot比Spring好在哪

Springboot用到了哪些设计模式

怎么理解SpringBoot中的约定大于配置

SpringBoot的项目结构是怎么样的

SpringBoot自动装配原理是什么

说几个启动器（start）

写过SpringBoot starter吗

SpringBoot里面有哪些重要的注解？还有一个配置相关的注解是什么

SpringBoot怎么开启事务

SpringBoot是怎么做到导入就可以直接使用的

SpringBoot过滤器和拦截器说一下

Mybatis

与传统的JDBC相比，Mybatis的优点

Mybatis绝的在哪方面做的比较好

还记得JDBC的连接数据库的步骤吗

项目中如何使用原生的mybatis去查询

Mybatis中的`#`和`$`的区别

MybatisPlus和Mybatis的区别

MyBatis运用了哪些常见的设计模式

SpringCloud

SpringCloud的了解，以及和SpringBoot的区别

用过哪些微服务组件

负载均衡算法有哪些

如何实现一直均衡给一个用户

介绍一下服务熔断

介绍一下服务降级

Mon, 01 Jan 0001 00:00:00 +0000

小林code

概念

Java特点

跨平台
面向对象
内存管理

Java的优劣势

优势：跨平台/生态系统/面向对象/内存管理/多线程/安全模型
劣势：编译开销/语法繁琐/内存消耗

Java跨平台原因

Java首先被编译成.class(字节码文件)
JVM将字节码翻译成机器码

JVM、JDK、JRE三者关系

JVM：运行环境。注：将字节码直接映射到本地的cpu指令集和OS的系统调用，所以屏蔽了与操作系统相关的信息
JDK：开发工具包
JRE：JVM+Java类库

Java解释和编译都有

解释：JVM方法调用计数器，当累计计数大于一定值的时候，使用JIT编译成机器码，否则就是用解释器进行解释执行
编译：源代码被编译成字节码，JIT会被那编译过的机器码保存起来

解释型语言和编译型语言区别

编译型语言：源代码被编译成机器码或是字节码，生成可执行文件。
解释型语言：逐行解释执行源代码，不生产独立的可执行文件。在执行程序时同时进行翻译

值传递和引用传递

值传递：传递实际值的副本
引用传递：实际上是伪概念，更改指向同一个对象的内部数据

数据类型

基本的数据类型

数值型：整型（byte short int long）、浮点型（float double）
字符型：char
布尔型：boolean

类型互转出现的问题

数据向上转一般是安全的
出现的问题1.数值溢出
出现的问题2.精度丢失

为什么要使用bigDecimal而不是double进行运算

double是使用二进制来进行的浮点运算，二进制不能精确的表示小数，比如说1/3
bigDecimal则是可以进行精确计算

装箱和拆箱

将数据类型和对应的包装类进行转换的过程
弊端：频繁的自动装箱操作可能会影响到程序的性能

Java中的Integer和int

Integer

Mon, 01 Jan 0001 00:00:00 +0000

https://www.bilibili.com/video/BV16J411h7Rd 小林code八股

多线程

内存模型JMM - 介绍

解决多线程并发的一套规则，规定了在多线程环境下，线程怎么访问共享变量才能不出错，核心处理是可见性、原子性、有序性这三个问题。核心思路：规定变量必须从主内存加载到工作内存才能进行操作，改完再写回主内存。

Mon, 01 Jan 0001 00:00:00 +0000

小林code

Mon, 01 Jan 0001 00:00:00 +0000

小林code

内存模型

介绍Java中的内存模型

JVM中的堆和栈有什么区别

栈中存的是指针还是对象

堆可以分为哪几部分

如果有个大对象一般是在哪个区域

程序计数器的作用，为什么是私有的

方法区中的方法的执行过程是怎么样的

方法区中还有哪些东西

String保存在哪里

`String s = new String("abc")`的执行过程中分别对应哪些内存区域

引用类型有哪些？有什么区别？

弱引用了解吗？举例说明在哪可以用到

内存泄漏和内存溢出的理解

jvm内存结构有哪几种内存溢出的情况

堆溢出的情况和对应解决办法

栈溢出的情况有哪些

内存泄漏和内存溢出的例子及解决办法

类初始化和类加载

创建对象的过程

对象的生命周期

类加载器有哪些

Java中双亲委派是什么，有什么用？

类加载过程

类加载和双亲委派原则

垃圾回收

什么是Java中的垃圾回收？如何触发垃圾回收？

判断垃圾的方法有哪些

垃圾回收算法是什么，解决了什么问题

java中的gc机制你知道什么

垃圾回收算法有哪些

垃圾回收器有哪些

标记清除算法的缺点是什么

垃圾回收算法哪些阶段会`stop the world`

`minorGC、majorGC、fullGC`的区别，什么场景会触发`fullGC`

垃圾回收器CMS和G1的区别

CMS和G1的使用场景

G1回收器的特色是什么

GC只会对堆进行GC吗

Mon, 01 Jan 0001 00:00:00 +0000

小林code

概念

数组和集合的区别

Java中的线程安全的集合是什么

`Collections`和`Collection`的区别

集合遍历的方法有哪些

`List`

Java中list的几种实现

list可以一边遍历一边修改元素吗

list如何删除某个指定下标的元素

`ArrayList`和`LinkedList`的区别，哪个集合线程安全

`ArrayList`和`vector`的区别

`ArrayList`为什么线程不安全

如何`ArrayList`转换为线程安全？

`ArrayList`和`LinkedList`的应用场景有哪些

`ArrayList`的扩容机制说一下

`CopyonWriteArraylist`是如何实现线程安全的

List里面填写基本数据类型为什么会报错

List和数组如何相互转换

`Set`

Java集合中`List`和`Set`的区别是什么

如何对`set`排序

`Set`集合的特点，是如何实现Key无重复的

有序的Set是什么？记录插入顺序的集合是什么

`Map`

如何对map进行快速遍历

HashMap实现原理介绍一下

`HashMap`链表发生转换后为什么不用平衡二叉树

了解的哈希冲突解决办法有哪些

`HashMap`是线程安全的吗

`hashMap.get()`方法是怎么样的过程

`hashMap.put()`方法是什么样的过程

`HashMap.get()和HashMap.put()的过程

`HashMap.get()`一定安全吗

`HashMap`一般用什么做Key,`String`为什么适合来做`key`呢

实现`HashMap`为什么用红黑树而不是平衡二叉树

`hashmap`的`key`可以为`null`吗

重写`HashMap`的`equal`和`hashcode`方法需要注意什么

重写`HashMap`的`equal`方法不当会造成什么后果

列举`HashMap`在多线程的情况下可能出现的问题

`HashMap`的扩容机制介绍一下

`HashMap`的大小为什么是2的n次方大小

往`HashMap`中存20各元素，会扩容几次

`HashMap`的负载因子是什么

`HashMap`和`HashTable`有什么不一样的？`HashMap`一般怎么用

`ConcurrentHashMap`是怎么实现的

分段锁是怎么加锁的

分段锁是可以重入的吗

既然有了`synchronized`为什么还要有CAS呢

`ConCurrentHashMap`用了乐观锁还是悲观锁

`HashTable`的底层原理是什么

`HashTable`的线程安全是怎么实现的

`hashMap,HashTable`和`concurrentHashTable`有什么区别

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //动态规划，点评dp[i][j]表示字符串s的前i个字符能否与字符串p的前j的字符串实现正则表达式匹配
  public boolean isMatch(String s, String p) {
       int m = s.length();
       int n = p.length();
       boolean[][] dp = new boolean[m+1][n+1];
       dp[0][0] = true;
       for (int i = 1; i <= n; i++) {
            if (p.charAt(i-1) == '*') {
                dp[0][i] = dp[0][i-2];
            }
       }
       for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (p.charAt(j - 1) == '.' || p.charAt(j-1) == s.charAt(i-1)) {
                dp[i][j] = dp[i-1][j-1];
            } else if (p.charAt(j-1) == '*') {
                dp[i][j] = dp[i][j-2] || ((s.charAt(i-1) == p.charAt(j-2) || p.charAt(j-2) == '.')&&dp[i-1][j] );
                // 匹配0次，匹配多次
            }
        }
       }
       return dp[m][n];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 找某个元素的右边的元素的最大值，作差，比较差的大小,暴力法会超时
    // 对于某一个具体的日子，在当天卖出股票所能获得的最大值，是当前的股票价格减去之前出现过的最小值
    // 求整个过程的最大值
    public int maxProfit(int[] prices) {
        int max = 0;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i]  < min) {
                min = prices[i];
            }
            if (prices[i] - min > max) {
                max = prices[i] - min;
                
            }
        }
        return max;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //动态规划 dp[]代表前i个字符能否由List里的字符串组成
    //初始化dp[0] = 0;
    //遍历顺序：从左到右
    //递推公式 
    //s.substring(start,endIndex) start是起始索引，endIndex是结束索引，不包括
    // 排列而不是组合
    public boolean wordBreak(String s, List<String> wordDict) {
            int n = s.length(); 
            boolean[] dp = new boolean[s.length() + 1];  //代表s的前i个元素能否由字典中的元素组成
            dp[0] = true;
            for (int i = 1; i <= n; i++) {
                for (String str : wordDict) {
                    if (i >= str.length() && dp [i - str.length()] && s.substring(i - str.length(), i).equals(str)) {
                        dp[i] = true;
                    }
                }
            } 
            return dp[n];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 两种方法： 方法一:用两个变量，记录以某个索引为末尾的子数组的最大乘积和最小乘积
    // 遍历
    // 方法二：dpMax[i], dpMin[i]维护两个动态规划数组，一个用来记录最大值，一个用来记录最小值

    public int maxProduct(int[] nums) {
    //    int min = nums[0];
    //    int max = nums[0]; // 当前索引位置的乘积最大值
    //    int res = nums[0]; // 当前所有位置的乘积最小值
    //    for (int i = 1; i < nums.length; i++) {
    //     if (nums[i] < 0) { // 如果nums[i] < 0 交换最大最小值
    //         int temp = max;
    //         max = min;
    //         min = temp;
    //     }
    //     max = Math.max(nums[i], nums[i]*max);
    //     min = Math.min(nums[i], nums[i]* min);
    //     res = Math.max(res,max);
    //    }
    //    return res;
        int n = nums.length;
        int[] dpMax = new int[n];
        int[] dpMin = new int[n];
        int res = nums[0];
        dpMax[0] = nums[0];dpMin[0] = nums[0];
        for (int i = 1; i < n; i++) {
            dpMax[i] = Math.max(nums[i],Math.max(nums[i]*dpMax[i-1],nums[i]*dpMin[i-1]));
            dpMin[i] = Math.min(nums[i], Math.min(nums[i] * dpMax[i-1],nums[i]*dpMin[i-1]));
            res = Math.max(res, dpMax[i]);
        }
        return res;
      

    }
}

Mon, 01 Jan 0001 00:00:00 +0000

dp

class Solution {
    //动态规划4步：1.确定dp数组及下标的含义
    // 2.确定递推公式
    // 3.dp数组如何初始化
    // 4.确定遍历顺序
    // 偷窃当前房屋，不偷窃当前房屋
    // dp[i] 代表从0-i间房偷窃获得的最大值是多少
    // dp[i] = Math.max(dp[i-1], dp[i-2] +nums[i]);
    // dp[0] = nums[0], dp[1] = Math.max(nums[1], nums[0]);
    //
    public int rob(int[] nums) {
        int n = nums.length;
        if (n == 1) {
            return nums[0];
        } else if (n == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int[] dp = new int[n];
        dp[0] = nums[0]; dp[1] = Math.max(nums[0], nums[1]);
        for (int i = 2; i < n; i++) {
            dp[i] = Math.max(dp[i-1], dp[i - 2] + nums[i]); //对于每到一下个房间有两种可能，1.偷当前房间， 2.不偷当前房间
        }
        return dp[n-1];
    }
}

dfs+递归

class Solution {
	public int rob(int[] nums) {  
		int n = nums.length;  
		Integer[] memo = new Integer[n]; // 记忆化数组  
		return dfs(nums, 0, memo);  
	}  
  
	private int dfs(int[] nums, int i, Integer[] memo) {  
		if (i >= nums.length) return 0;  //超出边介
		if (memo[i] != null) return memo[i];  
		  
		// 偷当前房子  
		int take = nums[i] + dfs(nums, i + 2, memo);  
		// 不偷当前房子  
		int notTake = dfs(nums, i + 1, memo);  
		  
		memo[i] = Math.max(take, notTake);  
		return memo[i];  
	}
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 动态规划： dp[i][j]代表以nums[i][j] 为右下角能得到的正方形的最大值
    // 递推公式： dp[i][j] = Math.min(dp[i-1][j], dp[i][j - 1], dp[i - 1][j - 1])
    // 初始化 对i==0 || j==0的情况进行初始化
    // 遍历顺序 从左到右，从上到下
    public int maximalSquare(char[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        int[][] dp = new int[m][n];
        int maxSide = 0;
        for (int i = 0; i < m; i++) {
            if (matrix[i][0] == '1') {
                dp[i][0] = 1;
                maxSide = 1; 
            }
        }
        for (int j = 0; j < n; j++) {
            if (matrix[0][j] == '1') {
                dp[0][j] = 1;
                maxSide = 1;
                
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == '1') {
                    dp[i][j] = Math.min(dp[i - 1][j],Math.min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
                    maxSide = Math.max(maxSide, dp[i][j]);
                }
            }
        }
        return maxSide*maxSide;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 题目要求o(n)的时间复杂度
    // 题目类型dp
    public int[] productExceptSelf(int[] nums) {
        //除nums[i]之外的所有数的乘积也就是将nums[i]当做1
        // 可以计算这个数左乘积和右乘积
        // 用三个数组分别存储前缀、后缀和乘积
        // 对于元素nums[0]，我们设定初始值left[0] = 1;
        // 对于元素nums[nums.length - 1] 设定初始值right[nums.length - 1] = 1;
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        int[] res = new int[n];
        left[0] = 1;right[n - 1] = 1;
        for (int i = 1; i < n; i++) {
            left[i] = left[i-1] * nums[i-1];
        }
        for (int j = n - 2; j >= 0; j--) {
            right[j] = right[j + 1] * nums[j + 1];
        }
        for (int i = 0; i < n; i++) {
            res[i] = left[i] * right[i];
        }
        return res;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //dp[]数组代表和为n的完全平方数的最少数量
    //递推公式
    // dp[i] = Math.min(dp[i],dp[i-j*j] + 1) for all j*j <= i;
    // 完全背包
    public int numSquares(int n) {
        // int[] dp = new int[n+1];
        // dp[0] = 0;
        // for(int i = 1; i <= n; i++) {
        //     int min = n;
        //     for(int j = 1;j*j <= i; j++) {
        //         min = Math.min(min,dp[i-j*j]);
        //     }
        //     dp[i] = min + 1;
        // }
        // return dp[n];
        int[] dp = new int[n + 1];
        Arrays.fill(dp,10001);
        dp[0] = 0;
       //dp[j] = Math.min(dp[j],dp[j-i*i] + 1);
       
       for (int i = 1; i*i<= n; i++) {
        for (int j = i*i; j <= n; j++) {
            dp[j] = Math.min(dp[j],dp[j- i*i] + 1);
        }
       } 
       return dp[n];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // dp[i] 表示到以元素i结尾的的最长递增子序列的长度
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        Arrays.fill(dp,1);
        for (int i = 1; i < nums.length; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    dp[i] = Math.max(dp[i],dp[j] + 1);
                } 
            }
        }
        int max = 0;
        for (int i = 0; i < nums.length; i++) {
            max = Math.max(dp[i],max);
        }
        return max;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //动态规划
    //动态规划四部曲：确定dp[]数组及下标对应的含义，递推公式、初始化、遍历顺序
    // 三种状态： 持有股票，不持有股票并且处于冷冻期，不持有股票并且不处于冷冻期对应dp[i][0],dp[i][1],dp[i][2];
    //  递推公式：dp[i][0] = dp[i-1][2] - prices[0];
    // dp[i][1] = dp[i][0] + prices[i] dp[i][2] = dp[i-1][1];
    public int maxProfit(int[] prices) {
       int n = prices.length;
       int[][] dp = new int[n][3];
       dp[0][0] = -prices[0];
       dp[0][1] = 0; dp[0][2] = 0;
       for (int i = 1; i < prices.length; i++) {
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][2] - prices[i]);
        dp[i][1] = dp[i-1][0] + prices[i];
        dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1]);
       }
       return Math.max(dp[n-1][1],dp[n-1][2]);
        
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // dp[i][j] 代表戳i到j之间内的气球能获得的硬币最大值
    // 递推公式：dp[i][j] = Math.max (dp[i][k] + dp[k][j] + val[i]*val[j]*val[k], dp[i][j])
    // k代表最后一次戳的气球
    public int maxCoins(int[] nums) {
        int n = nums.length;
        int[][] dp = new int[n + 2][n + 2];
        int[] val = new int[n + 2];
        val[0] = val[n + 1] = 1;
        for (int i = 1; i <= n; i++) {
            val[i] = nums[i - 1];
        }
        for (int len = 1; len <= n; len++) {  // 可以戳的气球数量
            for (int i = 1; i <= n - len + 1; i++) { // 可以戳的起点
                int j = i + len - 1; // 终点
                for (int k = i; k <= j; k++) { // 最后一个戳的气球
                   dp[i][j] = Math.max (dp[i][k-1] + dp[k + 1][j] + val[i-1]*val[j+1]*val[k], dp[i][j]);
                }
            }
        }
        return dp[1][n];
    }    
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 动态规划
    // dp[i] 代表以i结尾的最长有效括号子串的长度
    // s.charAt(i) == '( dp[i] = 0;
    // s.charAt(i) == ')' s.charAt(i - 1) = '(' dp[i] = dp[i - 2] + 2
    // if (i - dp[i - 1] - 2 >= 0)s.charAt(i - dp[i - 1] - 1) == '(' dp[i] = dp[i-1] + 2 + dp[i - dp[i - 1] - 2]
    // 初始化dp[0] = 0;
    // 遍历顺序 从左向右
    public int longestValidParentheses(String s) {
        int len = s.length();
        int[] dp = new int[len];
        int maxLen = 0;
        for (int i = 1; i <= len - 1; i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i-1) == '(') {
                    dp[i] = (i >= 2 ? dp[i-2] : 0) + 2;
                    maxLen = Math.max(maxLen,dp[i]);
                } else if (i-1 >= dp[i-1] && dp[i-1] > 0 && s.charAt(i-dp[i-1]-1) == '(') { // 需要判断dp[i-1] > 0
                    dp[i] = (i - dp[i-1] >= 2)? dp[i-1] + dp[i-dp[i-1]-2] + 2 : dp[i-1] + 2;
                }
                 maxLen = Math.max(dp[i],maxLen);
            }
        }
        return maxLen;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 背包问题，完全背包
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1]; // dp[i] 代表组成金额为i的最少硬币数
        Arrays.fill(dp, amount + 1);
        dp[0] = 0;
        for (int i = 0; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] = Math.min(dp[j], dp[j-coins[i]] + 1);
            }
        }
        return dp[amount]== amount+1 ? - 1 : dp[amount];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //对于每一个节点，都有选或者不选两种决定
    //选了该节点，则它的左子节点和右子节点不能选
    //设定一个数组，下标0代表选了该节点的最大偷盗金额，下标1代表未选择该节点的最小偷盗金额
    // dfs + dp
    // 时间复杂度O(n),空间复杂度O(n); 每个节点遍历一次
    public int rob(TreeNode root) {
        int[] res = dfs(root); // res[]记录选root和不选root可以偷窃的最大值
        return Math.max(res[0], res[1]);
    }
    public int[] dfs(TreeNode root) {
        if (root == null) {
            return new int[]{0,0};
        }
        int[] left = dfs(root.left);
        int[] right = dfs(root.right);
        int selected = root.val + left[1] + right[1];
        int noSelected = Math.max(left[0], left[1]) + Math.max (right[0], right[1]);
        return new int[]{selected, noSelected};
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //两重for循环计算
    public boolean canPartition(int[] nums) {
    
        int sum = 0;
        for(int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        if(sum % 2 == 1) return false;
        int target = sum / 2;
        boolean[] dp = new boolean[target + 1]; //dp数组代表容量为j的背包能否恰好装满
        dp[0] = true;
        for (int i = 0; i < nums.length; i++) {
            for (int j = target; j >= nums[i]; j--) {
                
                  dp[j] = dp[j] || dp[j-nums[i]];
            
              
            }
        }
        return dp[target];

        
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //下标i处能接的雨水为左右两边的最大值里的最小值- height[i]
    // 这里可以用双指针的思想 时间复杂度O(n),空间复杂度O(1)
    // 动态规划更直接， 用两个数组记录左右两边的最大值 时间复杂度O(n),空间复杂度O(1)
    public int trap(int[] height) {
        int n = height.length;
        // int[] leftMax = new int[n];
        // int[] rightMax = new int[n];
        // leftMax[0] = height[0];
        // rightMax[n - 1] = height[n - 1];
        // for (int i = 1; i < n; i++) {
        //     leftMax[i] = Math.max(leftMax[i-1], height[i]);
        // }
        // for (int i = n - 2; i >= 0; i--) {
        //     rightMax[i] = Math.max(rightMax[i + 1], height[i]);
        // }
        // int sum = 0;
        // for (int i = 0; i < n; i++) {
        //     sum += Math.min(leftMax[i], rightMax[i]) - height[i];
        // }
        // return sum;
        int leftMax = 0, rightMax = 0;
        int left = 0,right = n - 1, sum = 0;
        while (left <= right) {
            leftMax = Math.max(height[left], leftMax);
            rightMax = Math.max(height[right], rightMax);
            if (leftMax < rightMax) {
                sum += leftMax - height[left];
                left++;
            } else {
                sum += rightMax - height[right];
                right--;
            }
        }
        return sum;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 首先想到的是回溯，但是回溯的时间复杂度过大（2^n);
    // 想到背包问题：
    // 两个背包，一个放正数，一个放负数，
    // pos[i] - neg[i] = target;
    // pos[i] + neg[i] = sum;
    // pos[i] = (target + sum) / 2
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        //(target + sum)必须是偶数（否则 P 不是整数）
		//(target + sum)不能是负数（否则不可能）
        if ((target + sum) % 2 != 0 || (target + sum) < 0) {
            return 0;
        } 
        int[] pos = new int[(target + sum) / 2 + 1];
        pos[0]= 1; 
        //pos[i] 代表容量为i的背包有多少种方式填满
        for (int i = 0; i < nums.length; i++) {
            for (int j = (target + sum) / 2; j >= nums[i]; j--) {
                pos[j] += pos[j-nums[i]]; 
            }
        }
        return pos[(target + sum) / 2];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //最长回文子串，动态规划，
    //dp[i][j]代表从i到j的最长回文子串的长度
    //初始化的dp[i][i] = 1
    //遍历顺序：按长度遍历，再从左到右按索引遍历
    public String longestPalindrome(String s) {
        // char[] arr = s.toCharArray();
        // 反序与原始字符串相同，动态规划
        // 如果s.substring(i,j)是回文子串，则s.substring(i+1,j-1)一定也是回文子串
        // 每一个字符一定是回文子串，判断2个长度的字符串是不是回文子串只需要判断两个字符是否相等
        // 用二维哈希表来表示所有子串是不是回文子串，行下标与列下标的最大差值代表长度
    //    int len = arr.length;
    //    if(len < 2){     //长度小于2说明是动态数组
    //        return s;
    //    }
    //    boolean[][] hash = new boolean[len][len];
    //    int maxLen = 1;
    //    int begin = 0;
    //     for(int i = 0 ; i < len; i++){
    //         hash[i][i] = true;  // 单个字符一定是回文串
    //     }
    //     for(int L = 2; L <= len; L++){  //L代表的长度
    //         for(int i = 0 ; i < len; i++){   //左边界，字符串的起始下标
    //             int j = L + i - 1; //子字符串的长度为L, j - i + 1 = L;
    //             if( j >= len){
    //                 break;
    //             }
    //             if(arr[i] != arr[j]){ // 子字符串长度小于等于3的时候，只需要看左右边界
    //                 hash[i][j] = false; // 子字符串长度>3的时候，hash[i][j] = hash[i+1][j-1];
    //             }else {
    //                 if(L <= 3){
    //                     hash[i][j] = true;
    //                 }else{
    //                     hash[i][j] = hash[i+1][j-1];
    //                 }
    //             }
    //             if(hash[i][j]&& L > maxLen){
    //                 maxLen = L;
    //                 begin = i;
    //             }
    //         } 
    //     }
    //     return s.substring(begin,begin+maxLen); // 不包括begin+maxLen
        int n = s.length();
        if (n == 1) {
            return s;
        }
        boolean[][] dp = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }
        int maxLen = 1;
        int begin = 0;
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j < n;j++) {
                int k = j + i - 1;
                if(k >= n) {
                    break;
                }
                if (i <= 3) {
                    if (s.charAt(j) == s.charAt(k)) {
                        dp[j][k] = true;
                    }else {
                        dp[j][k] = false;
                    }
                } else {
                     if (s.charAt(j) == s.charAt(k)) {
                        dp[j][k] = dp[j +1][k - 1] ;
                    }else {
                        dp[j][k] = false;
                    }
                }
                if (dp[j][k] && i > maxLen ) {
                    maxLen = i;
                    begin = j;
                }
            }
        }
        return s.substring(begin,begin+maxLen);

    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
   public int maxSubArray(int[] nums) {
    // dp数组代表以nums[i]结尾的的最大子数组和，i代表索引
    // if (dp[i-1] < 0) dp[i] = nums[i];
    // else dp[i] = dp[i-1] + nums[i];
    // 找到dp数组的最大值
    
        int[] dp = new int[nums.length];
        int max = nums[0];
        dp[0] = nums[0];
        for (int i = 1; i < nums.length; i++) {
            dp[i] = Math.max(dp[i-1] + nums[i], nums[i]);
            max = Math.max(dp[i],max);
        }
        return max;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    
    // 动态规划
    // dp[i][j] 代表从（0,0）出发到(i,j)有多少条不同的路径
    // dp[i][j] = dp[i-1][j] + dp[i][j-1];
    // 左边界和上边界都只有1种可能
    // 从上向下，从左往右遍历
    int res = 0;
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n]; 
        dp[0][0] = 1;
        
        for(int i = 1; i < m;i++){
            dp[i][0] = 1;  
        }
        for(int j = 1; j < n; j++){
            dp[0][j] = 1;
        }
        for(int i = 1 ; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; 
            }
        } 
        return dp[m-1][n-1];
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //二维动态规划
    public int countSubstrings(String s) {
        int n = s.length();
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = 1;
        }
        for(int len = 2; len <= n; len++) {
            for (int i = 0; i <= n-len; i++) {
                int j = i + len - 1;
                if(s.charAt(i) == s.charAt(j)){
                    if (len > 2) {
                        dp[i][j] = dp[i + 1][j - 1];
                    } else {
                        dp[i][j] = 1;
                    }
                    
                }else {
                    dp[i][j] = 0;
                }
            }
        }
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dp[i][j] != 0){
                    count++;
                }
            }
        }
        return count;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // dp[n] 代表 爬到n接楼梯的方法数
    // 递推公式：f(n) = f(n-1) + f(n-2)
    // 初始值dp[0] = 1;dp[1] = 1;
    // 遍历顺序：从小到大 
    public int climbStairs(int n) {
        int[] res = new int[n+1];
        res[0] = 1;
        res[1] = 1;
        for(int i = 2; i <= n; i++){
            res[i] = res[i-1] + res[i-2];
        }
        return res[n];
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //动态规划 
    // dp[i][j] 意味着将word1的前i个字符转化为word2的前j个字符的最少操作数
    // dp[i][0] = i; dp[0][j] = j;
    //递推公式：if (s.charAt(i) == s.charAt(j)) dp[i][j] == dp[i - 1][j - 1]
    // else dp[i][j] = Math.max(dp[i - 1][j -1] + 1, dp[i-1][j] + 1, dp[i][j-1] + 1);
    // 对应替换的
    public int minDistance(String word1, String word2) {
        int n = word1.length();
        int m = word2.length();
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 0; i <= n; i++) {
            dp[i][0] = i;
        }    
        for (int j = 0; j <= m; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    dp[i][j] = Math.min(dp[i-1][j-1] + 1 , Math.min(dp[i-1][j] + 1, dp[i][j-1] + 1));
                }
            }
        }
        return dp[n][m];
    
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 把当前元素作为矩阵的右下角，用一个数组记录当前行到当前位置的连续的1的个数，得到矩阵的最大宽
    // 垂直遍历，计算宽和高，得到面积，求出对应位置面积的最大值
    public int maximalRectangle(char[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        int maxArea = 0;
        int[][] maxWidth = new int[row][col]; // 记录以当前元素为右下角的最大宽
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (matrix[i][j] == '1') {
                    maxWidth[i][j] = (j > 0) ? maxWidth[i][j - 1] + 1 : 1;
                }
            }
        }
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (matrix[i][j] == '1') {
                    int width = maxWidth[i][j];
                    int area = width;
                    for (int k = i - 1; k >= 0; k--) {
                        width = Math.min(maxWidth[k][j], width); //构建矩形的最大宽
                        area = Math.max(width*(i - k + 1), area);
                    }
                    maxArea = Math.max(area, maxArea);
                }
            }
        }
        return maxArea;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1]; //dp[i]表示n个节点组成的二叉搜索数的种数
        dp[1] = 1;
        dp[0] = 1;
        //递推公式：选定任意点i作为根节点，则左子树为[1,i-1];右子树为[i+1,n];
        //dp[i] = ∑(dp[i-1] * dp[n-i])
        // dp[1] = 1
        // 遍历顺序：从前向后
        for (int i = 2; i <=n; i++) { // 总共有多少个节点
            for (int j = 1; j <= i; j++) { // 选哪一个做根节点
                dp[i] += dp[j-1]*dp[i-j];
            }
        }
       
        return dp[n]; 
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    // 1.层序遍历，每次删除两个节点，判断轴对称的两个节点的值是否相等，并将他们的左右子节点的轴对称位置添加进行
    // 2.递归
    public boolean isSymmetric(TreeNode root) {
    //    if (root == null) {
    //     return true;
    //    }
    //    return isMirror(root.left, root.right);
        if (root == null) {
            return true;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root.left);
        que.offer(root.right);
        while (!que.isEmpty()) {
            int len = que.size();
            for (int i = len; i > 0; i -= 2) {
                TreeNode tmp1 = que.poll();
                TreeNode tmp2 = que.poll();
                if (tmp1 == null && tmp2 == null) {
                    continue;
                }
                if (tmp1 == null || tmp2 == null || tmp1.val != tmp2.val) {
                    return false;
                }
                que.offer(tmp1.left); //轴对称的添加节点
                que.offer(tmp2.right);
                que.offer(tmp1.right);
                que.offer(tmp2.left);
            }
        }
        return true;
    }

    // public boolean isMirror(TreeNode left, TreeNode right) {
    //     if (left == null && right == null) return true;
    //     if (left == null || right == null) return false;
    //     return left.val == right.val && isMirror(left.left, right.right) && isMirror(left.right, right.left);
    // }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    // public List<List<Integer>> levelOrder(TreeNode root) {
    //     checkFun(root);
    //     return resList;
    // }
    // public void checkFun(TreeNode node){
    //     Queue<TreeNode> que = new LinkedList<TreeNode>();
    //     if(node == null){
    //         return;
    //     }
    //     que.offer(node);
    //     while(!que.isEmpty()){
    //         List<Integer> itemList = new ArrayList();//每一层的元素放到一个列表里
    //         int len = que.size();       //遍历每一层的节点时。将他们的左右节点放入队列，队列的size就是整个
    //         while(len > 0){             //层的元素个数
    //             TreeNode tmpNode = que.poll();
    //             itemList.add(tmpNode.val);
    //             if(tmpNode.left != null){
    //                 que.offer(tmpNode.left);
    //             }
    //             if(tmpNode.right != null){
    //                 que.offer(tmpNode.right);
    //             }
    //             len--;
    //         }
    //         resList.add(itemList);
    //     }

    // }
   // 层序遍历，经典算法题，首先把头结点添加到队列，然后将队列中的元素按顺序poll(),如果左右节点不为空，则将左右节点添加到队列
    public List<List<Integer>> levelOrder(TreeNode root) {
         List<List<Integer>> res = new ArrayList<>();
         if (root == null) {
            return res;
         }
         Queue<TreeNode> que = new LinkedList<>();
         que.offer(root);
         while (!que.isEmpty()) {
            int len = que.size();
            List<Integer> level = new ArrayList<>();
            while (len > 0) {
                TreeNode tmp = que.poll();
                level.add(tmp.val);
                if (tmp.left != null) {
                    que.offer(tmp.left);
                }
                if (tmp.right != null) {
                    que.offer(tmp.right);
                }
                len--;
            }
            res.add(level);
         }
         return res;
    }
    
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 1. 层序遍历，用一个变量记录总共有多少层
    // 2.递归
    public int maxDepth(TreeNode root) {
       if (root == null) {
        return 0;
       }
       int leftDepth = maxDepth(root.left);
       int rightDepth = maxDepth(root.right);
       return Math.max(leftDepth,rightDepth) + 1;
        // if (root == null) {
        //     return 0;
        // }
        // Queue<TreeNode> que = new LinkedList<>();
        // que.offer(root);
        // int count = 0;
        // while (!que.isEmpty()) {
        //     int len = que.size();
        //     count++;
        //     while (len > 0) {
        //         TreeNode tmp = que.poll();
        //         if (tmp.left != null) {
        //             que.offer(tmp.left);
        //         }
        //         if (tmp.right != null) {
        //             que.offer(tmp.right);
        //         }
        //         len--;
        //     }
        // }
        // return count;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
public class Solution {
    // 对于一颗二叉树，前序遍历的第一个值是根节点的值，根据根节点的值和中序遍历可以得到左右子树
    // 递归的得到左右子树的根节点
    // 从先序遍历中取出第一个元素创建根节点。
    // 在中序遍历中找到该根节点的位置，这将中序遍历分为两部分，左边是树的左子树，右边是树的右子树。
    // 递归地使用左子树的先序和中序遍历结果重建左子树。
    // 递归地使用右子树的先序和中序遍历结果重建右子树。
    // 返回根节点
   int preIndex = 0;
    HashMap<Integer, Integer> hs = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i = 0; i < inorder.length; i++) {
            hs.put(inorder[i], i);
        }
        return buildTreeRecursive(preorder, 0, inorder.length - 1);    
    }
    // recursive 递归
    // 利用前序遍历的顺序构建子树，中序遍历得到左子树和右子树的范围
    public TreeNode buildTreeRecursive(int[] preorder, int left , int right) {
        if (left > right) {
            return null;
        }
        int rootVal = preorder[preIndex++]; // 前序遍历的第一个节点总是当前子树的根
        TreeNode root = new TreeNode(rootVal);
        int index = hs.get(rootVal);
        root.left = buildTreeRecursive(preorder, left, index - 1);
        root.right = buildTreeRecursive(preorder, index + 1, right);
        return root;
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 用一个列表存储先序遍历的结果，再构建单链表，将列表中的节点的左指针赋值为空，右指针指向列表中的下一个位置
   List<TreeNode> res = new ArrayList<>();
    public void flatten(TreeNode root) {
       if (root == null) {
            return;
       }
       preOrder(root);
       for (int i = 0; i < res.size() - 1; i++) {  // 这里是小于 res.size() - 1,确保不会数组越界
        TreeNode node = res.get(i);
        node.left = null;
        node.right = res.get(i + 1);
       }
    }
    public void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        res.add(root);
        preOrder(root.left);
        preOrder(root.right);
    }

}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 // 空间复杂度O(N) 递归的深度，最坏是节点的个数
 // 时间复杂度O(H) 树的高度
 // 方法： 递归 + 后序遍历
 // 对于一个节点，他能向上层节点提供的最大值是当前节点的值 + max(左,右子树的最大路径)
 // 当前节点嘴和路径中点的最大路径和 = 左右子树的的最大路径 + 当前节点的值
class Solution {
    private int  maxSum = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        maxGain(root);
        return maxSum;
    }

    private int maxGain(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftGain = Math.max(maxGain(node.left), 0);
        int rightGain = Math.max(maxGain(node.right), 0);
        maxSum = Math.max(maxSum, node.val + leftGain + rightGain); // 更新最大值
        return node.val + Math.max(leftGain, rightGain); // 返回不作为路径终点时能贡献的最大值
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 层序遍历，遍历过程中对每一个节点的位置进行交换
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return root;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while (!que.isEmpty()) {
            int len = que.size();
            while (len > 0) {
                TreeNode tmp = que.poll();
                TreeNode tmpSon = tmp.left;
                tmp.left = tmp.right;
                tmp.right = tmpSon;
                if (tmp.left != null) {
                    que.offer(tmp.left);
                }
                if (tmp.right != null) {
                    que.offer(tmp.right);
                }
                len--;
            }
        }
        return root;  
    } 
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    // 递归
    // 递归检查左子树 是否包含节点 p 或 q。
    // 递归检查右子树 是否包含节点 p 或 q。
    // 如果当前节点自身是 p 或 q 中的一个，且其左子树或右子树包含另一个节点，那么该节点就是最近的公共祖先。
    // 如果当前节点的左右子树各包含一个目标节点（p 和 q），那么当前节点就是最近的公共祖先。
    // 如果上述情况都不成立，返回找到的包含目标节点的子树（可能为空，表示当前子树不包含目标节点）。
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left!= null && right != null) {//都不为空，说明公共祖先在根节点
            return root;
        }else if (left != null && right == null) { //一边为空，一边不为空，说明在公共祖先在不为空的一边
            return left;
        }else if (left == null && right != null) {
            return right;
        }
        return null;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
// 一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构
// 序列化，层序遍历。反序列化，去除首尾"[]"，将字符串按照","划分，采用层序遍历的方式，还原树
// 层序遍历
public class Codec {
  
    // 序列化，层序遍历树。需要注意的是：在结尾删除","
    public String serialize(TreeNode root) {
        if (root == null) {
            return "[]";
        }
        Queue<TreeNode> que = new LinkedList<>();
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        que.offer(root);
        while (!que.isEmpty()) {
            TreeNode tmp = que.poll();
            if (tmp != null) {
                que.offer(tmp.left);
                que.offer(tmp.right); // 这里最终的结果会多出几个null值，对于序列化二叉树没有任何影响
                sb.append(tmp.val + ",");
            } else {
                sb.append("null,"); 
            }
        }
        sb.deleteCharAt(sb.length() - 1);
        sb.append("]");
        return sb.toString();
    }

    // Decodes your encoded data to tree.
    // 用split方法划分，将字符串划分为一个字符串数组
    // 字符串转为Integer的方法  Integer.parseInt();
    public TreeNode deserialize(String data) {
       if (data.equals("[]")) {
            return null;
       }
       String[] val = data.substring(1, data.length() - 1).split(",");
       TreeNode root = new TreeNode(Integer.parseInt(val[0]));
       Queue<TreeNode> que = new LinkedList<>();
       que.offer(root);
       int i = 1;
       while (!que.isEmpty()) {
            TreeNode tmp = que.poll();
            if (!val[i].equals("null")) {
                tmp.left = new TreeNode(Integer.parseInt(val[i]));
                que.offer(tmp.left);
            } 
            i++;
            if (!val[i].equals("null")) {
                tmp.right = new TreeNode(Integer.parseInt(val[i]));
                que.offer(tmp.right);
            }
            i++;
        }
        return root;
    }
}
// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //计算所有路径和为targetSym的路径：深度优先搜索
    //定义函数rootSum 用来计算以某个节点为起点时的路径和为targetSum的条数
    //pathSum函数递归调用自身，遍历所有节点；
    // 时间复杂度O(N^2),空间复杂度(N)
    // 采用前缀和的方式，时间复杂度O(N),空间复杂度O(N)
    // 采用先序遍历的方式用hashmap记录所有路径和，若遍历当前节点时，hashmap中存在路径和-targetsum
    // 说明此路径中存在某个节点到当前节点的路径和为target
    // 最后需要回溯，防止影响到其他节点
    public int pathSum(TreeNode root, long targetSum) { // taegetSum 会溢出，需要改为long
       Map<Long, Integer> prefix = new HashMap<>();
       prefix.put(0L, 1); // 为了处理路径和刚好等于targetSum的特殊情况
       return dfs(root, prefix, 0, targetSum);
    }
    public int dfs(TreeNode node, Map<Long, Integer> prefix, long curr,long targetSum) {
       if (node == null) {
        return 0;
       }
       int count = 0;
       curr += node.val;
       count = prefix.getOrDefault(curr - targetSum, 0);
       prefix.put(curr, prefix.getOrDefault(curr, 0) + 1);
       count += dfs(node.left, prefix, curr, targetSum);
       count += dfs(node.right, prefix, curr, targetSum);
       prefix.put(curr, prefix.get(curr) - 1); // 递归返回后，减少技术，防止影响其他路径的搜索
       return count;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 解决方案使用了一个递归的方法。算法的关键步骤如下:
    // 如果当前节点为空,则返回 null。
    // 首先递归处理右子树,因为我们需要先处理比当前节点大的节点。
    // 处理完右子树后,累加当前节点的值到 sum 变量中,并将当前节点的值更新为 sum。
    // 最后递归处理左子树
    int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        if (root == null) {
            return null;
        }
        convertBST(root.right);
        sum += root.val;
        root.val = sum;
        convertBST(root.left);
        return root;
    }
    
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //对每一个节点求左子树的最大深度 + 右子树的最大深度
    // 他们之和的最大值即为直径。
    // 直径为所有子节点的最大
    int sum = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return sum;
       
    } 
    public int maxDepth(TreeNode node) {
        if (node == null) {
            return 0;
        }
        int leftDepth = maxDepth(node.left);
        int rightDepth = maxDepth(node.right);
        sum = Math.max(sum, leftDepth + rightDepth);
        return Math.max(leftDepth, rightDepth) + 1; //左右节点的最大深度 + 1，因为要包括自身
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //层序遍历 两棵树的对应位置都不为空则值相加
    //以返回第一颗数为例，如果第一颗树和第二颗数对应位置都不为空，值相加；第一颗树为空，第二颗不空，让第一颗的对应的位置指向第二颗的
    //对应位置；第二颗为空，第一颗为空，不操作；
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root1);
        que.offer(root2);
        while (!que.isEmpty()) {
            TreeNode tmp1 = que.poll();
            TreeNode tmp2 = que.poll();
            tmp1.val += tmp2.val;
            if (tmp1.left != null && tmp2.left != null) {
                que.offer(tmp1.left); // 层序遍历，每次poll两棵树对应位置的两个点
                que.offer(tmp2.left);
            } else if (tmp1.left == null && tmp2.left != null) {
                tmp1.left = tmp2.left;
            }
            if (tmp1.right != null && tmp2.right != null) {
                que.offer(tmp1.right);
                que.offer(tmp2.right);
            }  else if (tmp1.right == null && tmp2.right != null) {
                tmp1.right = tmp2.right;
            }
        }
        return root1;   
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
 // 两种方法 ： 1. 递归 2.迭代
class Solution {
    List<Integer> res;
    public List<Integer> inorderTraversal(TreeNode root) {
       res = new ArrayList<>();
       Stack<TreeNode> stack = new Stack();
       TreeNode cur = root;
       while (!stack.isEmpty() || cur != null) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;  // 左
            }
            cur = stack.pop();
            res.add(cur.val); // 中
            cur = cur.right; // 右
       }
       return res;
    }
   
      
    

}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int numTrees(int n) {
        int[] dp = new int[n+1]; //dp[i]表示n个节点组成的二叉搜索数的种数
        dp[1] = 1;
        dp[0] = 1;
        //递推公式：选定任意点i作为根节点，则左子树为[1,i-1];右子树为[i+1,n];
        //dp[i] = ∑(dp[i-1] * dp[n-i])
        // dp[1] = 1
        // 遍历顺序：从前向后
        for (int i = 2; i <=n; i++) { // 总共有多少个节点
            for (int j = 1; j <= i; j++) { // 选哪一个做根节点
                dp[i] += dp[j-1]*dp[i-j];
            }
        }
       
        return dp[n]; 
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
   // 两种方法：一种是递归，一种是中序遍历
   // 对二叉树中序遍历得到的结果是升序的，
   // 需要注意边界值，如果最左边的节点的值是最小值
    public boolean isValidBST(TreeNode root) {
      long max = Long.MAX_VALUE;
      long min = Long.MIN_VALUE;
     
      return isValid(root, min, max);
    }
        // Deque<TreeNode> stack = new LinkedList<>();
        // long inorder = Long.MIN_VALUE;
        // while (!stack.isEmpty() || root != null) {
        //     while (root != null) {
        //         stack.push(root);
        //         root = root.left;
        //     }
        //     TreeNode tmp = stack.pop();
        //     if ((long)tmp.val <= inorder) {
        //         return false;
        //     }
        //     root = tmp.right;
        //     inorder = tmp.val;
        // }
        // return true;
    // }

    public boolean isValid(TreeNode node, long min, long max) {
        if (node == null) {
            return true;
        }
        if (node.val <= min || node.val >= max) {
            return false;
        }
        return isValid(node.left, min, node.val) && isValid(node.right, node.val, max);
    } 
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 二进制
    // 将当前元素与1按位与，计算二进制中1的个数
    public int[] countBits(int n) {
        int[] res= new int[n + 1];
        for (int i = 0; i <=n; i++) {
            int count = 0;
            int tmp = i;
            while (tmp != 0) {
                if ((tmp & 1) == 1) {
                    count++;
                }
                tmp >>= 1;
            }
            res[i] = count;
        }
        return res;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //检查x和y中的二进制不同的位数，可以先计算x异或y，x^y
    //再利用按位与判断尾数是否为1 xor&1
    public int hammingDistance(int x, int y) {
        int res = x^y, hammingDistance = 0;
        while (res != 0) {
            if ((res & 1) == 1) {
                hammingDistance++;
            }
            res >>= 1;
        }
        return hammingDistance; 
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 创建一个最小堆，存储所有的链表的头结点，每次从链表中取出一个节点，并将这个节点的下一个节点放入最小堆中
    // 这样就可以保证每次取得当前k个节点的最小值
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> pq = new PriorityQueue<>((a,b) -> a.val - b.val);
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        for (ListNode node :lists) {
            if (node != null) { // 需要判断是否为空，否则会出现空指针异常，优先队列不能加入空值
                pq.offer(node);
            }  
        }
        while (!pq.isEmpty()) {
            cur.next = pq.poll();
            cur = cur.next;
            if (cur.next != null) {
                pq.offer(cur.next);
            }
        }
        return dummy.next;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

1. 优先队列 PriorityQueue

class Solution {
    //优先队列存储当前元素值和索引，用大顶堆进行排序
    public int[] maxSlidingWindow(int[] nums, int k) {
        int n = nums.length;
        if (n == 1) {
            return nums;
        }
        int[] res = new int[n - k + 1];
        //初始化大顶堆
        PriorityQueue<int[]> pq = new PriorityQueue<>((a,b) -> b[0] - a[0]);
        for (int i = 0; i < k; i++) {
            pq.offer(new int[]{nums[i],i});
        }
        res[0] = pq.peek()[0];
        int j = 1;
        for (int i = k ; i < n; i++) {
            pq.offer(new int[]{nums[i],i});
            while (pq.peek()[1] < i - k + 1) { //滑动窗口的右边界k，左边界i-k+1
                pq.poll();
            }
            res[j++] = pq.peek()[0];
        }
        return res;
    }
}

2.单调队列 Deque

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        Deque<Integer> stack = new ArrayDeque<>();  
        int n = temperatures.length;  
        int[] ans = new int[n]; // 默认全是 0  
        for (int i = 0; i < n; i++) {  
            while (!stack.isEmpty() && temperatures[stack.peekLast()] < temperatures[i]) {  
                int idx = stack.pollLast();  
                ans[idx] = i - idx;  
            }  
            stack.offerLast(i);  
        }  
        return ans;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //面积，（索引的差 + 1）*（高度的最小值）
    // 单调栈
    // 对于index位置的最大矩形的款是到左右两边第一次出现比heights[index]小的位置， 
    public int largestRectangleArea(int[] heights) {
        int n = heights.length;  
		Deque<Integer> stack = new LinkedList<>();  
		int maxArea = 0;  
		
		for (int i = 0; i < heights.length; i++) {  
			// 当前柱子比栈顶小，说明找到了右边界  
			while (!stack.isEmpty() && heights[i] < heights[stack.peek()]) {  
				int top = stack.pop();  
				// 计算宽度  
				int maxWidth = stack.isEmpty() ? i : i - stack.peek() - 1;    
				maxArea = Math.max(maxWidth * heights[top], maxArea);  
			}  
			stack.push(i);  
		}  
		  
		// 处理右边没有更小柱子的情况  
		while (!stack.isEmpty()) {  
			int top = stack.pop();  
			int maxWidth = stack.isEmpty() ? n : n - stack.peek() - 1;  
			maxArea = Math.max(maxWidth * heights[top], maxArea);  
		}  
		  
		return maxArea;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 所有可能，全排列，回溯
    List<String> res = new ArrayList<>();
    String[] numbers = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    public List<String> letterCombinations(String digits) {
          if (digits.length() == 0) {
            return res;
          }
          backTracking(digits, 0);
          return res;
    }
    StringBuffer sb = new StringBuffer();
    public void backTracking(String digits, int num) {
       if (num == digits.length()) {
        res.add(sb.toString());
        return;
       }
        int index = digits.charAt(num) - '0'; // 这里-'0'得到数字，不能用Inter.valueOf(),这是将字符串转为数字
        String tmp = numbers[index];
        for (int i = 0; i < tmp.length(); i++) {
            sb.append(tmp.charAt(i));
            backTracking(digits, num + 1);
            sb.deleteCharAt(sb.length() - 1);           
        }
        
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 回溯，全排列
    // stringBuffer的append方法和deleteCharAt()方法
    // 有效的括号组合，对于任意括号左边的左括号的数量大于等于右括号的数量
    // 空间复杂度：O(n)
    List<String> res;
    int left, right;
    int count = 0;
    StringBuffer sb = new StringBuffer(); 
    public List<String> generateParenthesis(int n) {
        left = 0;
        right = 0;
        count = n;
        res = new ArrayList<>();
        backTracking();
        return res;
    }

    public void backTracking() {
        if (right == count) {
            res.add(sb.toString());
        }
        if (left < count) { // append左括号
            sb.append('(');
            left++;
            backTracking();
            sb.deleteCharAt(sb.length() - 1); 
            left--;
        }
        if (right < left) { // append右括号，右括号的数量需要小于左括号的数量
            sb.append(')');
            right++;
            backTracking();
            sb.deleteCharAt(sb.length() - 1);
            right--;
        }
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 1.回溯 因为是需要返回列表
    // 如果是求个数那就是完全背包
    // 递归三要素：1.返回值的类型和传递的参数 2.递归终止的条件  3.单层递归的逻辑
    List<List<Integer>> res = new ArrayList();
    List<Integer> path = new LinkedList();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        backTracking(candidates,target,0,0); // 后面俩个0,0 对应sum 和 startIndex 避免重复遍历
        return res;
    }
    public void backTracking(int[] candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            res.add(new ArrayList(path));
            return;
        }
        if (sum > target) {
            return;
        }
        for (int i = startIndex; i < candidates.length; i++) {
            sum += candidates[i];
            path.add(candidates[i]);
            backTracking(candidates,target,sum,i);
            sum -= candidates[i];
            path.removeLast();
        }
    }
    
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 回溯算法，用一个boolean类型的数组标记已经使用过的数字
    // 回溯三要素：回溯函数的参数和返回类型、回溯的终止条件、回溯搜索的遍历过程
    // 全排列：非常经典的回溯算法，回溯算法的本质上遍历所有的和能效
    List<List<Integer>> res = new ArrayList();
    List<Integer> path = new LinkedList();
    public List<List<Integer>> permute(int[] nums) {
        boolean[] used = new boolean[nums.length];
        backtracking(nums,used);
        return res;

    }
    public void backtracking(int[] nums, boolean[] used) {
        if (path.size() == nums.length) {
            res.add(new ArrayList(path));
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i] == true) continue;
            path.add(nums[i]);
            used[i] = true;
            backtracking(nums,used);
            path.remove(path.size() - 1); // 后两步是在回溯，表明当前前缀数字的所有可能性都已经遍历完
            used[i] = false; 
        }
    }
    // public void backtracking(int[] nums, boolean[] used){
    //     if(path.size() == nums.length){
    //         res.add(new ArrayList(path)); // 需要注意：这里是new ArrayList(path) ,不是直接path，因为path是一直在变化的
    //         return;
    //     }
    //     for(int i = 0; i < nums.length ; i++){
    //         if(used[i] == true)continue;
    //         path.add(nums[i]);
    //         used[i] = true;
    //         backtracking(nums,used);
    //         path.removeLast();
    //         used[i] = false;
    //     }
    // }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    List<List<Integer>> res = new ArrayList();
    List<Integer> path = new LinkedList();
    public List<List<Integer>> subsets(int[] nums) {
        backTracking(nums,0);
        return res;
    }
    public void backTracking(int[] nums,int startIndex){
        res.add(new ArrayList(path));
        if(startIndex >= nums.length){
            return;
        }
        for(int i = startIndex; i < nums.length ; i++){
                path.add(nums[i]);
                backTracking(nums,i+1); // 这里是i + 1
                path.removeLast();
        }
        
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 1.暴力求解，两重for循环分别代表起始元素
    // 2.用HashMap,时间复杂度为O(n),空间复杂度为O(n);
    // 两个数之和 = target 那么就是target - 其中一个数 = 另外一个target
    // 一重for循环，遍历整个数组，将出现过的值加入到hashmap中，key为值，value为索引
    // 对于当前元素，hashmap.contiansKey(target - value) ，则找到两个数
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        HashMap<Integer, Integer> hs = new HashMap();
        for (int i = 0; i < nums.length; i++) {
            int value = target - nums[i];
            if (hs.containsKey(value)) {
                res[1] = i;
                res[0] = hs.get(value);
                break;
            }
            hs.put(nums[i],i);
        }
        return res;
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int maxArea(int[] height) {
        // 暴力复杂度为O(n^2)
        // 双指针：时间复杂度为）（n）
        //最大容量：索引的差*两个索引最小高度；
         int left = 0, right = height.length - 1;
         int maxArea = 0;
         while (left < right) {
            int area = Math.min(height[left], height[right]) *(right - left);
            maxArea = Math.max(area, maxArea);
            if (height[left] > height[right]) { //宽已经是最大了，想要更大的面积只能是更大的高
                right--;
            } else {
                left++;
            }
         } 
         return maxArea;  
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 排序之后，使用双指针,左右指针，注意去重
    // 时间复杂度O(n^2)，空间复杂度:排序的复杂度O(logn) + 三数列表的个数O(m)
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>(); 
        Arrays.sort(nums);  // 排序
        int n = nums.length;
        for (int i = 0; i < n - 2; i++) {
            if (i > 0 && nums[i]== nums[i-1]) { //外部去除
                continue;
            }
            int target = -nums[i];
            int left = i + 1, right = n - 1;
            while (left < right) {
                if (nums[left] + nums[right] < target) {
                    left++;
                } else if (nums[left] + nums[right] > target) {
                    right--;
                } else {
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
                     while (left < right && nums[right] == nums[right - 1]) { //内部去重
                        right--;
                    }
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //用堆排序实现，删除前k-1个元素皆可以得到第k大的元素
    // 要求O(n),但是O(nlogn)可以通过
    public int findKthLargest(int[] nums, int k) {
    //     int n = nums.length;
    //     buildMaxHeap(nums);
    //     for (int i = n - 1; i > n  - k; i--) {
    //         swap(nums,0,i);
    //         heapify(nums,i,0);
    //     }
    //    return nums[0];
        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b)-> b-a);
        for (int i = 0; i < nums.length; i++) {
                pq.offer(nums[i]);
        }
        for (int i = 0; i < k - 1; i++) {
            pq.poll();
        } 
        
        int val = pq.poll();
        return val;
    }
    // public void buildMaxHeap(int[] arr) {
    //     int n = arr.length;
    //     for (int i = n / 2 - 1; i >= 0; i--) {
    //         heapify(arr,n,i);
    //     }
    // }
    // public void heapify(int[] arr, int n ,int i) {
    //     int largest = i;
    //     int left = 2 * i + 1;
    //     int right = 2 *i + 2;
    //     if (left < n && arr[left] > arr[largest]) {
    //         largest = left;
    //     }
    //     if (right < n &&  arr[right] > arr[largest]) {
    //         largest = right;
    //     }
    //     if (largest != i) {
    //         swap(arr,largest,i);
    //         heapify(arr,n,largest);
    //     }
    // }
    // public void swap(int[] arr, int i ,int j) {
    //     int temp = arr[i];
    //     arr[i] = arr[j];
    //     arr[j] = temp;
    // }

}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 题目要求o(n)的时间复杂度
    // 题目类型dp
    public int[] productExceptSelf(int[] nums) {
        //除nums[i]之外的所有数的乘积也就是将nums[i]当做1
        // 可以计算这个数左乘积和右乘积
        // 用三个数组分别存储前缀、后缀和乘积
        // 对于元素nums[0]，我们设定初始值left[0] = 1;
        // 对于元素nums[nums.length - 1] 设定初始值right[nums.length - 1] = 1;
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        int[] res = new int[n];
        left[0] = 1;right[n - 1] = 1;
        for (int i = 1; i < n; i++) {
            left[i] = left[i-1] * nums[i-1];
        }
        for (int j = n - 2; j >= 0; j--) {
            right[j] = right[j + 1] * nums[j + 1];
        }
        for (int i = 0; i < n; i++) {
            res[i] = left[i] * right[i];
        }
        return res;

    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        //从矩阵的左下角或者右上角开始遍历,时间复杂度O(m + n)
        int m = matrix.length;
        int n = matrix[0].length;
        int i = m - 1;
        int j = 0;
        while (i >= 0 && j < n) {
            if (matrix[i][j] == target) {
                return true;
            } else if(matrix[i][j] > target) {
                i--;
            } else {
                j++;
            }
        }
        
        return false;
    }

}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 用一个指针标记此新的数组的当下元素的索引
    // 对整个数组进行遍历，遍历完之后剩下的部分全部赋值为0
    // 或者说快慢指针，快指针用来遍历数组，慢指针用来指向移动后当前索引的元素
    public void moveZeroes(int[] nums) {
       int slow = 0;
       for (int i = 0; i < nums.length; i++) {
            if (nums[i] != 0) {
                nums[slow++] = nums[i];
            }
       }
        for (int i = slow; i < nums.length; i++) {
            nums[i] = 0;
        }
        

    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int findDuplicate(int[] nums) {
        // 1.二分查找 计算数组中小于等于该元素数量的个数，如果数量 > 该元素的值，说明，重复元素在l,元素区间内
        // 2.Floyd判圈算法
        // 快慢指针找相遇点 慢指针一次走一步，快指针一次走两步
        // 然后将其中一个指针移动到出发点
        // 两个指针的相遇点即为所求
        // 可以以i->nums[i]构建链表，有重复数字，说明有环
        int low = 0, high = nums.length -1;
        while (low < high) {
            int mid = low + (high - low) / 2;
            int count = 0;
            for (int i = 0; i < nums.length ; i++) {
                if (nums[i] <= mid) {
                    count++;
                }
            }
            if (count <= mid) {
                low = mid + 1;
            } else {
                high = mid ;
            }
        }
        return low;
    //    int slow = nums[0];
    //    int fast = nums[nums[0]];
    //    while (slow != fast) {
    //         slow = nums[slow];
    //         fast = nums[nums[fast]];
    //    }
    //    fast = 0;
    //    while (slow != fast) {
    //         slow = nums[slow];
    //         fast = nums[fast];
    //    }
    //    return fast;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //动态规划
    //动态规划四部曲：确定dp[]数组及下标对应的含义，递推公式、初始化、遍历顺序
    // 三种状态： 持有股票，不持有股票并且处于冷冻期，不持有股票并且不处于冷冻期对应dp[i][0],dp[i][1],dp[i][2];
    //  递推公式：dp[i][0] = dp[i-1][2] - prices[0];
    // dp[i][1] = dp[i][0] + prices[i] dp[i][2] = dp[i-1][1];
    public int maxProfit(int[] prices) {
       int n = prices.length;
       int[][] dp = new int[n][3];
       dp[0][0] = -prices[0];
       dp[0][1] = 0; dp[0][2] = 0;
       for (int i = 1; i < prices.length; i++) {
        dp[i][0] = Math.max(dp[i-1][0], dp[i-1][2] - prices[i]);
        dp[i][1] = dp[i-1][0] + prices[i];
        dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1]);
       }
       return Math.max(dp[n-1][1],dp[n-1][2]);
        
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public void nextPermutation(int[] nums) {
        //Arrays.sort(int[] nums, int fromIndex, int toIndex) 这个方法对nums中的fromIndex到toIndex - 1的部分进行排序
        // 从后向前遍历，一旦出现一个数大于前面的数，说明存在更大的数，记录该索引i
        // 下一个更大的数是，后面的数按从小到大排，将后面的数中第一个比i-1 大的数据与之交换
       int n = nums.length;
       for (int i = n - 1; i >= 0; i--) {
            if (i == 0) {
                Arrays.sort(nums);  //当前排序是最大排序，返回最小排序
            } else if (nums[i] > nums[i-1]) {  //nums[i] > nums[i-1] 说明存在下一个更大的排列
                Arrays.sort(nums, i, n);      //并且nums[i]之后的部分满足最大排列，下一个更大的排列，即对nums[i]和之后的部分排序 
                for (int index = i; index < n; index++) {  // 并取出第一个比nums[i-1]大的部分，进行交换
                    if (nums[index] > nums[i-1]) {
                        int temp = nums[i - 1];
                        nums[i - 1] = nums[index];
                        nums[index] = temp;
                        return;
                    }
                }
            }
       }
 }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 题目要求o(n)的时间复杂度
    // 题目类型dp
    public int[] productExceptSelf(int[] nums) {
        //除nums[i]之外的所有数的乘积也就是将nums[i]当做1
        // 可以计算这个数左乘积和右乘积
        // 用三个数组分别存储前缀、后缀和乘积
        // 对于元素nums[0]，我们设定初始值left[0] = 1;
        // 对于元素nums[nums.length - 1] 设定初始值right[nums.length - 1] = 1;
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        int[] res = new int[n];
        left[0] = 1;right[n - 1] = 1;
        for (int i = 1; i < n; i++) {
            left[i] = left[i-1] * nums[i-1];
        }
        for (int j = n - 2; j >= 0; j--) {
            right[j] = right[j + 1] * nums[j + 1];
        }
        for (int i = 0; i < n; i++) {
            res[i] = left[i] * right[i];
        }
        return res;

    class Solution {
    // 背包问题，完全背包
    public int coinChange(int[] coins, int amount) {
        int[] dp = new int[amount + 1]; // dp[i] 代表组成金额为i的最少硬币数
        Arrays.fill(dp, amount + 1);
        dp[0] = 0;
        for (int i = 0; i < coins.length; i++) {
            for (int j = coins[i]; j <= amount; j++) {
                dp[j] = Math.min(dp[j], dp[j-coins[i]] + 1);
            }
        }
        return dp[amount]== amount+1 ? - 1 : dp[amount];

    }
}}
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // o(log n) 二分法
    // 二分法的难点在于等号 
    // 判断nums[mid] 与 nums[left] 的关系，如果nums[mid] >= nums[left] ,说明 left 到 mid 有序 
    // if (nums[mid] < nums[left]) 说明 mid 到right 有序， 
    // 判断target是否落在有序部分，若不在则切换子数组
    // 据此缩小范围
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] >= nums[left]) { 
                if (target >= nums[left] && target < nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else {
                if (target > nums[mid] && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        return -1;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 时间复杂度O(log n)  空间复杂度O(1) 常量空间存放变量
    // 二分法
    // 寻找第一次target的位置，更新右边界
    // 最后一次target的位置，更新左边界
    public int[] searchRange(int[] nums, int target) {
        int firstPos = findBoundary(nums, target, true);
        if (firstPos == -1) {return new int[]{-1, -1};}
        int lastPos = findBoundary(nums, target, false);
        return  new int[]{firstPos, lastPos};
    }
    public int findBoundary(int[] nums, int target, boolean first) {
        int left = 0, right = nums.length - 1;
        int pos = -1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] < target) {
                left = mid + 1;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else {   // nums[mid] == target
                pos = mid;
                if (first) {
                    right = mid - 1; // 寻找第一次出现target的位置，向左移动右边界
                } else {
                    left = mid + 1; // 寻找最后一次出现target的位置，向右移动左边界
                }
            }   
        }
        return pos;
    }
    
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 算法的时间复杂度为O(log(min(m,n)))  
    // 二分
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        if (nums1.length > nums2.length) {
            return findMedianSortedArrays(nums2, nums1);
        }
        int m = nums1.length;
        int n = nums2.length;
        int left = 0, right = m;
            
        while (left <= right) {
            int i = left + (right - left) / 2;
            int j = (m + n + 1) / 2 - i;
            int nums1LeftMax = (i == 0 ? Integer.MIN_VALUE : nums1[i - 1]);
            int nums1RightMin = (i == m ? Integer.MAX_VALUE : nums1[i]);
            int nums2LeftMax = (j == 0 ? Integer.MIN_VALUE : nums2[j - 1]);
            int nums2RightMin = (j == n ? Integer.MAX_VALUE : nums2[j]);
            if (nums1LeftMax <= nums2RightMin && nums2LeftMax <= nums1RightMin) {
                if ((m + n) % 2 == 0) {
                    return (Math.max(nums1LeftMax, nums2LeftMax) + Math.min(nums1RightMin, nums2RightMin)) / 2.0;
                } else {
                    return Math.max(nums1LeftMax, nums2LeftMax);
                }
            } else if (nums1LeftMax > nums2RightMin) {
                right = i - 1;
            } else {
                left = i + 1;
            }
        }
        return -1;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public void rotate(int[][] matrix) {
        // 题目要求需要原地旋转，不能新建数组
        // 直接matrix[col][n-1-row] = matrix[row][col]的交换会导致原位置的值被覆盖，后续的交换无法进行
         //两步实现：1.转置matrix,使得matrix[i][j]变为matrix[j][i]
         //2.将matrix[j][i] 与 matrix[j][n-1-i]交换
         // 先转置或者先交换行都一样，需要注意的是：交换和转置的边界
        int n = matrix.length;
        for (int row = 0; row < n / 2; row++) {
            for (int col = 0; col < n; col++) {
                int temp = matrix[row][col];
                matrix[row][col] = matrix[n - 1 - row][col];
                matrix[n - 1 - row][col] = temp;
            }
        }
        for (int row = 0; row < n ; row++) {
            for (int col = row; col < n; col++) {
                int temp = matrix[row][col];
                matrix[row][col] = matrix[col][row];
                matrix[col][row] = temp;
            }
        }
        
        
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //贪心算法，局部最优得全局最优
    //每一步取最大,看最终能否走到nums[nums.length - 1]
    // if (coverrange == i) 说明到i为止就不能购在跳动了
    public boolean canJump(int[] nums) {
        int coverrange = 0;
        for (int i = 0; i < nums.length; i++) {

            coverrange = Math.max(nums[i] + i, coverrange);
            if (coverrange == i) {
                break;
            }

        }        
        return coverrange >= nums.length - 1 ? true : false;   
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 按照第数组中的第一个元素排序，排序之后
    // 后一个数组的左端点如果小于前一个数组的右端点则需要合并
    // 两种情况：1.后一个数组的左端点小于前一个数组的右端点，则直接合并前一个数组
    // 2.后一个数组的左端点大于于前一个数组的右端点，则取前一个数组的左端点和后一个数组的右端点
    // 由于合并之后的元素个数我们并不知道，所以一开始要用一个list存储结果
    public int[][] merge(int[][] intervals) {
       int n = intervals.length; // 列已知为2
       Arrays.sort(intervals, (a,b) -> (a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]));
       List<int[]> merge = new ArrayList<>();
       for (int i = 0; i < n; i++) { // intevlas[i][1]与merge中最后一个数组的[1]进行比较
            if (merge.isEmpty() || intervals[i][0] > merge.get(merge.size() - 1)[1]) {
                merge.add(intervals[i]);
            } else {
                merge.get(merge.size() - 1)[1] = Math.max(merge.get(merge.size() - 1)[1], intervals[i][1]);
            }
       }
    int row = merge.size();
    int[][] res = new int[row][2];
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < 2; j++) {
            res[i][j] = merge.get(i)[j];
        }
    }
    return res;    
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    
    // 动态规划
    // dp[i][j] 代表从（0,0）出发到(i,j)有多少条不同的路径
    // dp[i][j] = dp[i-1][j] + dp[i][j-1];
    // 左边界和上边界都只有1种可能
    // 从上向下，从左往右遍历
    int res = 0;
    public int uniquePaths(int m, int n) {
        int[][] dp = new int[m][n]; 
        dp[0][0] = 1;
        
        for(int i = 1; i < m;i++){
            dp[i][0] = 1;  
        }
        for(int j = 1; j < n; j++){
            dp[0][j] = 1;
        }
        for(int i = 1 ; i < m; i++){
            for(int j = 1; j < n; j++){
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]; 
            }
        } 
        return dp[m-1][n-1];
    }
   
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 原地排序 冒泡排序 选择排序 快速排序 插入排序
    // 快排 平均 O（nlogn） 最差O(n^2) 最好是O(nlogn)
    public void sortColors(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
    }
    public void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int index = partition(nums, low ,high);
            quickSort(nums, low ,index - 1);
            quickSort(nums, index + 1,high);
        }
    }
    public int partition(int[] nums, int low, int high) { // partition分区
        int pivot = nums[high];  // pivot基准
        int j = low;
        for (int i = low; i < high; i++) {
            if (nums[i] < pivot) {
                swap(nums, i, j);
                j++;
            }
        }
        swap(nums,j, high);
        return j;
    }
    public void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    List<List<Integer>> edges; //存储邻接矩阵
    int[] visited;
    boolean valid = true;
    public boolean canFinish(int numCourses, int[][] prerequisites) {
       edges = new ArrayList<>();
       //初始化邻接矩阵的列
       for (int i = 0; i < numCourses; i++) {
            edges.add(new ArrayList<Integer>());
       }
       //给每一列都添加他的后置课程
       for (int[] info : prerequisites) {
            edges.get(info[1]).add(info[0]);
       }
       //遍历每一个课程，和vaild值一起进行dfs，判断每一个课程是否可以学习完成
       visited = new int[numCourses];
       for (int i = 0; i < numCourses && valid ; i++) {
            if (visited[i] == 0) {
                dfs(i);
            }
       }
       return valid;
    }
    public void dfs(int u) {
        visited[u] = 1; //表示正在被访问
        for (int v : edges.get(u)) {
            if (visited[v] == 0) {
                dfs(v);
                if (!valid) {
                    return;
                }
            //当出现有一个环的时候即为false
	        }else if(visited[v] == 1) {
	            valid = false;
	            return;
	        }
	    }
         visited[u] = 2; //代表该门课程可以学习完成
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

// 定义前缀树的节点，每个节点有一个子数组和标志位，标志位代表该节点是否为最终节点
// insert方法插入字符串，若当前节点的子数组中的对应索引位置为空，则新建前缀树的节点
// search 和 startWiths的区别在于search需要判断返回节点的isEnd属性
class TrieNode {
    TrieNode[] children;
    boolean isEnd;
    TrieNode() {
        children = new TrieNode[26];
        isEnd = false;
    } 
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    
    public void insert(String word) {
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
            int index = word.charAt(i) - 'a';
            if (node.children[index] == null){
                node.children[index] = new TrieNode();
            }
            node = node.children[index];
        }
        node.isEnd = true;
    
    }
    
    public boolean search(String word) {
        TrieNode node = searchPrefix(word);
        return node != null && node.isEnd;
    }
    
    public boolean startsWith(String prefix) {
        TrieNode node = searchPrefix(prefix);
        return node != null;
    }
    public TrieNode searchPrefix(String word) {
        TrieNode node = root;
        for (int i = 0; i < word.length(); i++) {
            int index = word.charAt(i) - 'a';
            if (node.children[index] == null) {
                return null;
            }
            node = node.children[index];
        }
        return node;
    }
    
}

/**
 * Your Trie object will be instantiated and called as such:
 * Trie obj = new Trie();
 * obj.insert(word);
 * boolean param_2 = obj.search(word);
 * boolean param_3 = obj.startsWith(prefix);
 */

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    //使用构建图，使用HashMap存储节点和比率
    //对每个查询使用DFS查询两个节点是否存在连接，并计算比率
    
    // putIfAbsent方法 V putIfAbsent(K key, V value);
    // 如果之前 Map 中没有这个键，那么返回 null。
    // 如果之前已经有这个键了，那么返回该键之前关联的值，并且不会替换已有的值。
    HashMap<String, HashMap<String, Double>> hs = new HashMap<>();
    public double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
            for (int i = 0; i < equations.size(); i++) {
                String u = equations.get(i).get(0);
                String v = equations.get(i).get(1);
                double k = values[i];
                // 构建图
                hs.putIfAbsent(u, new HashMap<>());
                hs.putIfAbsent(v, new HashMap<>());
                hs.get(u).put(v, k);
                hs.get(v).put(u, 1 / k);
                
            }
            double[] res = new double[queries.size()];
            for (int i = 0; i < queries.size(); i++) {
                String u = queries.get(i).get(0);
                String v = queries.get(i).get(1);
                if (!hs.containsKey(u) || !hs.containsKey(v)) {
                    res[i] = -1.0;
                } else {
                    res[i] = dfs(u, v, new HashSet<String>());
                }
            }
            return res;
    }
    
    public double dfs(String start, String end, HashSet<String> visited) {
        if (hs.get(start).containsKey(end)) { //直接包含
            return hs.get(start).get(end);
        }
        visited.add(start);
        for (Map.Entry<String, Double> neighbor : hs.get(start).entrySet()) {
            if (!visited.contains(neighbor.getKey())) {
                double path = dfs(neighbor.getKey(), end, visited);
                if (path != -1.0) {
                    return path*neighbor.getValue();
                }
            }
        }
        return -1.0;
    }
        
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // O（n）就不能是排序 
    // 用HashSet存储所有元素
    // 对于一个最长序列hashSet中一定不包含当前的nums[i] - 1;
    // 判断是否存在nums[i] + 1;
    public int longestConsecutive(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        HashSet<Integer> hs = new HashSet<>();
        for (int i = 0; i < nums.length; i++) {
            hs.add(nums[i]);
        }
        int max = 1;
       
        for (int num : nums) {
            if (hs.contains(num - 1)) {
                continue;
            }
            int maxTmp = 1;
            while (hs.contains(num + 1)) {
                num += 1;
                maxTmp++;
            }
            max = Math.max(maxTmp, max);
        }
        return max;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int majorityElement(int[] nums) {
        //hashmap 使用HashMap,若其中存在，则value + 1,不存在则将相应的key添加进去
        Map<Integer,Integer> map = new HashMap();
        for(int num: nums){
            map.put(num,map.getOrDefault(num,0)+1);
            if(map.get(num) > nums.length /2){
                return num;
            }
        }
        return  -1;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public int majorityElement(int[] nums) {
        //hashmap 使用HashMap,若其中存在，则value + 1,不存在则将相应的key添加进去
        Map<Integer,Integer> map = new HashMap();
        for(int num: nums){
            map.put(num,map.getOrDefault(num,0)+1);
            if(map.get(num) > nums.length /2){
                return num;
            }
        }
        return  -1;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    public boolean isValid(String s) {
        
        // 字符串中出现左括号就将右括号压入栈中，
        // 出现右括号就与栈顶的元素匹配,判断栈顶的元素是不是对应的右括号
        // 不匹配则返回false
        // 最终需要检查栈是否为空
        // 不为空说明还有未匹配的左括号
        
        Deque<Character> stack = new LinkedList<>();
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(' || s.charAt(i) == '{' || s.charAt(i) == '[') {
                stack.push(s.charAt(i));
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char top = stack.pop();
                if (s.charAt(i) == ']' && top != '[' ||  (s.charAt(i) == '}' && top != '{') || (s.charAt(i) == ')' && top != '(')) {
                    return false;
                }
            }
        }
        return stack.isEmpty(); //不匹配说明有多余的左括号

       
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 时间复杂度O(n)，空间复杂度O(1) 
    public int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) {
            return 0;
        }
       // HashSet + 滑动窗口 or HashMap + 滑动窗口
       HashMap<Character, Integer> hs = new HashMap<>();
       int left = 0, right = 0, max = Integer.MIN_VALUE;
       while (right < s.length()) {
            char c = s.charAt(right);
            if (hs.containsKey(c) && hs.get(c) >= left) {  //发现重复字符且重复字符的位置 > 左边界
                left = hs.get(c) + 1; // left 的下一个位置是上一次出现重复的位置加1
            }
            hs.put(c, right);
            max = Math.max(right - left + 1, max);
            right++;
            
       }
        return max;
        
       
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    int ptr = 0;
    // 栈
    // 对于数字、字符串和左括号将其压入栈中
    // 遇到右括号时，将相邻的左括号和字符串数字都弹出
    // 并将解码后的字符串在压入栈中
    // 定义一个全局变量用来遍历字符串
    // 使用了StringBuffer的insert方法 StringBuffer insert(int offset, String str)  在指定位置插入字符串
    public String decodeString(String s) {
        Stack<String> stack = new Stack<>();
        while (ptr < s.length()) {
            char c = s.charAt(ptr);
            if (Character.isDigit(c)) { //数字
                String digits = getDigits(s);
                stack.push(digits);
            } else if (Character.isLetter(c) || c == '[') { 
                stack.push(String.valueOf(c));
                ptr++;
            } else {   // 右括号
                StringBuffer sb = new StringBuffer();
                while (!stack.peek().equals("[")) {
                    sb.insert(0, stack.pop());
                }
                String str = sb.toString(); // 
                stack.pop(); // 删除左括号
                StringBuffer tmp = new StringBuffer(); 
                int repeat = Integer.parseInt(stack.pop());
                for (int j = 0; j < repeat; j++) {
                    tmp.append(str); 
                }
               stack.push(tmp.toString());
                ptr++;
            }
        }
        StringBuffer sb = new StringBuffer();
        while (!stack.isEmpty()) {
            sb.insert(0, stack.pop());
        }
        return sb.toString(); 
    }

    public String getDigits(String s) { // 获得数字
        StringBuffer sb = new StringBuffer();
        while (Character.isDigit(s.charAt(ptr)) && ptr < s.length()) {
            sb.append(s.charAt(ptr++));
        }
        return sb.toString();
    }



}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 这一题和最小覆盖子串有点相似，但是这里需要找的子串不能包括其他元素,需要加一个长度限制的检查
    // 异位词就是不同的排列方式
    // 用哈希表存储字符串中每个字符出现的次数
    // 维护一个p.length()长度的滑动窗口
    // 如果滑动窗口内的元素出现频率等于p的频率，则为字母异位词
    // 时间复杂度O(m + (n - m + 1)*26)
    // 改进的时间复杂度O(m + n)
    public List<Integer> findAnagrams(String s, String p) {
        // List<Integer> res = new ArrayList();
        // int[] pCount = new int[26];
        // for (int i = 0; i < p.length(); i++) {
        //     pCount[p.charAt(i) - 'a']++;
        // }
        // int left = 0; int right = 0;
        // int[] sCount = new int[26] ;
        // while (right < s.length()) {
        //     if(right - left + 1 > p.length()) {
        //         sCount[s.charAt(left) - 'a']--;
        //         left++;
        //     }
        //     sCount[s.charAt(right) - 'a']++;
        //     if(right - left + 1 == p.length()) {
        //         boolean isEqual = true;
        //         for (int i = 0; i < 26; i++) {
        //             if(pCount[i] != sCount[i]) {
        //                 isEqual = false;
        //                 break;
        //             }
        //         }
        //         if (isEqual) {
        //             res.add(left);
        //         }
        //     }
        //     right++;
        // }
        // return res;
       List<Integer> res = new ArrayList<>();
       int sLen = s.length(), pLen = p.length();
       if (sLen < pLen) {
            return res;
       }
       HashMap<Character, Integer> hs = new HashMap<>();
       for (int i = 0; i < pLen; i++) {
            char c = p.charAt(i); 
            hs.put(c, hs.getOrDefault(c, 0) + 1);
       }
       int required = hs.size(), current = 0;
       HashMap<Character, Integer> window = new HashMap<>();
       int left = 0, right = 0;
       while (right < sLen) {
            char word = s.charAt(right);
            if (hs.containsKey(word)) {
                window.put(word, window.getOrDefault(word, 0) + 1);
                if (window.get(word).equals(hs.get(word))) {
                    current++;
                }
            }
            while (right - left + 1 >= pLen) {
                char tmp = s.charAt(left);
                if (current == required) {
                    res.add(left);
                }
                if (hs.containsKey(tmp)) {
                    if (window.get(tmp).equals(hs.get(tmp))) {
                        current--;
                    } 
                    window.put(tmp, window.get(tmp) - 1);
                }
                left++;
            }
            right++;
       }
        return res;       
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 方法1：暴力，两重for循环，第一重for循环代表开头，第二重for循环代表结尾，遍历求和， 时间复杂度O（n^2）
    // 方法2：前缀和+HashMap，类似于两数之和，用hashmap可以降时间复杂度
    // 
    public int subarraySum(int[] nums, int k) {
        int pre  = 0;
        int count = 0;
        HashMap<Integer,Integer> hs = new HashMap<>(); // hashput存储的是前缀和
        hs.put(0,1);  //连续子数组，什么都没有默认为0
        for (int i = 0; i < nums.length; i++) {
            pre += nums[i];
            if (hs.containsKey(pre - k)) {
                count += hs.get(pre - k);
            }
            hs.put(pre, hs.getOrDefault(pre, 0) + 1);
        } 
        return count;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 深度优先搜索：往一个方向遍历，走到头就回溯，再往另外一个方向遍历
    // 广度优先搜索：从一个位置开始，向他的相邻位置搜索，逐层进行，用队列实现，需要用一个boolean数组进行标记,避免重复


     // 岛屿数量这个题是深度优先搜索和广度优先搜索的基础题
     // 深度优先代码相对简单，遍历字符数组，过程碰到'1'就进行深搜，深搜的过程只要判断是否越界，元素是否为'1'，对相邻'1'进行深度优先 
    int[][] pos = {{1,0}, {-1,0},{0,1},{0,-1}};
    public int numIslands(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int num = 0;
        boolean[][] visited = new boolean[m][n];
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if ( grid[i][j] == '1') {
                    dfs(grid,i,j);
                    num++;
                }
            }
        }
        return num;
    }
    public void dfs(char[][] grid, int row, int col) {
        if (row < 0 || row >= grid.length || col < 0 || col >= grid[0].length || grid[row][col] == '0') {
             return;
         }
        
        grid[row][col] = '0';
        dfs(grid, row + 1, col);
        dfs(grid, row - 1, col);
        dfs(grid, row, col + 1);
        dfs(grid, row, col - 1);
    }
        
    // public void dfs (char[][] grid, int row, int col) {
    //     if (row < 0 || row >= grid.length || col < 0 || col >= grid[0].length || grid[row][col] == '0') {
    //         return;
    //     }
    //     grid[row][col] = '0';
    //     dfs(grid, row - 1, col);
    //     dfs(grid, row + 1, col);
    //     dfs(grid, row, col + 1);
    //     dfs(grid, row, col - 1);
    // }
    public void bfs(char[][] grid, int row, int col, boolean[][] visited) {
        grid[row][col] = '0';
        visited[row][col] = true;
        Queue<int[]> que = new LinkedList<>();
        que.offer(new int[]{row,col});
        while (!que.isEmpty()) {
            int[] cur = que.poll();
            int x = cur[0];
            int y = cur[1];
            for (int[] tmp : pos) {
                int curX = tmp[0] + x;
                int curY = tmp[1] + y;
                if (curX < 0 || curX >= grid.length || curY < 0 || curY >= grid[0].length || grid[curX][curY] == '0' || visited[curX][curY]) {
                    continue;
                }
                que.offer(new int[]{curX, curY});
                visited[curX][curY] = true;
            }
            
        }
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

ref

class Solution {
    //深度优先+回溯，
    
    int[][] directions = {{0,1},{0,-1},{1,0},{-1,0}};  
    public boolean exist(char[][] board, String word) {
        int row = board.length;
        int col = board[0].length;
        boolean[][] visited = new boolean[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                    if (dfs(i,j,board,word,0,visited)) {
                        return true;
                    }
                } 
            }
            return false;
    }
   
    public boolean dfs(int row, int col, char[][] board, String word, int index, boolean[][] visited) {
        if (index == word.length()) {
            return true;
        }
        if (row < 0 || row >= board.length || col < 0 || col >= board[0].length || word.charAt(index) != board[row][col] || visited[row][col] == true) {
            return false;
        }
        visited[row][col] = true; // 对当前的路径进行标记，避免重复访问
        for (int[] dir : directions) {
            int curRow = row + dir[0];
            int curRol = col + dir[1];
            if (dfs(curRow, curRol, board, word, index + 1, visited)) {
                return true;
            }
        }
        visited[row][col] = false; // 回溯，使得其他路径可以访问当前路径的元素
        return false;

    }
}

八皇后写法

class Solution {
    public boolean exist(char[][] board, String word) {
        int l = board.length;
        int w = board[0].length;
        boolean[][] visited = new boolean[l][w];
        for(int i=0;i<l;i++){
            for(int j=0;j<w;j++){
                if(pd(board,visited,word,0,i,j)) return true;
            }
        }
        return false;
    }

    public boolean pd(char[][] board,boolean visited[][],String word,int index,int i,int j){
        if(index == word.length()) return true;
        if(i<0||i>=board.length||j<0||j>=board[0].length||visited[i][j]||board[i][j] != word.charAt(index)) return false;
        visited[i][j] = true;
        boolean res = pd(board,visited,word,index+1,i+1,j)|pd(board,visited,word,index+1,i,j+1)|pd(board,visited,word,index+1,i-1,j)|pd(board,visited,word,index+1,i,j-1);
        visited[i][j] = false;
        return res;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 矮个子插队，高个子看不见；所以我们可以先安排高个子的位置，再通过插队的方式安排矮个子的位置
        // 身高从大到小排（身高相同k小的站前面）
        //先按照身高h降序排序，这样处理时可以确保当前插入的元素之前的所有元素身高都不小于它，从而简化位置的确定。
        //如果身高相同，则按照序号k升序排序，因为身高相同的情况下，序号小的人应该排在前面
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, (a,b) -> b[0] == a[0]? a[1] - b[1] : b[0] - a[0]);
        List<int[]> list = new ArrayList<>();
        for (int i = 0; i < people.length; i++) {
            list.add(people[i][1], people[i]);
        }
       
        return list.toArray(new int[list.size()][2]); // list.toArray将list转成array
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 矮个子插队，高个子看不见；所以我们可以先安排高个子的位置，再通过插队的方式安排矮个子的位置
        // 身高从大到小排（身高相同k小的站前面）
        //先按照身高h降序排序，这样处理时可以确保当前插入的元素之前的所有元素身高都不小于它，从而简化位置的确定。
        //如果身高相同，则按照序号k升序排序，因为身高相同的情况下，序号小的人应该排在前面
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, (a,b) -> b[0] == a[0]? a[1] - b[1] : b[0] - a[0]);
        List<int[]> list = new ArrayList<>();
        for (int i = 0; i < people.length; i++) {
            list.add(people[i][1], people[i]);
        }
       
        return list.toArray(new int[list.size()][2]); // list.toArray将list转成array
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

class Solution {
    // 贪心
    // 先执行次数最多的任务，可以充分利用任务之间的间隔。时间最短
    // 每次执行次数最多的任务，考虑优先队列，大根堆
    public int leastInterval(char[] tasks, int n) {
       PriorityQueue<Integer> pq = new PriorityQueue<>((a,b) -> b-a);
       int[] count = new int[26];
       int res = 0;
       for (int i = 0; i < tasks.length; i++) { //对任务计数
            count[tasks[i] - 'A']++;
       }
       for (int tmp : count) { // 出现次数大于0的元素才意味着任务需要完成
        if (tmp > 0) {
             pq.offer(tmp);
        }
           
       }
       while (!pq.isEmpty()) {
          List<Integer> list = new ArrayList<>(); // list记录一个间隔内完成的任务
          for (int i = 0; i <= n; i++) {
            if (!pq.isEmpty()) {
                list.add(pq.poll());
            } 
         }
         for (int t : list) {
            if ( --t > 0) {
                pq.offer(t);
            }
         }
         res += pq.isEmpty() ? list.size() : n + 1;
       } 
       return res;
    }
    // public int leastInterval(char[] tasks, int n) {
    //     // 统计每种任务的出现次数
    //     int[] count = new int[26];
    //     for (char task : tasks) {
    //         count[task - 'A']++;
    //     }

    //     // 创建一个优先队列,存储每种任务的下一次执行时间
    //     PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
    //     for (int c : count) {
    //         if (c > 0) {
    //             pq.offer(c);
    //         }
    //     }

    //     int time = 0;
    //     while (!pq.isEmpty()) {
    //         // 创建一个临时列表,存储当前时间可以执行的任务
    //         java.util.List<Integer> temp = new java.util.ArrayList<>();
    //         for (int i = 0; i <= n; i++) {
    //             if (!pq.isEmpty()) {
    //                 temp.add(pq.poll());
    //             }
    //         }

    //         // 将当前时间可以执行的任务加回优先队列,并更新它们的下一次执行时间
    //         for (int t : temp) {
    //             if (--t > 0) {
    //                 pq.offer(t);
    //             }
    //         }

    //         // 如果优先队列为空,说明所有任务已经完成,返回当前时间
    //         time += pq.isEmpty() ? temp.size() : n + 1;
    //     }

    //     return time;
    // }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    // 用一个列表存储先序遍历的结果，再构建单链表，将列表中的节点的左指针赋值为空，右指针指向列表中的下一个位置
   List<TreeNode> res = new ArrayList<>();
    public void flatten(TreeNode root) {
       if (root == null) {
            return;
       }
       preOrder(root);
       for (int i = 0; i < res.size() - 1; i++) {  // 这里是小于 res.size() - 1,确保不会数组越界
        TreeNode node = res.get(i);
        node.left = null;
        node.right = res.get(i + 1);
       }
    }
    public void preOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        res.add(root);
        preOrder(root.left);
        preOrder(root.right);
    }

}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
 //环形链表，快慢指针
public class Solution {
    // Floyd判圈法
    public boolean hasCycle(ListNode head) {
       if (head == null || head.next == null) {
        return false;
       }
       ListNode fast = head;
       ListNode slow = head;
       while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                return true;
            }
       }
       return false;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    // floyd判圈法，快慢指针
    // 设置快慢两个指针都指向头结点
    // 让一个快指针一次走两步，慢指针一次走一步
    // 两个指针相遇后，将快指针移到起点，一次走一步，相遇的位置就是链表中环的起始位置
    public ListNode detectCycle(ListNode head) {
       if (head == null || head.next == null) {
            return null;
       }
       ListNode fast = head;
       ListNode slow = head;
       while (fast != null && fast.next != null) { // fast需要走两步，所以需要判断fast != null && fast.next != null
            fast = fast.next.next;
            slow = slow.next;
            if (slow == fast) {
                fast = head;
               while (fast != slow) {
                fast = fast.next;
                slow = slow.next;
               } 
               return slow;
            }
       }
        return null;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

// LRU缓存机制可以通过哈希表辅以双向链表实现
// 使用双向链表的理由：方便删除节点，O(1)时间
// 双向链表中存储key的理由：size > capcity 时可以O(1)的时间删除哈希表中的键值对
// O(1)的get和put，用hashmap实现
// 基础还是链表的增删改查，只是这里是双向链表作为hashmap的value
// 链表的中节点的移动和删除修改通过双向链表可以在O(1)的时间内实现
// 每访问一个节点都要将其移动链表头。整个过程分为两步:1.双向链表中删除该节点，2.添加到头部
// 链表中的元素个数超过capcity后需要删除链表尾的节点
class LRUCache { 
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
        DLinkedNode() {}
        DLinkedNode(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    private int size;
    private int capacity;
    private DLinkedNode head = new DLinkedNode();
    private DLinkedNode tail = new DLinkedNode();
    private HashMap<Integer, DLinkedNode> hs = new HashMap<>();
    LRUCache(int capacity) {
        size = 0;
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }
    public int get (int key) {
        DLinkedNode node = hs.get(key);
        if (node == null) {
            return -1;
        }
        moveToHead(node);
        return node.value;
    }
    public void put(int key, int value) {
        DLinkedNode node = hs.get(key);
        if (node == null) {
            node = new DLinkedNode(key, value);
            hs.put(key, node);
            addToHead(node);
            size++;
            if (size > capacity) {
               DLinkedNode tail =  removeTail();
               hs.remove(tail.key);
               --size;
            }
        } else {
            node.value = value;
            moveToHead(node);
            
        }
    }
    public void addToHead(DLinkedNode node) { // 添加到头结点,意味着新建了一个节点
       node.next =  head.next;
       node.prev = head;
       head.next.prev = node;
       head.next = node; 
    }
    public void removeNode(DLinkedNode node) { // 删除节点
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    public void moveToHead(DLinkedNode node) { // 节点已经存在，改变他的值，需要将该节点移动到头的位置
        removeNode(node);
        addToHead(node);
    }
    public DLinkedNode removeTail() { // size > capacity 需要删除末尾节点
        DLinkedNode node = tail.prev;
        removeNode(node);
        return node;
    }
}

// java自带的LinkedHashMap已经实现了LRU缓存
// class LRUCache extends LinkedHashMap<Integer, Integer> {
//     private int capacity;
//     public LRUCache(int capacity) {
//         super(capacity, 0.75F, true); //调用父类的构造方法
//         this.capacity = capacity;
//     }
//     public int get(int key) {
//         return super.getOrDefault(key, -1);
//     }
//     public void put(int key, int value) {
//         super.put(key, value);
//     }
//     @Override
//     protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest){
//         return size() > capacity;
//     }
  
// }


/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
 // 排序，归并排序
class Solution {
    // 归并排序注意中点的划分
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode fast = head.next;
        ListNode slow = head;
        while ( fast!= null && fast.next != null ) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode tmp = slow.next;
        slow.next = null;
        ListNode left = sortList(head);
        ListNode right = sortList(tmp);
        ListNode dummy = new ListNode(-100001);
        ListNode res = dummy;
        while (left != null && right != null) {
            if (left.val <= right.val) {
                res.next = left;
                left = left.next;
            } else {
                res.next = right;
                right = right.next;
            }
            res = res.next;
        }
        res.next = left == null ? right : left;
        return dummy.next;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

哈希表

public class Solution { 
	public ListNode getIntersectionNode(ListNode headA, ListNode headB) { 
	//先存储A链表的所有结点，在遍历B链表。所以空间复杂度来到了O(m),A有m个节点的话
		Set<ListNode> visited = new HashSet<ListNode>(); 
		ListNode temp = headA; 
		while (temp != null) { 
			visited.add(temp); 
			temp = temp.next; 
		} 
		temp = headB; 
		while (temp != null) { 
			if (visited.contains(temp)) { return temp; } 
			temp = temp.next; 
		} 
		return null; 
	} 
}

双指针

public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if (headA == null || headB == null) {
            return null;
        }
        ListNode pA = headA, pB = headB;
        while (pA != pB) {
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        }
        return pA;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 思路：1. 得出链表的长度，然后走size - n - 1,接着进行删除
    //      2. 快慢指针，让快指针先走n步，之后慢指针再出发，
    //      当快指针走到结尾的时候，慢指针指向的就是倒数第n个节点的前一个节点  
    public ListNode removeNthFromEnd(ListNode head, int n) {
          ListNode dummy = new ListNode(-1,head);
          ListNode fast = dummy;
          ListNode low = dummy;
          int count = 0;
          while (fast.next != null) { // fast走到最后一个节点需要停下来
            fast = fast.next;
            count++;
            if (count >= n + 1) {
                low = low.next;
            }
          }
          low.next = low.next.next;
          return dummy.next;
    //     int size = 1;
        
    //     ListNode cur = head;
    //     while (cur.next != null) {
    //         cur = cur.next;
    //         size++;
    //     }
    //     if (n == size) return head.next; // 特判 n == size 的情况
    //     cur = head;
    //     for (int i = 1; i < size - n; i++) {
    //         cur = cur.next;
    //     }
    //     cur.next = cur.next.next;
    //     return head;
    }
    
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 用一个变量记录进位
    // 
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
       ListNode dummyRes = new ListNode();
       ListNode cur = dummyRes;
       int yushu = 0, sum = 0;
       while (l1 != null || l2 != null) {
         cur.next = new ListNode();
            int var1 = (l1 == null) ? 0 : l1.val;
            int var2 = (l2 == null) ? 0 : l2.val;
            sum = var1 + var2 + yushu;
            cur.next = new ListNode(sum % 10);
            cur = cur.next;
            yushu = sum / 10;
            if (l1 != null) {
                l1 = l1.next;
            }
            if (l2 != null) {
                l2 = l2.next;
            }
            
       }
       if (yushu != 0) {
            cur.next = new ListNode(yushu);
       }
       return dummyRes.next;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 链表的题往往使用虚拟头结点的方法 ListNode dummy 让虚拟头结点指向head，避免对head特判
    // 链表的题删除链表、翻转节点、添加节点都要用双指针
    public ListNode reverseList(ListNode head) {
       ListNode pre = null;
       ListNode cur = head;
       while (cur != null) {
        ListNode tmp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = tmp;
       }
       return pre;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
     public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        //创建一个新的链表，比较两个链表将小的值加入这个链表；
        //创建一个新的链表，比较两个链表将小的值加入这个链表；
        // 类似于归并排序的合并过程
        ListNode dummy = new ListNode();
        ListNode cur = dummy;
        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                cur.next = list1;
                list1 = list1.next;
            } else {
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        cur.next = (list1 == null) ? list2 : list1;
        return dummy.next;    
   
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    // 创建一个最小堆，存储所有的链表的头结点，每次从链表中取出一个节点，并将这个节点的下一个节点放入最小堆中
    // 这样就可以保证每次取得当前k个节点的最小值
    public ListNode mergeKLists(ListNode[] lists) {
        PriorityQueue<ListNode> pq = new PriorityQueue<>((a,b) -> a.val - b.val);
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        for (ListNode node :lists) {
            if (node != null) { // 需要判断是否为空，否则会出现空指针异常，优先队列不能加入空值
                pq.offer(node);
            }  
        }
        while (!pq.isEmpty()) {
            cur.next = pq.poll();
            cur = cur.next;
            if (cur.next != null) {
                pq.offer(cur.next);
            }
        }
        return dummy.next;
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public boolean isPalindrome(ListNode head) {
        //思路：创建一个链表和原链表相同，再翻转，然后比较；两条链表
        if (head == null) {
            return true;
        }
        ListNode headNew = new  ListNode(head.val);
        ListNode curNew = headNew;
        ListNode cur = head;
        while (cur.next != null) { // 复制链表
            curNew.next = new ListNode(cur.next.val);
            cur = cur.next;
            curNew = curNew.next; 
        } 
        ListNode pre = null;
        curNew = headNew;
        while (curNew != null) {    // 翻转链表
            ListNode tmp = curNew.next;
            curNew.next = pre;
            pre = curNew;
            curNew = tmp;
        }
        curNew = pre;
        cur = head;
        while (curNew != null) {
            if (curNew.val != cur.val) {
                return false;
            } else {
                curNew = curNew.next;
                cur = cur.next;
            }

        }
        return true;    
    }
}

Mon, 01 Jan 0001 00:00:00 +0000

LeetCode_Hot100_Java_Solution

本文将Leetcode hot 100题目按照类型分类。部分题目可能属于多个类型。

刷leetcode hot 100以前需要了解一些基础知识：

常见排序：冒泡排序，插入排序，选择排序，归并排序，快速排序，堆排序。时间复杂度为O(nlogn)：归并排序和堆排序。快速排序时间复杂度最好的情况下是O(nlogn)，最坏的情况下是O(n^2)。
字符串的常用方法：length()，substring()，spilt()。 StringBuffer()的常用方法：deleteCharAt()，reverse()，toString()，append()，insert。
常用数据结构及其常用方法：List，HashMap，HashSet，PriorityQueue，stack，queue。
Arrays.sort()自定义排序，PriorityQueue()自定义排序。

数据结构	常用方法
List	add()，remove(), get()
HashMap	put()，size()，remove()，containsKey()
HashSet	add()，remove()，size()，contains()
PriorityQueue	poll()，offer()，isEmpty()，size()，peek()
stack	push()，size()，pop()，isEmpty()，peek()
queue	poll()，offer()，isEmpty()，size()，peek()

dp

dp数组和下标的含义，递推公式，初始化，遍历顺序。

关于我

Mon, 01 Jan 0001 00:00:00 +0000

about