更新leetcode 321, 322, 324, 326, 327, 328, 329, 330, 331, 332, 334, 337, 338

Author: blacksea3

cpp/leetcode/320. generalized-abbreviation.cpp renamed to cpp/leetcode/321. create-maximum-number.cpp

@@ -1,6 +1,6 @@
 #include "public.h"
 
-//56ms, 87.25%
+//48ms, 91.61%
 //分治
 //一定是从nums1中取i个数, 从nums2中取k-i个数
 

cpp/leetcode/322. coin-change.cpp

@@ -1,42 +1,39 @@
 #include "public.h"
 
-//68ms, 79.30%
+//40ms, 97.13%
 //DP problem
 //每一个当前的金额都可以用coins中的任意一个加上之前的金额数量获得, 然后扣出最小值即可
 
 class Solution {
 public:
 	int coinChange(vector<int>& coins, int amount) {
+		sort(coins.begin(), coins.end());
+		vector<int> dp(amount + 1, 0x7f7f7f7f);
 
-		vector<int> dp(amount + 1, 0);
+		dp[0] = 0;
 
 		for (int i = 1; i <= amount; ++i)
 		{
 			//挨个凑
-			int mintemp = INT_MAX;
-			bool haschance = false;
+			int mintemp = 0x7f7f7f7f;
 			for (int c = 0; c < coins.size(); ++c)
 			{
 				int history = i - coins[c];
-				if ((history >= 0) && (dp[history] != -1))
-				{
-					mintemp = min(mintemp, dp[history] + 1);
-					haschance = true;
-				}
+				if (history < 0) break;
+				else mintemp = min(mintemp, dp[history] + 1);
 			}
-			if (haschance) dp[i] = mintemp;
-			else dp[i] = -1;
+			dp[i] = mintemp;
 		}
-		return dp[amount];
+		return dp[amount] < 0x7f7f7f7f ? dp[amount] : -1;
 	}
 };
 
 /*
 int main()
 {
 	Solution* s = new Solution();
-	vector<int> coins = { 2 };
-	cout << s->coinChange(coins, 3);
+	vector<int> coins = { 1,2,5 };
+	cout << s->coinChange(coins, 11);
 	return 0;
 }
 */

cpp/leetcode/324. wiggle-sort-ii.cpp

@@ -1,7 +1,8 @@
 #include "public.h"
 
-//108ms, 77.78%
-//我看了评论, 还不如先排序然后插入数据
+//88ms, 91.70%
+//O(nlogn), 理论时间复杂度可以O(n), 待优化
+//先排序然后插入数据
 
 class Solution {
 public:

cpp/leetcode/326. power-of-three.cpp

@@ -1,15 +1,12 @@
 #include "public.h"
 
-//16ms, 95.20%
-//¿´´úÂë°É
+//16ms, 88.65%
+//使用极大的3的幂次来操作
 
 class Solution {
 public:
 	bool isPowerOfThree(int n) {
-		if (n <= 0) return false;
-
-		int thefuck3 = (int)pow(3, 19);
-
-		return (thefuck3%n == 0);
+		//int thefuck3=(int)pow(3,19);
+		return (n > 0) && (1162261467 % n == 0);
 	}
 };

cpp/leetcode/327. count-of-range-sum.cpp

@@ -3,6 +3,7 @@
 //TLE
 //典型的线段树
 //目前是无懒惰标记的线段树, 时间复杂度O(nnlogn) 比暴力还大...
+//待更久之后研究, 线段树难度太大
 
 class Solution {
 private:
@@ -80,10 +81,12 @@ class Solution {
 	}
 };
 
+/*
 int main()
 {
 	Solution* s = new Solution();
 	vector<int> nums = {-2,5,-1};
 	cout << s->countRangeSum(nums, -2, 2);
 	return 0;
 }
+*/

cpp/leetcode/328. odd-even-linked-list.cpp

@@ -1,16 +1,8 @@
 #include "listnode.h"
 
-//24ms, 83.79%
-//easy problem, but code may be difficult
+//20ms, 89.16%
+//Ęąźä¸´ÔÓśČO(n)żŐźä¸´ÔÓśČO(1)
 
-/**
- * Definition for singly-linked list.
- * struct ListNode {
- *     int val;
- *     ListNode *next;
- *     ListNode(int x) : val(x), next(NULL) {}
- * };
- */
 class Solution {
 public:
 	ListNode* oddEvenList(ListNode* head) {

cpp/leetcode/329. longest-increasing-path-in-a-matrix.cpp

@@ -1,12 +1,13 @@
 #include "public.h"
 
-//4ms, 98.91%
+//44ms, 94.30%
 //DFS加记忆化
-//搜过的地方存储结果, 如果某个未搜过的地方搜到了搜过的地方, 可以直接相加, 这是因为那个搜过的地方的路径绝不可能与当前走过的路径相交(总路径是递增路径)
+//搜过的地方存储结果, 如果某个未搜过的地方搜到了搜过的地方, 可以直接相加, 
+//  这是因为那个搜过的地方的路径绝不可能与当前走过的路径相交(总路径是递增路径)
 
 class Solution {
 private:
-	int DFS(const vector<vector<int>>& matrix, vector<vector<int>>& memory, int row, int col)
+	int DFS(vector<vector<int>> const& matrix, vector<vector<int>>& memory, int row, int col)
 	{
 		if (memory[row][col] != -1) return memory[row][col];
 
@@ -44,10 +45,12 @@ class Solution {
 	}
 };
 
+/*
 int main()
 {
 	Solution* s = new Solution();
 	vector<vector<int>> matrix = { {3,4,5},{3,2,6},{2,2,1} };
 	cout << s->longestIncreasingPath(matrix);
 	return 0;
 }
+*/

cpp/leetcode/330. patching-array.cpp

@@ -1,6 +1,6 @@
 #include "public.h"
 
-//8ms, 94.59%
+//4ms, 100%
 /*
 参考至作者：Faber99
 链接：https ://leetcode-cn.com/problems/two-sum/solution/an-yao-qiu-bu-qi-shu-zu-tan-lan-by-faber99/

cpp/leetcode/331. verify-preorder-serialization-of-a-binary-tree.cpp

@@ -1,6 +1,6 @@
 #include "BinaryTree.h"
 
-//8ms, 87.56%
+//4ms, 97.21%
 //在未结束之前, 读取到的节点数量应大于叶子节点数量
 //结束时叶子数量应等于节点数量
 

cpp/leetcode/332. Reconstruct Itinerary.cpp

@@ -1,15 +1,8 @@
 #include "public.h"
 
-//28ms, 100%
-
-//Graph algorithm, carry out a route that can traverse all the tickets, and is the minimun (string sort)
-
-//problem say that there must be a solution!
-//because we need to carry out the minimun (string sort), so we should use multiset<string> to store the next airports
-
-//In DFS: we traverse all the next airports and use ano DFS recursively
-//note that if one DFS not include all the routes, this is not bug, because we "traverse" all the next airports
-//note that in the whole recursive precedure, the graph is modified anywhere!
+//24ms, 96.25%
+//图, DFS, 倒过来生成行程, 然后reverse它
+//对某个机场的下一个目的地, 按照优先队列排序
 
 class Solution {
 private:
@@ -31,11 +24,11 @@ class Solution {
 		unordered_map<string, priority_queue<string, vector<string>, greater<string>>> graph;
 
 		//generate the graph
-		for (auto ticket : tickets)
+		for (auto& ticket : tickets)
 			graph[ticket[0]].push(ticket[1]);
 
 		DFS("JFK", graph);
 		reverse(res.begin(), res.end());
 		return res;
 	}
-};
+};