刷题篇--热题HOT 61-70

 1 class Solution {
 2     public boolean canFinish(int numCourses, int[][] prerequisites) {
 3         //计算入度数组
 4         int[] degree = new int[numCourses];
 5         for(int[] cp : prerequisites){
 6             degree[cp[0]]++;
 7         }
 8         //存放入度为0课程
 9         LinkedList<Integer> queue = new LinkedList();
10         //找出入度为0的课程
11         for(int i=0;i<numCourses;i++){
12             if(degree[i]==0) queue.addLast(i);
13         }
14         //找到下一个入度为0的
15         while(!queue.isEmpty()){
16             //出栈，能够完成的课程
17             Integer pre = queue.removeFirst();
18             numCourses--;
19             for(int[] req : prerequisites){
20                 if(req[1] != pre) continue;
21                 degree[req[0]]--;
22                 if(degree[req[0]] == 0) queue.addLast(req[0]);
23             }
24         }
25         return numCourses==0;
26     }
27 }

 1 class TrieNode{
 2     TrieNode[] chiled;//记录孩子节点
 3     boolean is_end;
 4     TrieNode(){
 5         chiled = new TrieNode[26];//一个孩子节点有2266个分支，即一层树有26各分支
 6         is_end = false;
 7     }
 8 }
 9 class Trie {
10     TrieNode root;//根节点，不存值
11     /** Initialize your data structure here. */
12     public Trie() {
13         root = new TrieNode();
14     }
15     
16     /** Inserts a word into the trie. */
17     public void insert(String word) {
18         TrieNode node = root;
19         for(int i=0;i<word.length();i++){
20             char c = word.charAt(i);
21             if(node.chiled[c-‘a‘]==null){//如果该层该字符位置为空,则新建一个
22                 node.chiled[c-‘a‘] = new TrieNode();
23             }
24             node = node.chiled[c-‘a‘];//指向下一层
25         }
26         node.is_end = true;//字符串最后一个字符那层的位置is_end=true
27     }
28     
29     /** Returns if the word is in the trie. */
30     public boolean search(String word) {
31         TrieNode node = root;
32         for(int i=0;i<word.length();i++){
33             char c= word.charAt(i);
34             if(node.chiled[c-‘a‘] == null){//判断是否存在
35                 return false;
36             }
37             node = node.chiled[c-‘a‘];
38         }
39         return node.is_end;//判断结尾
40     }
41     
42     /** Returns if there is any word in the trie that starts with the given prefix. */
43     /**
44     *serach和startWith区别在于是否判断结尾is_end，startWith是只要字符存在就行
45     */
46     public boolean startsWith(String prefix) {
47         TrieNode node = root;
48         for(int i=0;i<prefix.length();i++){
49             char c= prefix.charAt(i);
50             if(node.chiled[c-‘a‘] == null){//判断是否存在
51                 return false;
52             }
53             node = node.chiled[c-‘a‘];
54         }
55         return true;
56     }
57 }
58 
59 /**
60  * Your Trie object will be instantiated and called as such:
61  * Trie obj = new Trie();
62  * obj.insert(word);
63  * boolean param_2 = obj.search(word);
64  * boolean param_3 = obj.startsWith(prefix);
65  */

 1 class Solution {
 2     public int findKthLargest(int[] nums, int k) {
 3         //利用最小堆，创建k+1的size，遍历数组进行添加，并poll一个
 4         PriorityQueue<Integer> heap = new PriorityQueue(k+1);
 5         for(int num : nums){
 6             heap.add(num);
 7             if(heap.size() > k){
 8                 heap.poll();
 9             }
10         }
11         return heap.poll();
12     }
13 }

 1 class Solution {
 2     public int maximalSquare(char[][] matrix) {
 3         if(matrix.length == 0) return 0;
 4         int rl = matrix.length;
 5         int cl = matrix[0].length;
 6         int[][] dp = new int[rl+1][cl+1];
 7         int maxLen = 0;
 8         for(int i=1;i<=rl;i++){
 9             for(int j=1;j<=cl;j++){
10                 if(matrix[i-1][j-1] == ‘1‘){
11                     dp[i][j] = Math.min(dp[i-1][j-1], Math.min(dp[i-1][j],dp[i][j-1]))+1;
12                     maxLen = Math.max(maxLen, dp[i][j]);
13                 }
14             }
15         }
16         return maxLen*maxLen;
17     }
18 }

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode(int x) { val = x; }
 8  * }
 9  */
