diff --git a/.gitignore b/.gitignore
index 259148f..2cdb370 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,3 +30,6 @@
 *.exe
 *.out
 *.app
+
+*dSYM
+.vscode
diff --git a/leetcode/1297.cc b/leetcode/1297.cc
new file mode 100644
index 0000000..39424b9
--- /dev/null
+++ b/leetcode/1297.cc
@@ -0,0 +1,58 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年03月03日 13:05:26
+ * @LastEditTime: 2022年03月03日 13:35:38
+ * @FilePath: /Algorithm/leetcode/1297.cc
+ */
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <iostream>
+
+class Solution {
+public:
+ int maxFreq(std::string &s, int maxLetters, int minSize, int maxSize)
+ {
+ int n = s.size();
+ std::unordered_map<std::string, int> mm;
+ int ans = 0;
+ for (int i = 0; i + minSize - 1 < n; ++i) + { + + std::unordered_set<char> ss;
+ int cnt_letters = 0;
+ for (int j = i; j - i + 1 <= minSize; ++j) + { + if (!ss.count(s[j])) + { + cnt_letters++; + } + ss.insert(s[j]); + } + if (cnt_letters <= maxLetters) + { + mm[s.substr(i, minSize)]++; + std::cout << s.substr(i, minSize) << std::endl; + } + } + + int max_cnt = 0; + for (auto it = mm.begin(); it != mm.end(); ++it) + { + if (it->second> max_cnt)
+ {
+ max_cnt = it->second;
+ }
+ }
+ return max_cnt;
+ }
+};
+
+int main()
+{
+ std::string s = "abcde";
+ Solution ss;
+ ss.maxFreq(s, 2, 3, 3);
+
+}
\ No newline at end of file
diff --git a/leetcode/476.cc b/leetcode/476.cc
new file mode 100644
index 0000000..6a971da
--- /dev/null
+++ b/leetcode/476.cc
@@ -0,0 +1,55 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年03月03日 11:59:36
+ * @LastEditTime: 2022年03月03日 12:51:48
+ * @FilePath: /Algorithm/leetcode/476.cc
+ */
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <iostream>
+#include <algorithm>
+
+
+class Solution {
+public:
+ int findSubstringInWraproundString(std::string p)
+ {
+ int n = p.size();
+ if (n == 0)
+ {
+ return 0;
+ }
+
+ std::unordered_map<char, int> mm;
+ mm[p[0]] = 1;
+ int pre = 1;
+ for (int i = 1; i < p.size(); ++i) + { + if (p[i] - p[i-1] == 1 &#124;&#124; p[i] - p[i-1] == -25) + { + pre++; + } + else + { + pre = 1; + } + mm[p[i]] = std::max(mm[p[i]], pre); + } + int ans = 0; + for (auto it = mm.begin(); it != mm.end(); it++) + { + ans += it->second;
+ }
+ return ans;
+ }
+};
+
+
+int main(int argc, char* argv[])
+{
+ Solution sol;
+ std::string p = "aabb";
+ auto ret = sol.findSubstringInWraproundString(p);
+ std::cout << ret; +} \ No newline at end of file diff --git a/leetcode/64.cc b/leetcode/64.cc new file mode 100644 index 0000000..1b1112e --- /dev/null +++ b/leetcode/64.cc @@ -0,0 +1,53 @@ +/** + * @file 64.cc + * @author vihowe(vihowe@outlook.com) + * 给定一个包含非负整数的 m x n 网格 grid ,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。 + * 说明:每次只能向下或者向右移动一步。 + * @version 0.1 + * @date 2021-12-02 + * + * @copyright Copyright (c) 2021 + * + */ + +#include <iostream>
+#include <vector>
+#include <algorithm>
+
+class Solution
+{
+public:
+ int minPathSum(std::vector<std::vector<int>>& grid)
+ {
+ int m = grid.size();
+ int n = grid[0].size();
+ int sum[200] = {0};
+
+ for(int i = m-1; i>= 0; --i)
+ {
+ for(int j = n-1; j>= 0; --j)
+ {
+ int r = j < n-1 ? sum[j+1] : sum[j]; + int d = i < m-1 ? sum[j] : sum[j+1]; + sum[j] = grid[i][j] + std::min(r, d); + } + } + return sum[0]; + } +}; + +int main(int argc, char* argv[]) +{ + std::vector<std::vector<int>> grid;
+ std::vector<int> a{1, 3, 1};
+ std::vector<int> b{1, 5, 1};
+ std::vector<int> c{4, 2, 1};
+ grid.push_back(a);
+ grid.push_back(b);
+ grid.push_back(c);
+
+ Solution solution;
+ int res = solution.minPathSum(grid);
+ std::cout << res; + +} \ No newline at end of file diff --git a/leetcode/795.cc b/leetcode/795.cc new file mode 100644 index 0000000..bba3db7 --- /dev/null +++ b/leetcode/795.cc @@ -0,0 +1,36 @@ +/* + * @Author: vihowe + * @Date: 2022-03-03 13:54:53 + * @LastEditTime: 2022-03-03 14:06:14 + * @FilePath: /Algorithm/leetcode/795.cc + */ + +#include <vector>
+
+class Solution {
+public:
+
+ int atMost(std::vector<int> &nums, int k)
+ {
+ int n = nums.size();
+ int ans = 0, pre = 0;
+ for (int i = 0; i < n; ++i) + { + if (nums[i] <= k) + { + pre++; + } + else + { + pre = 0; + } + ans += pre; + } + return ans; + } + int numSubarrayBoundedMax(std::vector<int> &nums, int left, int right)
+ {
+ // sum of prefix
+ return atMost(nums, right) - atMost(nums, left-1);
+ }
+};
diff --git a/leetcode/7_12.py b/leetcode/7_12.py
new file mode 100644
index 0000000..8cb5fc5
--- /dev/null
+++ b/leetcode/7_12.py
@@ -0,0 +1,127 @@
+from typing import List
+
+
+class Solution:
+ def combine(self, n: int, k: int) -> List[List[int]]:
+ ret = []
+ tmp = []
+ def dfs(t: int):
+ if len(tmp) == k:
+ ret.append(list(tmp))
+ return
+ if t> n:
+ return
+ 
+ for ne in range(t+1, n+1):
+ tmp.append(ne)
+ dfs(ne)
+ tmp.pop(-1)
+ dfs(0)
+ return ret
+ 
+
+ # No216 组合总和3
+ def combinationSum3(self, k: int, n: int) -> List[List[int]]:
+ ret = []
+ tmp = []
+ def dfs(t):
+ if sum(tmp) == n and len(tmp) == k:
+ ret.append(list(tmp))
+ return
+ if sum(tmp)> n or len(tmp)> k:
+ return
+ 
+ for ne in range(t+1, 10):
+ tmp.append(ne)
+ dfs(ne)
+ tmp.pop(-1)
+ 
+ dfs(0)
+ return ret
+ 
+ # No17 电话号码的字母组合
+ def letterCombinations(self, digits: str) -> List[str]:
+ n = len(digits)
+ ret = []
+ if n == 0:
+ return ret
+ tmp = []
+ candidate_set = {
+ '2': ['a', 'b', 'c'],
+ '3': ['d', 'e', 'f'],
+ '4': ['g', 'h', 'i'],
+ '5': ['j', 'k', 'l'],
+ '6': ['m', 'n', 'o'],
+ '7': ['p', 'q', 'r', 's'],
+ '8': ['t', 'u', 'v'],
+ '9': ['w', 'x', 'y', 'z'],
+ }
+ def dfs(cur):
+ if len(tmp) == n:
+ ret.append(''.join(list(tmp)))
+ return
+ 
+ s_ne = digits[cur]
+
+ candidates = candidate_set[s_ne]
+ for candidate in candidates:
+ tmp.append(candidate)
+ dfs(cur+1)
+ tmp.pop(-1)
+
+ dfs(0)
+ return ret
+
+ # No39 组合总和
+ def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
+ candidates.sort()
+ n = len(candidates)
+ ret = []
+ if n == 0:
+ return ret
+ tmp = []
+
+ def search(cur):
+ if sum(tmp) == target:
+ ret.append(list(tmp))
+ return
+ if sum(tmp)> target:
+ return
+
+ for j in range(cur, n):
+ if len(tmp) + candidates[j]> target:
+ break
+ tmp.append(candidates[j])
+ search(j)
+ tmp.pop(-1)
+ search(0)
+ return ret
+
+
+ # No40 组合总和2
+ def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
+ ret = []
+ tmp = []
+ candidates.sort()
+ def search(cur_idx):
+ if sum(tmp) == target:
+ ret.append(list(tmp))
+ if cur_idx == len(candidates):
+ return
+ 
+ for j in range(cur_idx, len(candidates)):
+ if sum(tmp) + candidates[j]> target:
+ break
+ tmp.append(candidates[j])
+ search(j+1)
+ tmp.pop(-1)
+ search(0)
+ return ret
+ 
+ # No131 分割回文串
+ def partition(self, s: str) -> List[List[str]]:
+
+
+
+solution = Solution()
+print(solution.letterCombinations("7"))
diff --git a/leetcode/7_13.py b/leetcode/7_13.py
new file mode 100644
index 0000000..98ef442
--- /dev/null
+++ b/leetcode/7_13.py
@@ -0,0 +1,175 @@
+from typing import List
+from typing import Optional
+
+class TreeNode:
+ def __init__(self, val=0, left=None, right=None):
+ self.val = val
+ self.left = left
+ self.right = right
+
+
+class Solution:
+ def is_num(self, s: str):
+ try:
+ float(s)
+ return True
+ except ValueError:
+ pass
+ try:
+ import unicodedata
+ unicodedata.numeric(s)
+ return True
+ except Exception:
+ pass
+ return False
+ def evalRPN(self, tokens: List[str]) -> int:
+ st = []
+ for c in tokens:
+ if self.is_num(c):
+ st.append(int(c))
+ else:
+ num2 = st.pop(-1)
+ num1 = st.pop(-1)
+ if c == '+':
+ st.append(num1+ num2)
+ if c == '-':
+ st.append(num1 - num2)
+ if c == '*':
+ st.append(num1 * num2)
+ if c == '/':
+ st.append(int(num1 / num2))
+ return st[0]
+
+ def generateParenthesis(self, n: int) -> List[str]:
+ ret = []
+ tmp = []
+ def dfs(left, right):
+ if len(tmp) == 2 * n:
+ ret.append(''.join(tmp))
+ return
+ if left < n: + tmp.append('(') + dfs(left+1, right) + tmp.pop(-1) + if left> right:
+ tmp.append(')')
+ dfs(left, right+1)
+ tmp.pop(-1)
+ dfs(0, 0)
+ return ret
+ 
+ def generateParenthesis2(self, n: int) -> List[str]:
+ dp = [[] for _ in range(n+1)]
+ dp[0].append('')
+
+ for i in range(1, n+1):
+ for p in range(i):
+ L = dp[p]
+ R = dp[i-1-p]
+ for l in L:
+ for r in R:
+ dp[i].append(f'({l}){r}')
+ return dp[n]
+ 
+ def generateParenthesis3(self, n: int) -> List[str]:
+ mem = [None for _ in range(n+1)]
+ mem[0] = [""]
+
+ def recur(m):
+ if mem[m] != None:
+ return mem[m]
+ 
+ tmp = []
+ for c in range(m):
+ for l in recur(c):
+ for r in recur(n-1-c):
+ tmp.append(f'({l}){r}')
+ mem[m] = tmp
+ return tmp
+ recur(n)
+ return mem[n]
+
+ # No15 三数之和
+ def threeSum(self, nums: List[int]) -> List[List[int]]:
+ ret = []
+ nums.sort()
+ for k in range(len(nums)-2):
+ if k != 0 and nums[k] == nums[k-1]:
+ continue
+ i = k + 1
+ j = len(nums) - 1
+ while i < j: + if nums[i] + nums[j] + nums[k] < 0: + i += 1 + while i < j and nums[i] == nums[i-1]: + i += 1 + elif nums[i] + nums[j] + nums[k]> 0:
+ j -= 1
+ while i < j and nums[j] == nums[j+1]: + j -= 1 + else: + ret.append([nums[i], nums[j], nums[k]]) + i, j = i + 1, j - 1 + while i < j and nums[i] == nums[i-1]: + i += 1 + while i < j and nums[j] == nums[j+1]: + j += 1 + return ret + + + # No98 验证二叉搜索树 + def isValidBST(self, root: Optional[TreeNode]) -> bool:
+ if not root or (not root.left and not root.right):
+ return True
+ 
+ l, r = self.isValidBST(root.left), self.isValidBST(root.right)
+ if not l or not r:
+ return False
+ 
+ 
+ def findm(r, mode):
+ if mode == 0: # find most left one
+ while r.left:
+ r = r.left
+ else:
+ while r.right:
+ r = r.right
+ return r.val
+ 
+ l_m = findm(root.left, 1)
+ r_m = findm(root.right, 0)
+ return l_m <= root.val and root.val <= r_m + + + # No322. 零钱兑换 + def coinChange(self, coins: List[int], amount: int) -> int:
+ ret = float('inf')
+ tmp = []
+ coins.sort()
+ def search():
+ nonlocal ret
+ if sum(tmp) == amount:
+ ret = min(ret, len(tmp))
+ 
+ if sum(tmp)> amount:
+ return
+
+ for i in range(len(coins)):
+ tmp.append(coins[i])
+ search()
+ tmp.pop(-1)
+ 
+ search()
+ return ret if ret != float('inf') else -1
+ 
+
+ 
+
+
+
+so = Solution()
+# so.evalRPN(
+# ["10","6","9","3","+","-11","*","/","*","17","+","5","+"])
+# so.generateParenthesis3(2)
+so.threeSum(
+[-2,0,0,2,2])
\ No newline at end of file
diff --git a/leetcode/7_14.py b/leetcode/7_14.py
new file mode 100644
index 0000000..b3cca04
--- /dev/null
+++ b/leetcode/7_14.py
@@ -0,0 +1,140 @@
+import collections
+from typing import List, Optional
+
+class TreeNode:
+ def __init__(self, val=0, left=None, right=None):
+ self.val = val
+ self.left = left
+ self.right = right
+
+
+class Solution:
+ # No238. 除自身以外数组的乘积
+ def productExceptSelf(self, nums: List[int]) -> List[int]:
+ n = len(nums)
+ ans = [1 for _ in range(len(nums))]
+ tmp = nums[0]
+ for i in range(1, n):
+ ans[i] *= tmp
+ tmp *= nums[i]
+
+ tmp = nums[-1]
+ for j in range(n-2, -1, -1):
+ ans[j] *= tmp
+ tmp *= nums[j]
+ 
+ return ans
+
+ 
+ # 用栈实现中序遍历
+ def inOrderTraverse(self, root: Optional[TreeNode]):
+ if root is None:
+ return []
+ 
+ ans = []
+ st = [root]
+ while st or root:
+ if root.left:
+ st.append(root.left)
+ root = root.left
+ node = st.pop()
+ ans.append(node.val)
+ if node.right:
+ root = node.right
+ return ans
+
+ 
+ # No210 课程表2
+ def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
+ # numCourses = 2, prerequisites = [[1,0]]
+ indegree = [0 for _ in range(numCourses)]
+ adj = [set() for _ in range(numCourses)]
+ for prerequisite in prerequisites:
+ course, pre = prerequisite
+ indegree[course] += 1
+ adj[pre].add(course)
+
+ queue = collections.deque([c for c in range(numCourses) if indegree[c]==0])
+
+ ans = []
+ while queue:
+ c = queue.pop()
+ ans.append(c)
+ for cc in adj[c]:
+ indegree[cc] -= 1
+ if indegree[cc] == 0:
+ queue.append(cc)
+ 
+ return ans
+
+ # No47. 全排列 II
+ def permuteUnique(self, nums: List[int]) -> List[List[int]]:
+ ans = []
+ tmp = []
+ n = len(nums)
+ if n == 0:
+ return ans
+ 
+ nums.sort()
+ visited = [0 for _ in range(n)]
+ def dfs(idx):
+ if idx == n:
+ ans.append(tmp[:])
+ 
+ for i in range(n):
+ if visited[i] or (i> 0 and nums[i] == nums[i-1] and not visited[i-1]):
+ continue
+ tmp.append(nums[i])
+ visited[i] = 1
+ dfs(idx+1)
+ visited[i] = 0
+ tmp.pop()
+ dfs(0)
+ return ans
+
+
+ def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
+ m, n = len(obstacleGrid), len(obstacleGrid[0])
+ dp = [[0]*n for _ in range(m)]
+ dp[0][0] = 1
+ for j in range(n):
+ dp[0][j] = 1
+ 
+ flag = False
+ for j in range(n):
+ if obstacleGrid[0][j] == 1:
+ flag = True
+ break
+ if flag:
+ for k in range(j, n):
+ dp[0][k] = 0
+ 
+ flag = False
+ for i in range(m):
+ dp[i][0] = 1
+ for i in range(m):
+ if obstacleGrid[i][0] == 1:
+ flag = True
+ break
+ if flag:
+ for k in range(i, m):
+ dp[k][0] = 0
+ 
+ for i in range(1, m):
+ for j in range(1, n):
+ if obstacleGrid[i][j] == 1:
+ dp[i][j] = 0
+ else:
+ dp[i][j] = dp[i-1][j] + dp[i][j-1]
+ return dp[-1][-1]
+
+ def integerBreak(self, n: int) -> int:
+ dp = [1 for _ in range(n)]
+ for i in range(3, n):
+ for j in range(1, i-1):
+ dp[i] = max(j * (i-j), dp[j] * (i-j), dp[i])
+ return dp[n]
+ 
+ 
+so = Solution()
+so.uniquePathsWithObstacles(obstacleGrid=[[0,1],[0,0]])
\ No newline at end of file
diff --git a/leetcode/7_18.py b/leetcode/7_18.py
new file mode 100644
index 0000000..8a8ac7f
--- /dev/null
+++ b/leetcode/7_18.py
@@ -0,0 +1,12 @@
+from typing import List
+class Solution:
+ def lastStoneWeightII(self, stones: List[int]) -> int:
+ target = sum(stones) // 2
+ dp = [0 for _ in range(target+1)]
+
+ for i in range(len(stones)):
+ for j in range(target, 0, -1):
+ if j - stones[i]>= 0:
+ dp[j] = max(dp[j], dp[j-stones[i]]+stones[i])
+ 
+ return sum(stones) - target - dp[target]
diff --git a/leetcode/7_19.py b/leetcode/7_19.py
new file mode 100644
index 0000000..0ad4f31
--- /dev/null
+++ b/leetcode/7_19.py
@@ -0,0 +1,55 @@
+from curses.ascii import SO
+
+
+class ListNode:
+ def __init__(self, val=0, next=None):
+ self.val = val
+ self.next = next
+
+class Solution:
+ def detectCycle(self, head: ListNode) -> ListNode:
+ slow, fast = head, head
+ while fast and fast.next:
+ slow = slow.next
+ fast = fast.next.next
+
+ if slow == fast:
+ p, q = head, slow
+ while p != q:
+ p = p.next
+ q = q.next
+ return p
+ return None
+ def swapPairs(self, head: ListNode) -> ListNode:
+ dummy_h = ListNode(next=head)
+ pre = dummy_h
+ while pre.next and pre.next.next:
+ cur = pre.next
+ post = pre.next.next
+ cur.next = post.next
+ post.next = cur
+ pre.next = post
+ pre = cur
+ return dummy_h.next
+
+ def reverseList(self, head: ListNode) -> ListNode:
+ if not head or not head.next:
+ return head
+ ret = self.reverseList(head.next)
+ head.next.next = head
+ head.next = None
+ return ret
+ def reverseList(self, head: ListNode) -> ListNode:
+ if not head or not head.next:
+ return head
+ pre, cur = None, head
+ while cur:
+ nt = cur.next
+ cur.next = pre
+ pre = cur
+ cur = nt
+ return pre
+
+
+so = Solution()
+so.swapPairs(ListNode(1,ListNode(2,ListNode(3,ListNode(4)))))
\ No newline at end of file
diff --git a/leetcode/904.cc b/leetcode/904.cc
new file mode 100644
index 0000000..a62b1e4
--- /dev/null
+++ b/leetcode/904.cc
@@ -0,0 +1,94 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年03月04日 11:01:46
+ * @LastEditTime: 2022年03月07日 19:35:59
+ * @FilePath: /Algorithm/leetcode/904.cc
+ */
+#include <vector>
+#include <algorithm>
+#include <unordered_map>
+#include <iostream>
+
+class Solution {
+public:
+ int totalFruit(std::vector<int>& fruits)
+ {
+ int n = fruits.size();
+ int first = -1, second = -1, second_idx = -1;
+ int l = 0, ans = 0, ansl = 0;
+ while (l < n) + { + int tmp = 0, i = l; + first = fruits[l]; + for (; i < n; ++i) + { + + if (second == -1 && fruits[i] != first) + { + second = fruits[i]; + second_idx = i; + tmp++; + } + else if (fruits[i] == first &#124;&#124; fruits[i] == second) + { + tmp++; + } + else { + l = second_idx; + first = -1; + second = -1; + if (tmp> ans) ansl = l;
+ ans = std::max(tmp, ans);
+ break;
+ }
+ }
+ if (i == n)
+ {
+ if (tmp> ans ) ansl = l;
+ ans = std::max(tmp, ans);
+ break;
+ }
+ }
+ return ansl;
+ }
+
+ int totalFruit2(std::vector<int>& fruits)
+ {
+ int k = 2, n = fruits.size();
+ std::unordered_map<int, int> mm;
+ int ans = 0, l = 0, ansl = 0, ansr = 0;
+ for (int j = 0; j < n; ++j) + { + if (mm[fruits[j]] == 0) + { + k--; + } + mm[fruits[j]]++; + while (k < 0) // contract the sliding window + { + mm[fruits[l]]--; + if (mm[fruits[l]] == 0) + { + k++; + } + l++; + } + int tmp = j - l + 1; + if (tmp> ans)
+ {
+ ansl = l;
+ }
+ ans = std::max(ans, j - l + 1);
+ }
+ return ansl;
+ }
+};
+
+int main()
+{
+ std::vector<int> nums {1,0,1,0,1,0,0,1,0,0,1,1,1,0,0,1,0,0,439,0,439,0,439,0,439,439,0,0,0,0,366,366,692,692,366,366,692,692,366,692,692,366,366,692,366,692,692,692,366,692,313,692,313,692,692,313,692,313,692,692,313,692,313,313,313,145,313,145,145,420,145,420,145,145,145,145,420,145,145,420,145,145,424,145,145,424,145,464,464,464,145,145,464,145,464,145,145,464,145,960,145,145,960,960,141,141,141,960,960,903,960,395,395,960,395,395,960,960,395,960,395,395,960,960,960,395,395,395,395,395,395,395,960,395,971,971,395,971,386,386,971,386,386,665,386,665,665,386,386,665,665,665,386,386,665,665,665,386,386,665,386,665,386,609,609,386,386,609,386,609,386,386,386,386,386,386,386,609,386,386,386,609,386,386,609,386,386,386,386,386,386,609,609,386,386,609,386,44,386,44,386,44,307,923,923,307,307,982,307,307,461,307,461,461,461,461,461,307,307,461,484,484,484,484,484,484,461,461,461,461,461,505,461,505,505,461,461,505,461,505,461,505,505,505,505,505,505,461,461,505,275,275,275,275,899,275,275,899,968,968,968,899,420,420,404,420,404,420,404,236,404,404,236,404,236,404,236,236,236,404,236,236,236,236,236,236,215,215,236,215,215,236,215,215,236,236,215,215,215,215,236,236,236,236,236,236,215,215,215,215,215,236,215,236,215,236,215,236,215,236,236,492,236,730,730,236,730,236,338,849,338,849,849,338,849,338,849,338,338,338,849,338,338,849,849,338,338,849,849,849,849,338,849,849,849,849,338,338,338,338,759,427,759,759,427,759,759,759,759,759,759,427,759,759,759,664,48,664,664,48,664,48,490,490,490,490,490,48,48,490,490,48,490,48,48,490,490,48,48,490,48,863,72,72,863,863,863,863,72,863,736,863,55,55,863,55,55,55,55,863,863,863,863,863,863,55,863,55,55,55,55,55,863,55,55,346,55,55,55,55,55,55,55,346,346,346,346,55,55,55,55,346,55,55,346,346,346,346,346,55,173,55,55,55,55,173,55,173,173,55,173,95,173,95,173,173,95,95,95,173,173,35,35,173,173,173,173,101,101,101,101,173,101,998,998,101,998,101,998,998,101,101,998,101,101,998,838,838,998,892,287,287,892,892,287,892,892,287,84,287,84,287,719,719,287,719,202,202,719,719,719,202,719,202,719,202,719,202,202,202,202,719,202,719,719,202,719,719,719,719,202,719,202,947,852,947,852,852,852,947,133,947,133,133,682,133,682,682,682,133,133,133,682,682,133,682,682,682,133,133,682,682,133,133,682,682,133,682,682,306,682,682,306,682,992,682,710,710,710,682,682,682,682,710,682,682,682,710,682,682,682,710,710,710,682,682,682,682,682,710,682,710,710,710,682,710,710,682,682,710,710,710,682,710,682,335,682,167,167,167,682,851,851,851,851,682,851,851,682,851,851,851,693,693,693,693,693,851,851,693,693,693,851,693,851,851,693,851,851,922,851,851,851,922,851,922,922,851,922,851,851,922,851,922,922,922,922,922,851,851,539,539,851,539,539,539,539,539,851,539,539,539,851,851,539,539,851,539,851,539,851,539,539,539,851,508,851,851,508,508,851,851,979,979,851,851,851,979,979,979,851,979,851,979,979,979,851,588,588,588,588,851,588,851,588,588,588,588,588,851,588,588,588,851,930,930,930,851,930,930,851,851,851,851,851,930,930,851,930,930,930,930,851,851,851,851,851,851,851,851,718,718,851,769,851,769,851,851,851,851,851,851,769,769,769,851,447,447,447,447,851,851,909,851,851,880,851,851,880,851,851,851,880,880,880,851,880,931,931,931,880,880,931,931,684,684,931,684,931,931,931,242,931,242,242,242,931,242,931,931,931,931,242,931,931,728,931,728,931,848,931,848,188,188,188,188,848,188,188,188,188,848,188,188,848,848,848,848,848,188,848,848,759,848,759,759,848,759,848,931,848,848,931,930,931,930,930,930,930,930,750,750,930,930,930,750,750,930,930,930,750,750,750,930,750,930,930,750,750,750,930,930,750,750,750,930,750,930,930,930,329,930,930,329,784,784,329,329,784,784,329,784,784,329,329,784,329,329,329,784,329,784,329,784,784,784,329,329,784,784,329,784,329,329,784,784,329,575,575,575,575,329,575,329,329,329,575,329,329,260,329,329,329,329,46,329,189,189,618,618,618,618,618,189,189,438,262,363,363,262,262,262,363,262,363,262,262,262,262,363};
+ Solution ss;
+ // auto a = ss.totalFruit(nums);
+ auto b = ss.totalFruit2(nums);
+ // std::cout << a << " " << b; +} \ No newline at end of file diff --git a/leetcode/analyse.py b/leetcode/analyse.py new file mode 100644 index 0000000..6343fe6 --- /dev/null +++ b/leetcode/analyse.py @@ -0,0 +1 @@ +# %% diff --git a/leetcode/array.cc b/leetcode/array.cc new file mode 100644 index 0000000..058e849 --- /dev/null +++ b/leetcode/array.cc @@ -0,0 +1,234 @@ +/* + * @Author: vihowe + * @Date: 2022-02-17 15:43:23 + * @LastEditTime: 2022-03-01 14:58:47 + * @FilePath: /Algorithm/leetcode/array.cc + */ +#include <vector>
+#include <random>
+#include <algorithm>
+#include <iostream>
+#include <unordered_map>
+
+class Solution0 {
+public:
+ void moveZeroes(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ int k= n;
+ for (int i = 0; i < k;) + { + if (nums[i] == 0) + { + // move nums[i+1,...] forward + for (int j = i + 1; j < n; ++j) + { + nums[j-1] = nums[j]; + } + nums[n-1] = 0; + k--; + } + else + { + ++i; + } + } + } + + void moveZeroes2(std::vector<int> &nums)
+ {
+ // partition的思想
+ int n = nums.size();
+ int ptr = 0;
+ for (int i = 0; i < n; ++i) + { + if (nums[i]) + { + std::swap(nums[ptr++], nums[i]); + } + } + } + + void moveZeroes3(std::vector<int> &nums)
+ {
+ // 覆盖 + 补0
+ int n = nums.size();
+ int i = 0, j = 0;
+ for (; i < n; ++i) + { + if (nums[i]) + { + nums[j++] = nums[i]; + } + } + for (; j < n; ++j) + { + nums[j] = 0; + } + } + + int minSubArrayLen(int target, std::vector<int> &nums)
+ {
+ int n = nums.size();
+ int ans = n + 1;
+ int l = 0, r = 0;
+ int sum = 0;
+ while (r < n) + { + sum += nums[r]; + while (sum>= target)
+ {
+ ans = std::min(ans, r - l + 1);
+ sum -= nums[l];
+ l++;
+ }
+ }
+ return ans == n + 1 ? 0 : ans;
+ }
+
+
+ bool haveRepeat(std::unordered_map<char, int> &mm)
+ {
+ auto map_it = mm.begin();
+ while (map_it != mm.end())
+ {
+ if (map_it->second> 1)
+ {
+ return true;
+ }
+ map_it++;
+ }
+ return false;
+ }
+
+ int lengthOfLongestSubstring(std::string s)
+ {
+ std::unordered_map<char, int> mm;
+ int n = s.size();
+ int ans = 0;
+ int l = 0, r = 0;
+ while (r < n) + { + mm[s[r]] += 1; + while (mm[s[r]]> 1)
+ {
+ mm[s[l++]] -= 1;
+ }
+ ans = std::max(ans, r - l + 1);
+ r++;
+ }
+ return ans;
+ }
+
+ bool isDone(const std::unordered_map<char, int> &mm)
+ {
+ auto map_it = mm.begin();
+ while (map_it != mm.end())
+ {
+ if (map_it->second> 0)
+ {
+ return false;
+ }
+ map_it++;
+ }
+ return true;
+ }
+
+ std::string minWindow(std::string s, std::string t)
+ {
+ // 返回s中覆盖t全部字符的最小字串
+ int n_s = s.size();
+ int n_t = t.size();
+ if (n_s < n_t) + { + return ""; + } + std::unordered_map<char, int> mm;
+ for (auto c : t)
+ {
+ mm[c]++;
+ }
+ int l = 0, r = 0, ans_l = 0, ans_r = 0, ans_min = n_s + 1;
+ while (r < n_s) + { + mm[s[r]]--; + while (isDone(mm)) + { + if (r - l + 1 < ans_min) + { + ans_min = r - l + 1; + ans_l = l; + ans_r = r; + } + mm[s[l++]]++; + } + r++; + } + return ans_min == n_s + 1 ? "" : s.substr(ans_l, ans_r - ans_l + 1); + } + + + void nextPermutation(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ int i, j , k;
+ i = j = k = n - 1;
+ while (j> 0)
+ {
+ i = j - 1;
+ if (nums[j]> nums[i])
+ {
+ break;
+ }
+ j--;
+ }
+ while (k>= j)
+ {
+ if (nums[k]> nums[i])
+ {
+ std::swap(nums[k], nums[i]);
+ break;
+ }
+ k--;
+ }
+ std::reverse(nums.begin()+j, nums.end());
+ }
+};
+
+class Solution {
+public:
+ Solution(std::vector<int> &nums)
+ {
+ this->nums = nums;
+ }
+
+ std::vector<int> reset()
+ {
+ return nums;
+ }
+
+ std::vector<int> shuffle()
+ {
+ std::vector<int> rand_m(nums.begin(), nums.end());
+ std::random_device rd;
+ std::mt19937 g(rd());
+ std::shuffle(rand_m.begin(), rand_m.end(), g);
+ return rand_m;
+ }
+
+private:
+ std::vector<int> nums;
+};
+
+int main()
+{
+ std::vector<int> nums {3, 2, 1};
+ std::string s = "ADOBECODEBANC";
+ std::string t = "ABC";
+ Solution0 ss;
+ // ss.lengthOfLongestSubstring(s);
+ auto ans = ss.minWindow(s, t);
+ std::cout << ans; + + +} \ No newline at end of file diff --git a/leetcode/binaryTree.cc b/leetcode/binaryTree.cc new file mode 100644 index 0000000..9be5378 --- /dev/null +++ b/leetcode/binaryTree.cc @@ -0,0 +1,208 @@ +/* + * @Author: vihowe + * @Date: 2022-02-15 09:10:12 + * @LastEditTime: 2022-02-15 16:39:27 + * @FilePath: /leetcode/binaryTree.cc + */ +#include <vector>
+#include <stack>
+#include <queue>
+
+struct TreeNode {
+ int val;
+ TreeNode *left;
+ TreeNode *right;
+ TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+
+class Soulution {
+public:
+ std::vector<int> preorderTraversal(TreeNode *root) {
+ std::vector<int> res;
+ preorder(root, res);
+ return res;
+ }
+
+ void preorder(TreeNode *root, std::vector<int> &res) {
+ if (root == nullptr) {
+ return;
+ }
+ res.push_back(root->val);
+ preorder(root->left, res);
+ preorder(root->right, res);
+ }
+
+ void inorder(TreeNode *root, std::vector<int> &res) {
+ if (root == nullptr) {
+ return;
+ }
+ inorder(root->left, res);
+ res.push_back(root->val);
+ inorder(root->right, res);
+ }
+
+ void postorder(TreeNode *root, std::vector<int> &res) {
+ if (root == nullptr) {
+ return;
+ }
+ postorder(root->left, res);
+ postorder(root->right, res);
+ res.push_back(root->val);
+ }
+
+ // 迭代版遍历
+ std::vector<int> preOrder(TreeNode *root) {
+ if (!root) {
+ return {};
+ }
+ std::vector<int> res;
+ std::stack<div class="naked_tr"> s;
+ s.push(root);
+ while (!s.empty()) {
+ TreeNode *cur = s.top();
+ s.pop();
+ res.push_back(cur->val);
+
+ if (cur->right) {
+ s.push(cur->right);
+ }
+ if (cur->left) {
+ s.push(cur->left);
+ }
+ }
+ return res;
+ }
+
+ std::vector<int> inOrder(TreeNode *root) {
+ if (!root) {
+ return {};
+ }
+
+ std::vector<int> res;
+ std::stack<div class="naked_tr"> s;
+ TreeNode* cur = root;
+ while (cur &#124;&#124; !s.empty()) {
+ while (cur) {
+ s.push(cur);
+ cur = cur->left;
+ }
+ cur = s.top();
+ s.pop();
+ res.push_back(cur->val);
+ cur = cur->right;
+ }
+ }
+
+ std::vector<std::vector<int>> levelOrder(TreeNode* root) {
+ if (!root) {
+ return {};
+ }
+ std::vector<std::vector<int>> res;
+ std::vector<int> temp;
+ std::queue<div class="naked_tr"> q;
+ q.push(root);
+ while (!q.empty()) {
+ int qLen = q.size();
+ for (int i = 0; i < qLen; ++i) { + TreeNode *cur = q.front(); + q.pop(); + temp.push_back(cur->val);
+ res.push_back(temp);
+ if (cur->left) {
+ q.push(cur->left);
+ }
+ if (cur->right) {
+ q.push(cur->right);
+ }
+ }
+ temp.clear();
+ }
+ return res;
+ }
+
+ std::vector<int> levelorder(TreeNode *root) {
+ if (!root) {
+ return {};
+ }
+ std::vector<int> res;
+ std::queue<div class="naked_tr"> q;
+ q.push(root);
+ while (!q.empty()) {
+ TreeNode *cur = q.front();
+ q.pop();
+ res.push_back(cur->val);
+ if (cur->left) {
+ q.push(cur->left);
+ }
+ if (cur->right) {
+ q.push(cur->right);
+ }
+ }
+ }
+
+ bool isSymmetric(TreeNode* root) {
+ if (!root) {
+ return true;
+ }
+ return isMirror(root->left, root->right);
+ }
+ bool isMirror(TreeNode *t1, TreeNode *t2) {
+ if (!t1 && !t2) {
+ return true;
+ }
+ if (!t1 &#124;&#124; !t2) {
+ return false;
+ }
+ return (t1->val == t2->val && isMirror(t1->left, t2->right) && isMirror(t1->right, t2->left));
+ }
+
+
+ bool hasPathSum(TreeNode* root, int targetSum) {
+ if (!root) {
+ return false;
+ }
+ if (!root->left && !root->right) {
+ return root->val == targetSum;
+ }
+ return hasPathSum(root->left, targetSum - root->val) &#124;&#124; hasPathSum(root->right, targetSum - root->val);
+
+ }
+
+ bool hasPathSum2(TreeNode *root, int targetSum) {
+ if (!root) {
+ return false;
+ }
+ 
+ std::queue<div class="naked_tr"> nodeQ;
+ std::queue<int> valQ;
+
+ nodeQ.push(root);
+ valQ.push(root->val);
+
+ while (!nodeQ.empty()) {
+ TreeNode *cur = nodeQ.front();
+ int temp = valQ.front();
+ nodeQ.pop();
+ valQ.pop();
+ if (!cur->left && !cur->right) {
+ if (temp == targetSum) {
+ return true;
+ }
+ continue;
+ }
+ if (cur->left) {
+ nodeQ.push(cur->left);
+ valQ.push(temp + cur->left->val);
+ }
+
+ if (cur->right) {
+ nodeQ.push(cur->right);
+ valQ.push(temp + cur->right->val);
+ }
+ }
+ return false;
+ }
+
+};
\ No newline at end of file
diff --git a/leetcode/containDuplicatie.cc b/leetcode/containDuplicatie.cc
new file mode 100644
index 0000000..cfb21d2
--- /dev/null
+++ b/leetcode/containDuplicatie.cc
@@ -0,0 +1,73 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月17日 13:43:16
+ * @LastEditTime: 2022年02月17日 15:05:34
+ * @FilePath: /Algorithm/leetcode/containDuplicatie.cc
+ */
+#include <vector>
+#include <unordered_map>
+#include <unordered_set>
+
+class Solution {
+public:
+ bool containsDuplicate(std::vector<int> &nums)
+ {
+ std::unordered_set<int> s(nums.begin(), nums.end());
+ return s.size() < nums.size(); + } + + /** + * 给定一个包含 n + 1 个整数的数组 nums ,其数字都在 [1, n] 范围内(包括 1 和 n),可知至少存在一个重复的整数。 + * 假设 nums 只有 一个重复的整数 ,返回 这个重复的数 。 + * 你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。 + */ + int findDuplicate(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ int left = 0, right = n - 1;
+ while (left < right) + { + int mid = left + (right - left)>> 1;
+ int cnt = 0;
+ for (auto item : nums)
+ {
+ if (item <= mid) + cnt++; + } + if (cnt <= mid) + { + left = mid + 1; + } + else + { + right = mid; + } + } + } + + int findDuplicate2(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ int bitMax = 31;
+ int ans = 0;
+ while (!(n-1)>> bitMax) bitMax--;
+
+ for (int bit = 0; bit <= bitMax; bit++) + { + int x = 0, y = 0; + for (int i = 0; i < n; ++i) + { + if (nums[i] & (1 << bit)) + x++; + } + for (int i = 1; i < n; ++i) + { + if (i & (1 << bit)) + y++; + } + if (x> y)
+ ans &#124;= (1 << bit); + } + return ans; + } +}; \ No newline at end of file diff --git a/leetcode/copyRandomList.cc b/leetcode/copyRandomList.cc new file mode 100644 index 0000000..12c1fd1 --- /dev/null +++ b/leetcode/copyRandomList.cc @@ -0,0 +1,98 @@ +/* + * @Author: vihowe + * @Date: 2022-02-22 11:04:33 + * @LastEditTime: 2022-02-22 12:06:29 + * @FilePath: /Algorithm/leetcode/copyRandomList.cc + */ +#include <ul class="image_map">
+#include <set>
+class Node
+{
+public:
+ int val;
+ Node *next;
+ Node *random;
+ Node (int _val) : val(_val), next(nullptr), random(nullptr) { };
+};
+
+class Solution
+{
+
+public:
+ Node* copyRandomList(Node *head)
+ {
+ if (!head)
+ return nullptr;
+
+ std::map<node*, Node*> m;
+
+ Node *cur = head;
+ while(cur)
+ {
+ Node *newCur = new Node(cur->val);
+ m[cur] = newCur;
+ cur = cur->next;
+ }
+
+ cur = head;
+ while(cur)
+ {
+ m[cur]->next = m[cur->next];
+ m[cur]->random = m[cur->random];
+ cur = cur->next;
+ }
+ return m[head];
+ }
+
+ Node* copyRandomList2(Node *head)
+ {
+ if (!head)
+ {
+ return nullptr;
+ }
+
+ for (Node *cur = head; cur; cur = cur->next->next)
+ {
+ Node *newNode = new Node(cur->val);
+ newNode->next = cur->next;
+ cur->next = newNode;
+ }
+
+ for (Node *cur = head; cur; cur = cur->next->next)
+ {
+ cur->next->random = cur->random ? cur->random->next : nullptr;
+ }
+
+ Node *newHead = head->next;
+ for (Node *cur = head; cur; cur = cur->next)
+ {
+ Node* newCur = cur->next;
+ cur->next = cur->next->next;
+ newCur->next = newCur->next ? newCur->next->next : nullptr;
+ }
+ return newHead;
+ }
+
+ 
+ std::map<node*, Node*> mm;
+ Node* copyRandomList3(Node *head)
+ {
+ if (!head)
+ {
+ return nullptr;
+ }
+ if (mm.count(head))
+ {
+ return mm[head];
+ }
+ else
+ {
+ Node *newNode = new Node(head->val);
+ mm[head] = newNode;
+ newNode->next = copyRandomList3(head->next);
+ newNode->random= copyRandomList3(head->random);
+ }
+ }
+
+ 
+};
\ No newline at end of file
diff --git a/leetcode/dp.cc b/leetcode/dp.cc
new file mode 100644
index 0000000..a1769a2
--- /dev/null
+++ b/leetcode/dp.cc
@@ -0,0 +1,60 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月28日 21:51:45
+ * @LastEditTime: 2022年02月28日 22:06:45
+ * @FilePath: /Algorithm/leetcode/dp.cc
+ */
+#include <string>
+#include <vector>
+
+
+class Solution {
+ bool dp[1010][1010];
+public:
+
+ std::string longestPalindrome(std::string s)
+ {
+ int n = s.size();
+ // 如果不用静态二维数组
+ std::vector<std::vector<int>> dp(n, std::vector<int>(n, 0));
+ if (n == 0)
+ {
+ return "";
+ }
+ int maxLen = 1;
+ std::string ans = s.substr(0, 1);
+
+ for (int i = 0; i < n; ++i) + { + for (int j = 0; j < n; ++j) + { + if (j <= i) + { + dp[i][j] = true; + } + else + { + dp[i][j] = false; + } + } + } + + for (int intv = 1; intv < n; ++intv) + { + for (int i = 0; i < n - intv; ++i) + { + int j = i + intv; + if (s[i] == s[j] && dp[i+1][j-1]) + { + dp[i][j] = true; + if (j - i + 1> maxLen)
+ {
+ maxLen = j - i + 1;
+ ans = s.substr(i, j - i + 1);
+ }
+ }
+ }
+ }
+ return ans;
+ }
+};
\ No newline at end of file
diff --git a/leetcode/eggDropping b/leetcode/eggDropping
new file mode 100755
index 0000000..956dd45
Binary files /dev/null and b/leetcode/eggDropping differ
diff --git a/leetcode/eggDropping.cc b/leetcode/eggDropping.cc
new file mode 100644
index 0000000..abd2266
--- /dev/null
+++ b/leetcode/eggDropping.cc
@@ -0,0 +1,71 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年01月21日 11:09:46
+ * @LastEditTime: 2022年01月26日 17:44:38
+ * @FilePath: /leetcode/eggDropping.cc
+ */
+// 给你 k 枚相同的鸡蛋,并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑。
+
+// 已知存在楼层 f ,满足 0 <= f <= n ,任何从 高于 f 的楼层落下的鸡蛋都会碎, +// 从 f 楼层或比它低的楼层落下的鸡蛋都不会破。 + +// 每次操作,你可以取一枚没有碎的鸡蛋并把它从任一楼层 x 扔下(满足 1 <= x <= n)。 +// 如果鸡蛋碎了,你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎,则可以在之后的操作中 重复使用 这枚鸡蛋。 + +// 请你计算并返回要确定 f 确切的值 的 最小操作次数 是多少? +// DP方程:f(k,n): k个鸡蛋,n层楼,确定f的次数 +// f(1,n) = n: 最坏需要试n次,(f=n) +// f(k,n) = 1 + max(f(k-1, n/2-1), f(k, n-n/2)) +#include <iostream>
+#include <vector>
+
+class Solution {
+public:
+ std::vector<std::vector<int>> ret = std::vector<std::vector<int>>(110, std::vector<int>(10010, -1));
+ int max(int a, int b) {
+ return a> b ? a : b;
+ }
+
+ int min(int a, int b) {
+ return a < b ? a : b; + } + int superEggDrop(int k, int n) { + + if (k == 1) { + return n; + } + if (n == 0) { + return 0; + } + if (ret[k][n] != -1) { + return ret[k][n]; + } + + int res = 1 << 30; + int low = 1, high = n; + while (low <= high) { + int mid = low + (high - low) / 2; + int broken = superEggDrop(k-1, mid - 1); + int notBroken = superEggDrop(k, n - mid); + if (broken> notBroken) {
+ high = mid - 1;
+ res = min(res, broken + 1);
+ }
+ else {
+ low = mid + 1;
+ res = min(res, notBroken + 1);
+ }
+ }
+ // for (int i = 1; i <= n; ++i) { + // res = min(res, 1 + max(superEggDrop(k-1, i - 1), superEggDrop(k, n - i))); + // } + ret[k][n] = res; + return ret[k][n]; + } +}; + + +int main() { + Solution s; + std::cout << s.superEggDrop(2, 9) << std::endl; +} \ No newline at end of file diff --git a/leetcode/isPalindrome b/leetcode/isPalindrome new file mode 100755 index 0000000..7200c15 Binary files /dev/null and b/leetcode/isPalindrome differ diff --git a/leetcode/isPalindrome.cc b/leetcode/isPalindrome.cc new file mode 100644 index 0000000..198d4da --- /dev/null +++ b/leetcode/isPalindrome.cc @@ -0,0 +1,41 @@ +/* + * @Author: vihowe + * @Date: 2022-01-26 18:19:39 + * @LastEditTime: 2022-01-27 11:14:31 + * @FilePath: /leetcode/isPalindrome.cc + */ + +#include <iostream>
+#include <string>
+#include <cctype>
+
+class Solution {
+public:
+ bool isPalindrome(std::string s) {
+ int i = 0, j = s.size() - 1;
+ while (i < j) { + while(i < j && !isalnum(s[i])) { + ++i; + } + while(i < j && !isalnum(s[j])) { + --j; + } + if (i < j) { + s[i] = tolower(s[i]); + s[j] = tolower(s[j]); + if (s[i] != s[j]) { + return false; + } + ++i; + --j; + } + } + return true; + } +}; + +int main() { + std::string s = "A man, a plan, a canal: Panama"; + Solution ss; + std::cout << ss.isPalindrome(s); +} \ No newline at end of file diff --git a/leetcode/kthSmallest.cc b/leetcode/kthSmallest.cc new file mode 100644 index 0000000..a7cc274 --- /dev/null +++ b/leetcode/kthSmallest.cc @@ -0,0 +1,37 @@ +/* + * @Author: vihowe + * @Date: 2022-02-15 08:38:39 + * @LastEditTime: 2022-02-15 08:54:24 + * @FilePath: /leetcode/kthSmallest.cc + */ + +struct TreeNode { + int val; + TreeNode *left; + TreeNode *right; + TreeNode() : val(0), left(nullptr), right(nullptr) {} + TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} + TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(nullptr), right(nullptr) {} +}; + +class Solution { +public: + int getNum(TreeNode* root) { + if (root == nullptr) { + return 0; + } + return getNum(root->left) + getNum(root->right) + 1;
+ }
+ int kthSmallest(TreeNode* root, int k) {
+ int n = getNum(root->left);
+ if (n == k - 1) {
+ return root->val;
+ }
+ else if (n> k - 1) {
+ return kthSmallest(root->left, k);
+ }
+ else {
+ return kthSmallest(root->right, k - n - 1);
+ }
+ }
+};
\ No newline at end of file
diff --git a/leetcode/largestNumber.cc b/leetcode/largestNumber.cc
new file mode 100644
index 0000000..8dace11
--- /dev/null
+++ b/leetcode/largestNumber.cc
@@ -0,0 +1,30 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月15日 16:51:38
+ * @LastEditTime: 2022年02月15日 17:09:00
+ * @FilePath: /leetcode/largestNumber.cc
+ */
+#include <vector>
+#include <string>
+#include <algorithm>
+
+
+class Solution {
+public:
+ std::string largestNumber(std::vector<int> & nums) {
+ std::vector<std::string> sNums;
+ for (auto item : nums) {
+ sNums.push_back(std::to_string(item));
+ }
+
+ std::sort(sNums.begin(), sNums.end(), [](std::string s1, std::string s2) {
+ return s2 + s1 < s1 + s2; + }); + + std::string res; + for (auto item : sNums) { + res += item; + } + return res[0] == '0' ? "0" : res; + } +}; \ No newline at end of file diff --git a/leetcode/linkList.cc b/leetcode/linkList.cc new file mode 100644 index 0000000..a77027a --- /dev/null +++ b/leetcode/linkList.cc @@ -0,0 +1,422 @@ +/* + * @Author: vihowe + * @Date: 2022-02-17 15:11:02 + * @LastEditTime: 2022-02-23 10:19:44 + * @FilePath: /Algorithm/leetcode/linkList.cc + */ + +#include <unordered_set>
+#include <iostream>
+
+
+struct ListNode {
+ int val;
+ ListNode *next;
+ ListNode(int x) : val(x), next(nullptr) {}
+};
+
+class Solution {
+public:
+ bool hasCycle(ListNode *head)
+ {
+ if (!head)
+ return false;
+ ListNode *slow = head, *fast = head;
+ while(fast && fast->next)
+ {
+ slow = slow->next;
+ fast = fast->next->next;
+
+ if (slow == fast)
+ return true;
+ }
+ return false;
+ }
+
+ bool hasCycle2(ListNode *head)
+ {
+ std::unordered_set<listnode*> seen;
+ while (!head)
+ {
+ if (seen.count(head))
+ {
+ return true;
+ }
+ seen.insert(head);
+ head = head->next;
+ }
+ return false;
+ }
+
+
+ void swap(ListNode *a, ListNode *b)
+ {
+ int tmp = a->val;
+ a->val = b->val;
+ b->val = tmp;
+ }
+
+ ListNode* sortList(ListNode *head)
+ {
+ int n = 0;
+ ListNode *temp;
+ while (temp)
+ {
+ n++;
+ temp = temp->next;
+ }
+
+ for (int i = 1; i < n; ++i) + { + ListNode *cur = head; + while (cur->next)
+ {
+ if (cur->val> cur->next->val)
+ {
+ swap(cur, cur->next);
+ }
+ cur = cur->next;
+ }
+ }
+ return head;
+ }
+
+ ListNode* sortList2(ListNode *head)
+ {
+ if (!head &#124;&#124; !head->next)
+ {
+ return head;
+ }
+
+ ListNode *slow = head, *fast = head;
+ while (fast->next && fast->next->next)
+ {
+ fast = fast->next->next;
+ slow = slow->next;
+ }
+ ListNode* temp = slow->next;
+ slow->next = nullptr;
+
+ ListNode *l1 = sortList(head);
+ ListNode *l2 = sortList(temp);
+ ListNode *ret = new ListNode(0);
+ ListNode *h = ret;
+ while (l1 && l2)
+ {
+ if (l1->val < l2->val)
+ {
+ h->next = l1;
+ l1 = l1->next;
+ }
+ else
+ {
+ h->next = l2;
+ l2 = l2->next;
+ }
+ h = h->next;
+ }
+ 
+ if (l1)
+ {
+ h->next = l1;
+ }
+ if (l2)
+ {
+ h->next = l2;
+ }
+ return ret->next;
+ }
+
+
+ ListNode* sortList3(ListNode *head)
+ {
+ if (!head)
+ {
+ return nullptr;
+ }
+
+ int n = 0;
+ ListNode *temp = head;
+ while (temp)
+ {
+ n++;
+ temp = temp->next;
+ }
+
+ ListNode *ret = new ListNode(0);
+ ret->next = head;
+
+ int interval = 1;
+ while (interval < n) + { + ListNode *pre = ret, *h = ret->next;
+
+ while (h)
+ {
+ ListNode *h1 = h;
+ int i = interval;
+ while (h && i)
+ {
+ h = h->next;
+ i--;
+ }
+ if (i)
+ {
+ break; // h2 not exists
+ }
+ ListNode *h2 = h;
+ i = interval;
+ while (h && i)
+ {
+ h = h->next;
+ i--;
+ }
+ int c1 = interval, c2 = interval - i;
+
+ while (c1 && c2)
+ {
+ if (h1->val < h2->val)
+ {
+ pre->next = h1;
+ h1 = h1->next;
+ c1--;
+ }
+ else
+ {
+ pre->next = h2;
+ h2 = h2->next;
+ c2--;
+ }
+ pre = pre->next;
+ }
+ pre->next = c1 ? h1 : h2;
+ while (c1> 0 &#124;&#124; c2> 0)
+ {
+ pre = pre->next;
+ c1--;
+ c2--;
+ }
+ // pre->next = h;
+ }
+ interval *= 2;
+ }
+ return ret->next;
+ }
+
+ ListNode* getIntersectionNode(ListNode *headA, ListNode *headB)
+ {
+ int n1 = 0, n2 = 0;
+ ListNode *temp = headA;
+ while(temp)
+ {
+ n1++;
+ temp = temp->next;
+ }
+ temp = headB;
+ while(temp)
+ {
+ n2++;
+ temp = temp->next;
+ }
+
+ int d = abs(n1 - n2);
+ if (n1> n2)
+ {
+ while (d)
+ {
+ headA = headA->next;
+ d--;
+ }
+ }
+ else
+ {
+ while (d)
+ {
+ headB = headB->next;
+ d--;
+ }
+ }
+ while (headA && headB)
+ {
+ if (headA == headB)
+ {
+ return headA;
+ }
+ headA = headA->next;
+ headB = headB->next;
+ }
+ return nullptr;
+
+ }
+
+ ListNode* reverseList(ListNode* head)
+ {
+ ListNode *pre = nullptr, *cur = head, *next = nullptr;
+ while (cur)
+ {
+ next = cur->next;
+ cur->next = pre;
+ pre = cur;
+ cur = next;
+ }
+ return pre;
+ }
+
+ ListNode* reverseList2(ListNode *head)
+ {
+ if (!head &#124;&#124; !head->next)
+ {
+ return head;
+ }
+ ListNode *newHead = reverseList2(head->next);
+ head->next->next = head;
+ head->next = nullptr;
+ return newHead;
+ }
+
+
+ ListNode* front;
+
+ bool checkRrecurrsive(ListNode* curr)
+ {
+ if (curr)
+ {
+ if (!checkRrecurrsive(curr->next))
+ {
+ return false;
+ }
+ if (front->val != curr->val)
+ {
+ return false;
+ }
+ front = front->next;
+ return true;
+ }
+ return true;
+ }
+ bool isPalindrome(ListNode *head)
+ {
+ front = head;
+ return checkRrecurrsive(head);
+ }
+
+ bool isPalindrome2(ListNode *head)
+ {
+ if (!head &#124;&#124; !head->next)
+ {
+ return true;
+ }
+ ListNode *slow = head, *fast = head;
+ ListNode *pre = head, *prepre = nullptr;
+ while (fast && fast->next)
+ {
+ pre = slow;
+ slow = slow->next;
+ fast = fast->next->next;
+ pre->next = prepre;
+ prepre = pre;
+ }
+ if (fast)
+ {
+ slow = slow->next;
+ }
+ while (pre && slow)
+ {
+ if (pre->val != slow->val)
+ {
+ return false;
+ }
+ pre = pre->next;
+ slow = slow->next;
+ }
+ }
+
+ void deleteNode(ListNode *node)
+ {
+ // can not access the head node, so we need to find the previous node
+ // just to delete the value of node
+ node->val = node->next->val;
+ node->next = node->next->next;
+ }
+
+ ListNode* oddEvenList(ListNode *head)
+ {
+ if (!head &#124;&#124; !head->next &#124;&#124; !head->next->next)
+ {
+ return head;
+ }
+ int n = 0;
+ ListNode *temp = head;
+ while (temp)
+ {
+ n++;
+ temp = temp->next;
+ }
+ int k = (n - 1) / 2;
+ for (int i = 1; i <= k; ++i) + { + ListNode *start = head, *pre = nullptr; + int j = i; + while(j--) + { + pre = start; + start = start->next;
+ }
+
+ int round = k - i + 1;
+ while (round--)
+ {
+ // swap (start, start->next)
+ temp = start->next;
+ start->next = start->next->next;
+ pre->next = temp;
+ temp->next = start;
+ pre = start;
+ start = start->next;
+ }
+ }
+ return head;
+ }
+
+ ListNode* oddEvenList2(ListNode *head)
+ {
+ if (!head &#124;&#124; !head->next &#124;&#124; !head->next->next)
+ {
+ return head;
+ }
+ ListNode *odd = head, *evenHead = head->next, *even = head->next;
+ while(even && even->next)
+ {
+ odd->next = even->next;
+ odd = odd->next;
+ even->next = odd->next;
+ even = even->next;
+ }
+ odd->next = evenHead;
+ return head;
+ }
+};
+
+int main()
+{
+ ListNode *head = new ListNode(2);
+ head->next = new ListNode(1);
+ head->next->next = new ListNode(3);
+ head->next->next->next = new ListNode(5);
+ head->next->next->next->next = new ListNode(6);
+ head->next->next->next->next->next = new ListNode(4);
+ head->next->next->next->next->next->next = new ListNode(7);
+
+
+ Solution s;
+ head = s.oddEvenList(head);
+ while (head)
+ {
+ std::cout << head->val << " "; + head = head->next;
+ }
+ 
+
+
+}
+
diff --git a/leetcode/majorElement.cc b/leetcode/majorElement.cc
new file mode 100644
index 0000000..e24ee1e
--- /dev/null
+++ b/leetcode/majorElement.cc
@@ -0,0 +1,75 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年01月21日 09:04:55
+ * @LastEditTime: 2022年01月21日 10:39:02
+ * @FilePath: /leetcode/majorElement.cc
+ */
+#include <iostream>
+#include <vector>
+
+
+// 给定一个大小为n的数组,找到其中的多数元素,多数元素是指在数组中出现次数大于
+// floor(n/2)的元素,假设数组非空,并且给定的数组元素总是存在多数元素。
+
+// 1. 排序后取出,O(nlogn)
+// 2. hash, O(n), O(n)
+// 3.
+class Solution {
+public:
+ int majorElement(std::vector<int>& nums) {
+ quickSort(nums, 0, nums.size()-1);
+ return nums[nums.size()/2];
+ }
+ 
+ int majorityElement(std::vector<int>& nums) {
+ int candidate = -1;
+ int cnt = 0;
+ for (int num : nums) {
+ if (num == candidate) {
+ cnt++;
+ }
+ else if(--cnt < 0) { + candidate = num; + cnt = 1; + } + } + return candidate; + } + + void swap(int &a, int &b) { + int tmp = a; + a = b; + b = a; + } + + int partition(std::vector<int>& nums, int left, int right) {
+ int pivot = nums[left];
+ while(left < right) { + while(left < right && nums[right]> pivot) {
+ right--;
+ }
+ if (left < right) { + nums[left] = nums[right]; + left++; + } + while(left < right && nums[left] < pivot) { + left++; + } + if (left < right) { + nums[right] = nums[left]; + right--; + } + } + nums[left] = pivot; + return left; + } + + void quickSort(std::vector<int>& nums, int left, int right) {
+ if (left>= right) {
+ return;
+ }
+ int pivotIdx = partition(nums, left, right);
+ quickSort(nums, left, pivot-1);
+ quickSort(nums, pivot+1, right);
+ }
+};
\ No newline at end of file
diff --git a/leetcode/maxProduct.cc b/leetcode/maxProduct.cc
new file mode 100644
index 0000000..39c322a
--- /dev/null
+++ b/leetcode/maxProduct.cc
@@ -0,0 +1,30 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月14日 16:48:38
+ * @LastEditTime: 2022年02月14日 17:20:05
+ * @FilePath: /leetcode/maxProduct.cc
+ */
+#include <vector>
+#include <algorithm>
+
+/**
+ * 给你一个整数数组 nums ,请你找出数组中乘积最大的非空连续子数组(该子数组中至少包含一个数字)
+ * 并返回该子数组所对应的乘积。
+ */
+class Solution {
+public:
+ int maxProduct(std::vector<int>& nums) {
+ std::vector<int> maxF(nums), minF(nums);
+ for (int i = 1; i < nums.size(); ++i) { + maxF[i] = std::max(maxF[i-1] * nums[i], std::max(nums[i], minF[i-1] * nums[i])); + minF[i] = std::min(maxF[i-1] * nums[i], std::min(nums[i], minF[i-1] * nums[i])); + } + int ret = maxF[0]; + for (auto item : maxF) { + if (item> ret) {
+ ret = item;
+ }
+ }
+ return ret;
+ }
+};
\ No newline at end of file
diff --git a/leetcode/maxSlidingWindow.cc b/leetcode/maxSlidingWindow.cc
new file mode 100644
index 0000000..da2326a
--- /dev/null
+++ b/leetcode/maxSlidingWindow.cc
@@ -0,0 +1,98 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月23日 19:12:58
+ * @LastEditTime: 2022年02月26日 09:51:45
+ * @FilePath: /Algorithm/leetcode/maxSlidingWindow.cc
+ */
+#include <vector>
+#include <queue>
+#include <iostream>
+
+class Solution {
+private:
+ std::vector<int> heap;
+public:
+
+ void adjustHeap(int i)
+ {
+ int n = heap.size();
+ for (int k = 2 * i + 1; k < n; k = 2 * k + 1) + { + if (k + 1 < n && heap[k+1]> heap[k])
+ {
+ k++;
+ }
+ if (heap[k]> heap[i])
+ {
+ std::swap(heap[k], heap[i]);
+ i = k;
+ }
+ else
+ break;
+ }
+ }
+
+ void insert(int val)
+ {
+ heap.push_back(val);
+ int n = heap.size();
+ for (int i = (n - 2) / 2; i>= 0; i = i ? (i - 1) / 2 : -1)
+ {
+ adjustHeap(i);
+ }
+ }
+
+ void del(int val)
+ {
+ std::vector<int>::size_type i = 0;
+ for (; i < heap.size(); ++i) + { + if (heap[i] == val) + break; + } + std::swap(heap[i], heap[heap.size()-1]); + heap.pop_back(); + adjustHeap(i); + } + + int pop() + { + std::swap(heap[0], heap[heap.size()-1]); + int ans = heap.back(); + heap.pop_back(); + adjustHeap(0); + return ans; + } + + std::vector<int> maxSlidingWindow(std::vector<int> &nums, int k)
+ {
+ std::vector<int> ans;
+ int n = nums.size();
+ int i = 0;
+ for (; i < k && i < n; ++i) + { + insert(nums[i]); + } + ans.push_back(heap[0]); + while (i < n) // slide window + { + del(nums[i-k]); + insert(nums[i]); + ans.push_back(heap[0]); + i++; + } + return ans; + } +}; + +int main() +{ + std::vector<int> nums {-6,-10,-7,-1,-9,9,-8,-4,10,-5,2,9,0,-7,7,4,-2,-10,8,7};
+ int k = 7;
+ Solution s;
+ auto ans = s.maxSlidingWindow(nums, 7);
+ for (auto i : ans)
+ {
+ std::cout << i << " "; + } +} \ No newline at end of file diff --git a/leetcode/mergeTwoArraies.cc b/leetcode/mergeTwoArraies.cc new file mode 100644 index 0000000..1675fa6 --- /dev/null +++ b/leetcode/mergeTwoArraies.cc @@ -0,0 +1,35 @@ +/* + * @Author: vihowe + * @Date: 2022-01-21 10:55:44 + * @LastEditTime: 2022-01-21 11:07:37 + * @FilePath: /leetcode/mergeTwoArraies.cc + */ + +// 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2,另有两个整数 m 和 n , +// 分别表示 nums1 和 nums2 中的元素数目。 +// 请你 合并 nums2 到 nums1 中,使合并后的数组同样按 非递减顺序 排列。 +// 注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况, +// nums1 的初始长度为 m + n,其中前 m 个元素表示应合并的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n + +#include <vector>
+
+class Solution{
+public:
+ void merge(std::vector<int>& nums1, int m, std::vector<int>& nums2, int n) {
+ int i, j, k;
+ i = m - 1, j = n - 1, k = m + n - 1;
+
+ while(i>= 0 && j>= 0) {
+ if(nums1[i]>= nums2[j]) {
+ nums1[k--] = nums1[i--];
+ }
+ else {
+ nums1[k--] = nums2[j--];
+ }
+ }
+ while (j>= 0) {
+ nums1[k--] = nums2[j--];
+ }
+ }
+}
+
diff --git a/leetcode/minStack.cc b/leetcode/minStack.cc
new file mode 100644
index 0000000..5a5077c
--- /dev/null
+++ b/leetcode/minStack.cc
@@ -0,0 +1,66 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月18日 17:40:10
+ * @LastEditTime: 2022年02月18日 17:46:39
+ * @FilePath: /Algorithm/leetcode/minStack.cc
+ */
+#include <stack>
+class MinStack {
+public:
+ MinStack() {
+ }
+ 
+ void push(int val) {
+ if (s.empty())
+ {
+ s.push(val);
+ min_s.push(val);
+ }
+ else
+ {
+ int cur_m = min_s.top();
+ s.push(val);
+ min_s.push(val < cur_m ? val : cur_m); + } + } + + void pop() { + if (!s.empty()) + { + s.pop(); + min_s.pop(); + } + } + + int top() { + if (!s.empty()) + { + return s.top(); + } + return -1; + } + + int getMin() { + if (!s.empty()) + { + return min_s.top(); + } + else + { + return -1; + } + } + +private: + std::stack<int> s;
+ std::stack<int> min_s;
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack* obj = new MinStack();
+ * obj->push(val);
+ * obj->pop();
+ * int param_3 = obj->top();
+ * int param_4 = obj->getMin();
+ */
\ No newline at end of file
diff --git a/leetcode/numberShownOnce.cc b/leetcode/numberShownOnce.cc
new file mode 100644
index 0000000..56a6b3a
--- /dev/null
+++ b/leetcode/numberShownOnce.cc
@@ -0,0 +1,28 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年01月21日 08:49:30
+ * @LastEditTime: 2022年01月21日 09:02:06
+ * @FilePath: /leetcode/numberShownOnce.cc
+ */
+#include <iostream>
+#include <vector>
+
+// 只有一个数字出现一次,其他数字都出现两次,找出仅出现一次的数字
+// 通过异或位运算,出现两次的数字各位经过异或都消除了
+class Solution {
+public:
+ int singleNumber(std::vector<int>& nums) {
+ int ret = 0;
+ for (int num : nums) {
+ ret = ret ^ num;
+ }
+ return ret;
+ }
+};
+
+int main() {
+ std::vector<int> nums {1, 1, 2, 2, 3, 3, 4, 4, 5};
+ Solution s;
+ int ret = s.singleNumber(nums);
+ std::cout << ret << std::endl; +} \ No newline at end of file diff --git a/leetcode/palindromePartition.cc b/leetcode/palindromePartition.cc new file mode 100644 index 0000000..749bd86 --- /dev/null +++ b/leetcode/palindromePartition.cc @@ -0,0 +1,75 @@ +/* + * @Author: vihowe + * @Date: 2022-01-27 11:21:07 + * @LastEditTime: 2022-01-30 16:11:09 + * @FilePath: /leetcode/palindromePartition.cc + */ +#include <iostream>
+#include <string>
+#include <vector>
+
+class Solution {
+public:
+ std::vector<std::vector<bool>> f;
+ std::vector<std::vector<std::string>> ret;
+ std::vector<std::string> ans;
+
+ bool isPalindrome(std::string s) {
+ int i = 0, j = s.size() - 1;
+ while (i < j) { + if (s[i] != s[j]) { + return false; + } + i++; + j--; + } + return true; + } + + void preprocess(std::string s) { + int n = s.size(); + f.assign(n, std::vector<bool>(n, true));
+
+ for (int i = 1; i < n; ++i) { + for (int j = 0; j + i < n; ++j) { + int k = j + i; + f[j][k] = s[j] == s[k] && f[j+1][k-1]; + } + } + + } + + std::vector<std::vector<std::string>> dfs(std::string s, int i) {
+ int n = s.size();
+ if (i == n) {
+ ret.push_back(ans);
+ }
+ for(int j = i; j < n; ++j) { + // whether s[i-j] is a palindrome + if (f[i][j]) { + ans.push_back(s.substr(i, j - i + 1)); + dfs(s, j+1); + ans.pop_back(); + } + } + } + + std::vector<std::vector<std::string>> partition(std::string s) {
+ preprocess(s);
+ dfs(s, 0);
+ return ret;
+ }
+};
+
+int main() {
+ std::string s = "aab";
+ Solution ss;
+ std::vector<std::vector<std::string>> ret = ss.partition(s);
+ for (auto item : ret) {
+ std::cout << "["; + for (auto i : item) { + std::cout << i << ","; + } + std::cout << "]" << std::endl; + } +} \ No newline at end of file diff --git a/leetcode/roads b/leetcode/roads new file mode 100755 index 0000000..f403f96 Binary files /dev/null and b/leetcode/roads differ diff --git a/leetcode/roads.cc b/leetcode/roads.cc new file mode 100644 index 0000000..c9db401 --- /dev/null +++ b/leetcode/roads.cc @@ -0,0 +1,64 @@ +#include <iostream>
+#include <vector>
+#include <unordered_set>
+#include <algorithm>
+
+int K, N, R;
+
+struct road
+{
+ int s;
+ int e;
+ int L;
+ int T;
+ road(int ss, int ee, int ll, int tt) : s(ss), e(ee), L(ll), T(tt) {}
+};
+
+std::vector<road> roads;
+std::unordered_set<int> visited;
+
+int minLen = 1 << 30; +int curLen = 0; + +void DFS(int s) +{ + if(s == N) + { + minLen = std::min(curLen, minLen); + return; + } + visited.insert(s); + + for(int i = 0; i < roads.size(); ++i) + { + road r = roads[i]; + if(r.s == s && (visited.find(r.e) == visited.end()) && K>= r.T)
+ {
+ curLen += r.L;
+ K -= r.T;
+ DFS(r.e);
+ K += r.T;
+ curLen -= r.L;
+ visited.erase(s);
+ }
+ }
+}
+
+
+int main()
+{
+ std::cin>> K>> N>> R;
+ for(int i = 0; i < R; ++i) + { + int s, e, L, T; + std::cin>> s>> e>> L>> T;
+ 
+ roads.push_back(road(s, e, L, T));
+ }
+ DFS(1);
+ minLen = (minLen < (1 << 30) ? minLen : -1); + std::cout << minLen << std::endl; + + return 0; + +} \ No newline at end of file diff --git a/leetcode/rotateVector.cc b/leetcode/rotateVector.cc new file mode 100644 index 0000000..ea5be21 --- /dev/null +++ b/leetcode/rotateVector.cc @@ -0,0 +1,54 @@ +/* + * @Author: vihowe + * @Date: 2022-02-14 19:16:22 + * @LastEditTime: 2022-02-14 20:46:43 + * @FilePath: /leetcode/rotateVector.cc + */ +#include <vector>
+#include <algorithm>
+
+class Solution {
+public:
+ void rotate(std::vector<int>& nums, int k) {
+ int n = nums.size();
+ std::vector<int> newNums(n);
+ for (int i = 0; i < n; ++i) { + newNums[(i + k) % n] = nums[i]; + } + nums.assign(newNums.begin(), newNums.end()); + + } + + void rotating(std::vector<int>& nums, int i, int j) {
+ while(i < j) { + int temp = nums[i]; + nums[i] = nums[j]; + nums[j] = temp; + i++; + j--; + } + } + void rotate2(std::vector<int>& nums, int k) {
+ int n = nums.size();
+ k = k % n;
+ rotating(nums, 0, n - k - 1);
+ rotating(nums, n - k, n - 1);
+ rotating(nums, 0, n - 1);
+ }
+
+ void rotate3(std::vector<int> &nums, int k) {
+ int n = nums.size();
+ int cnt = 0;
+ int start = 0;
+ while (cnt < n) { + int prev = nums[start]; + int cur = start; + do { + int next = (cur + k) % n; + std::swap(prev, nums[next]); // store nums[cur] in prev + cur = next; + } while(cur != start); + start++; + } + } +}; \ No newline at end of file diff --git a/leetcode/search2dMatrix.cc b/leetcode/search2dMatrix.cc new file mode 100644 index 0000000..9b397d9 --- /dev/null +++ b/leetcode/search2dMatrix.cc @@ -0,0 +1,32 @@ +/* + * @Author: vihowe + * @Date: 2022-01-21 10:39:40 + * @LastEditTime: 2022-01-21 10:54:03 + * @FilePath: /leetcode/search2dMatrix.cc + */ +#include <iostream>
+#include <vector>
+
+// 从一个二维矩阵中搜索target
+// 矩阵从左到右从上到下都是升序
+
+class Solution {
+public:
+ bool searchMatrix(std::vector<std::vector<int>>& nums, int target) {
+ int m = nums.size();
+ int n = nums[0].size();
+ int i = 0, j = n - 1;
+ while(i < m && j>= 0 ) {
+ if(target < nums[i][j]) { + j--; + } + else if (target> nums[i][j]) {
+ i++;
+ }
+ else {
+ return true;
+ }
+ }
+ return false;
+ }
+}
\ No newline at end of file
diff --git a/leetcode/sort.cc b/leetcode/sort.cc
new file mode 100644
index 0000000..3f1cf8e
--- /dev/null
+++ b/leetcode/sort.cc
@@ -0,0 +1,259 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月16日 19:37:10
+ * @LastEditTime: 2022年02月19日 18:41:04
+ * @FilePath: /Algorithm/leetcode/sort.cc
+ */
+#include <vector>
+#include <iostream>
+#include <queue>
+
+class Solution {
+
+public:
+
+ int partition(std::vector<int> &nums, int left, int right)
+ {
+ int pivot = nums[left];
+ while (left < right) + { + while (left < right && nums[right]>= pivot) right--;
+ if (left < right) + { + nums[left] = nums[right]; + } + while (left < right && nums[left] <= pivot) left++; + if (left < right) + { + nums[right] = nums[left]; + } + } + nums[left] = pivot; + return left; + } + + void quickSort(std::vector<int> &nums, int left, int right)
+ {
+ if (left>= right)
+ {
+ return;
+ }
+
+ int pivotIdx = partition(nums, left, right);
+ quickSort(nums, left, pivotIdx - 1);
+ quickSort(nums, pivotIdx + 1, right);
+ }
+
+ void reverse(std::vector<int> &nums, int left, int right)
+ {
+ while (left < right) + { + int temp = nums[left]; + nums[left] = nums[right]; + nums[right] = temp; + left++; + right--; + } + } + + int count(std::vector<int> &nums, int left, int right, int target)
+ {
+ int cnt = 0;
+ for (int i = left; i <= right; ++i) + { + if (nums[i] == target) + { + cnt++; + } + } + return cnt; + } + + void wiggleSort(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ quickSort(nums, 0, n - 1);
+
+ int k = n / 2;
+ if (nums[n-k] == nums[n-k-1])
+ {
+ int cnt1 = count(nums, 0, n - k - 1, nums[n-k]);
+ int cnt2 = count(nums, n - k, n - 1, nums[n-k]);
+ if (cnt1 + cnt2>= (n+1) / 2)
+ {
+ reverse(nums, 0, n - k - 1);
+ reverse(nums, n - k, n - 1);
+ }
+ }
+
+ for (int i = n - k; i < n; ++i) + { + int temp = nums[i]; + int j = i; + for (; j> 2 * (i - n + k + 1) - 1; --j)
+ {
+ nums[j] = nums[j - 1];
+ }
+ nums[j] = temp;
+ }
+ }
+
+ void threeWayPartition(std::vector<int> &nums)
+ {
+ using std::swap;
+ int i = 0, j = 0, k = nums.size() - 1;
+ int mid = 1;
+ while(j < k){ + if(nums[j]> mid){
+ swap(nums[j], nums[k]);
+ --k;
+ }
+ else if(nums[j] < mid){ + swap(nums[j], nums[i]); + ++i; + ++j; + } + else{ + ++j; + } + } + } + + int partition2(std::vector<int> &nums, int left, int right)
+ {
+ int pivot = nums[left];
+ while (left < right) + { + while (left < right && nums[right] <= pivot) right--; + if (left < right) + { + nums[left] = nums[right]; + } + + while (left < right && nums[left]>= pivot) left++;
+ if (left < right) + { + nums[right] = nums[left]; + } + } + nums[left] = pivot; + return left; + } + + void kthBiggestHelper(std::vector<int> &nums, int k, int left, int right)
+ {
+ if (left>= right)
+ return;
+ int pivotIdx = partition2(nums, left, right);
+ kthBiggestHelper(nums, k, left, pivotIdx - 1);
+ kthBiggestHelper(nums, k, pivotIdx + 1, right);
+ 
+ }
+
+ int kthBiggest(std::vector<int> &nums, int k)
+ {
+ kthBiggestHelper(nums, k, 0, nums.size() - 1);
+ return nums[k-1];
+ }
+
+ /************************heap sort*******************************/
+ void adjustHeap(std::vector<int> &nums, int i, int n)
+ {
+ for (int k = 2 * i + 1; k < n; k = 2 * k + 1) + { + if (k + 1 < n && nums[k+1]> nums[k])
+ {
+ k++;
+ }
+ if (nums[k]> nums[i])
+ {
+ std::swap(nums[k], nums[i]);
+ i = k;
+ }
+ }
+ }
+
+ int findKthLargest(std::vector<int> &nums, int k)
+ {
+ int n = nums.size();
+ for (int i = (n - 1) / 2; i>= 0; --i)
+ {
+ adjustHeap(nums, i, n);
+ }
+ for (int i = 0; i < k; ++i) + { + std::swap(nums[0], nums[n-1-i]); + adjustHeap(nums, 0, n - 1 - i); + } + return nums[n - k]; + } + void heapSort(std::vector<int> &nums)
+ {
+ int n = nums.size();
+ // construct the heap
+ // start from the first non-leaf node
+ for (int i = (n - 1) / 2; i>= 0; --i)
+ {
+ adjustHeap(nums, i, n);
+ }
+ for (int i = n - 1; i> 0; --i)
+ {
+ std::swap(nums[0], nums[i]);
+ adjustHeap(nums, 0, i);
+ }
+ }
+};
+
+
+class MedianFinder {
+ std::priority_queue<int, std::vector<int>, std::less<int>> queMin;
+ std::priority_queue<int, std::vector<int>, std::greater<int>> queMax;
+ 
+public:
+ MedianFinder() {}
+
+ void addNum(int num)
+ {
+ if (queMin.empty() &#124;&#124; num <= queMin.top()) + { + queMin.push(num); + if (queMin.size()> queMax.size() + 1)
+ {
+ queMax.push(queMin.top());
+ queMin.pop();
+ }
+ }
+ else
+ {
+ queMax.push(num);
+ if (queMax.size()> queMin.size())
+ {
+ queMin.push(queMax.top());
+ queMax.pop();
+ }
+ }
+ }
+
+ double findMedian()
+ {
+ if (queMin.size()> queMax.size())
+ {
+ return queMin.top();
+ }
+ return (queMin.top() + queMax.top()) / 2;
+ }
+
+};
+
+int main()
+{
+ std::vector<int> nums {3,2,3,1,2,4,5,5,6};
+ Solution s;
+ // s.wiggleSort(nums);
+ s.heapSort(nums);
+ // std::cout << s.kthBiggest(nums, 4) << std::endl; + for (auto i : nums) + { + std::cout << i << " "; + } +} \ No newline at end of file diff --git a/leetcode/tree.cc b/leetcode/tree.cc new file mode 100644 index 0000000..649496a --- /dev/null +++ b/leetcode/tree.cc @@ -0,0 +1,31 @@ +/* + * @Author: vihowe + * @Date: 2022-03-07 19:37:07 + * @LastEditTime: 2022-03-07 19:41:48 + * @FilePath: /Algorithm/leetcode/tree.cc + */ +#include <vector>
+
+class TreeNode {
+public:
+ int val;
+ TreeNode *left;
+ TreeNode *right;
+ TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+};
+
+
+class Solution {
+
+public:
+ TreeNode* lowestCommonAncestor(TreeNode *root, TreeNode *p, TreeNode *q)
+ {
+ if (!root &#124;&#124; root == p &#124;&#124; root == q)
+ return root;
+ TreeNode *left = lowestCommonAncestor(root->left, p, q);
+ TreeNode *right = lowestCommonAncestor(root->right, p, q);
+ if (left && right)
+ return root;
+ return left ? left : right;
+ }
+};
\ No newline at end of file
diff --git a/leetcode/trie.cc b/leetcode/trie.cc
new file mode 100644
index 0000000..620e231
--- /dev/null
+++ b/leetcode/trie.cc
@@ -0,0 +1,71 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年02月23日 14:48:54
+ * @LastEditTime: 2022年02月23日 15:47:06
+ * @FilePath: /Algorithm/leetcode/trie.cc
+ */
+#include <string>
+#include <vector>
+
+class Trie {
+private:
+ std::vector<div class="naked_tr"> children;
+ bool isEnd;
+
+public:
+ Trie() : children(26), isEnd(false) {};
+
+ void insert(std::string str)
+ {
+ Trie *node = this;
+ for (auto ch : str)
+ {
+ if (!node->children[ch - 'a'])
+ {
+ node->children[ch - 'a'] = new Trie();
+ }
+ node = node->children[ch - 'a'];
+ }
+ node->isEnd = true;
+ }
+ 
+ bool search(std::string str)
+ {
+ Trie *node = this;
+ for (auto ch : str)
+ {
+ if (node->children[ch - 'a'])
+ {
+ node = node->children[ch - 'a'];
+ }
+ else
+ return false;
+ }
+ return node->isEnd;
+ }
+
+ bool startsWith(std::string str)
+ {
+ Trie *node = this;
+ for (auto ch : str)
+ {
+ if (node->children[ch - 'a'])
+ {
+ node = node->children[ch - 'a'];
+ }
+ else
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ std::vector<std::string> findWords(std::vector<std::vector<char>> &board, 
+ std::vector<std::string> words)
+ {
+ int m = board.size(), n = board[0].size();
+ 
+ }
+
+};
diff --git a/leetcode/wordBreak.cc b/leetcode/wordBreak.cc
new file mode 100644
index 0000000..bc2235c
--- /dev/null
+++ b/leetcode/wordBreak.cc
@@ -0,0 +1,119 @@
+/*
+ * @Author: vihowe
+ * @Date: 2022年01月31日 10:18:32
+ * @LastEditTime: 2022年02月23日 14:09:07
+ * @FilePath: /Algorithm/leetcode/wordBreak.cc
+ */
+#include <string>
+#include <vector>
+#include <unordered_set>
+#include <iostream>
+
+class Solution{
+public:
+
+ std::unordered_set<std::string> wordSet;
+ std::vector<int> memo;
+
+ bool dfs(std::string s, int i) {
+ int n = s.size();
+ if (i == n) {
+ return true;
+ }
+ // start from s[i] to find a word in dict
+ for(int j = i; j < n; ++j) { + std::string temp = s.substr(i, j - i + 1); + if (wordSet.find(temp) != wordSet.end()) { + if (memo[j+1] &#124;&#124; dfs(s, j+1) == true) { + memo[j+1] = true; + return true; + } + } + } + return false; + + } + bool wordBreak(std::string s, std::vector<std::string>& wordDict) {
+ for (auto word : wordDict) {
+ wordSet.insert(word);
+ }
+ for (int i = 0; i < s.size(); ++i) { + memo.push_back(false); + } + return dfs(s, 0); + + } + + + bool wordBreak2(std::string s, std::vector<std::string>& wordDict) {
+ auto dp = std::vector<bool> (s.size() + 1, false);
+ auto ws = std::unordered_set<std::string> ();
+ for (auto word : wordDict) {
+ ws.insert(word);
+ }
+ dp[0] = true;
+ for (int i = 0; i < s.size(); i++) { + for (int j = i + 1; j < s.size() + 1; j++) { + if (dp[i] && (ws.find(s.substr(i, j - i)) != ws.end())) { + dp[j] = true; + } + } + } + return dp[s.size()]; + } + + std::vector<std::string> ret;
+ void dfs(std::string s, std::unordered_set<std::string> wordSet, 
+ int start, std::vector<std::string> temp)
+ {
+ if (start == s.size())
+ {
+ std::string r_temp;
+ for (int i = 0; i < temp.size(); ++i) + { + r_temp += temp[i]; + if (i < temp.size() - 1) + r_temp += " "; + } + ret.push_back(r_temp); + return; + } + + for (int end = start; end < s.size(); ++end) + { + std::string sub = s.substr(start, end - start + 1); + if (wordSet.find(sub) != wordSet.end()) + { + temp.push_back(sub); + dfs(s, wordSet, end + 1, temp); + temp.pop_back(); + } + } + return; + } + + std::vector<std::string> wordBreak4(std::string s, std::vector<std::string> wordDict)
+ {
+ auto wordSet = std::unordered_set<std::string> ();
+ for (auto word : wordDict)
+ {
+ wordSet.insert(word);
+ }
+ std::vector<std::string> temp; // store the intermediate result
+ dfs(s, wordSet, 0, temp);
+ return ret;
+ }
+};
+
+int main()
+{
+ std::vector<std::string> wordDict {"cats", "dog", "sand", "and", "cat"};
+ std::string s {"catsanddog"};
+
+ Solution ss;
+ std::vector<std::string> ret = ss.wordBreak4(s, wordDict);
+ for (auto s : ret)
+ {
+ std::cout << s << std::endl; + } +} \ No newline at end of file diff --git "a/leetcode/345円237円216円345円240円241円351円227円256円351円242円230円.cc" "b/leetcode/345円237円216円345円240円241円351円227円256円351円242円230円.cc" new file mode 100644 index 0000000..22aa8b4 --- /dev/null +++ "b/leetcode/345円237円216円345円240円241円351円227円256円351円242円230円.cc" @@ -0,0 +1,58 @@ +#include <iostream>
+
+const int MAXN = 60;
+int room[MAXN][MAXN];
+int color[MAXN][MAXN];
+int max_area = 0;
+int cur_area = 0;
+int room_num = 0;
+
+
+void DFS(int i, int j)
+{
+ if(color[i][j])
+ return;
+ 
+ color[i][j] = room_num;
+ ++cur_area;
+
+ if((room[i][j] & 1) == 0)
+ DFS(i, j-1);
+ if((room[i][j] & 2) == 0)
+ DFS(i-1, j);
+ if((room[i][j] & 4) == 0)
+ DFS(i, j+1);
+ if((room[i][j] & 8) == 0)
+ DFS(i+1, j);
+}
+
+
+int main()
+{
+ int r, c;
+ std::cin>> r>> c;
+ for(int i = 0; i < r; ++i) + { + for(int j = 0; j < c; ++j) + { + std::cin>> room[i][j];
+ }
+ }
+ memset(color, 0, sizeof(color));
+ for(int i = 0; i < r; ++i) + { + for(int j = 0; j < c; ++j) + { + if(!color[i][j]) + { + cur_area = 0; + room_num++; + DFS(i, j); + } + max_area = max_area> cur_area ? max_area : cur_area;
+ }
+ }
+ std::cout << room_num << std::endl; + std::cout << max_area << std::endl; + return 0; +} \ No newline at end of file diff --git "a/leetcode/345円260円217円346円270円270円346円210円217円" "b/leetcode/345円260円217円346円270円270円346円210円217円" new file mode 100755 index 0000000..1aa59d5 Binary files /dev/null and "b/leetcode/345円260円217円346円270円270円346円210円217円" differ diff --git "a/leetcode/345円260円217円346円270円270円346円210円217円.cc" "b/leetcode/345円260円217円346円270円270円346円210円217円.cc" new file mode 100644 index 0000000..2ec88a2 --- /dev/null +++ "b/leetcode/345円260円217円346円270円270円346円210円217円.cc" @@ -0,0 +1,107 @@ +#include <iostream>
+#include <cstring>
+
+const int MaxLen = 80;
+char board[MaxLen][MaxLen];
+bool visited[MaxLen][MaxLen];
+
+int w, h, minStep;
+// for directions
+int to[4][2] = {
+ {0,1},{1,0},{0,-1},{-1,0}
+};
+
+void DFS(int x1, int y1, int x2, int y2, int step, int f)
+{
+ if((x1 == x2) && (y1 == y2))
+ {
+ minStep = step < minStep ? step : minStep; + return; + } + if(step>= minStep)
+ {
+ return;
+ }
+ for(int i = 0; i < 4; ++i) + { + int x = x1 + to[i][0], y = y1 + to[i][1]; + if((x> -1) && (x < w + 2) && (y> -1) && (y < h + 2) && + ((board[y][x] == ' ') && (visited[y][x] == false) &#124;&#124; + (x == x2 && y == y2 && board[y][x] == 'X') + ) + ) + { + visited[y][x] = true; + if(f != i) + { + ++step; + } + DFS(x, y, x2, y2, step, i); + + // 回溯 + visited[y][x] = false; + if(f != i) + { + --step; + } + } + } +} + +int main() +{ + int board_num = 0; + while(std::cin>> w>> h)
+ {
+ if(w == 0 && h == 0)
+ break;
+ ++board_num;
+ std::cout << "Board #" << board_num << ":" << std::endl; + for(int i = 0; i < MaxLen; ++i) + { + board[0][i] = board[i][0] = ' '; + } + + for(int i = 1; i <= h; ++i) + { + getchar(); + for(int j = 1; j <= w; ++j) + { + board[i][j] = getchar(); + } + } + + // 在矩形板最外层加一圈格子 + for(int j = 0; j <= w; ++j) + { + board[h+1][j+1] = ' '; + } + for(int i = 0; i <= h; ++i) + { + board[i+1][w+1] = ' '; + } + + int x1, y1, x2, y2, count = 0; + while((std::cin>> x1>> y1>> x2>> y2) && x1> 0)
+ {
+ ++count;
+ minStep = 1 << 30; + memset(visited, false, sizeof(visited)); + + DFS(x1, y1, x2, y2, 0, -1); + if (minStep < (1<<30)) + { + std::cout << "Pair " << count << ": " << minStep << " segments." << std::endl; + } + else + { + std::cout << "Pair " << count << ": impossible." << std::endl; + } + } + std::cout << std::endl; + } + +} + + + diff --git "a/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円" "b/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円" new file mode 100755 index 0000000..14e4077 Binary files /dev/null and "b/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円" differ diff --git "a/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円.cc" "b/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円.cc" new file mode 100644 index 0000000..2628f8c --- /dev/null +++ "b/leetcode/346円234円200円351円225円277円344円270円212円345円215円207円345円255円220円345円272円217円345円210円227円.cc" @@ -0,0 +1,41 @@ +#include <iostream>
+#include <algorithm>
+
+int main()
+{
+ int N;
+ std::cin>> N;
+
+ int data[110];
+ int dp[110];
+ memset(dp, 0, sizeof(dp));
+
+ for (int i = 0; i < N; ++i) + { + std::cin>> data[i];
+ }
+ dp[0] = 1;
+ 
+ for(int i = 1; i < N; ++i) + { + int temp = 0; + for(int j = 0; j < i; ++j) + { + if(data[i]> data[j])
+ {
+ temp = dp[j]> temp ? dp[j] : temp;
+ }
+ }
+ dp[i] = temp + 1;
+ }
+ int ret = 1;
+ for(int i = 0; i < N; ++i) + { + if (dp[i]> ret)
+ ret = dp[i];
+ }
+ std::cout << ret << std::endl;
+ 
+
+ return 0;
+}
\ No newline at end of file
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="https://github.com/AngelKitty/Algorithm/compare/master...vihowe:Algorithm:master.diff">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="https://github.com/AngelKitty/Algorithm/compare/master...vihowe:Algorithm:master.diff" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>