leetcode 350 easy

350. Intersection of Two Arrays II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> dict;
        vector<int> res;
        for(int i = ; i < (int)nums1.size(); i++) dict[nums1[i]]++;
        for(int i = ; i < (int)nums2.size(); i++)
            if(dict.find(nums2[i]) != dict.end() && --dict[nums2[i]] >= ) res.push_back(nums2[i]);
        return res;
    }
};

345. Reverse Vowels of a String

class Solution {
public:
    string reverseVowels(string s) {
        int i = , j = s.size() - ;
        while (i < j) {
            i = s.find_first_of("aeiouAEIOU", i);
            j = s.find_last_of("aeiouAEIOU", j);
            if (i < j) {
                swap(s[i++], s[j--]);
            }
        }
        return s;
    }
};

387. First Unique Character in a String

Brute force solution, traverse string s  times. First time, store counts of every character into the hash table, second time, find the first character that appears only once.
//遍历两次string
class Solution {
public:
    int firstUniqChar(string s) {
        unordered_map<char, int> m;
        for (auto &c : s) {
            m[c]++;
        }
        for (int i = ; i < s.size(); i++) {
            if (m[s[i]] == ) return i;
        }
        return -;
    }
};
if the string is extremely long, we wouldn't want to traverse it twice, so instead only storing just counts of a char, we also store the index, and then traverse the hash table.
//遍历一次string和一次map
class Solution {
public:
    int firstUniqChar(string s) {
        unordered_map<char, pair<int, int>> m;
        int idx = s.size();
        for (int i = ; i < s.size(); i++) {
            m[s[i]].first++;
            m[s[i]].second = i;
        }
        for (auto &p : m) {
            if (p.second.first == ) idx = min(idx, p.second.second);
        }
        return idx == s.size() ? - : idx;
    }
};

409. Longest Palindrome

Python:

def longestPalindrome(self, s):
    odds = sum(v &  for v in collections.Counter(s).values())
    return len(s) - odds + bool(odds)
C++:

int longestPalindrome(string s) {
    int odds = ;
    for (char c='A'; c<='z'; c++)
        odds += count(s.begin(), s.end(), c) & ; //如果是奇数则加1，偶数不加
    return s.size() - odds + (odds > );
}

412. Fizz Buzz

class Solution {
public:
    vector<string> fizzBuzz(int n) {
        vector<string> ret_vec(n);
        for(int i=; i<=n; ++i)
        {
            if( == i%)
            {
                ret_vec[i-] += "Fizz";
            }
            if( == i%)
            {
                ret_vec[i-] += "Buzz";
            }
            if(ret_vec[i-].empty())
            {
                ret_vec[i-] += to_string(i);
            }
        }
        return ret_vec;
    }
};

414. Third Maximum Number

class Solution {
public:
    int thirdMax(vector<int>& nums) {
    set<int> top3;
    for (int num : nums) {
        top3.insert(num);
        if (top3.size() > )
            top3.erase(top3.begin());
    }
    return top3.size() ==  ? *top3.begin() : *top3.rbegin();
}
};

415. Add Strings

class Solution {
public:
string addStrings(string num1, string num2) {
    int i = num1.size() - ;
    int j = num2.size() - ;
    int carry = ;
    string res = "";
    while(i>= || j>= || carry){
        long sum = ;
        if(i >= ){sum += (num1[i] - '');i--;}
        if(j >= ){sum += (num2[j] - '');j--;}
        sum += carry;
        carry = sum / ;
        sum = sum % ;
        res =  res + to_string(sum);
    }
    reverse(res.begin(), res.end());
    return res;
}
};

437. Path Sum III

class Solution {
public:
    int pathSum(TreeNode* root, int sum) {
        if(!root) return ;
        return dfs(root,,sum)+pathSum(root->left,sum)+pathSum(root->right,sum);
    }
    int dfs(TreeNode* root,int pre,int sum)
    {
       if(!root) return ;
       int cur=pre+root->val;
       return (cur==sum)+dfs(root->left,cur,sum)+dfs(root->right,cur,sum);
    }
};

438. Find All Anagrams in a String

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        vector<int> pv(,), sv(,), res;
        if(s.size() < p.size())
           return res;
        for(int i = ; i < p.size(); ++i)
        {
            ++pv[p[i]];
            ++sv[s[i]];
        }
        if(pv == sv)
           res.push_back();
        for(int i = p.size(); i < s.size(); ++i)
        {
            ++sv[s[i]];
            --sv[s[i-p.size()]];
            if(pv == sv)
               res.push_back(i-p.size()+);
        }
        return res;
    }
};