add new answers

Change-Id: Ib413119076014fff9d0bdfbd8dda2b4d83c61adb

Author: lixiang.2533

.DS_Store

@@ -1,42 +1,3 @@
-```python
-import os
-from glob import glob
-
-dirs = os.listdir('/Users/lixiang.2533/Desktop/Blogs/Leetcode/')
-dir = '/Users/lixiang.2533/Desktop/Blogs/Leetcode'
-dirs = ['动态规划','栈','回溯']
-for a in dirs:
-    md_list = glob(os.path.join(dir, a, '*.md'))
-    md_list = sorted(md_list)
-    contents = []
-    file_name = [i.split('/')[-1].split('.md')[0] for i in md_list]
-    file_name = dict([(i.split('.')[0], i) for i in file_name])
-    ## 给总结md加入title  
-    with open(md_list[0], 'r') as f:
-        lines = f.readlines()
-    new_lines = []
-    for i in lines:
-        if i.strip():
-            nums = i.split('- ')[1]
-            if nums.isdigit():
-                new_lines.append('   - ' + file_name.get(nums, nums) + '\n')
-            else:
-                new_lines.append('- ' + file_name.get(nums, nums) + '\n')
-
-    with open(md_list[0], 'w') as f:
-        f.writelines(new_lines)
-    for md in md_list:
-        md_name = md.split('/')[-1]
-        contents.append('### ' + md_name + "\n")
-        with open(md, 'r') as f:
-            contents.append(f.read() + "\n")
-
-    with open(os.path.join(dir, "{}总结.md".format(a)), "w") as f:
-        f.writelines(contents)
-```
-
-
-
 ```
 dirs = os.listdir('/Users/lixiang.2533/Desktop/Blogs/Leetcode/')
 dir = '/Users/lixiang.2533/Desktop/Blogs/Leetcode'

merge_md.md

@@ -1,19 +1,22 @@
 - 找target
-  - 69 x 的平方根：牛顿法
-  - 74 搜索二维矩阵
-  - 367 有效的完全平方数：牛顿法
-  - 374 猜数字大小
-  - 704 二分查找
+  - [ ] 69 x 的平方根：牛顿法
+  - [ ] 74 搜索二维矩阵
+  - [ ] 367 有效的完全平方数：牛顿法
+  - [ ] 374 猜数字大小
+  - [ ] 704 二分查找
 - 找边界
-  - 34 在排序数组中查找元素的第一个和最后一个位置：注意判断是否存在该元素
-  - 35 搜索插入位置
-  - 278 第一个错误的版本
-  - 441 排列硬币
+  - [ ] 34 在排序数组中查找元素的第一个和最后一个位置：注意判断是否存在该元素
+  - [ ] 35 搜索插入位置
+  - [ ] 278 第一个错误的版本
+  - [ ] 441 排列硬币
 - 有技巧的二分法
-  - 29 两数相除
+  
+  - [ ] 4 寻找两个正序数组的中位数：收缩区间法
+  - [ ] 29 两数相除
   - 旋转数组
-    - 33 搜索旋转排序数组：左右闭区间，
-    - 81 搜索旋转排序数组 II：在33的基础上对所有mid=left/right无法判断搜索方向的场景跳过
-    - 153 寻找旋转排序数组中的最小值：开区间，只能和右边界进行判断，避免从小值跳到大值
-  - 162 寻找峰值：通过mid左右值大小判断搜索方向
-  - 240 搜索二维矩阵 II：Z字形搜索（每个点都有唯一的搜索方向）
+    - [ ] 33 搜索旋转排序数组：左右闭区间，
+    - [ ] 81 搜索旋转排序数组 II：在33的基础上对所有mid=left/right无法判断搜索方向的场景跳过
+    - [ ] 153 寻找旋转排序数组中的最小值：开区间，只能和右边界进行判断，避免从小值跳到大值
+  - [ ] 162 寻找峰值：通过mid左右值大小判断搜索方向
+  - [ ] 240 搜索二维矩阵 II：Z字形搜索（每个点都有唯一的搜索方向）
+  - [ ] 287 寻找重复数

个人项目总结.pdf

@@ -0,0 +1,62 @@
+给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。
+
+假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。
+
+你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。
+
+ 
+
+示例 1：
+
+输入：nums = [1,3,4,2,2]
+输出：2
+
+示例 2：
+
+输入：nums = [3,1,3,4,2]
+输出：3
+
+ 
+
+提示：
+
+    1 <= n <= 105
+    nums.length == n + 1
+    1 <= nums[i] <= n
+    nums 中 只有一个整数 出现 两次或多次 ，其余整数均只出现 一次
+
+ 
+
+
+进阶：
+
+    如何证明 nums 中至少存在一个重复的数字?
+    你可以设计一个线性级时间复杂度 O(n) 的解决方案吗？
+
+
+
+```python
+class Solution:
+    def findDuplicate(self, nums: List[int]) -> int:
+        def check(i):
+            cnt = 0 
+            for n in nums:
+                if n<=i:
+                    cnt+=1
+            return cnt<=i 
+        left =0 
+        right = len(nums)-1
+        while left<right:
+            mid =(left+right)//2
+            if check(mid):
+                left = mid+1
+            else:
+                right =mid
+        return right
+```
+
+
+
+Tips
+
+隐形的二分搜索题，通过判断nums中小于mid的部分是否可能存在重复，来缩小搜索区间，需要使用二分单纯是为了不使用额外的内存空间

二分法/0.二分法总结.md

@@ -0,0 +1,87 @@
+给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
+
+算法的时间复杂度应该为 O(log (m+n)) 。
+
+ 
+
+示例 1：
+
+输入：nums1 = [1,3], nums2 = [2]
+输出：2.00000
+解释：合并数组 = [1,2,3] ，中位数 2
+
+示例 2：
+
+输入：nums1 = [1,2], nums2 = [3,4]
+输出：2.50000
+解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
+
+示例 3：
+
+输入：nums1 = [0,0], nums2 = [0,0]
+输出：0.00000
+
+示例 4：
+
+输入：nums1 = [], nums2 = [1]
+输出：1.00000
+
+示例 5：
+
+输入：nums1 = [2], nums2 = []
+输出：2.00000
+
+ 
+
+提示：
+
+    nums1.length == m
+    nums2.length == n
+    0 <= m <= 1000
+    0 <= n <= 1000
+    1 <= m + n <= 2000
+    -106 <= nums1[i], nums2[i] <= 106
+
+
+
+```python
+class Solution:
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        def helper(k):
+            index1, index2 = 0,0
+            while True:
+                # 其中一个数组已经遍历完
+                if index1==l1:
+                    return nums2[index2+k-1]
+                if index2==l2:
+                    return nums1[index1+k-1]
+                if k==1:
+                    return min(nums1[index1], nums2[index2])
+
+                newindex1 = min(index1+ k//2-1, l1-1) #右边界是闭区间 取min避免指针越界
+                newindex2 = min(index2+ k//2-1, l2-1)
+                if nums1[newindex1]<=nums2[newindex2]:
+                    k -= newindex1-index1+1 #双闭区间，右-左+1
+                    index1 = newindex1 +1
+                else:
+                    k -= newindex2 - index2 + 1  # 双闭区间，右-左+1
+                    index2 = newindex2 +1
+
+        l1 = len(nums1)
+        l2 = len(nums2)
+        total = l1+l2
+        if total%2==1:
+            return helper(total//2+1) # k是第几个元素，是index+1
+        else:
+            return (helper(total//2) + helper(total//2+1))/2
+```
+
+
+
+Tips
+
+- K=7，中位数就是排名第4的数字（k//2+1）
+- 这里的二分搜索通过比较nums1[index1], nums2[index2]的大小，较小的一方如果是nums1[index1]则index1之前的元素都不可能是中位数，可以从搜索范围内剔除，同时K也会跟着缩小。
+- 最难处理的部分是边界问题
+  - Nums1，Nums2任意一个碰到边界，直接返回另一个的对应位置
+  - 搜索时双闭区间