132-补交四周作业

Week_01/id_132/LeetCode_441_132.java

@@ -0,0 +1,10 @@
+class Solution {
+    public int arrangeCoins(int n) {
+        int curCoins = 1, residual = n - 1;
+        while (residual >= curCoins + 1) {
+            ++curCoins;
+            residual -= curCoins;
+        }
+        return n == 0 ? 0 : curCoins;
+    }
+}

Week_01/id_132/LeetCode_687_132.java

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    /*
+    最长同值路径，需要比较以不同节点为根节点时的最长同值路径，取最大值。
+    以某节点为根节点时的最长同值路径 = 以其左孩子为根节点的最长同值路径 + 以其右孩子为根节点的最长同值路径。
+    注意，分支节点的最长同值路径也可以理解为最大同值深度
+    */
+    int maxP = 0;
+    public int longestUnivaluePath(TreeNode root) {
+        if(root == null) return 0;
+        getMaxP(root,root.val);
+	    return maxP;
+	}
+	private int getMaxP(TreeNode root, int val){
+        if(root == null) return 0;
+        int left = getMaxP(root.left, root.val);
+        int right = getMaxP(root.right, root.val);
+        maxP = Math.max(maxP,left+right);
+        if(root.val == val)
+            //其左右子树的最大同值路径中较长的那个加上该节点后继续向父节点回溯构成最长同值路径
+            return Math.max(left,right)+1;
+        return 0;
+    } 
+}

Week_02/id_132/LeetCode_242_132.java

@@ -0,0 +1,17 @@
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+        int [] arr = new int [26];
+        boolean flag = false;
+        for (char c : s.toCharArray()){
+            arr[c - 'a']++;
+        }
+
+        for (char d : t.toCharArray()){
+            if (arr[d - 'a'] == 0) return flag;
+            arr[d - 'a']--;
+        }
+
+        return true;
+    }
+}

Week_02/id_132/LeetCode_783_132.cpp

@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void pre(vector<int>& res,TreeNode* root)
+    {
+        if(root != NULL)
+        {
+
+            pre(res,root->left);
+            res.push_back(root->val);
+            pre(res,root->right);
+        }
+    }
+    int minDiffInBST(TreeNode* root) {
+        vector<int> res;
+        pre(res,root);
+        vector<int> r;
+        for(int i=0;i < res.size()-1;i++)
+            r.push_back(res[i+1] - res[i]);
+        sort(r.begin(),r.end()); 
+        return r[0];
+    }
+
+
+}

Week_03/id_132/LeetCode_429_132.java

@@ -0,0 +1,37 @@
+/*
+// Definition for a Node.
+class Node {
+    public int val;
+    public List<Node> children;
+    public Node() {}
+    public Node(int _val,List<Node> _children) {
+        val = _val;
+        children = _children;
+    }
+};
+*/
+class Solution {
+    public List<List<Integer>> levelOrder(Node root) {
+        List<List<Integer>> llist = new ArrayList<>();
+        if (root == null){
+            return llist;
+        }
+        ArrayDeque<Node> que = new ArrayDeque<>();
+        que.offer(root);
+        while (!que.isEmpty()){
+            int size = que.size();
+            List<Integer> list = new ArrayList<>();
+            for (int i = 0; i < size; ++ i){
+                Node tmp = que.poll();
+                list.add(tmp.val);
+                for (Node node : tmp.children){
+                    if (node != null){
+                        que.offer(node);
+                    }
+                }
+            }
+            llist.add(list);
+        }
+        return llist;
+    }
+}

Week_03/id_132/LeetCode_703_132.java

@@ -0,0 +1,29 @@
+class KthLargest {
+    PriorityQueue<Integer> minHeap;
+    int k;
+
+    public KthLargest(int k, int[] nums) {
+        this.minHeap = new PriorityQueue<Integer>();
+        this.k = k;
+        for(int num : nums){
+            add(num);
+        }
+    }
+
+    public int add(int val) {
+        if(minHeap.size() < k){
+            minHeap.add(val);
+        }else if(minHeap.peek() < val){
+            minHeap.poll();
+            minHeap.add(val);
+        }
+
+        return minHeap.peek();
+    }
+}
+
+/**
+ * Your KthLargest object will be instantiated and called as such:
+ * KthLargest obj = new KthLargest(k, nums);
+ * int param_1 = obj.add(val);
+ */

Week_04/id_132/LeetCode_455_132.java

@@ -0,0 +1,19 @@
+public int findContentChildren(int[] g, int[] s) {
+    int ret = 0;
+
+    Arrays.sort(g);
+    Arrays.sort(s);
+
+    int i = 0, j = 0;
+    while (i < g.length && j < s.length) {
+        if (g[i] <= s[j]) {
+            ret++;
+            i++;
+            j++;
+        }else if (g[i] > s[j]) {
+            j++;
+        }
+    }
+
+    return ret;
+}

Week_04/id_132/LeetCode_720_132.java

@@ -0,0 +1,29 @@
+class Solution {
+    public String longestWord(String[] words) {
+        //给定字符串数组，找出包含最长的字符串（包含其他单词的字母），如果存在相同长度，取字母排序小的
+        //思路：对数组排序，再利用Set对字母存储，小的单词一定包含在后面大的单词里面。后面只需要取前缀相同的
+
+        Set<String> set=new HashSet<String>();
+        for(int i=0;i<words.length;i++){
+            set.add(words[i]);
+        }
+        int length=0;
+        String word="";
+        for(int i=0;i<words.length;i++){
+            if(words[i].length()>length||(words[i].length()==length&&words[i].compareTo(word)<0)){
+                //如果存在相同长度的字符串，取字母排序较小的
+                int len=words[i].length();
+                while(len>0&&set.contains(words[i].substring(0,len))){
+                    //求相同的部分
+                    len--;
+                }
+                if(len==0){
+                    //说明该单词的所有字符串均为公共字母,将其标记为匹配串
+                    length=words[i].length();
+                    word=words[i];
+                }
+            }
+        }
+        return word;
+    }
+}