LeetCode: 继续easy题11

Find Mode in Binary Search Tree

"""
二叉树的递归，迭代中序遍历。
Morris 遍历： https://www.zhihu.com/question/21556707
"""

Base 7

"""
"""
class Solution {
public:
    string convertToBase7(int num) {
        bool minus = (num<0);
        if(minus)
            num = -num;
        int t = 1;
        int sum = 0;
        while(num){
            sum += (num%7*t);
            t *= 10;
            num /= 7;
        }

        string res=to_string(sum); 
        if (minus)
            res = '-'+res;
        return res;
    }
};

"""
更短的递归写法
"""
class Solution {
public:
    string convertToBase7(int num) {
        if (num < 0) return "-" + convertToBase7(-num);
        if (num < 7) return to_string(num);
        return convertToBase7(num / 7) + to_string(num % 7);
    }
};

Relative Ranks

"""几个stl容器的用法
"""

Perfect Number

class Solution {
public:
    bool checkPerfectNumber(int num) {
        if(num==1)
            return false;

        int temp = num-1;
        for(int i=2;i<=sqrt(num);i++){
            if(num%i==0){
                temp -= i;
                if(num/i!=i)
                    temp -= num/i;
            }
            if(temp<0)
                break;
        }
        return temp==0;
    }
};

Detect Capital

class Solution {
public:
    bool isUpper(char c){
        return c>='A' && c<='Z';
    }
    bool detectCapitalUse(string word) {
        bool second = isUpper(word[1]);
        for(int i=2;i<word.size();i++){
            if(isUpper(word[i])!=second)
                return false;
        }

        if(second)
            if(!isUpper(word[0]))
                return false;

        return true;
    }
};

Longest Uncommon Subsequence I

class Solution {
public:
    int findLUSlength(string a, string b) {
        return a==b?-1:max(a.size(),b.size());
    }
};

Minimum Absolute Difference in BST

"""老朋友中序遍历，简单。
先序遍历也可以：http://www.cnblogs.com/grandyang/p/6540165.html
"""
class Solution {
public:
    void cal(TreeNode* node, long & res, long & pre){
        if(!node)
            return;

        cal(node->left, res, pre);

        res = min(res, node->val - pre);
        pre = node->val;

        cal(node->right, res, pre);

    }
    int getMinimumDifference(TreeNode* root) {
        long res = INT_MAX;
        long pre = -INT_MAX;
        cal(root, res, pre);
        return res;
    }
};

K-diff Pairs in an Array

class Solution {
public:
    int findPairs(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        int res = 0;
        for(int n:nums)
            map[n]++;
        for(auto m:map){
            if(k==0 && m.second>1) res++;
            if(k>0 && map.count(m.first+k)) res++;
        }
        return res;
    }
};

Convert BST to Greater Tree

class Solution {
public:
    void cal(TreeNode* node, int & pre){
        if(!node)
            return;
        cal(node->right, pre);
        node->val += pre;
        pre = node->val;
        cal(node->left, pre);
    }

    TreeNode* convertBST(TreeNode* root) {
        int  t = 0;
        cal(root, t);
        return root;
    }
};

Reverse String II

class Solution {
public:
    /*
    void helper(string & s, int start, int end){
        char temp;
        for(int i=0; i<(end-start)/2; i++){
            temp = s[i];
            s[i] = s[end-i];
            s[end-i] = temp;
        }
    }*/
    string reverseStr(string s, int k) {
        char temp;
        int start = 0;
        int end = k-1;
        while(start<s.size()){
            //helper(s, start, end);
            end = min((int)s.size()-1,end);
            reverse(s.begin()+start, s.begin()+end+1);
            start += 2*k;
            end = start + k-1;
        }
        return s;
    }
};

Diameter of Binary Tree

class Solution {
public:
    int helper(TreeNode* node, int & n){
        if(!node)
            return 0;
        int left = helper(node->left, n);
        int right = helper(node->right, n);
        n = max(left+right, n);
        return 1 + max(left, right);
    }
    int diameterOfBinaryTree(TreeNode* root) {
        int n = 0;
        int temp = helper(root, n);
        return n;
    }

};

Student Attendance Record I

"""
简单，其他思路很有意思：http://www.cnblogs.com/grandyang/p/6736484.html
"""
class Solution {
public:
    bool checkRecord(string s) {
        int nA = 0;
        for(int i=0;i<s.size();i++){
            if(s[i]=='A'){
                nA ++;
                if(nA>=2)
                    return false;
            }
            if(i<s.size()-2)
                if(s[i]=='L' && s[i+1]=='L' && s[i+2]=='L')
                    return false;
        }
        return true;
    }
};

Reverse Words in a String III

class Solution {
public:
    string reverseWords(string s) {
        int i = 0;
        while(i<s.size()){
            while(s[i]==' ')
                i++;
            int j = i+1;
            while(s[j]!=' ' && j<s.size())
                j++;
            reverse(s.begin()+i,s.begin()+j);
            i = j+1;
        }

        return s;
    }
};

Array Partition I

class Solution {
public:
    int arrayPairSum(vector<int>& nums) {
        int res = 0;
        sort(nums.begin(), nums.end());
        for(int i=nums.size()-2;i>=0;i-=2)
            res += nums[i];
        return res;
    }
};

Binary Tree Tilt

class Solution {
public:
    int helper(TreeNode* node, int & n){
        if(!node)
            return 0;
        int left = helper(node->left, n);
        int right = helper(node->right, n);
         n += abs(left-right);
        return left+right+node->val;
    }
    int findTilt(TreeNode* root) {
        int n = 0;
        int tmp = helper(root, n);
        return n;
    }
};

Reshape the Matrix

class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        int row = nums.size();
        int col = nums[0].size();
        if(row*col != r*c)
            return nums;

        vector<vector<int>> res(r);
        for(int i=0;i<r;i++)
            for(int j=0;j<c;j++){
                res[i].push_back(nums[(c*i+j)/col][(c*i+j)%col]);
            }
        return res;
    }
};