常规提交

Author: gwtak

121_买卖股票的最佳时机_easy/dp_自己写的.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int res=0;
+        int min_price=INT_MAX;
+        for(int i=0;i<prices.size();i++){
+            res=max(res,prices[i]-min_price);
+            min_price=min(prices[i],min_price);
+        }
+        return res;
+    }
+};

122_买卖股票的最佳时机 II_easy/自己写的_双指针法.cpp

@@ -0,0 +1,53 @@
+/*给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
+
+注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+ 
+
+示例 1:
+
+输入: [7,1,5,3,6,4]
+输出: 7
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
+示例 2:
+
+输入: [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
+     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
+     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+示例 3:
+
+输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
+ 
+
+提示：
+
+1 <= prices.length <= 3 * 10 ^ 4
+0 <= prices[i] <= 10 ^ 4
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+class Solution {
+public:
+    int maxProfit(vector<int>& prices) {
+        int res=0;
+        int i=prices.size()-1;
+        int j=prices.size()-1;
+        while(i>=0){
+            if(i-1>=0&&prices[i]>prices[i-1]) i--;
+            else{
+                res+=(prices[j]-prices[i]);
+                i--;
+                j=i;
+            }
+        }
+        return res;
+    }
+};

152_乘积最大子数组_normal/dp_抄的_53类似.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+    int maxProduct(vector<int>& nums) {
+        int res=INT_MIN;
+        int nums_max=1;
+        int nums_min=1;
+        for(int i=0;i<nums.size();i++){
+            if(nums[i]<0) nums_max^=nums_min^=nums_max^=nums_min;
+            nums_max=max(nums_max*nums[i],nums[i]);
+            nums_min=min(nums_min*nums[i],nums[i]);
+            res=max(nums_max,res);
+        }
+        return res;
+    }
+};

152_乘积最大子数组_normal/自己写的_暴力法_超时.cpp

@@ -0,0 +1,32 @@
+/*给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
+
+ 
+
+示例 1:
+
+输入: [2,3,-2,4]
+输出: 6
+解释: 子数组 [2,3] 有最大乘积 6。
+示例 2:
+
+输入: [-2,0,-1]
+输出: 0
+解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/maximum-product-subarray
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+class Solution {
+public:
+    int maxProduct(vector<int>& nums) {
+        int res=INT_MIN;
+        for(int i=0;i<nums.size();i++){
+            int tmp=1;
+            for(int j=i;j<nums.size();j++){
+                tmp*=nums[j];
+                res=max(tmp,res);
+            }
+        }
+        return res;
+    }
+};

167_两数之和 II - 输入有序数组_easy/双指针法_自己写的.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        int i=0;
+        int j=nums.size()-1;
+        vector<int> res;
+        while(i<j){
+            if(nums[i]+nums[j]==target){
+                res.push_back(i+1);
+                res.push_back(j+1);
+                return res;
+            }
+            else if(nums[i]+nums[j]<target) i++;
+            else if(nums[i]+nums[j]>target) j--;
+        }
+        return res;
+    }
+};

167_两数之和 II - 输入有序数组_easy/暴力法_超时.cpp

@@ -0,0 +1,33 @@
+/*给定一个已按照升序排列 的有序数组，找到两个数使得它们相加之和等于目标数。
+
+函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。
+
+说明:
+
+返回的下标值（index1 和 index2）不是从零开始的。
+你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
+示例:
+
+输入: numbers = [2, 7, 11, 15], target = 9
+输出: [1,2]
+解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/two-sum-ii-input-array-is-sorted
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        vector<int> res;
+        for(int i=0;i<nums.size();i++){
+            for(int j=i+1;j<nums.size();j++){
+                if(nums[i]+nums[j]==target){
+                    res.push_back(i+1);
+                    res.push_back(j+1);
+                    return res;
+                }
+            }
+        }
+        return res;
+    }
+};

207_课程表_normal/直接把210的代码拿过来用.cpp

@@ -0,0 +1,59 @@
+/*你这个学期必须选修 numCourse 门课程，记为 0 到 numCourse-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。这是不可能的。
+ 
+
+提示：
+
+输入的先决条件是由 边缘列表 表示的图形，而不是 邻接矩阵 。详情请参见图的表示法。
+你可以假定输入的先决条件中没有重复的边。
+1 <= numCourses <= 10^5
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/course-schedule
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+class Solution {
+public:
+    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+        vector<int> res;
+        int in[numCourses];
+        int out[numCourses];
+        memset(in,0,sizeof(in));
+        memset(out,0,sizeof(out));
+        for(int i=0;i<prerequisites.size();i++){
+            in[prerequisites[i][0]]++;
+            out[prerequisites[i][1]]++;
+        }
+        int flag=1;
+        while(flag){
+            flag=0;
+            for(int i=0;i<numCourses;i++){
+                if(in[i]==0){
+                    flag=1;
+                    res.push_back(i);
+                    in[i]--;
+                    for(int j=0;j<prerequisites.size();j++){
+                        if(prerequisites[j][1]==i) in[prerequisites[j][0]]--;
+                    }
+                }
+            }
+        }
+        if(res.size()==numCourses) return 1;
+        else return 0;
+    }
+};

210_课程表 II_normal/有所借鉴.cpp

@@ -0,0 +1,67 @@
+/*现在你总共有 n 门课需要选，记为 0 到 n-1。
+
+在选修某些课程之前需要一些先修课程。 例如，想要学习课程 0 ，你需要先完成课程 1 ，我们用一个匹配来表示他们: [0,1]
+
+给定课程总量以及它们的先决条件，返回你为了学完所有课程所安排的学习顺序。
+
+可能会有多个正确的顺序，你只要返回一种就可以了。如果不可能完成所有课程，返回一个空数组。
+
+示例 1:
+
+输入: 2, [[1,0]] 
+输出: [0,1]
+解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。
+示例 2:
+
+输入: 4, [[1,0],[2,0],[3,1],[3,2]]
+输出: [0,1,2,3] or [0,2,1,3]
+解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
+     因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。
+说明:
+
+输入的先决条件是由边缘列表表示的图形，而不是邻接矩阵。详情请参见图的表示法。
+你可以假定输入的先决条件中没有重复的边。
+提示:
+
+这个问题相当于查找一个循环是否存在于有向图中。如果存在循环，则不存在拓扑排序，因此不可能选取所有课程进行学习。
+通过 DFS 进行拓扑排序 - 一个关于Coursera的精彩视频教程（21分钟），介绍拓扑排序的基本概念。
+拓扑排序也可以通过 BFS 完成。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/course-schedule-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+
+
+//先计算出度和入度
+//push入入度为0值，将其入度置为-1
+//并开始查找其下个节点，将下个节点的入度-1
+class Solution {
+public:
+    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
+        vector<int> res;
+        int in[numCourses];
+        int out[numCourses];
+        memset(in,0,sizeof(in));
+        memset(out,0,sizeof(out));
+        for(int i=0;i<prerequisites.size();i++){
+            in[prerequisites[i][0]]++;
+            out[prerequisites[i][1]]++;
+        }
+        int flag=1;
+        while(flag){
+            flag=0;
+            for(int i=0;i<numCourses;i++){
+                if(in[i]==0){
+                    flag=1;
+                    res.push_back(i);
+                    in[i]--;
+                    for(int j=0;j<prerequisites.size();j++){
+                        if(prerequisites[j][1]==i) in[prerequisites[j][0]]--;
+                    }
+                }
+            }
+        }
+        if(res.size()==numCourses) return res;
+        else return (vector<int>)NULL;
+    }
+};

230_二叉搜索树中第K小的元素_normal/暴力法_自己写的_又是树的遍历.cpp

@@ -0,0 +1,56 @@
+/*给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。
+
+说明：
+你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。
+
+示例 1:
+
+输入: root = [3,1,4,null,2], k = 1
+   3
+  / \
+ 1   4
+  \
+   2
+输出: 1
+示例 2:
+
+输入: root = [5,3,6,2,4,null,null,1], k = 3
+       5
+      / \
+     3   6
+    / \
+   2   4
+  /
+ 1
+输出: 3
+进阶：
+如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+/**
+ * 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:
+    vector<int> tree;
+    void fill_tree(vector<int>& tree,TreeNode* root){
+        if(root){
+            tree.push_back(root->val);
+            fill_tree(tree,root->left);
+            fill_tree(tree,root->right);
+        }
+    }
+    int kthSmallest(TreeNode* root, int k) {
+        fill_tree(tree,root);
+        sort(tree.begin(),tree.end());
+        return tree[k-1];
+    }
+};

278_第一个错误的版本_easy/二分查找_自己写的.cpp

@@ -0,0 +1,34 @@
+/*你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
+
+假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
+
+你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
+
+示例:
+
+给定 n = 5，并且 version = 4 是第一个错误的版本。
+
+调用 isBadVersion(3) -> false
+调用 isBadVersion(5) -> true
+调用 isBadVersion(4) -> true
+
+所以，4 是第一个错误的版本。 
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/first-bad-version
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。*/
+// The API isBadVersion is defined for you.
+// bool isBadVersion(int version);
+
+class Solution {
+public:
+    int firstBadVersion(int n) {
+        long i=1;
+        long j=n;
+        while(i<j){
+            if(isBadVersion((i+j)/2)) j=(i+j)/2;
+            else i=(i+j)/2+1;
+        }
+        return i;
+    }
+};