添加496, 498, 503等题

Author: moranzcw

Algorithms/300.Longest-Increasing-Subsequence/solution.cpp

@@ -15,4 +15,4 @@ class Solution {
         }
         return maxlen;
     }
-};
+};

Algorithms/496.Next-Greater-Element-I/solution.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+    vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
+        map<int, int> max;
+        for(int i=0;i<nums.size();i++){
+            for(int j=i+1;j<nums.size();j++){
+                if(nums[j] > nums[i]){
+                    max[nums[i]] = nums[j];
+                    break;
+                }
+            }
+        }
+        
+        vector<int> result(findNums.size(),0);
+        for(int i=0;i<findNums.size();i++){
+            if(max.find(findNums[i]) == max.end()){
+                result[i] = -1;
+            }else
+                result[i] = max[findNums[i]];
+        }
+        return result;
+    }
+};

Algorithms/498.Diagonal-Traverse/solution.cpp

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
+        int row = matrix.size();
+        int col = row>0?matrix[0].size():0;
+        vector<int> result(row*col,0);
+        int cur = 0;
+        bool right = false;
+        int i,j,minn,start;
+        for(int sum = 0;sum<row + col - 1;sum++){
+            if(right){
+                minn = min(row,sum+1);
+                start = max(sum-col+1,0);
+                for(i=start;i<minn;i++){
+                    result[cur] = matrix[i][sum-i];
+                    cur++;
+                }
+            }else{
+                minn = min(col,sum+1);
+                start = max(sum-row+1,0);
+                for(j=start;j<minn;j++){
+                    result[cur] = matrix[sum-j][j];
+                    cur++;
+                }
+            }
+            right = !right;
+        }
+        return result;
+    }
+};

Algorithms/503.Next-Greater-Element-II/solution.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    vector<int> nextGreaterElements(vector<int>& nums) {
+        vector<int> max;
+        for(int i=0;i<nums.size();i++){
+            int find = false;
+            for(int j=(i+1)%nums.size();j!=i;j=(j+1)%nums.size()){
+                if(nums[j] > nums[i]){
+                    max.push_back(nums[j]);
+                    find = true;
+                    break;
+                }
+            }
+            if(!find)
+                max.push_back( -1);
+        }
+        return max;
+    }
+};

Algorithms/506.Relative-Ranks/solution.cpp

@@ -0,0 +1,26 @@
+bool cmp(pair<int,int> i, pair<int,int> j){
+    return j.first < i.first;
+}
+
+class Solution {
+public:
+    vector<string> findRelativeRanks(vector<int>& nums) {
+        vector<pair<int, int> > mapp;
+        for(int i=0;i<nums.size();i++){
+            mapp.push_back(pair<int,int>(nums[i],i));
+        }
+        sort(mapp.begin(), mapp.end(), cmp);
+        
+        vector<string> str(nums.size());
+        for(int i=0;i<mapp.size();i++){
+            str[mapp[i].second] = to_string(i + 1);
+        }
+        if(mapp.size() > 0)
+            str[mapp[0].second] = "Gold Medal";
+        if(mapp.size() > 1)
+            str[mapp[1].second] = "Silver Medal";
+        if(mapp.size() > 2)
+            str[mapp[2].second] = "Bronze Medal";
+        return str;
+    }
+};

Algorithms/674.Longest-Continuous-Increasing-Subsequence/solution.cpp

@@ -5,19 +5,21 @@ class Solution {
             return 0;
 
         int max = 1;
-        int temp = 1;
-        int last = nums[0];
-        for(int i=1;i<nums.size();i++){
-            if(nums[i] > last){
-                temp += 1;
-                if(temp > max)
-                    max = temp;
-            }
-            else{
-                temp = 1;
+        
+        for(int i=0;i<nums.size();i++){
+            // cout << "i=" << i << ':' << endl;
+            int temp = 1;
+            for(int j=i;j+1<nums.size();j++){
+                // cout << "  j=" << j << ':' << nums[j] << "," << nums[j+1] << endl;
+                if(nums[j+1] > nums[j])
+                    temp += 1;
+                else
+                    break;
             }
-            last = nums[i];
+            if(temp > max)
+                max = temp;
         }
         return max;
     }
-};
+};
+

Algorithms/680.Valid-Palindrome-II/solution.cpp

@@ -34,4 +34,4 @@ class Solution {
         }
         return result;
     }
-};
+};

Algorithms/762.Prime-Number-of-Set-Bits-in-Binary-Representation/solution.cpp

@@ -0,0 +1,20 @@
+class Solution {
+public:
+    int countPrimeSetBits(int L, int R) {
+        int arr[11] = {2,3,5,7,11,13,17,19,23,29,31};
+        set<int> primeSet(arr,arr+11);
+        int prime = 0;
+        for(int i=L;i<=R;i++){
+            int temp=0;
+            int num = i;
+            while(num>0){
+                if(num & 1)
+                    temp += 1;
+                num  = num >> 1;
+            }
+            if(primeSet.find(temp) != primeSet.end())
+                prime += 1;
+        }
+        return prime;
+    }
+};

Algorithms/824.Goat-Latin/solution.cpp

