码迷,mamicode.com
首页 > 其他好文 > 详细

刷题篇--热题HOT 61-70

时间:2020-01-11 00:36:20      阅读:109      评论:0      收藏:0      [点我收藏+]

标签:另一个   rod   ddl   Fix   结构   tree   The   计算   直接   

207.课程表

现在你总共有 n 门课需要选,记为 0 到 n-1。在选修某些课程之前需要一些先修课程。 例如,想要学习课程 0 ,你需要先完成课程 1 ,我们用一个匹配来表示他们: [0,1]给定课程总量以及它们的先决条件,判断是否可能完成所有课程的学习?

示例 1:输入: 2, [[1,0]],输出: true,解释: 总共有 2 门课程。学习课程 1 之前,你需要完成课程 0。所以这是可能的

示例 2:输入: 2, [[1,0],[0,1]]输出: false,解释: 总共有 2 门课程。学习课程 1 之前,你需要先完成?课程 0;并且学习课程 0 之前,你还应先完成课程 1。这是不可能的。

分析:这个问题相当于查找一个循环是否存在于有向图中,可使用BFS/DFS,本体先使用BFS,易于理解。如何判断一门课程能够学习--这门课程不用先修课程,或者先修课程已经完成,我们将已经修完的课程直接抛弃参与以后的讨论。一门课程的先修课程数即使‘’入度‘,当入度为0时,就说明这门课程可以完成,所以我们首先创建一个degree数组存储每门课程的入度。当一个有向图中不存在环,那么刚开始时肯定有一个入度为0,即没有先修课程的课程。我们以此课程进行广度遍历。没遍历到一门课程,那么说明此条路径可达,那么这门课程的入度减一,如果入度变为0,说明此课程不在环内,待完成课程数减一。最后查看待完成课程是否为0.如何实现遍历呢,使用队列,先进先出

实例:degree[] = {0 ,0 ,1, 1, 2, 1}

技术图片

 

以课程1为出发点遍历有序图,将课程1放入队列。此时栈内:1

 技术图片

出栈,遍历prerequisites[][],发现课程2的先修课程是1,那么就将degree[2] -1,此时degree[2]=0,那么说明2入度为0,可完成,入栈。此时栈内:2

技术图片

出栈,遍历prerequisites[][],发现课程3的先修课程是2,那么就将degree[3 ]-1,此时degree[3]=0,那么说明3入度为0,可完成,入栈。此时栈内:3

 

技术图片

(此处不用出栈,因为还在以课程2为入度的循环内)遍历prerequisites[][],发现课程4的先修课程是2,那么就将degree[4] -1,此时degree[4]=1,那么说明4入度为0,可完成,入栈。此时栈内:3,4

技术图片

 

出栈,遍历prerequisites[][],发现课程5的先修课程是3,那么就将degree[5 ]-1,此时degree[5]=1,那么说明5入度为1,不可完成。此时栈内:4

出栈,遍历prerequisites[][],发现课程5的先修课程是4,那么就将degree[5 ]-1,此时degree[5]=0,那么说明5入度为0,可完成。入栈,此时栈内:5

出栈,遍历prerequisites[][],发现没有以5为先修课程的,那么结束循环。此时队列也为空,那么结束循环。判断此时待修课程是否为0;

 

 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 }

 

 

 

208.实现Trie(前缀树)

实现一个 Trie (前缀树),包含 insert, search, 和 startsWith 这三个操作。
示例:
Trie trie = new Trie();
trie.insert("apple");
trie.search("apple");   // 返回 true
trie.search("app");     // 返回 false
trie.startsWith("app"); // 返回 true
trie.insert("app");   
trie.search("app");     // 返回 true

分析:Trie根节点不存入值

1.Trie节点结构:一个int[26]数组来存储字符值,一个boolean类型is_end判断是否以该字符结尾。下图表示leet在树中的表示。

技术图片

 

 2.插入:插入一个值,从根部开始搜索字符值,存在两种情况:

    链接存在:继续向下搜索

    链接不存在:创建新节点,直到达到插入值最后一个字符,将末尾字符is_end设置为true

技术图片

3.查找:

技术图片

 

 4.前缀

技术图片

 

 

 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  */

 

215.数组中最K个最大元素

示例 1:输入: [3,2,1,5,6,4] 和 k = 2,输出: 5
示例 2:输入: [3,2,3,1,2,4,5,5,6] 和 k = 4,输出: 4
分析:排序,输出nums[length-K],快排O(NlogN);复杂度不咋地,看了题解使用堆排序,维持一个大小为K的小顶堆,那么堆顶就是答案,如果大于堆顶且堆满就加入,反之不操作,复杂度为O(NlogK)。

 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 }

 

221.最大正方形

在一个由 0 和 1 组成的二维矩阵内,找到只包含 1 的最大正方形,并返回其面积。

示例:

输入: 

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0

输出: 4

分析:动态规划,建立一个二维数组dp[i][j],在左上角矩阵中由matrix[i-1][j-1]参与构成的最大正方形边长。

如果matrix[i-1][j-1]=‘1‘  =>  dp[i][j] = min{dp[i-1][j], dp[i-1][j-1], dp[i][j-1] } +1。否则 dp[i][j]=0。

技术图片

 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 }

 

226.翻转二叉树

示例:

