Add 953-955.

Author: moranzcw

Algorithms/953.Verifying-an-Alien-Dictionary/solution.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    bool less(string &s1, string &s2, map<char, int> &m){
+        int l = min(s1.size(),s2.size());
+        for(int i=0;i<l;i++){
+            if(m[s1[i]]<m[s2[i]])
+                return true;
+            if(m[s1[i]]>m[s2[i]])
+                return false;
+        }
+        if(s1.size() <= s2.size())
+            return true;
+        return false;
+    }
+    bool isAlienSorted(vector<string>& words, string order) {
+        map<char, int> m;
+        int i=0;
+        for(char &a:order){
+            m.insert(pair<char, int>(a,i));
+            i++;
+        }
+        
+        for(int i=1;i<words.size();i++){
+            if(!less(words[i-1],words[i],m))
+                return false;
+        }
+        return true;
+    }
+};

Algorithms/954.Array-of-Doubled-Pairs/solution.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    bool canReorderDoubled(vector<int>& A) {
+        sort(A.begin(),A.end());
+        unordered_map<int,int> used;
+        for(auto &i:A){
+            if(used.find(i) == used.end())
+                used.insert(pair<int,int>(i,1));
+            else
+                used[i] ++;
+        }
+        
+        for(int i=0;i<A.size();i++){
+            if((used.find(A[i]) != used.end() ) && (used[A[i]] != 0 ) ){
+                used[A[i]] --;
+                int d = A[i] * 2;
+                if(d < 0)
+                    d = A[i] / 2;
+                if((used.find(d) != used.end()) && (used[d] != 0)){
+                    used[d] --;
+                }
+                else
+                    return false;
+            }
+        }
+        return true;
+    }
+};

Algorithms/955.Delete-Columns-to-Make-Sorted-II/solution.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    int lexicographic(vector<string>& A, vector<int> &col){
+        for (int i=0; i<A.size()-1; i++){
+            for(auto &j:col){
+                if (A[i][j] < A[i+1][j])
+                    break;
+                if (A[i][j] > A[i+1][j])
+                    return false;
+            }
+        }
+        return true;
+    }
+    
+    int minDeletionSize(vector<string>& A) {
+        int l = A.size();
+        int w = A[0].size();
+        
+        vector<int> col;
+        int res=0;
+        for(int i=0;i<w;i++){
+            col.push_back(i);
+            if(!lexicographic(A,col)){
+                col.pop_back();
+                res += 1;
+            }
+        }
+        return res;
+    }
+};
+

README.md

@@ -651,4 +651,10 @@
 
 [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)
+[952.Largest-Component-Size-by-Common-Factor](Algorithms/952.Largest-Component-Size-by-Common-Factor/solution.cpp)
+
+[953.Verifying-an-Alien-Dictionary](Algorithms/953.Verifying-an-Alien-Dictionary/solution.cpp)
+
+[954.Array-of-Doubled-Pairs](Algorithms/954.Array-of-Doubled-Pairs/solution.cpp)
+
+[955.Delete-Columns-to-Make-Sorted-II](Algorithms/955.Delete-Columns-to-Make-Sorted-II/solution.cpp)