@@ -0,0 +1,43 @@
+class Solution {
+public:
+    string toGoatLatin(string S) {
+        string result;
+        int i = 0;
+        int count = 0;
+        bool vowel = false;
+        string word;
+        while(i<S.size()){
+            if(S[i]==' '){
+                i++;
+                continue;
+            }else if(S[i]=='a'||S[i]=='A'||S[i]=='e'||S[i]=='E'||S[i]=='i'
+                     ||S[i]=='I'||S[i]=='o'||S[i]=='O'||S[i]=='u'||S[i]=='U'){
+                int j=0;
+                for(;i+j<S.size();j++)
+                    if(S[i+j] == ' ')
+                        break;
+                word = S.substr(i, j);
+                result.append(word);
+                result.append("ma");
+                result.append(count+1, 'a');
+                result.append(1, ' ');
+                count += 1;
+                i += j;
+            }else{
+                int j=0;
+                for(;i+j<S.size();j++)
+                    if(S[i+j] == ' ')
+                        break;
+                word = S.substr(i+1, j-1);
+                result.append(word);
+                result.append(1,S[i]);
+                result.append("ma");
+                result.append(count+1, 'a');
+                result.append(1, ' ');
+                count += 1;
+                i += j;
+            }
+        }
+        return result.substr(0,result.size()-1);
+    }
+};

Algorithms/825.Friends-Of-Appropriate-Ages/solution.cpp

@@ -0,0 +1,25 @@
+class Solution {
+public:
+    int numFriendRequests(vector<int>& ages) {
+        sort(ages.begin(),ages.end());
+        int count = 0;
+        int edge;
+        for(int i=0;i<ages.size();i++){
+            int j;
+            edge = ages[i] * 0.5 + 7;
+            for(j=i-1;j>=0;j--)
+                if(ages[j] > edge)
+                    count ++;
+                else
+                    break;
+            
+            for(j=i+1;j<ages.size();j++)
+                if(ages[j] == ages[i] && ages[j] > edge)
+                    count ++;
+                else
+                    break;
+        }
+        
+        return count;
+    }
+};

Algorithms/826.Most-Profit-Assigning-Work/solution.cpp

@@ -0,0 +1,36 @@
+bool cmp(pair<int,int> i, pair<int,int> j){
+    return i.first < j.first;
+}
+
+class Solution {
+public:
+    int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {
+        vector<pair<int,int> > prolist(difficulty.size());
+        for(int i=0;i<difficulty.size();i++){
+            prolist[i].first = difficulty[i];
+            prolist[i].second = profit[i];
+        }
+        
+        sort(prolist.begin(),prolist.end(),cmp);
+        
+        // vector<int> pro(profit.size());
+        int maxpro = 0;
+        for(int i=0;i<profit.size();i++){
+            maxpro = max(maxpro,prolist[i].second);
+            prolist[i].second = maxpro;
+        }
+        int result = 0;
+        int temppro = 0;
+        for(int i=0;i<worker.size();i++){
+            temppro = 0;
+            for(int j=0;j<difficulty.size();j++){
+                if(worker[i] >= prolist[j].first)
+                    temppro = prolist[j].second;
+                else
+                    break;
+            }
+            result += temppro;
+        }
+        return result;
+    }
+};

Algorithms/897.Increasing-Order-Search-Tree/solution.cpp

@@ -0,0 +1,30 @@
+/**
+ * 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:
+    TreeNode *nt;
+    TreeNode *cur;
+    TreeNode* increasingBST(TreeNode* root) {
+        nt = new TreeNode(0);
+        cur = nt;
+        midOrder(root);
+        return nt->right;
+    }
+    
+    int midOrder(TreeNode* node){
+        if(node == NULL)
+            return 0;
+        midOrder(node->left);
+        cur->right = new TreeNode(node->val);
+        cur = cur->right;
+        midOrder(node->right);
+        return 0;
+    }
+};

Algorithms/925.Long-Pressed-Name/solution.cpp

@@ -0,0 +1,31 @@
+class Solution {
+public:
+    bool isLongPressedName(string name, string typed) {
+        vector<pair<char, int> > na, ty;
+        char last='0';
+        for(int i=0;i<name.size();i++){
+            if(name[i] == last)
+                na[na.size()-1].second += 1;
+            else
+                na.push_back(pair<char, int>(name[i], 1));
+            last = name[i];
+        }
+        
+        last='0';
+        for(int i=0;i<typed.size();i++){
+            if(typed[i] == last)
+                ty[ty.size()-1].second += 1;
+            else
+                ty.push_back(pair<char, int>(typed[i], 1));
+            last = typed[i];
+        }
+        
+        if(na.size() != ty.size())
+            return false;
+        for(int i=0;i<na.size();i++){
+            if( (na[i].first != ty[i].first) || (na[i].second > ty[i].second))
+                return false;
+        }
+        return true;
+    }
+};

Algorithms/926.Flip-String-to-Monotone-Increasing/solution.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    int minFlipsMonoIncr(string S) {      
+        vector<pair<int, int> > group;
+        int t;
+        int last = S[0]=='1'?1:0;
+        group.push_back(pair<int,int>(last, 1));
+        for(int i=1;i<S.size();i++){
+            t = S[i]=='1'?1:0;
+            if(t == last)
+                group[group.size()-1].second += 1;
+            else
+                group.push_back(pair<int,int>(t, 1));
+            last = t;
+        }
+
+        
+        vector<int> leftOne(group.size(),0), rightZero(group.size(),0);
+        
+        for(int i=1;i<group.size();i++){
+            leftOne[i] = group[i-1].first==1?group[i-1].second:0;
+            leftOne[i] += leftOne[i-1];
+        }
+        for(int i=group.size()-2;i>=0;i--){
+            rightZero[i] = group[i+1].first==0?group[i+1].second:0;
+            rightZero[i] += rightZero[i+1];
+        }
+
+        
+        int min = S.size();
+        for(int i=0;i<group.size();i++)
+            if(leftOne[i] + rightZero[i] < min)
+                min = leftOne[i] + rightZero[i];
+        
+        return min;
+    }
+};