427-Week 02

README.md

@@ -2,7 +2,7 @@
 
 ## 讲师课件下载地址
 
-请大家通过该链接查看讲师课件并进行下载：链接:https://pan.baidu.com/s/18S8C5ZIXfzbOTr378B4n3A  密码:964l
+请大家通过该链接查看讲师课件并进行下载：链接:https://pan.baidu.com/s/14kX8vGP4_0lMyC9FaBu8Tw  密码:31zj
 
 
 ## 仓库目录结构说明

Week_00/G20200343030029/NOTE.md

@@ -1 +1,3 @@
-学习笔记
+#预习周脑图绘制
+*算法脑图*
+[算法脑图地址](https://www.processon.com/mindmap/5e47c4cae4b0834dd835b666 "超链接title")

Week_00/G20200343030373/NOTE.md

@@ -1 +1,30 @@
-学习笔记
+# 极客大学 算法训练营 第六期
+- `打点`#活动#开始
+- 讲师
+    - 覃超
+- 第六期
+    - 2.10 - 4.12
+    - [课程安排](https://shimo.im/docs/K9pv9HdcJ6KkRDQh/read)
+- 任务与作业
+    - 上周日00:00-本周日23:59
+- 每周作业
+    - 至少2道代码作业提交
+    - 一篇学习总结
+    - code review 并点评至少5位代码作业或总结
+- [GitHub仓库](https://github.com/algorithm006-class01/algorithm006-class01)
+    - ReadMe
+    - Fork, Clone
+    - PullRequest, e.g. 373-Week 02
+    - 作业，e.g. /Week_01/G20200343030373/LeetCode_2_373/LeetCode_2_373_test.go
+    - 总结，Issues, e.g. 【373-week 03】二叉树的更多理解
+- 毕业
+    - 60分（日常作业，期中考试，期末考试）
+    - 毕业总结
+    - 视频观看超80%
+- 优秀学员
+    - 90分
+    - 20分钟以上分享
+- 优秀小组
+- 助教
+    - 吴铮
+    - 金泽

Week_00/G20200343030391/LeetCode_11_391.java

@@ -0,0 +1,48 @@
+public class LeetCode_11_391 {
+    public static void main(String[] args) {
+        int[] nums = {1, 8, 6, 2, 5, 4, 8, 3, 7};
+        int max = maxAreaDoubleCursor(nums);
+        System.out.println(max);
+
+    }
+
+    /**
+     * 暴力解法
+     * 时间复杂度O(n^2)
+     * @param height
+     * @return
+     */
+    public static int maxAreaViolence(int[] height) {
+        int max = 0;
+        for (int i = 0; i < height.length; i++) {
+            for (int j = i + 1; j < height.length; j++) {
+                max = Math.max(max, Math.min(height[i], height[j]) * (j - i));
+            }
+        }
+        return max;
+    }
+
+    /**
+     * 双指针：
+     *  两侧夹逼移动最小板
+     *  时间复杂度O(n^2)
+     * @param height
+     * @return
+     */
+    public static int maxAreaDoubleCursor(int[] height) {
+        int max = 0;
+        int i = 0;
+        int j = height.length - 1;
+        while (i < j) {
+            if (height[i] < height[j]) {
+                max = Math.max(max, height[i] * (j - i));
+                i++;
+            } else {
+                max = Math.max(max, height[j] * (j - i));
+                j--;
+            }
+
+        }
+        return max;
+    }
+}

Week_00/G20200343030391/LeetCode_141_391.java

@@ -0,0 +1,46 @@
+package G20200343030391;
+
+public class LeetCode_141_391 {
+    public static void main(String[] args) {
+        //1->2->3->4->5->NULL
+        ListNode listNode1 = new ListNode(1);
+        ListNode listNode2 = new ListNode(2);
+        ListNode listNode3 = new ListNode(3);
+        ListNode listNode4 = new ListNode(4);
+        ListNode listNode5 = new ListNode(5);
+        listNode1.next = listNode2;
+        listNode2.next = listNode3;
+        listNode3.next = listNode4;
+        listNode4.next = listNode5;
+        listNode5.next = listNode2;
+
+        boolean b = hasCycle(listNode1);
+        System.out.println(b);
+    }
+
+    public static boolean hasCycle(ListNode head) {
+        if (head == null || head.next == null) {
+            return false;
+        }
+        ListNode slow = head;
+        ListNode fast = head.next;
+        while (slow != fast) {
+            if (fast == null || fast.next == null) {
+                return false;
+            }
+            slow = slow.next;
+            fast = fast.next.next;
+        }
+        return true;
+    }
+    public static class ListNode {
+        int val;
+        ListNode next;
+
+        ListNode(int x) {
+            val = x;
+        }
+
+    }
+
+}

Week_00/G20200343030391/LeetCode_15_391.java

@@ -0,0 +1,43 @@
+package G20200343030391;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class LeetCode_15_391 {
+    public static void main(String[] args) {
+        int[] nums = {-1, 0, 1, 2, -1, -4};
+        List<List<Integer>> lists = threeSum(nums);
+        System.out.println(lists);
+    }
+
+    public static List<List<Integer>> threeSum(int[] nums) {
+        List<List<Integer>> ans = new ArrayList<>();
+        int len = nums.length;
+        if (len < 3) {
+            return ans;
+        }
+        Arrays.sort(nums); // 排序
+        for (int i = 0; i < len; i++) {
+            if (nums[i] > 0) break; // 如果当前数字大于0，则三数之和一定大于0，所以结束循环
+            if (i > 0 && nums[i] == nums[i - 1]) continue; // 去重
+            int L = i + 1;
+            int R = len - 1;
+            while (L < R) {
+                int sum = nums[i] + nums[L] + nums[R];
+                if (sum == 0) {
+                    ans.add(Arrays.asList(nums[i], nums[L], nums[R]));
+                    while (L < R && nums[L] == nums[L + 1]) L++; // 去重
+                    while (L < R && nums[R] == nums[R - 1]) R--; // 去重
+                    L++;
+                    R--;
+                } else if (sum < 0) {
+                    L++;
+                } else {
+                    R--;
+                }
+            }
+        }
+        return ans;
+    }
+}

Week_00/G20200343030391/LeetCode_70_391.java

@@ -0,0 +1,56 @@
+package G20200343030391;
+
+public class LeetCode_70_391 {
+
+    public static void main(String[] args) {
+        System.out.println(climbStairs_2(3));
+    }
+
+
+    /**
+     * 动态规划
+     * @param n
+     * @return
+     */
+    public static int climbStairs_1(int n) {
+        int[] dp = new int[n + 1];
+        dp[0] = 1;
+        dp[1] = 1;
+        for(int i = 2; i <= n; i++) {
+            dp[i] = dp[i - 1] + dp[i - 2];
+        }
+        return dp[n];
+    }
+
+    /**
+     * 记忆搜索
+     * @param n
+     * @return
+     */
+    public static int climbStairs_2(int n) {
+        int[] memo = new int[n + 1];
+        memo[0] = 1;
+        return help(memo, n);
+    }
+
+    private static int help(int[] memo, int n) {
+        if (n <= 1) {
+            return 1;
+        }
+        if (memo[n] == 0) {
+            memo[n] = help(memo, n - 1) + help(memo, n - 2);
+        }
+        return memo[n];
+    }
+
+    /**
+     * 傻递归
+     * @param n
+     * @return
+     */
+    public static int climbStairs_3(int n) {
+        return n <= 1 ? 1 : climbStairs_3(n - 1) + climbStairs_3(n - 2);
+    }
+
+
+}

Week_00/G20200343030395/NOTE.md

@@ -1 +0,0 @@
-学习笔记

Week_00/G20200343030431/LeetCode_026_431.java

@@ -0,0 +1,21 @@
+package FistWork;
+//  1 遍历数组，找到重复的元素--java中有现成的函数吧
+//  2 删除重复元素，返回新数组
+//  3 思路尝试不通，估使用（copy）的是leetcode上的解法
+public class Solution01 {
+	public int removeDuplicates(int[] nums) {
+		if (nums == null || nums.length == 1) {
+			return nums.length;
+		}
+		int i = 0, j = 1;
+		while (j < nums.length) {
+			if (nums[i] == nums[j]) {
+				j++;
+			} else {
+				i++;
+				nums[i] = nums[j];
+			}
+		}
+		return i + 1;
+	}
+}

Week_00/G20200343030431/LeetCode_088_431.java

@@ -0,0 +1,15 @@
+package FistWork;
+// 自己思路： 分别遍历数组1 ，数组2 ， 合并到一起组成数组3， 在遍历一次，排序，成数组4
+//  最终还是使用(copy代码)leetCode的代码
+public class Solution02 {
+	public void merge(int[] nums1,int m , int[] nums2, int n){
+		int len1 = m - 1;
+		int len2 = n - 1;
+		int len = m + n - 1;
+		while(len1 >= 0 && len2 >= 0){
+			nums1[len--] = nums1[len1] > nums2[len2] ? nums1[len1--] : nums2[len2--];
+			System.arraycopy(nums2,0,nums1,0,len2+1);
+		}
+	}
+
+}

Week_00/G20200343030437/readme.txt

@@ -0,0 +1 @@
+我是第一次

Week_00/G20200343030453/LeetCode_21_453

@@ -0,0 +1,71 @@
+/*
+ * @lc app=leetcode.cn id=21 lang=c
+ *
+ * [21] 合并两个有序链表
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+
+// 解法一 迭代
+struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
+    if(!l1 || !l2) {
+        return l1 == NULL ? l2 : l1;
+    }
+    struct ListNode *head = NULL;
+    if(l1 -> val < l2 -> val) {
+        head = l1;
+        l1 = l1 -> next;
+    }
+    else {
+        head = l2;
+        l2 = l2 -> next;
+    }
+    struct ListNode *p = head;
+    while(l1 || l2) {
+        if(!l1) {
+            p -> next = l2;
+            break;
+        }
+        else if(!l2) {
+            p -> next = l1;
+            break;
+        }
+        else if(l1 -> val < l2 -> val) {
+            p -> next = l1;
+            p = p -> next;
+            l1 = l1 -> next;
+        }
+        else {
+            p -> next = l2;
+            p = p -> next;
+            l2 = l2 -> next;
+        }
+    }
+    return head;
+}
+
+
+// 解法二 递归
+struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
+    if(!l1) {
+        return l2;
+    }
+    else if(!l2) {
+        return l1;
+    }
+    else if(l1 -> val < l2 -> val) {
+        l1 -> next = mergeTwoLists(l1 -> next, l2);
+        return l1;
+    }
+    else {
+        l2 -> next = mergeTwoLists(l1, l2 -> next);
+        return l2;
+    }
+}

Week_00/G20200343030453/LeetCode_26_453

@@ -0,0 +1,16 @@
+//[26] 删除排序数组中的重复项
+int removeDuplicates(int* nums, int numsSize){
+    // 1. 暴力法
+    // 2. 双指针 O(n)
+    if(numsSize < 2) {
+        return numsSize;
+    }
+    int i = 0;
+    int j = 0;
+    for(i = 1; i < numsSize; i++) {
+        if(nums[i] != nums[j]) {
+            nums[++j] = nums[i];
+        }
+    }
+    return j + 1;
+}