leetcode-第十五周

329. Longest Increasing Path in a Matrix

class Solution {
private:
    typedef vector<int> VI;
    typedef vector<VI> VVI;
    int dfs(VVI &dp, VVI &A, int x, int y) {
        if (dp[x][y] != -1) return dp[x][y]; // 收敛条件
        const int n = A.size(), m = A[0].size();
        const int dx[4] = {-1, 1, 0, 0};
        const int dy[4] = { 0, 0, 1,-1};
        int mx = 0;
        for (int dir = 0; dir < 4; dir++) {
            int nx = x + dx[dir], ny = y + dy[dir];
            if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
            if (A[nx][ny] <= A[x][y]) continue;
            mx = max(mx, dfs(dp, A, nx, ny));
        }
        dp[x][y] = mx + 1;
        return dp[x][y];
    }
public:
    int longestIncreasingPath(vector<vector<int>>& A) {
        if (A.empty() || A[0].empty()) return 0;
        const int n = A.size(), m = A[0].size();
        int ret = 0;
        VVI dp(n, VI(m, -1));
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret = max(ret, dfs(dp, A, i, j));
            }
        }
        return ret;
    }
};

336. Palindrome Pairs

class Solution {
private:
    bool isPalindrome(const string &a, int l, int r) {
        while (l < r) if (a[l++] != a[r--]) return false;
        return true;
    }
public:
    vector<vector<int>> palindromePairs(vector<string>& words) {
        unordered_map<string, int> mp;
        vector<vector<int> > ret;
        for (int i = 0; i < words.size(); i++) mp[words[i]] = i;
        for (int i = 0; i < words.size(); i++) {
            for (int len = 0; len <= words[i].size(); len++) {
                string &s = words[i];
                if (len > 0 && isPalindrome(s, 0, len - 1)) {
                    string tmp = s.substr(len, s.size() - len);
                    reverse(tmp.begin(), tmp.end());
                    if (mp.find(tmp) != mp.end()) ret.push_back({mp[tmp], i});
                }
                if (isPalindrome(s, s.size() - len, s.size() - 1)) {
                    string tmp = s.substr(0, s.size() - len);
                    reverse(tmp.begin(), tmp.end());
                    if (mp.find(tmp) != mp.end() && i != mp[tmp]) ret.push_back({i, mp[tmp]});
                }
            }
        }
        return ret;
    }
};