add new

Author: gitgou

.vscode/settings.json

@@ -64,5 +64,6 @@
         "utility": "cpp",
         "vector": "cpp",
         "list": "cpp"
-    }
+    },
+    "C_Cpp.errorSquiggles": "enabled"
 }

a.out

@@ -0,0 +1,59 @@
+#include<vector>
+#include<iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    void bfs(vector<vector<int>>& grid, int i, int j, bool& isVaild){
+      visited[i][j] = true;
+      for(int index = 0; index < 4; ++index){
+        if(i + neighbor[index][0] >= row || i + neighbor[index][0] < 0){
+          isVaild = false;
+          continue;
+        }
+        
+        if(j + neighbor[index][1] >= col || j + neighbor[index][1] < 0){
+          isVaild = false;
+          continue;
+        }
+
+        int tmpI = i + neighbor[index][0], tmpJ = j + neighbor[index][1];
+        if(grid[tmpI][tmpJ] == 0 && !visited[tmpI][tmpJ])
+          bfs(grid, tmpI, tmpJ, isVaild);
+      }
+    }
+
+    int closedIsland(vector<vector<int>>& grid) {
+      row = grid.size(), col = grid[0].size();
+      visited.resize(row, vector<bool>(col, false));
+      res = 0; 
+      for(int i = 0; i < row; ++i){
+        for(int j = 0; j < col; ++j){
+          if(!visited[i][j] && grid[i][j] == 0){
+            bool isVaild = true;
+            bfs(grid, i, j, isVaild);
+            if(isVaild)
+              res++;
+          }
+        }
+      }
+
+      return res;
+    }
+
+private:
+  int row;
+  int col;
+  int res;
+  vector<vector<bool>> visited;
+  vector<vector<int>> neighbor = {{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
+};
+
+int main(){
+
+  Solution s;
+  vector<vector<int>> grid = {{1,1,1,1,1,1,1,0},{1,0,0,0,0,1,1,0},{1,0,1,0,1,1,1,0},{1,0,0,0,0,1,0,1},{1,1,1,1,1,1,1,0}};
+  cout << s.closedIsland(grid) << endl;
+  return 0;
+}

closedIsland_1254.cpp

@@ -0,0 +1,51 @@
+#include<string>
+#include<iostream>
+#include<vector>
+using namespace std;
+
+class Solution {
+public:
+    const int MOD = 1e9 + 7;
+    int countPalindromicSubsequences(string s) {
+      //  先求回文子串
+      int n = s.size();
+      vector<vector<vector<int>>> dp(4, vector<vector<int>>(n, vector<int>(n, 0)));
+      for(int i = 0; i < n; ++i){
+        dp[s[i] - 'a'][i][i] = 1;
+      }
+
+      for(int len = 2; len <= n; ++len){
+        for(int i = 0; i <= n - len; ++i){
+          int j = i + len - 1;
+          for(int x = 0; x < 4; ++x){
+            char c = 'a' + x;
+            if(s[i] == c && s[i] == s[j]){
+              dp[x][i][j] = (2LL + dp[0][i+1][j-1] + dp[1][i+1][j-1] + dp[2][i+1][j-1] +
+               dp[3][i+1][j-1]) % MOD;
+            }else if(s[i] == c && s[j] != c){
+              dp[x][i][j] = dp[x][i][j-1];
+              dp[x][i][j] %= MOD;
+            }else if(s[i] != c && s[j] == c){
+              dp[x][i][j] = dp[x][i+1][j];
+              dp[x][i][j] %= MOD;
+            }else if(s[i] != c && s[j] != c){
+              dp[x][i][j] = dp[x][i+1][j-1];
+              dp[x][i][j] %= MOD;
+            }
+          }
+        }
+      }
+
+      int res = 0;
+      for(int i = 0; i < 4; ++i){
+        res += dp[i][0][n-1];
+        res %= MOD;
+      }
+      return res;
+    }
+};
+
+int main(){
+
+  return 0;
+}

countPalindromicSubsequences_730.cpp

@@ -0,0 +1,41 @@
+#include<string>
+#include<vector>
+#include<iostream>
+
+using namespace std;
+
+class Solution {
+public:
+    int countSubstrings(string s, string t) {
+      // 关键点在于找到 s[i] 不等于 t[j]时 
+      //dpl[i][j] 以 s[i] s[j] 为终点的左边最长相等序列 以及 右边最长相等序列 dpr[i][j] 
+      int n = s.size(), m = t.size();
+      vector<vector<int>> dpl(n + 1, vector<int>(m + 1, 0)), dpr(n + 1, vector<int>(m + 1, 0));
+      for(int i = 0; i < n; ++i){
+        for(int j = 0; j < m; ++j){
+          dpl[i+1][j+1] = s[i] == t[j] ? dpl[i-1][j-1] + 1 : 0; 
+        }
+      }
+
+      for(int i = n - 1; i >= 0; --i){
+        for(int j = m - 1; j >= 0; --j){
+          dpr[i][j] = s[i] == t[j] ? dpr[i+1][j+1] + 1 : 0;
+        }
+      }
+
+      int res = 0;
+      for(int i = 0; i < n; ++i){
+        for(int j = 0; j < m; ++j){
+          if(s[i] != t[j]){
+            res += (dpl[i][j] + 1) * (dpr[i+1][j+1] +1);
+          }
+        }
+      }
+      return res;
+    }
+};
+
+int main(){
+
+  return 0;
+}

countSubstrings_1638.cpp

@@ -0,0 +1,43 @@
+#include<vector>
+#include<iostream>
+
+using namespace std;
+
+// k 为在现有范围内的第 k 个数
+double getKth(vector<int>& nums1, int start1, int end1, vector<int>& nums2, int start2, int end2, int k){
+  if(start1 > end1){
+    return nums2[start2 + k - 1];
+  }
+  if(start2 > end2){
+    return nums1[start1 + k - 1];
+  }
+
+  if(k == 1){
+    return nums1[start1] < nums2[start2] ? nums1[start1] : nums2[start2];
+  }
+  int tmp = k / 2;
+  int index1 = start1 + tmp - 1;
+  int index2 = start2 + tmp - 1;
+  index1 = index1 < end1 ? index1 : end1;
+  index2 = index2 < end2 ? index2 : end2;
+
+  if(nums1[index1] < nums2[index2]){
+    return getKth(nums1, index1 + 1, end1, nums2, start2, end2, k - (index1 - start1 + 1));
+  }else{
+    return getKth(nums1, start1, end1, nums2, index2 + 1, end2, k - (index2 - start2 + 1));
+  }
+}
+double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
+  int m = nums1.size(), n = nums2.size();
+  int left = (m + n + 1) / 2; // 如果为偶数，left 即为中位数的第 k th， right = k + 1 th
+  int right = (m + n + 2) / 2; 
+
+  return (getKth(nums1, 0, m - 1, nums2, 0, n - 1, left) + getKth(nums1, 0, m - 1, nums2, 0, n - 1, right)) * 0.5;
+}
+
+int main(){
+  vector<int> vec1{1,2,3,4,5};
+  vector<int> vec2{1,1,3,4,5};
+  double res = findMedianSortedArrays(vec1, vec2);
+  return 0;
+}

