leetcode-第六周

33. Search in Rotated Sorted Array

/**
 * 思路：二分查找，闭区间
 * 三种case：
 * 1. A[l] <= A[r]
 * 2. A[l] > A[r] && A[l] < A[mid]
 * 3. A[l] > A[r] && A[mid] < A[r]
 */
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (target == nums[mid]) return mid;
            if (nums[l] <= nums[r]) {
                if (nums[mid] < target) l = mid + 1;
                else r = mid - 1;
            } else {
                if (nums[mid] < nums[r]) {
                    if (nums[mid] < target && target <= nums[r]) l = mid + 1;
                    if (target < nums[mid]) r = mid - 1;
                    if (nums[r] < target) r = mid - 1;
                } else {
                    if (nums[l] <= target && target < nums[mid]) r = mid - 1;
                    if (target < nums[l]) l = mid + 1;
                    if (nums[mid] < target) l = mid + 1;
                }
            }
        }
        return -1;
    }
};

28. Implementing strStr()

/*
 * Time: O(n + m)
 * Space: O(m)
 * 思路：KMP算法，维护next数组，遇到不匹配时更加next数组进行跳转
 */
class Solution {
private:
    void getNext(string s, vector<int> &next) {
        for (int i = 0, j = -1; i < s.size(); ) {
            if (-1 == j || s[i] == s[j]) {
                i++, j++;
                next[i] = j;
            } else j = next[j];
        }
    }
public:
    int strStr(string haystack, string needle) {
        if (needle == "") return 0;
        int n = haystack.size(), m = needle.size();
        vector<int> next(m + 1, -1);
        getNext(needle, next);
        for (int i = 0, j = 0; i < n && j < m; ) {
            if (j == -1 || haystack[i] == needle[j]) {
                i++, j++;
                if (j == m) return i - m;
            } else j = next[j];
        }
        return -1;
    }
};

79. Word Search

/*
 * Time: O(n * m * k)
 * Space: O(n * m)
 * 思路：深搜+枝剪，要注意走过的路径不能重走
 */
typedef vector<int> VI;
typedef vector<VI> VVI;
class Solution {
private:
    bool dfs(int x, int y, vector<vector<char>>& board, VVI &vis, string &word, int k) {
        if (k == word.size()) return true;
        if (board[x][y] != word[k]) return false;
        if (k + 1 == word.size()) return true;
        const int dx[4] = {-1, 1, 0, 0};
        const int dy[4] = { 0, 0, 1,-1};
        bool ret = false;
        vis[x][y] = 1;
        for (int i = 0; i < 4 && !ret; i++) { //枝剪
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || nx >= board.size() || ny < 0 || ny >= board[0].size()) continue;
            if (vis[nx][ny]) continue;
            ret |= dfs(nx, ny, board, vis, word, k + 1);
        }
        vis[x][y] = 0;
        return ret;
    }
public:
    bool exist(vector<vector<char>>& board, string word) {
        if (word == "") return true;
        if (board.empty() || board[0].empty()) return false;
        int n = board.size(), m = board[0].size();
        VVI vis(n, VI(m));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (dfs(i, j, board, vis, word, 0)) return true;
            }
        }
        return false;
    }
};

329. Longest Increasing Path in a Matrix

/*
 * Time: O(n * m)
 * Space: O(n * m)
 * 思路：记忆化搜索，用dp[i][j]记录点(i, j)最长上升路径长度，
 * 状态的转移是dp[x][y] = max(dp[x+-1][y+-1]) + 1，答案为dp二维数组的最大值
 */
typedef vector<int> VI;
typedef vector<VI> VVI;
class Solution {
private:
    int dfs(VVI &mat, VVI &dp, int x, int y) {
        if (dp[x][y]) return dp[x][y];
        const int dx[4] = {-1, 1, 0, 0};
        const int dy[4] = { 0, 0,-1, 1};
        dp[x][y] = 1;
        for (int i = 0; i < 4; i++) {
            int nx = x + dx[i], ny = y + dy[i];
            if (nx < 0 || nx >= mat.size() || ny < 0 || ny >= mat[0].size()) continue;
            if (mat[x][y] >= mat[nx][ny]) continue;
            int nxt = dfs(mat, dp, nx, ny);
            dp[x][y] = max(dp[x][y], nxt + 1);
        }
        return dp[x][y];
    }
public:
    int longestIncreasingPath(vector<vector<int>>& mat) {
        if (mat.empty() || mat[0].empty()) return 0;
        int n = mat.size(), m = mat[0].size();
        VVI dp(n, VI(m, 0));
        int ret = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if(!dp[i][j]) dfs(mat, dp, i, j);
                ret = max(ret, dp[i][j]);
            }
        }
        return ret;
    }
};