从零开始的刷LeetCode生活 第12期 121-130

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int res = 0, pre_min = INT_MAX;
        for(auto x : prices)
        {
            res = max(res, x - pre_min);
            pre_min = min(pre_min, x);
        }
        return res;
    }
};

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int res = 0;
        for(int i = 1; i < prices.size(); i ++)
            if(prices[i] > prices[i - 1])
                res += prices[i] - prices[i - 1];
        return res;
    }
};

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;        
        int s1 = -prices[0], s2 = INT_MIN, s3 = INT_MIN, s4 = INT_MIN;
        for(int i = 1; i < prices.size(); i ++)
        {
            s1 = max(s1, -prices[i]);//第一次买入
            s2 = max(s2, s1 + prices[i]);// 第一次卖出
            s3 = max(s3, s2 - prices[i]); //第二次买入
            s4 = max(s4, s3 + prices[i]); // 第二次卖出
        }
         return max(0, s4);
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res = INT_MIN;
    int maxPathSum(TreeNode* root) {
        dfs(root);
        return res;
    }

    int dfs(TreeNode* u)
    {
        if(!u) return 0;
        int l = max(0, dfs(u->left));
        int r = max(0, dfs(u->right));
        res = max(res, l + r + u->val);
        return u->val + max(l, r);
    }
};

class Solution {
public:
    bool check(char c) //判断是不是数字或字母
    {
        return c >= '0' && c <= '9' || c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z';
    }

    bool isPalindrome(string s) {
        for(int i = 0, j = s.size() - 1; i < j; i ++, j --)
        {
            while(i < j && !check(s[i])) i ++;
            while(i < j && !check(s[j])) j --;
            //在ascii码里，大小写字母之间的差是32，比如 ‘a’ - ‘A’ = 32。
            if(s[i] != s[j] && s[i] != (s[j] ^ 32)) return false;
        }
        return true;
    }
};

…

class Solution {
public:
    int ladderLength(string beginWord, string endWord, vector<string>& wordList) {
        unordered_set<string> dict(wordList.begin(), wordList.end());
        if(!dict.count(endWord)) return 0;

        queue<string> que;
        que.push(beginWord);
        int step = 0;
        while(!que.empty())
        {
            step ++;
            for(int size = que.size(); size; size --)
            {
                string w = que.front();
                que.pop();
                for(int i = 0; i < beginWord.size(); i ++)
                {
                    char c = w[i];
                    for(int j = 'a'; j <= 'z'; j ++)
                    {
                        w[i] = j;
                        if(w == endWord) return step + 1;
                        if(!dict.count(w)) continue;
                        dict.erase(w);
                        que.push(w);
                    }
                    w[i] = c;
                }
            }
        }        
        return 0;
    }
};

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int res = 0;
        unordered_map<int, int>tr_left, tr_right;
        for(auto &x : nums)
        {
            int left = tr_right[x - 1];
            int right = tr_left[x + 1];
            tr_left[x - left] = max(tr_left[x - left], left + 1 + right);
            tr_right[x + right] = max(tr_right[x + right], left + 1 + right);
            res = max(res, left + 1 + right);
        }
        return res;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int res = 0;
    int sumNumbers(TreeNode* root) {
        dfs(root, 0);
        return res;
    }

    void dfs(TreeNode* u, int s)
    {
        if(!u) return;
        s = s * 10 + u->val;
        if(u->left) dfs(u->left, s);
        if(u->right) dfs(u->right, s);
        if(!u->left && !u->right) res += s;
    } 
};

class Solution {
public:
    int n, m;
    vector<vector<bool>> st;
    void solve(vector<vector<char>>& board) {
        if(board.empty() || board[0].empty()) return;
        n = board.size(), m = board[0].size();      

        st = vector<vector<bool>>(n, vector<bool>(m, false));

        for(int i = 0; i < n; i ++) //左右
        {
            if(board[i][0] == 'O') dfs(board, i, 0);
            if(board[i][m - 1] == 'O') dfs(board, i, m - 1);
        }

        for(int i = 0; i < m; i ++) //上下
        {
            if(board[0][i] == 'O') dfs(board, 0, i);
            if(board[n - 1][i] == 'O') dfs(board, n - 1, i);
        }

        for(int i = 0; i < n; i ++)
            for(int j = 0; j < m; j ++)
                if(!st[i][j])
                    board[i][j] = 'X';
    }

    void dfs(vector<vector<char>>&board, int x, int y)
    {
        st[x][y] = true;
        int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(a >= 0 && a < n && b >= 0 && b < m && !st[a][b] && board[a][b] == 'O')
                dfs(board, a, b);
        }
    }
};