LeetCode: 继续easy题9

Escape The Ghosts

"""
"""
class Solution {
public:
    int distance(vector<int>& s1, vector<int>& s2){
        return abs(s1[0]-s2[0])+abs(s1[1]-s2[1]);
    }
    bool escapeGhosts(vector<vector<int>>& ghosts, vector<int>& target) {
        vector<int> s(2);
        int d = distance(s, target);
        for(vector<int> a:ghosts){
            if(distance(target, a)<=d)
                return false;
        }
        return true;
    }
};

Path Sum III

"""O(n)解法有难度，O(n^2)好想
http://www.cnblogs.com/grandyang/p/6007336.html
"""
class Solution {
public:
    int cal(TreeNode* node, int sum, unordered_map<int,int>& m, int cur){
        if(!node)
            return 0;
        cur += node->val;
        int res = m[cur-sum];//m[sum-node->val];
        m[cur] ++;
        res += cal(node->left, sum, m, cur) + cal(node->right, sum, m, cur);
        m[cur] --;
        return res;
    }
    int pathSum(TreeNode* root, int sum) {
        unordered_map<int,int> m;
        m[0] = 1;
        return cal(root, sum, m, 0);
    }
};

Find All Anagrams in a String

"""用两个hash table，简单，类似计算conv，可以利用邻接关系减少计算量。
"""
class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> res;
        if(s.size()<p.size())
            return res;
        unordered_map<char,int> mp;
        unordered_map<char,int> ms;
        for(char c:p)
            mp[c] ++;

        bool ok = true;
        for(int j=0;j<p.size()-1;j++){
                ms[s[j]] ++;
            }
        for(int i=0;i<=s.size()-p.size();i++){
            if(i)
                ms[s[i-1]]--;
            ms[s[i+p.size()-1]] ++;

            for(auto m:mp)
                if(m.second!=ms[m.first])
                    ok = false;
            if(ok)
                res.push_back(i);
            ok = true;
        }

        return res;
    }
};

Arranging Coins

class Solution {
public:
    int arrangeCoins(int n) {
        long num = 1;
        while(1){
            if(num*(num+1)/2>n)
                return num-1;
            num ++;
        }
    }
};

String Compression

"""处理边界
"""
class Solution {
public:
    int compress(vector<char>& chars) {
        char temp = chars[0];
        int num = 0;
        int start = 0; 
        for(int j=0;j<=chars.size();j++){
            char c;
            if (j==chars.size())
                c = '1';
            else
                c = chars[j];
            if(c==temp){
                num ++;
            }
            if(c!=temp){
                chars[start] = temp;
                if(num==1){
                    start ++;
                    temp = c;
                    num = 1;    
                }
                else{
                    string nums = to_string(num);
                    for(int i=0;i<nums.size();i++)
                        chars[start+1+i] = nums[i];
                    start += nums.size()+1;
                    temp = c;
                    num = 1;
                }
            }
        }

        return start;
    }
};

Number of Boomerangs

class Solution {
public:
    int d(pair<int,int>& x, pair<int,int>& y){
        return pow(x.first-y.first,2)+pow(x.second-y.second,2);
    }

    int numberOfBoomerangs(vector<pair<int, int>>& points) {
        int re = 0;

        for(int i=0;i<points.size();i++){
            unordered_map<int, int> map;
            for(int j=0;j<points.size();j++){
                if(j!=i)
                    map[d(points[i],points[j])] ++;
            }

            for(auto m: map)
                re += m.second*(m.second-1);
        }

        return re;
    }
};

Find All Numbers Disappeared in an Array

"""不容易
"""
class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        vector<int> re;
        int tmp;
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=nums[nums[i]-1]){
                //tmp = nums[nums[i]-1];
                //nums[nums[i]-1] = nums[i];
                //nums[i] = tmp;
                swap(nums[i], nums[nums[i] - 1]);
                i --;
            }
        }
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=i+1)
                re.push_back(i+1);
        }
        return re;
    }
};

Minimum Moves to Equal Array Elements

"""很巧妙
"""
class Solution {
public:
    int minMoves(vector<int>& nums) {
        int m=INT_MAX, res=0;
        for(int i:nums) m=min(m,i);
        for(int i:nums) res+=(i-m);
        return res;
    }
};