📖juc

Author: Jstarfish

docs/.DS_Store

@@ -97,7 +97,7 @@ categories: Algorithm
 
 ### 斐波那契数列
 
-PS：我们先从一个简单的斐波那契数列来进一步理解下重叠子问题与状态转移方程（斐波那契数列并不是严格意义上的动态规划，因为它没有求最值，所以也没设计到最优子结构的问题）
+PS：我们先从一个简单的斐波那契数列来进一步理解下重叠子问题与状态转移方程（斐波那契数列并不是严格意义上的动态规划，因为它没有求最值，所以也没涉及到最优子结构的问题）
 
 **1、暴力递归**
 
@@ -647,22 +647,25 @@ public int coinChange(int[] coins, int amount) {
 
  //初始值
  dp[0] = 0;
- // 外层 for 循环在遍历所有状态的所有取值
+ // 外层 for 循环在遍历所有可能得金额，（从1到amount）
  //dp[i]上的值不断选择已含有硬币值当前位置的数组值 + 1，min保证每一次保存的是最小值
  for (int i = 1; i < amount + 1; i++) {
- //内层 for 循环在求所有选择的最小值 状态转移方程
+ //内层循环所有硬币面额
  for (int coin : coins) {
+ //如果i<coin，当前硬币coin面额太大，无法凑成金额i
  if (i >= coin) {
  //分两种情况，使用硬币coin和不使用，取最小值
  dp[i] = Math.min(dp[i - coin] + 1, dp[i]);
  }
  }
  }
- return dp[amount] > amount ? -1 : dp[amount];
+ return dp[amount] == amount + 1 ? -1 : dp[amount];
 }
 ```
 
 > 为啥 `dp` 数组初始化为 `amount + 1` 呢，因为凑成 `amount` 金额的硬币数最多只可能等于 `amount`（全用 1 元面值的硬币），所以初始化为 `amount + 1` 就相当于初始化为正无穷，便于后续取最小值。为啥不直接初始化为 int 型的最大值 `Integer.MAX_VALUE` 呢？因为后面有 `dp[i - coin] + 1`，这就会导致整型溢出。
+>
+> 最终，dp[amout] 就是凑成总金额所需的最少硬币数，如果dp[amount] 仍是初始化的较大值，说明无法凑出，返回 -1。
 
 
 
@@ -692,7 +695,7 @@ public int coinChange(int[] coins, int amount) {
 我们需要找出给定数组中两个数字之间的最大差值（即，最大利润）。此外，第二个数字（卖出价格）必须大于第一个数字（买入价格）
 
 ```java
