Add 906,917-919,949-952

Author: moranzcw

Algorithms/906.Super-Palindromes/solution.cpp

@@ -0,0 +1,65 @@
+class Solution {
+public:
+ bool larger(string a, string b){
+ if(a.size() < b.size())
+ return false;
+ if(a.size() > b.size())
+ return true;
+ for(int i = 0; i < a.size(); i++){
+ if(a[i] != b[i]) {
+ return a[i] > b[i];
+ }
+ }
+ return false;
+ }
+ 
+ string square(string input){
+ // 平方
+ long long temp = stoll(input);
+ long long result = temp*temp;
+ return to_string(result);
+ }
+ bool isPar(string input){
+ // 回文 
+ for(int l=0, r=input.size()-1;l<=r;l++,r--){
+ if(input[l] != input[r])
+ return false;
+ }
+ return true;
+ }
+ 
+ int superpalindromesInRange(string L, string R) {
+ int n = R.size();
+ vector<vector<string>> pool; // 按相同位数存储回文串
+ for(int i=0; i<n/2+1; i++){
+ vector<string> cur;
+ if(i == 0){
+ cur = {"0", "1", "2", "3", "4", "5", "6", "7","8", "9"};
+ }else if(i == 1){
+ cur = {"00", "11", "22", "33", "44", "55", "66", "77", "88", "99"};
+ }else{
+ vector<string> &prev = pool[i-2];
+ for(auto &p:prev){
+ for(auto &dig:pool[0]){
+ cur.push_back(dig + p + dig);
+ }
+ }
+ }
+ pool.push_back(cur);
+ }
+ 
+ // 统计符合条件的super
+ int count = 0;
+ for(auto &strs:pool){
+ for(auto &str:strs){
+ string super = square(str);
+ if(isPar(super) && (larger(super, L) || super == L ) && (larger(R, super) || super == R ) ){
+ count ++;
+ }
+ }
+ }
+ return count;
+ }
+ 
+ 
+};

Algorithms/917.Reverse-Only-Letters/solution.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+ string reverseOnlyLetters(string S) {
+ int l=0,r=S.size()-1;
+ while(l<r){
+ while(!isalpha(S[l]))
+ l++;
+ while(!isalpha(S[r]))
+ r--;
+ if(l<r){
+ swap(S[l],S[r]);
+ l++;
+ r--;
+ }
+ }
+ return S;
+ }
+};

Algorithms/918.Maximum-Sum-Circular-Subarray/solution.cpp

@@ -0,0 +1,33 @@
+class Solution {
+public:
+ int maxSubarraySumCircular(vector<int>& A) {
+ if(A.size()==0)
+ return 0;
+ if(A.size()==1)
+ return A[0];
+ int ans=INT_MIN;
+ int tol=0;
+ int least=0;
+ int num=INT_MAX;
+ int sum=0;
+ for(auto ele : A){
+ tol+=ele;
+ sum+=ele;
+ if(sum<0){
+ ans=max(ans,ele);
+ sum=0;
+ }else{
+ ans=max(sum,ans);
+ }
+ least+=ele;
+ if(least>0)
+ least=0;
+ else
+ num=min(least,num);
+ }
+ if(ans<=0)
+ return ans;
+ else
+ return max(ans,tol-num);
+ }
+};

Algorithms/919.Complete-Binary-Tree-Inserter/solution.cpp

@@ -0,0 +1,54 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class CBTInserter {
+public:
+ TreeNode* r;
+ queue<TreeNode *> q;
+ CBTInserter(TreeNode* root) {
+ r = root;
+ queue<TreeNode *> tq;
+ tq.push(r);
+ TreeNode *t;
+ while(tq.size()>0){
+ t = tq.front();
+ tq.pop();
+ if(t->left != NULL)
+ tq.push(t->left);
+ if(t->right != NULL)
+ tq.push(t->right);
+ if(t->left == NULL || t->right == NULL)
+ q.push(t);
+ }
+ }
+ 
+ int insert(int v) {
+ TreeNode *t = new TreeNode(v);
+ TreeNode *n = q.front();
+ if(n->left == NULL){
+ n->left = t;
+ }else{
+ n->right = t;
+ q.pop();
+ }
+ q.push(t);
+ return n->val;
+ }
+ 
+ TreeNode* get_root() {
+ return r;
+ }
+};
+
+/**
+ * Your CBTInserter object will be instantiated and called as such:
+ * CBTInserter obj = new CBTInserter(root);
+ * int param_1 = obj.insert(v);
+ * TreeNode* param_2 = obj.get_root();
+ */

Algorithms/949.Largest-Time-for-Given-Digits/solution.cpp

@@ -0,0 +1,44 @@
+class Solution {
+public:
+ string largestTimeFromDigits(vector<int>& A) {
+ vector<bool> used(4,false);
+ vector<int> result;
+ for(int i=0;i<A.size();i++){
+ if(A[i]<0 || A[i]>2)
+ continue;
+ int t1 = A[i];
+ used[i] = true;
+ for(int j=0;j<A.size();j++){
+ if(used[j] || (t1==2 && (A[j]>3 || A[j]<0) ) )
+ continue;
+ int t2 = t1*10 + A[j];
+ used[j] = true;
+ for(int k=0;k<A.size();k++){
+ if(used[k] || A[k]>5 || A[k]<0)
+ continue;
+ int t3 = t2*10 + A[k];
+ used[k] = true;
+ for(int y=0;y<A.size();y++){
+ if(used[y])
+ continue;
+ result.push_back(t3*10+A[y]);
+ // cout<<t3*10+A[y]<<endl;
+ }
+ used[k] = false;
+ }
+ used[j] = false;
+ }
+ used[i] = false;
+ }
+ 
+ if(result.empty())
+ return "";
+ 
+ vector<int>::iterator it = max_element(result.begin(), result.end());
+ string r = to_string(*it);
+ if(r.size()<4)
+ r = string(4-r.size(),'0') + r;
+ 
+ return r.substr(0,2) + ":" + r.substr(2);
+ }
+};