输入:

     4
   /   \
  2     7
 / \      / \
1   3 6   9

输出:

     4
   /   \
  7     2
 / \      / \
9   6 3   1

分析:递归

 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;
    }
}

 

234.回文链表

请判断一个链表是否为回文链表。
示例 1:输入: 1->2输出: false
示例 2:输入: 1->2->2->1输出: true
分析:1.快慢指针,指向中间。2.将前半段倒序。3.遍历比较

 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 }

 

 

236.二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为:“对于有根树 T 的两个结点 p、q,最近公共祖先表示为一个结点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”
例如,给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]
技术图片

示例 1:输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1;输出: 3,解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4;输出: 5,解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
分析:递归,从根节点开始。如果存在公共祖先,所以要么是根节点,要么在左子树或右子树。如果根节点已经包含待求值中的某一值,则根节点一定是最早公共祖先(一个节点先遍历到,另一个节点是其祖先)。遍历过程中,存在三种情况:

- 如果左子树中没有待求值,但右子树中返回了某一节点值,则可判断右子树中存在公共子节点,而递归操作就可以达到查找到最早公共子节点的作用

- 如果左子树中返回每一节点,而右子树中为空,与上述情况相同

- 如果左右子树均有返回节点,则可判断左右子树中应分别有一个待求节点,故此时的根节点一定是最早公共祖先。

 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 lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
12         if(root == null || root == p || root == q){
13             return root;
14         }
15         //根据当前节点寻找左右子树
16         TreeNode left = lowestCommonAncestor(root.left,p,q);
17         TreeNode right = lowestCommonAncestor(root.right,p,q);
18         //如果左子树有一个,右子树也找到一个,则返回当前节点
19         if(left!=null&&right!=null){
20             return root;
21         }
22         //左子树没有,那么去右子树找
23         if(left == null) return right;
24         //与上述相反
25         if(right == null) return left;
26         return null;
27     }
28 }

 

238.除自身以外数组的乘积

给定长度为 n 的整数数组 nums,其中 n > 1,返回输出数组 output ,其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。
示例:输入: [1,2,3,4],输出: [24,12,8,6]
说明: 请不要使用除法,且在 O(n) 时间复杂度内完成此题。

分析:暴力法不可取,O(N^2)。乘积 = 当前数左边乘积 * 当前数右边乘积。设置一数组,一次从头到尾遍历原数组存入左边乘值,一次从未到头遍历原数组存入右边乘值。例如:[1,2,3,4]

从前往后:[1,1*1, 2*1, 2*3]

从后往前:[1*2*3*4,1*1 * 3*4,2*1 * 4,2*3]

 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 }

 

239.滑动窗口最大值

给定一个数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
示例:
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3,输出: [3,3,5,5,6,7]
解释:
  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

提示:你可以假设 k 总是有效的,在输入数组不为空的情况下,1 ≤ k ≤ 输入数组的大小。
分析:双向链表:剑指Offer

Step1.使用一个双端队列存储滑窗内元素的下标。

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

queue

     

 

Step2.若queue为空,说明刚开始滑动,将num第一个元素的索引压入队列中。

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 queue

 0    

 

Step3.遍历num下一个元素num[1]=3,

  ①先判断当前索引位置减去队列最左边元素是否>=size,如果是,那么说明随着滑窗滑动,当前滑窗内的最大值滑出去了,已经不再这个滑窗内,这是需要将队列最左边元素弹出。(队列最左边为滑窗内最大值索引,判断是否有效)

  ②将当前元素与队列最右边的索引处的数组值对比,如果当前元素大于队列最右边对应的值,则将队列最右边的值弹出,直到找到对应值比当前元素值大的。(队列左边是最大的值,随着上述操作,会逐渐更新队列,滑出去或者新添加的值更大的话将会更新队列,保证队头对应值最大)

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

 1    

 

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

2    

---输出4

 

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

 2 3  

---输出4

 

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

4    

---输出6

 

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

4 5  

---输出6

 

value 2 3 4 2 6 2 5
index 0 1 2 3 4 5 6

 

4  5  

---输出6

 

value 2 3 4 2 6 2 5 1
index 0 1 2 3 4 5 6 7

 --当前索引处位置(7)-队列最左边(4)=size(3)--》滑出

 4 5 7

 --

5 7  

 --输出5

 补充:队头是存储最大值的索引,队头被弹出的情况:新来的比队内所有数都大、队头不在当前子数组中。新来成员时,判断是否有老成员太老了和新成员是否比其他老成员大(循环比,大一个弹一个,直到队列为空或者比老成员小)。队内情况:索引由小到大,因为位于当前元素前面并且小的被淘汰了。

 

 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 }

 

 

 

 

240.搜索二维矩阵Ⅱ

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性:每行的元素从左到右升序排列。每列的元素从上到下升序排列。
示例:
现有矩阵 matrix 如下:
[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5,返回 true。给定 target = 20,返回 false。
分析:矩阵特点:左上角最小,右下角最大。本题从左下角遍历,如果大于当前元素,则向右寻找,反之,向上寻找。复杂度O(n+m)。

 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 }

刷题篇--热题HOT 61-70

标签:另一个   rod   ddl   Fix   结构   tree   The   计算   直接   

原文地址:https://www.cnblogs.com/qmillet/p/12161319.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!