-public static int dp(int[] prices) {
+public int dp(int[] prices) {
  int length = prices.length;
  if (length == 0) {
  return 0;
@@ -853,8 +856,6 @@ class Solution{
 
 ### 动态规划与其它算法的关系
 
-这一章我们将会介绍分治和贪心算法的核心思想，并与动态规划算法进行比较。
-
 #### 分治
 
 解决分治问题的时候，思路就是想办法把问题的规模减小，有时候减小一个，有时候减小一半，然后将每个小问题的解以及当前的情况组合起来得出最终的结果。例如归并排序和快速排序，归并排序将要排序的数组平均地分成两半，快速排序将数组随机地分成两半。然后不断地对它们递归地进行处理。

docs/data-structure-algorithms/.DS_Store

@@ -686,3 +686,192 @@ public void merge(int[] nums1, int m, int[] nums2, int n) {
 }
 ```
 
+
+
+### [136. 只出现一次的数字](https://leetcode.cn/problems/single-number/)
+
+> 给你一个 **非空** 整数数组 `nums` ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
+>
+> 你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。
+>
+> ```
+> 输入：nums = [4,1,2,1,2]
+> 
+> 输出：4
+> ```
+
+思路：**异或运算**
+
+异或运算（`^`）有以下几个重要性质：
+
+1. 任何数和 `0` 做异或运算，结果仍然是原来的数，即 `a ^ 0 = a`。
+2. 任何数和其自身做异或运算，结果是 `0`，即 `a ^ a = 0`。
+3. 异或运算满足交换律和结合律，即 `a ^ b ^ c = a ^ (b ^ c) = (a ^ b) ^ c`。
+
+```java
+public int singleNumber(int[] nums) {
+ int result = 0;
+ for (int num : nums) {
+ result ^= num;
+ }
+ return result;
+}
+```
+
+
+
+### [169. 多数元素](https://leetcode.cn/problems/majority-element/)
+
+> 给定一个大小为 `n` 的数组 `nums` ，返回其中的多数元素。多数元素是指在数组中出现次数 **大于** `⌊ n/2 ⌋` 的元素。
+>
+> 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+>
+> ```
+> 输入：nums = [2,2,1,1,1,2,2]
+> 输出：2
+> ```
+
+思路：排序后取中间元素，如果将数组 `nums` 中的所有元素按照单调递增或单调递减的顺序排序，那么下标为 ⌊2*n*⌋ 的元素（下标从 `0` 开始）一定是众数。
+
+```java
+class Solution {
+ public int majorityElement(int[] nums) {
+ Arrays.sort(nums);
+ return nums[nums.length / 2];
+ }
+}
+```
+
+
+
+### [75. 颜色分类](https://leetcode.cn/problems/sort-colors/)
+
+> 给定一个包含红色、白色和蓝色、共 `n` 个元素的数组 `nums` ，**[原地](https://baike.baidu.com/item/原地算法)** 对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。
+>
+> 我们使用整数 `0`、 `1` 和 `2` 分别表示红色、白色和蓝色。
+>
+> 必须在不使用库内置的 sort 函数的情况下解决这个问题。
+>
+> ```
+> 输入：nums = [2,0,2,1,1,0]
+> 输出：[0,0,1,1,2,2]
+> ```
+
+思路：双指针（荷兰国旗问题）。用 3 个指针遍历数组，过程中，移动 left 、right 和 curr 指针即可。
+
+```java
+public void sortColors(int[] nums) {
+ // 初始化三个指针
+ int left = 0; // 左指针，指向当前遍历到的最左边的一个0的右侧
+ int right = nums.length - 1; // 右指针，指向当前遍历到的最右边的一个2的左侧
+ int curr = 0; // 当前遍历指针
+
+ // 遍历数组
+ while (curr <= right) {
+ // 如果当前元素是0，则将其与左指针指向的元素交换，并将左指针和右指针都向右移动一位
+ if (nums[curr] == 0) {
+ swap(nums, curr, left);
+ left++;
+ curr++;
+ } 
+ // 如果当前元素是2，则将其与右指针指向的元素交换，但只将右指针向左移动一位
+ // 因为交换过来的元素可能是0或1，需要再次判断
+ else if (nums[curr] == 2) {
+ swap(nums, curr, right);
+ right--;
+ } 
+ // 如果当前元素是1，则只需将当前指针向右移动一位
+ else {
+ curr++;
+ }
+ }
+}
+
+// 交换数组中两个元素的位置
+private void swap(int[] nums, int i, int j) {
+ int temp = nums[i];
+ nums[i] = nums[j];
+ nums[j] = temp;
+}
+```
+
+
+
+### [287. 寻找重复数](https://leetcode.cn/problems/find-the-duplicate-number/)
+
+> 给定一个包含 `n + 1` 个整数的数组 `nums` ，其数字都在 `[1, n]` 范围内（包括 `1` 和 `n`），可知至少存在一个重复的整数。
+>
+> 假设 `nums` 只有 **一个重复的整数** ，返回 **这个重复的数** 。
+>
+> 你设计的解决方案必须 **不修改** 数组 `nums` 且只用常量级 `O(1)` 的额外空间。
+>
+> ```
+> 输入：nums = [1,3,4,2,2]
+> 输出：2
+> ```
+
+**思路**：由于题目要求不能修改原数组（不能排序），且空间复杂度为$O(1)$，时间复杂度低于$O(n^2)$，我们可以使用二分查找或者快慢指针（循环检测）的方法。
+
+1. 二分查找（基于抽屉原理）
+
+ 抽屉原理：如果有 n 个抽屉和 n+1 个物品，那么至少有一个抽屉有至少两个物品。
+
+ 我们不是在原始数组上进行二分，而是在数字范围上进行二分。数字的范围是 [1, n]。
+ 对于中间数 mid，统计数组中 <= mid 的元素的个数 count：
+
+ - 如果 count <= mid，那么重复元素一定在 [mid+1, n] 之间。
+
+ - 否则，重复元素在 [1, mid] 之间。
+
+ ```java
+ public int findDuplicate(int[] nums) {
+ int left = 1;
+ int right = nums.length - 1;
+ while (left < right) {
+ int mid = left + (right - left) / 2;
+ int count = 0;
+ for (int num : nums) {
+ if (num <= mid) {
+ count++;
+ }
+ }
+ if (count > mid) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+ }
+ ```
+
+2. 快慢指针法
+
+ 把数组`nums`看成一个特殊的链表，数组的索引是链表节点的编号，数组的值是指向下一个节点的指针。因为存在重复数字，所以链表中必然存在环，那么问题就转化为寻找链表环的入口，该入口对应的数字就是重复的数。
+
+ - 初始化两个指针`slow`和`fast`，都指向数组的第一个元素，即`nums[0]`。
+ - 让`slow`指针每次走一步（`slow = nums[slow]`），`fast`指针每次走两步（`fast = nums[nums[fast]]`），直到`slow`和`fast`相遇。
+ - 相遇后，将`fast`指针重新指向`nums[0]`，然后`slow`和`fast`指针每次都走一步，当它们再次相遇时，相遇点对应的数字就是重复的数。
+
+ ```java
+ public int findDuplicate(int[] nums) {
+ int slow = nums[0];
+ int fast = nums[0];
+ // 第一轮，找到相遇点
+ do {
+ slow = nums[slow];
+ fast = nums[nums[fast]];
+ } while (slow != fast);
+ 
+ // 重置其中一个指针到起点
+ fast = nums;
+ // 两个指针都每次一步移动，直到相遇
+ while (slow != fast) {
+ slow = nums[slow];
+ fast = nums[fast];
+ }
+ return slow; // 或者fast，此时它们相等
+ }
+ ```
+
+ 

docs/data-structure-algorithms/algorithm/Dynamic-Programming.md

@@ -1,16 +1,24 @@
+---
+title: 动态规划 通关秘籍
+date: 2025-07-08
+tags: 
+ - DP
+categories: leetcode
+---
+
 > 个人感觉动态规划是最难的，一会爬楼梯，一会兑零钱，一会又要去接雨水，炒股就不说了，还要去偷东西，哎，我太南了
 
 ![](https://cdn.nlark.com/yuque/0/2021/png/21674094/1639551516595-9b6a2bad-c55b-43e1-b172-ced36ffa96cc.png)
 
 ## 子序列问题
 
-一旦涉及到子序列和最值，那几乎可以肯定，**考察的是动态规划技巧，时间复杂度一般都是 O(n^2)**
+一旦涉及到子序列和最值，那几乎可以肯定，**考察的是动态规划技巧，时间复杂度一般都是 $O(n^2)$**
 
 两种思路
 
 **1、第一种思路模板是一个一维的 dp 数组**
 
-```
+```java
 int n = array.length;
 int[] dp = new int[n];
 
@@ -53,18 +61,15 @@ for (int i = 0; i < n; i++) {
 
 PS： 注意「子序列」和「子串」这两个名词的区别，子串一定是连续的，而子序列不一定是连续的
 
-> https://leetcode-cn.com/problems/longest-increasing-subsequence/solution/zui-chang-shang-sheng-zi-xu-lie-dong-tai-gui-hua-2/
-
-这种题目看懂需要看动图
-
-![img](https://labuladong.online/algo/images/%E6%9C%80%E9%95%BF%E9%80%92%E5%A2%9E%E5%AD%90%E5%BA%8F%E5%88%97/gif1.gif)
+![](https://writings.sh/assets/images/posts/algorithm-longest-increasing-subsequence/longest-increasing-subsequence-dp1-2.jpeg)
 
 ```java
- public static int getLengthOfLIS(int[] nums) {
+ public int getLengthOfLIS(int[] nums) {
 
  int[] dp = new int[nums.length];
  Arrays.fill(dp, 1);
 
+ int maxLength = 1;
  for (int i = 0; i < nums.length; i++) {
  for (int j = 0; j < i; j++) {
  //当 nums[i] <= nums[j] 时： nums[i] 无法接在 nums[j]之后，此情况上升子序列不成立，跳过，不是比较dp[i]和dp[j]
@@ -76,10 +81,7 @@ PS： 注意「子序列」和「子串」这两个名词的区别，子串一
  dp[i] = Math.max(dp[i], dp[j] + 1);
  }
  }
- }
- int res = 0;
- for (int i = 0; i < len; i++) {
- res = Math.max(res, dp[i]);
+ maxLength = Math.max(maxLength, dp[i]);
  }
  return res;
  }

docs/data-structure-algorithms/soultion/Array-Solution.md

@@ -307,8 +307,14 @@ Java 通过 `Thread.State` 枚举定义了线程的**6 种状态**（JDK 1.5 后
 
 ### 说说 sleep() 方法和 wait() 方法区别和共同点?
 
-- 两者最主要的区别在于：**sleep 方法没有释放锁，而 wait 方法释放了锁** 。
-- 两者都可以暂停线程的执行。
+sleep () 和 wait () 的核心区别在于锁的处理机制：
+
+1. **锁释放**：sleep () 不释放锁，wait () 释放锁并进入等待队列；
+2. **唤醒方式**：sleep () 依赖时间或中断，wait () 依赖其他线程通知；
+3. **使用场景**：sleep () 用于线程暂停，wait () 用于线程协作（wait 方法必须在 synchronized 保护的代码中使用）。
+
+
+
 - `wait ()`通常被用于线程间交互/通信（wait 方法必须在 synchronized 保护的代码中使用），sleep 通常被用于暂停执行。
 - `wait()` 方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的 `notify()` 或者 `notifyAll()` 方法。`sleep()` 方法执行完成后，线程会自动苏醒。或者可以使用 `wait(long timeout)` 超时后线程会自动苏醒。
 
@@ -320,6 +326,14 @@ Java 通过 `Thread.State` 枚举定义了线程的**6 种状态**（JDK 1.5 后
 
 
 
+#### 为什么 wait () 必须在 synchronized 块中？
+
+- **原子性保障**：避免线程安全问题（如生产者修改队列后，消费者未及时感知）。
+
+- **JVM 实现机制**：锁对象的 `monitor` 记录等待线程，需通过 `synchronized` 获取锁后才能操作 `monitor`
+
+ 
+
 ### 为什么我们调用 start() 方法时会执行 run() 方法，为什么我们不能直接调用 run() 方法？
 
 调用 `start()` 方法最终会导致在新的执行路径上执行 `run()` 方法中的代码，这是 Java 实现多线程的标准方式。直接调用 `run()` 方法通常是一个错误，原因在于两者在行为、线程生命周期和底层执行机制上存在根本区别：
@@ -1413,11 +1427,11 @@ LongAdder 引入了分段累加的概念，内部一共有两个参数参与计
 ### 为什么要用线程池，优势是什么？
 
 > **池化技术相比大家已经屡见不鲜了，线程池、数据库连接池、Http 连接池等等都是对这个思想的应用。池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。**
-
-如果每个任务都创建一个线程会带来哪些问题：
-
-1. 第一点，反复创建线程系统开销比较大，每个线程创建和销毁都需要时间，如果任务比较简单，那么就有可能导致创建和销毁线程消耗的资源比线程执行任务本身消耗的资源还要大。
-2. 第二点，过多的线程会占用过多的内存等资源，还会带来过多的上下文切换，同时还会导致系统不稳定。
+>
+> 如果每个任务都创建一个线程会带来哪些问题：
+>
+> 1. 第一点，反复创建线程系统开销比较大，每个线程创建和销毁都需要时间，如果任务比较简单，那么就有可能导致创建和销毁线程消耗的资源比线程执行任务本身消耗的资源还要大。
+> 2. 第二点，过多的线程会占用过多的内存等资源，还会带来过多的上下文切换，同时还会导致系统不稳定。
 
 线程池是一种基于池化思想管理线程的工具。
 

docs/data-structure-algorithms/soultion/DP-Solution.md

@@ -107,7 +107,17 @@ Exception 又分为**可检查**（checked）异常和**不检查**（unchecked
 
 面向对象 ( Object Oriented ) 是将现实问题构建关系，然后抽象成 **类 ( class )**，给类定义属性和方法后，再将类实例化成 **实例 ( instance )** ，通过访问实例的属性和调用方法来进行使用。
 
-类具有三个基本特征：封装、继承、多态
+类具有基本特征：封装、继承、多态、抽象
+
+设计原则：
+
+| 原则 | 核心思想 | 典型应用 |
+| ------------ | ---------------------------- | ------------------------------------------------- |
+| **单一职责** | 一个类只做一件事 | 拆分`UserManager`为`AuthService`+`ProfileService` |
+| **开闭原则** | 对扩展开放，对修改关闭 | 通过策略模式实现支付方式扩展 |
+| **里氏替换** | 子类不破坏父类契约 | `Bird`类不应继承`Penguin`（企鹅不会飞） |
+| **接口隔离** | 多个专用接口优于单一臃肿接口 | 拆分`Animal`为`Flyable`/`Swimmable` |
+| **依赖倒置** | 依赖抽象而非实现 | 订单模块通过`PaymentGateway`接口调用支付 |