findMedianSortedArrays_4.cpp

@@ -0,0 +1,67 @@
+#include<string>
+#include<iostream>
+#include<vector>
+using namespace std;
+
+class Solution {
+public:
+
+  bool dfs(string& tmp){
+    
+    if(tmp.size() == n){
+      //cout << "tmp " << tmp << endl;
+      if(k == 1){
+        res = tmp;
+        return true;
+      }else{
+        k--;
+      }
+    }
+
+    for(int i = 0; i < n; ++i){
+      if(visited[i])
+        continue;
+      tmp.push_back('1' + i);
+      visited[i] = true;
+      if(dfs(tmp))
+        return true;
+      tmp.pop_back();
+      visited[i] = false;
+    }
+
+    return false;
+  }
+
+  int jiecheng(int x){
+    if(x == 0 || x == 1){
+      return 1;
+    }
+
+    return x * jiecheng(x-1);
+  }
+
+  string getPermutation(int n, int k) {
+    // 从 i 开始的排序数有 m 个, k/m 即为只需遍历从 k/m 开始的排序
+    int m = jiecheng(n-1);
+    int start = k/m;
+    this->n = n;
+    this->k = k % (m+1);
+    visited.resize(n, false);
+    visited[start] = true;
+    string tmp;
+    tmp.push_back('1' + start);
+    dfs(tmp);
+    return res;
+  }
+
+private:
+  vector<bool> visited;
+  int n;
+  int k;
+  string res;
+};
+
+int main(){
+
+  return 0;
+}