10 class Solution {
11     public TreeNode invertTree(TreeNode root) {
12         if(root == null){
13             return root;
14         }
15         TreeNode leftNode = invertTree(root.left);
16         TreeNode rightNode = invertTree(root.right);
17         root.left = rightNode;
18         root.right = leftNode;
19         return root;
20     }
21 }

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return null;
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            TreeNode temp = node.left;
            node.left = node.right;
            node.right = temp;
            if(node.left!=null) queue.add(node.left);
            if(node.right!=null) queue.add(node.right);
        }
        return root;
    }
}

 1 /**
 2  * Definition for singly-linked list.
 3  * public class ListNode {
 4  *     int val;
 5  *     ListNode next;
 6  *     ListNode(int x) { val = x; }
 7  * }
 8  */
 9 class Solution {
10     public boolean isPalindrome(ListNode head) {
11         if(head == null || head.next == null) return true;
12         ListNode cur = head;
13         ListNode slow = head, fast = head.next, pre = null, prepre = null;
14         while(fast!=null&&fast.next!=null){
15             pre = slow;//先保存slow
16             slow = slow.next;
17             fast = fast.next.next;
18             //先移动再反转
19             pre.next = prepre;
20             prepre = pre;
21         }
22         ListNode p2 = slow.next;//右边
23         slow.next = pre;
24         ListNode p1 = fast == null ? slow.next : slow;//如果是奇数个，则跳过中间节点
25         while(p1 != null){
26             if(p1.val != p2.val) 
27                 return false;
28             p1 = p1.next;
29             p2 = p2.next;
30         }
31         return true;
32     }
33 }

 1 class Solution {
 2     public int[] productExceptSelf(int[] nums) {
 3         int[] res = new int[nums.length];
 4         int k = 1;
 5         for(int i=0;i<nums.length;i++){
 6             res[i] = k;//[1,1,2,6]
 7             k *= nums[i];//[1,2,6,24]给下次乘值使用，这样就是i左边的乘值
 8         }
 9         k = 1;
10         for(int i=nums.length-1;i>=0;i--){
11             res[i] *= k;//[24,12,8,6]
12             k *= nums[i];//[24,24,12,4] i右边的乘值 
13         }
14         return res;
15     }
16 }

 1 class Solution {
 2     public int[] maxSlidingWindow(int[] nums, int k) {
 3         if(nums==null||nums.length==0) return nums;
 4         int len = nums.length;
 5         int[] res = new int[len-k+1];
 6         int index = 0;
 7         ArrayDeque<Integer> queue = new ArrayDeque<Integer>();//队列存储的是索引值
 8         for(int i=0;i<nums.length;i++){
 9             if(queue.isEmpty()){
10                 queue.add(i);//刚开始时
11             }
12             if(i-queue.peekFirst()>=k){
13                 queue.pollFirst();//将太老的老成员提出
14             }
15             while(!queue.isEmpty() && nums[i]>=nums[queue.peekLast()]){
16                 queue.pollLast();
17             }
18             queue.addLast(i);
19             if(i>=k-1){//k-1个元素开始，就要输出了
20                 res[index++] = nums[queue.peekFirst()];
21             }
22         }
23         return res;
24     }
25 }

 1 class Solution {
 2     public boolean searchMatrix(int[][] matrix, int target) {
 3         if(matrix == null || matrix.length ==0 || matrix[0].length == 0){
 4             return false;
 5         }
 6         int m = matrix.length;
 7         int n = matrix[0].length;
 8         int row = m-1, col = 0;
 9         while(row >= 0 && col <= n-1){
10             if(matrix[row][col] == target){
11                 return true;
12             }else if(matrix[row][col] < target){
13                 col++;
14             }else{
15                 row--;
16             }
17         }
18         return false;
19     }
20 }