从零开始的刷LeetCode生活 第0期 1-10

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

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carried = 0;  
        ListNode dummy(-1);
        ListNode* p = &dummy;
        while(l1 || l2)
        {
            int sum = carried;
            auto a = l1 ? l1->val : 0;
            auto b = l2 ? l2->val : 0;
            sum = a + b + sum;
            carried = sum / 10;
            sum = sum % 10;
            ListNode* newNode = new ListNode(sum);
            p->next = newNode;
            p = p->next;
            if(l1)
                l1 = l1->next;
            if(l2)    
                l2 = l2->next;
        }   
        if(carried)//最终的进位
        {
            ListNode* newNode = new ListNode(1);
            p->next = newNode;
        }
        return dummy.next;
    }
};

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int>hash;
        int res = 0;
        for(int i = 0, j = 0; j < s.size(); j ++)
        {
            if(++ hash[s[j]] > 1)//下一个字符串 如果有次数大于1的字母 则滑动左边窗口
            {
                while(i < j)
                {
                    hash[s[i]] --;
                    i ++;
                    if(hash[s[j]] == 1) break;
                }
            }
            res = max(res, j - i + 1);
        }
        return res;
    }
};

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size() + nums2.size();
        if(n % 2 == 0) //偶数
        {
            int left = findKthNumber(nums1, 0, nums2, 0, n / 2);
            int right = findKthNumber(nums1, 0, nums2, 0, n / 2 + 1);
            return (left + right) / 2.0;
        }
        else //奇数
        {
            return findKthNumber(nums1, 0, nums2, 0, n / 2 + 1);
        }        
    }

    //寻找第k小的数
        int findKthNumber(vector<int>&nums1, int i, vector<int>&nums2, int j, int k)
        {
            if(nums1.size() - i > nums2.size() - j) return findKthNumber(nums2, j, nums1, i, k);
            //第一组已经选完
            if(nums1.size() == i) return nums2[j + k - 1];
            if(k == 1) return min(nums1[i], nums2[j]);
            int si = min(i + k / 2, (int)nums1.size()), sj = j + k / 2;
            if(nums1[si - 1] > nums2[sj - 1])
                return findKthNumber(nums1, i, nums2, sj, k - k / 2);
            else
                return findKthNumber(nums1, si, nums2, j, k - (si - i));     
        }
};

class Solution {
public:
    string longestPalindrome(string s) {
        int len = 0;
        string res;
        //枚举中心点
        for(int k = 0; k < s.size(); k ++)
        {
            //回文串是偶数
            int i = k, j = k + 1;
            while(i >= 0 && j < s.size() && s[i] == s[j]) i --, j ++;
            if(j - i - 1 > len)
            {
                len = j - i - 1;
                res = s.substr(i + 1, len);
            }
            //回文串是奇数
            i = k - 1, j = k + 1;
            while(i >= 0 && j < s.size() && s[i] == s[j]) i --, j ++;
            if(j - i - 1 > len)
            {
                len = j - i - 1;
                res = s.substr(i + 1, len);
            }
        }
        return res;
    }
};

class Solution {
public:
    string convert(string s, int numRows) {
        if(numRows == 1) return s;

        vector<string>rows(min(numRows, (int)s.size()));
        int curRow = 0;
        bool down = false;

        for(auto c : s)
        {
            rows[curRow] += c;
            if(curRow == 0 || curRow == numRows - 1) down = !down;
            curRow += down ? 1 : -1;
        }
        string res;
        for(auto c : rows) res += c;
        return res;
    }
};

class Solution {
public:
    int reverse(int x) {
        int res = 0;
        int pop = 0;
        while(x)
        {
            pop = (x % 10);
            x /= 10;
            if(res > INT_MAX / 10) return 0;
            if(res < INT_MIN / 10) return 0;
            res = res * 10 + pop;
        }
        return res;
    }
};

class Solution {
public:
    int myAtoi(string str) {
        int i = 0; //位置
        long long res = 0; 
        int is = 1;//正负号
        while(i < str.size() && str[i] == ' ') i ++;
        if(str[i] == '-') is = -1, i ++;
        else if(str[i] == '+') is = 1, i ++;
        while(i < str.size() && str[i] >= '0' && str[i] <= '9')
        {
            res = res * 10 + str[i++] - '0';
            if(res >= 2147483648)
            {
                if(is == 1) return INT_MAX; //-1也是真，不能if(is)判断
                else return INT_MIN;
            }
        }  
        return res * is;
    }
};

class Solution {
public:
    bool isPalindrome(int x) {
        int xx = x;
        int palindrome = 0;
        if(x < 0 || (x % 10 == 0 && x != 0))
            return false;
        while(x)
        {
            palindrome = palindrome * 10ll + x % 10;
            x /= 10;    
        }
        return palindrome == xx;
    }
};

class Solution {
public:
    vector<vector<int>> f;
    int n, m;
    bool isMatch(string s, string p) {
        n = s.size();
        m = p.size();
        f = vector<vector<int>>(n + 1, vector<int>(m + 1, -1)); //初始化
        return dp(0, 0, s, p);
    }

    bool dp(int x, int y, string &s, string &p)
    {
        if(f[x][y] != -1) return f[x][y];
        if(y == m)
            return f[x][y] = x == n;
        bool first_match = x < n && (s[x] == p[y] || p[y] == '.');
        bool ans;
        if(y + 1 < m && p[y + 1] == '*')
            ans = dp(x, y + 2, s, p) || first_match && dp(x + 1, y, s, p);
        else
            ans = first_match && dp(x + 1, y + 1, s, p);
        return f[x][y] = ans;          
    }
};