getPermutation_60.cpp

@@ -0,0 +1,34 @@
+#include<vector>
+#include<iostream>
+#include<string>
+#include<unordered_map>
+using namespace std;
+
+    vector<vector<string>> groupAnagrams(vector<string>& strs) {
+      vector<vector<string>> res;
+      unordered_map<string, vector<string>> hash;
+      for(int i = 0; i < strs.size(); ++i){
+        string tmp = strs[i];
+        sort(tmp.begin(), tmp.end());
+        if(hash.count(tmp)){
+          hash[tmp].push_back(strs[i]);
+        }else{
+          hash.insert(pair<string, vector<string>>(tmp, vector<string>()));
+          //hash.emplace((tmp, vector<string>()));
+          hash[tmp].push_back(strs[i]);
+        }
+      }
+
+      for(auto ite : hash){
+        res.emplace_back(std::move(ite.second));
+      }
+      
+      return res;
+    }
+
+int main(){
+
+  vector<int> vec {2,1,3,4};
+  sort(vec.begin(), vec.end(), std::less<int>());
+  return 0;
+}

groupAnagrams_49.cpp

@@ -0,0 +1,56 @@
+#include<string>
+#include<vector>
+#include<iostream>
+#include<unordered_map>
+using namespace std;
+class Solution {
+public:
+
+    void dealString(const string& str, vector<string>& tmp){
+      int start = 0;
+      for(int i = 0; i < 3; ++i){
+        int end = str.find(',', start);
+        tmp.push_back(str.substr(start, end - start));
+        start = end + 1;
+      }
+      tmp.push_back(str.substr(start, str.size() - start));
+      //tmp.push_back(str);
+    }
+    vector<string> invalidTransactions(vector<string>& transactions) {
+      vector<string> res;
+      unordered_multimap<string, vector<string>> hash;
+      unordered_set<int> repeated_res;
+      for(int i = 0; i < transactions.size(); ++i){
+        vector<string> tmp;
+        dealString(transactions[i], tmp);        
+        if(atoi(tmp[2].c_str()) > 1000){
+          repeated_res.insert(i);
+          res.push_back(transactions[i]);
+        }
+
+        auto range = hash.equal_range(tmp[0]); //hash.find(tmp[0]);
+        for(auto ite = range.first; ite != range.second; ++ite){
+          if(ite->second[3] != tmp[3] && abs(atoi(ite->second[1].c_str()) - atoi(tmp[1].c_str())) <= 60){
+            if(repeated_res.find(i) == repeated_res.end()){
+              res.push_back(transactions[i]);
+              repeated_res.insert(i);
+            }
+            int tmp_index = atoi(ite->second[4].c_str());
+            cout << "tmp_index " << tmp_index << "ite: " << ite->second[3] << endl;
+            if(repeated_res.find(tmp_index) == repeated_res.end()){
+              res.push_back(transactions[tmp_index]);
+              repeated_res.insert(tmp_index);
+            }
+            
+            
+          }
+        }
+
+        tmp.push_back(to_string(i));
+        hash.insert(make_pair(tmp[0], tmp));
+      }
+
+      return res;
+    }
+
+};