Algorithms/950.Reveal-Cards-In-Increasing-Order/solution.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+ vector<int> deckRevealedIncreasing(vector<int>& deck) {
+ sort(deck.begin(),deck.end());
+ queue<int> q;
+ for(int i=deck.size()-1;i>=0;i--){
+ if(!q.empty()){
+ int t = q.front();
+ q.pop();
+ q.push(t);
+ }
+ q.push(deck[i]);
+ }
+ vector<int> result(q.size());
+ int i = q.size()-1;
+ while(!q.empty()){
+ result[i] = q.front();
+ i--;
+ q.pop();
+ }
+ return result;
+ }
+};

Algorithms/951.Flip-Equivalent-Binary-Trees/solution.cpp

@@ -0,0 +1,34 @@
+/**
+ * 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:
+ bool eq(TreeNode* n1, TreeNode* n2){
+ if(n1 == NULL && n2 == NULL)
+ return true;
+ else if(n1 == NULL || n2 == NULL)
+ return false;
+ else{
+ if(n1->val == n2->val)
+ return true;
+ }
+ return false;
+ }
+ 
+ bool flipEquiv(TreeNode* root1, TreeNode* root2) {
+ if(eq(root1,root2)){
+ if(root1 != NULL){
+ return flipEquiv(root1->left, root2->left) && flipEquiv(root1->right, root2->right) 
+ || flipEquiv(root1->left, root2->right) && flipEquiv(root1->right, root2->left);;
+ }
+ return true;
+ }
+ return false;
+ }
+};

Algorithms/952.Largest-Component-Size-by-Common-Factor/solution.cpp

@@ -0,0 +1,42 @@
+class Solution {
+public:
+ int p[100100], sz[100100];
+ 
+ int find(int x) {
+ return x == p[x] ? x : p[x] = find(p[x]);
+ }
+ 
+ void merge(int x, int y) {
+ x = find(x);
+ y = find(y);
+ if(x == y) return;
+ sz[x] += sz[y];
+ p[y] = x;
+ }
+ 
+ int largestComponentSize(vector<int>& A) {
+ bool mark[100100] = {0}, used[100100] = {0};
+ for(int x : A) {
+ mark[x] = 1;
+ p[x] = x;
+ sz[x] = 1;
+ }
+ // Sieve of erastosthenes
+ for(long long i = 2; i <= 100000; i++) {
+ if(!used[i]) {
+ int last = -1;
+ // i is a prime, union all numbers which has i as its factor.
+ for(long long j = i; j <= 100000; j += i) {
+ used[j] = 1;
+ if(mark[j]) {
+ if(last != -1) merge(last, j);
+ last = j;
+ }
+ }
+ }
+ }
+ int ans = 0;
+ for(int x : A) ans = max(ans, sz[x]);
+ return ans;
+ }
+};

README.md

@@ -597,10 +597,18 @@
 
 [897.Increasing-Order-Search-Tree](Algorithms/897.Increasing-Order-Search-Tree/solution.cpp)
 
+[906.Super-Palindromes](Algorithms/906.Super-Palindromes/solution.cpp)
+
 [914.X-of-a-Kind-in-a-Deck-of-Cards](Algorithms/914.X-of-a-Kind-in-a-Deck-of-Cards/solution.cpp)
 
 [915.Partition-Array-into-Disjoint-Intervals](Algorithms/915.Partition-Array-into-Disjoint-Intervals/solution.cpp)
 
+[918.Maximum-Sum-Circular-Subarray](Algorithms/918.Maximum-Sum-Circular-Subarray/solution.cpp)
+
+[917.Reverse-Only-Letters](Algorithms/917.Reverse-Only-Letters/solution.cpp)
+
+[919.Complete-Binary-Tree-Inserter](Algorithms/919.Complete-Binary-Tree-Inserter/solution.cpp)
+
 [925.Long-Pressed-Name](Algorithms/925.Long-Pressed-Name/solution.cpp)
 
 [926.Flip-String-to-Monotone-Increasing](Algorithms/926.Flip-String-to-Monotone-Increasing/solution.cpp)
@@ -635,4 +643,12 @@
 
 [947.Most-Stones-Removed-with-Same-Row-or-Column](Algorithms/947.Most-Stones-Removed-with-Same-Row-or-Column/solution.cpp)
 
-[948.Bag-of-Tokens](Algorithms/948.Bag-of-Tokens/solution.cpp)
+[948.Bag-of-Tokens](Algorithms/948.Bag-of-Tokens/solution.cpp)
+
+[949.Largest-Time-for-Given-Digits](Algorithms/949.Largest-Time-for-Given-Digits/solution.cpp)
+
+[950.Reveal-Cards-In-Increasing-Order](Algorithms/950.Reveal-Cards-In-Increasing-Order/solution.cpp)
+
+[951.Flip-Equivalent-Binary-Trees](Algorithms/951.Flip-Equivalent-Binary-Trees/solution.cpp)
+
+[952.Largest-Component-Size-by-Common-Factor](Algorithms/952.Largest-Component-Size-by-Common-Factor/solution.cpp)