LeetCode总结

Easy部分：

1. Two Sum
   自己做第一遍，暴力匹配：

public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> sequence;
        for(size_t i = 0; i < nums.size(); i++) {
            for(size_t j = i + 1; j < nums.size(); j++) {
                if(target == nums[i] + nums[j]) {
                    sequence.push_back(i);
                    sequence.push_back(j);
                    return sequence;
                }
            }
        }
        return {};
    }

学习了哈希表，看了Solution，用Two-pass Hash Table做了一遍，先哈希映射，再比较：

public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash_map;
        for (int i = 0; i < nums.size(); i++) {
            hash_map[nums[i]] = i;
        }
        for (int i = 0; i < nums.size(); i++) {
            int rest = target - nums[i];
            if(hash_map.find(rest) != hash_map.end() && hash_map[rest] != i) {
                return {i, hash_map[rest]};
            }
        }
        return {};
    }

One-pass Hash Table做了一遍，边哈希映射，边比较：

public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hash_map;
        const int size = nums.size();
        for (int i = 0; i < size; i++) {
            if(hash_map.find(target - nums[i]) != hash_map.end()) {
                return vector<int>{i, hash_map[target - nums[i]]};
            }
            hash_map[nums[i]] = i;
        }
        return vector<int>{0};
    }

7. Reverse Integer
   自己做第一遍：

public:
    int reverse(int x) {
        int length = 0;
        int sum = x;
        while (sum) {
            length++;
            sum /= 10;
        }
        int result = 0;
        for (int i = 0; i < length; i++) {
            result += (x % 10) * pow(10, length - i - 1);
            if (result < - INT_MAX || (result > INT_MAX - 1)) {
                return 0;
            }
            x /= 10;
        }
        return result;
    }

用“弹出”和“推入”操作，并且预先检查最后一位数字是否溢出
第二遍：

public:
    int reverse(int x) {
        int rev = 0;
        while (x != 0) {
            int pop = x % 10;
            x /= 10;
            if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && pop > 7)) return 0;
            if (rev < INT_MIN / 10 || (rev == INT_MIN / 10 && pop < -8)) return 0;
            rev = rev * 10 + pop;
        }
        return rev;
    }

9. Palindrome Number
   第一遍自己做，运用7题思路，将输入数反转和原输入数比较：

public:
    bool isPalindrome(int x) {
        if (x < 0) return false;
        else {
            int data = x;
            int rev = 0;
            while (data != 0) {
                int pop = data % 10;
                data /= 10;
                if (rev > INT_MAX / 10 || (rev == INT_MAX / 10 && pop > 7)) return false;
                rev = rev * 10 + pop;
            }
            if (rev == x) return true;
            else return false;
        }
    }

看了Solution，自己修改了参考答案做了第二遍，边比较边反转：

public:
    bool isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        } else {
            int rev = 0;
            while (x >= rev) {
                int pop = x % 10;
                if (rev == x || rev == x / 10) return true;
                rev = rev * 10 + pop;
                x /= 10;
        }
        return false;
        }
    }

第三遍，精简下：

public:
    bool isPalindrome(int x) {
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        } else {
            int rev = 0;
            while (x >= rev) {
                if (rev == x || rev == x / 10) return true;
                rev = rev * 10 +x % 10;
                x /= 10;
            }
            return false;
        }
    }

13. Roman to Integer
    第一遍，穷举法，从前往后添加，超时Time Limit Exceeded：

public:
    int romanToInt(string s) {
        int rev = 0;
        int i = 0;
        while(i != s.size()) {
            if (s[i] == 'I') {
                if (s[i+1] == 'V') { 
                    rev += 4;
                    i += 2;
                } else if (s[i+1] = 'X') {
                    rev += 9;
                    i += 2;
                } else {
                    rev += 1;
                    i++;
                }
            }
            
            if (s[i] == 'V') {
                rev += 5;
                i++;
            }
            
            if (s[i] == 'X') {
                if (s[i+1] == 'L') { 
                    rev += 40;
                    i += 2;
                } else if (s[i+1] = 'C') {
                    rev += 90;
                    i += 2;
                } else {
                    rev += 10;
                    i++;
                }
            }
            
            if (s[i] == 'L') {
                rev += 50;
                i++;
            }
            
            if (s[i] == 'C') {
                if (s[i+1] == 'D') { 
                    rev += 400;
                    i += 2;
                } else if (s[i+1] = 'M') {
                    rev += 900;
                    i += 2;
                } else {
                    rev += 100;
                    i++;
                }
            }
            
            if (s[i] == 'D') {
                rev += 500;
                i++;
            }
            
            if (s[i] == 'M') {
                rev += 1000;
                i++;
            }
        }
        return rev;
    }

第二遍，参考讨论区答案，同样的穷举法，设定prev和next两个指针类变量：

public:
    int romanToInt(string s) {
        int result = 0;
        for (int i = 0; i < s.size(); i++) {
            char current = s.at(i);
            char prev = i == 0 ? '0' : s.at(i - 1);
            char next = i == s.size() - 1 ? '0' : s.at(i + 1);

            if (current == 'M') {
                if (prev == '0' || prev == 'M') {
                    result += 1000;
                } else if (prev == 'C') {
                    result += 900;
                }
            } else if (current == 'D') {
                if (prev == '0' || prev == 'D' || prev == 'M') {
                    result += 500;
                } else if (prev == 'C') {
                    result += 400;
                }
            } else if (current == 'C') {
                if (next == 'M' || next == 'D') {
                    continue;
                } else if (prev == 'X'){
                    result += 90;
                } else {
                    result += 100;
                }
            } else if (current == 'L' ) {
                if (prev == 'X') {
                    result += 40;
                } else {
                    result += 50;
                }
            } else if (current == 'X') {
                if (next == 'L' || next == 'C') {
                    continue;
                } else if (prev == 'I') {
                    result += 9;
                } else {
                    result += 10;
                }
            } else if (current == 'V') {
                if (prev == 'I') {
                    result += 4;
                } else {
                    result += 5;
                }
            } else if (current == 'I') {
                if (next == 'V' || next == 'X') {
                    continue;
                } else {
                    result += 1;
                }
            }
        }
        return result;
    }

第三遍，同样参考讨论区，采用哈希map，代码很精简：

public:
    int romanToInt(string s) {
        unordered_map<char, int> romans = {
            {'I', 1},
            {'V', 5},
            {'X', 10},
            {'L', 50},
            {'C', 100},
            {'D', 500},
            {'M', 1000}
        };
        int ans = romans[s[s.size() - 1]];
        int i = s.size() - 2;
        int pre = ans;
        int cur = 0;
        while (i >= 0) {
            cur = romans[s[i]];
            ans += cur < pre ? -cur : cur;
            pre = cur;
            --i;
        }
        return ans;
    }