add notes

Author: CharonChui

Algorithm/24.文本左右对齐.md

@@ -71,6 +71,86 @@
 
 ### 思路
 
+字符串大模拟，分情况讨论即可：
+
+- 如果当前行只有一个单词，特殊处理为左对齐；
+- 如果当前行为最后一行，特殊处理为左对齐；
+- 其余为一般情况，分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」，然后依次进行拼接。当空格无法均分时，每次往靠左的间隙多添加一个空格，直到剩余的空格能够被后面的间隙所均分。
+
+```java
+
+class Solution {
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        List<String> ans = new ArrayList<>();
+        int n = words.length;
+        List<String> list = new ArrayList<>();
+        for (int i = 0; i < n; ) {
+            // list 装载当前行的所有 word
+            list.clear();
+            list.add(words[i]);
+            int cur = words[i++].length();
+            while (i < n && cur + 1 + words[i].length() <= maxWidth) {
+                cur += 1 + words[i].length();
+                list.add(words[i++]);
+            }
+
+            // 当前行为最后一行，特殊处理为左对齐
+            if (i == n) {
+                StringBuilder sb = new StringBuilder(list.get(0));
+                for (int k = 1; k < list.size(); k++) {
+                    sb.append(" ").append(list.get(k));
+                }
+                while (sb.length() < maxWidth) sb.append(" ");
+                ans.add(sb.toString());
+                break;
+            }
+
+            // 如果当前行只有一个 word，特殊处理为左对齐
+            int cnt = list.size();
+            if (cnt == 1) {
+                String str = list.get(0);
+                while (str.length() != maxWidth) str += " ";
+                ans.add(str);
+                continue;
+            }
+
+            /**
+            * 其余为一般情况
+            * wordWidth : 当前行单词总长度;
+            * spaceWidth : 当前行空格总长度;
+            * spaceItem : 往下取整后的单位空格长度
+            */
+            int wordWidth = cur - (cnt - 1);
+            int spaceWidth = maxWidth - wordWidth;
+            int spaceItemWidth = spaceWidth / (cnt - 1);
+            String spaceItem = "";
+            for (int k = 0; k < spaceItemWidth; k++) spaceItem += " ";
+            StringBuilder sb = new StringBuilder();
+            for (int k = 0, sum = 0; k < cnt; k++) {
+                String item = list.get(k);
+                sb.append(item);
+                if (k == cnt - 1) break;
+                sb.append(spaceItem);
+                sum += spaceItemWidth;
+                // 剩余的间隙数量（可填入空格的次数）
+                int remain = cnt - k - 1 - 1;
+                // 剩余间隙数量 * 最小单位空格长度 + 当前空格长度 < 单词总长度，则在当前间隙多补充一个空格
+                if (remain * spaceItemWidth + sum < spaceWidth) {
+                    sb.append(" ");
+                    sum++;
+                }
+            }
+            ans.add(sb.toString());
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：会对 words 做线性扫描，最坏情况下每个 words[i] 独占一行，此时所有字符串的长度为 n∗maxWidth。复杂度为 O(n∗maxWidth)
+- 空间复杂度：最坏情况下每个 words[i] 独占一行，复杂度为 O(n∗maxWidth)
 
 
 ---

Algorithm/25.验证回文串.md

@@ -39,7 +39,63 @@
 
 ### 思路
 
+##### 方法一
 
+最简单的方法是对字符串 s 进行一次遍历，并将其中的字母和数字字符进行保留，放在另一个字符串 sgood 中。这样我们只需要判断 sgood 是否是一个普通的回文串即可。
+
+判断的方法有两种:     
+
+- 第一种是使用语言中的字符串翻转 API 得到 sgood 的逆序字符串 sgood_rev，只要这两个字符串相同，那么 sgood 就是回文串。
+- 第二种是使用双指针。初始时，左右指针分别指向 sgood 的两侧，随后我们不断地将这两个指针相向移动，每次移动一步，并判断这两个指针指向的字符是否相同。当这两个指针相遇时，就说明 sgood 时回文串。
+
+```java
+class Solution {
+    public boolean isPalindrome(String s) {
+        StringBuffer sgood = new StringBuffer();
+        int length = s.length();
+        for (int i = 0; i < length; i++) {
+            char ch = s.charAt(i);
+            if (Character.isLetterOrDigit(ch)) {
+                sgood.append(Character.toLowerCase(ch));
+            }
+        }
+        int n = sgood.length();
+        int left = 0, right = n - 1;
+        while (left < right) {
+            if (Character.toLowerCase(sgood.charAt(left)) != Character.toLowerCase(sgood.charAt(right))) {
+                return false;
+            }
+            ++left;
+            --right;
+        }
+        return true;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(n)。由于我们需要将所有的字母和数字字符存放在另一个字符串中，在最坏情况下，新的字符串sgood与原字符串s完全相同，因此需要使用 O(n) 的空间。
+
+
+##### 方法二：在原字符串上直接判断
+
+我们可以对方法一中第二种判断回文串的方法进行优化，就可以得到只使用 O(1) 空间的算法。
+
+我们直接在原字符串 s 上使用双指针。在移动任意一个指针时，需要不断地向另一指针的方向移动，直到遇到一个字母或数字字符，或者两指针重合为止。
+
+也就是说，我们每次将指针移到下一个字母字符或数字字符，再判断这两个指针指向的字符是否相同。
+
+
+
+
+复杂度分析：   
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(1)。
 
 ---
 - 邮箱 ：charon.chui@gmail.com  

Algorithm/26.判断子序列.md

@@ -0,0 +1,129 @@
+26.判断子序列
+===
+
+
+### 题目
+
+给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
+
+字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
+
+进阶：
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+ 
+
+示例 1:   
+
+- 输入：s = "abc", t = "ahbgdc"
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "axc", t = "ahbgdc"
+- 输出：false
+ 
+
+提示:    
+
+- 0 <= s.length <= 100
+- 0 <= t.length <= 10^4
+- 两个字符串都只由小写字符组成。
+
+### 思路
+
+
+首先，如果 s 是空串，直接返回 true，因为空串是任何字符串的子序列。  
+设置双指针 i , j 分别指向字符串 s , t 的首个字符，遍历字符串 t:    
+
+- 当 s[i] == t[j] 时，代表匹配成功，此时同时 i++ , j++ ；
+    - 进而，若 i 已走过 s 尾部，代表 s 是 t 的子序列，此时应提前返回 true ；
+- 当 s[i] != t[j] 时，代表匹配失败，此时仅 j++ ；
+
+若遍历完字符串 t 后，字符串 s 仍未遍历完，代表 s 不是 t 的子序列，此时返回 false 。
+
+```java
+
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        int i = 0, j = 0;
+        while (i < s.length() && j < t.length()) {
+            if (s.charAt(i) == t.charAt(j)) {
+                i++;
+            }
+            j++;
+        }
+        return i == s.length();
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度 O(N) ： 其中 N 为字符串 t 的长度。最差情况下需完整遍历 t 。
+- 空间复杂度 O(1) ： i , j 变量使用常数大小空间。
+
+
+##### 进阶问题解法
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+
+
+这种类似对同一个长字符串做很多次匹配的 ，可以像 KMP 算法一样，先用一些时间将长字符串中的数据 提取出来，磨刀不误砍柴功。有了提取好的数据，就可以快速的进行匹配。
+
+因为S非常多，所以可以通过一次性对T进行简化处理，这样来减少后续每一次S匹配T的遍历时间:     
+
+- 这里需要的数据就是匹配到某一点时,待匹配的字符在长字符串中 下一次 出现的位置。
+
+- 所以我们前期多做一点工作，将长字符串研究透彻，假如长字符串的长度为 n，建立一个 n∗26 大小的矩阵，表示每个位置上26个字符下一次出现的位置。实现如下：
+
+- 对于要匹配的短字符串，遍历每一个字符，不断地寻找该字符在长字符串中的位置，然后将位置更新，寻找下一个字符，相当于在长字符串上“跳跃”。
+
+- 如果下一个位置为 -1，表示长字符串再没有该字符了，返回 false 即可。
+
+- 如果能正常遍历完毕，则表示可行，返回 true
+
+- 需要注意的一点
+
+    - 对于 "abc" 在 "ahbgdc" 上匹配的时候，由于长字符串第一个 a 的下一个出现 a 的位置为 -1（不出现），会导致一个 bug。
+
+    - 所以在生成数组时在长字符串前插入一个空字符即可。
+
+```java
+
+//进阶问题的解决 
+public boolean isSubsequence(String s, String t) {
+
+    //考虑到  对第一个字符的处理 ，在t 之前一个空字符
+    t=' '+t;
+
+    //对t长字符串 做预处理
+    int[][] dp = new int[t.length()][26];//存储每一个位置上  a--z的下一个字符出现的位置
+    for (char c = 'a'; c <= 'z'; c++) {//依次对每个字符作处理
+        int nextPos = -1;//表示接下来不会在出现该字符
+
+        for (int i = t.length() - 1; i >= 0; i--) {//从最后一位开始处理
+            dp[i][c - 'a'] = nextPos;//dp[i][c-'a']  加上外层循环  就是对每一个位置的a---z字符的处理了
+            if (t.charAt(i) == c) {//表示当前位置有该字符  那么指向下一个该字符出现的位置就要被更新  为i
+                nextPos = i;
+            }
+        }
+    }
+
+    //数据的利用 ，开始匹配
+    int index=0;
+    for (char c:s.toCharArray()){
+        index=dp[index][c-'a'];//因为加了' '，所以之后在处理第一个字符的时候  如果是在第一行，就会去第一行，不影响之后字符的判断
+        if(index==-1){
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

Algorithm/27.两数之和 II - 输入有序数组.md

@@ -0,0 +1,97 @@
+27.两数之和 II - 输入有序数组
+===
+
+
+### 题目
+
+给你一个下标从1开始的整数数组numbers，该数组已按非递减顺序排列，请你从数组中找出满足相加之和等于目标数target的两个数。     
+
+如果设这两个数分别是numbers[index1]和numbers[index2]，则`1 <= index1 < index2 <= numbers.length`。     
+
+以长度为`2`的整数数组`[index1, index2]`的形式返回这两个整数的下标`index1`和`index2`。      
+
+你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。     
+
+你所设计的解决方案必须只使用常量级的额外空间。     
+
+ 
+示例 1:    
+
+- 输入：numbers = [2,7,11,15], target = 9
+- 输出：[1,2]
+- 解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+
+示例 2:    
+
+- 输入：numbers = [2,3,4], target = 6
+- 输出：[1,3]
+- 解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
+
+示例 3:   
+
+- 输入：numbers = [-1,0], target = -1
+- 输出：[1,2]
+- 解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+ 
+
+提示:    
+
+- 2 <= numbers.length <= 3 * 104
+- -1000 <= numbers[i] <= 1000
+- numbers 按 非递减顺序 排列
+- -1000 <= target <= 1000
+- 仅存在一个有效答案
+
+### 思路
+
+注意题目说仅存在一个有效答案
+
+
+初始时两个指针分别指向第一个元素位置和最后一个元素的位置。每次计算两个指针指向的两个元素之和，并和目标值比较。如果两个元素之和等于目标值，则发现了唯一解。如果两个元素之和小于目标值，则将左侧指针右移一位。如果两个元素之和大于目标值，则将右侧指针左移一位。移动指针之后，重复上述操作，直到找到答案。
+
+使用双指针的实质是缩小查找范围。那么会不会把可能的解过滤掉？答案是不会。
+
+假设`numbers[i]+numbers[j]=target`是唯一解，其中`0≤i<j≤numbers.length−1`。        
+
+初始时两个指针分别指向下标0和下标`numbers.length−1`，左指针指向的下标小于或等于i，右指针指向的下标大于或等于 j。        除非初始时左指针和右指针已经位于下标 i 和 j，否则一定是左指针先到达下标 i 的位置或者右指针先到达下标 j 的位置。
+
+- 如果左指针先到达下标 i 的位置，此时右指针还在下标 j 的右侧，`sum>target`，因此一定是右指针左移，左指针不可能移到 i 的右侧。
+
+- 如果右指针先到达下标 j 的位置，此时左指针还在下标 i 的左侧，`sum<target`，因此一定是左指针右移，右指针不可能移到 j 的左侧。
+
+由此可见，在整个移动过程中，左指针不可能移到 i 的右侧，右指针不可能移到 j 的左侧，因此不会把可能的解过滤掉。
+
+
+由于题目确保有唯一的答案，因此使用双指针一定可以找到答案。
+
+
+```python
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        left = 0
+        right = len(numbers) - 1
+        result = [-1]*2
+        while left < right:
+            sum = numbers[left] + numbers[right]
+            if sum < target:
+                left += 1
+            elif sum > target:
+                right -= 1
+            else:
+                return [left+1, right+1]
+
+        return [-1, -1]
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是数组的长度。两个指针移动的总次数最多为 n 次。
+
+- 空间复杂度：O(1)。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+