O(n^2) Archives - Huahua's Tech Road

花花酱 LeetCode 1301. Number of Paths with Max Score

zxi — Sat, 28 Dec 2019 18:20:16 +0000

You are given a square board of characters. You can move on the board starting at the bottom right square marked with the character 'S'.

You need to reach the top left square marked with the character 'E'. The rest of the squares are labeled either with a numeric character 1, 2, ..., 9 or with an obstacle 'X'. In one move you can go up, left or up-left (diagonally) only if there is no obstacle there.

Return a list of two integers: the first integer is the maximum sum of numeric characters you can collect, and the second is the number of such paths that you can take to get that maximum sum, taken modulo 10^9 + 7.

In case there is no path, return [0, 0].

Example 1:

Input: board = ["E23","2X2","12S"]
Output: [7,1]

Example 2:

Input: board = ["E12","1X1","21S"]
Output: [4,2]

Example 3:

Input: board = ["E11","XXX","11S"]
Output: [0,0]

Constraints:

2 <= board.length == board[i].length <= 100

Solution: DP

dp[i][j] := max score when reach (j, i)
count[i][j] := path to reach (j, i) with max score

m = max(dp[i + 1][j], dp[i][j+1], dp[i+1][j+1])
dp[i][j] = board[i][j] + m
count[i][j] += count[i+1][j] if dp[i+1][j] == m
count[i][j] += count[i][j+1] if dp[i][j+1] == m
count[i][j] += count[i+1][j+1] if dp[i+1][j+1] == m

Time complexity: O(n^2)
Space complexity: O(n^2)

C++

// Author: Huahua
class Solution {
public:
  vector pathsWithMaxScore(vector& board) {
    constexpr int kMod = 1e9 + 7;
    const int n = board.size();
    vector> dp(n + 1, vector(n + 1));
    vector> cc(n + 1, vector(n + 1, 0));
    board[n - 1][n - 1] = board[0][0] = '0';
    cc[n - 1][n - 1] = 1;
    for (int i = n - 1; i >= 0; --i)
      for (int j = n - 1; j >= 0; --j) {
        if (board[i][j] != 'X') {          
          int m = max({dp[i + 1][j], dp[i][j + 1], dp[i + 1][j + 1]});
          dp[i][j] = (board[i][j] - '0') + m;
          if (dp[i + 1][j] == m) 
            cc[i][j] = (cc[i][j] + cc[i + 1][j]) % kMod;
          if (dp[i][j + 1] == m)
            cc[i][j] = (cc[i][j] + cc[i][j + 1]) % kMod;
          if (dp[i + 1][j + 1] == m)
            cc[i][j] = (cc[i][j] + cc[i + 1][j + 1]) % kMod;
        }
      }
    return {cc[0][0] ? dp[0][0] : 0, cc[0][0]};
  }
};

The post 花花酱 LeetCode 1301. Number of Paths with Max Score appeared first on Huahua's Tech Road.

花花酱 LeetCode 1230. Toss Strange Coins

zxi — Sun, 20 Oct 2019 04:05:29 +0000

You have some coins. The i-th coin has a probability prob[i] of facing heads when tossed.

Return the probability that the number of coins facing heads equals target if you toss every coin exactly once.

Example 1:

Input: prob = [0.4], target = 1
Output: 0.40000

Example 2:

Input: prob = [0.5,0.5,0.5,0.5,0.5], target = 0
Output: 0.03125

Constraints:

1 <= prob.length <= 1000
0 <= prob[i] <= 1
0 <= target <= prob.length
Answers will be accepted as correct if they are within 10^-5 of the correct answer.

Solution: DP

dp[i][j] := prob of j coins face up after tossing first i coins.
dp[i][j] = dp[i-1][j] * (1 – p[i]) + dp[i-1][j-1] * p[i]

Time complexity: O(n^2)
Space complexity: O(n^2) -> O(n)

C++

// Author: Huahua
class Solution {
public:
  double probabilityOfHeads(vector& prob, int target) {
    const int n = prob.size();
    vector dp(target + 1);    
    dp[0] = 1.0;
    for (int i = 0; i < n; ++i)
      for (int j = min(i + 1, target); j >= 0; --j)
        dp[j] = dp[j] * (1 - prob[i]) + (j > 0 ? dp[j - 1] : 0) * prob[i];
    return dp[target];
  }
};

Solution 2: Recursion + Memorization

Time complexity: O(n^2)
Space complexity: O(n^2)

C++

// Author: Huahua
class Solution {
public:
  double probabilityOfHeads(vector& prob, int target) {    
    vector> mem(prob.size() + 1, vector(target + 1, -1)); 
    function dp = [&](int n, int k) {
      if (k > n || k < 0) return 0.0;      
      if (n == 0) return 1.0;
      if (mem[n][k] >= 0) return mem[n][k];
      const double p = prob[n - 1];
      return mem[n][k] = p * dp(n - 1, k - 1) + (1 - p) * dp(n - 1, k);
    };    
    return dp(prob.size(), target);
  }
};

The post 花花酱 LeetCode 1230. Toss Strange Coins appeared first on Huahua's Tech Road.

花花酱 LeetCode 48. Rotate Image

zxi — Wed, 02 Oct 2019 16:20:55 +0000

You are given an n x n 2D matrix representing an image.

Rotate the image by 90 degrees (clockwise).

Note:

You have to rotate the image in-place, which means you have to modify the input 2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.

Example 1:

Given input matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

rotate the input matrix in-place such that it becomes:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]

Example 2:

Given input matrix =
[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
], 

rotate the input matrix in-place such that it becomes:
[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]

Solution: 2 Passes

First pass: mirror around diagonal
Second pass: mirror around y axis

Time complexity: O(n^2)
Space complexity: O(1)

C++

// Author: Huahua
class Solution {
public:
  void rotate(vector>& matrix) {
    const int n = matrix.size();
    for (int i = 0; i < n; ++i)
      for (int j = i + 1; j < n; ++j)
        swap(matrix[i][j], matrix[j][i]);
    for (int i = 0; i < n; ++i)
      reverse(begin(matrix[i]), end(matrix[i]));
  }
};

The post 花花酱 LeetCode 48. Rotate Image appeared first on Huahua's Tech Road.

花花酱 LeetCode 59. Spiral Matrix II

zxi — Mon, 30 Sep 2019 03:13:27 +0000

Given a positive integer n, generate a square matrix filled with elements from 1 to n² in spiral order.

Example:

Input: 3
Output:
[
 [ 1, 2, 3 ],
 [ 8, 9, 4 ],
 [ 7, 6, 5 ]
]

Solution: Simulation

Time complexity: O(n^2)
Space complexity: O(n^2)

C++

// Author: Huahua
class Solution {
public:
  vector > generateMatrix(int n) {
    vector> ans(n, vector(n));
    int dir = 2, x = 0, y = 0;
    int max_x = n - 1, max_y = n - 1;
    int min_x = 0, min_y = 1;
    int i = 0;

    while (++i <= n*n) {
      ans[y][x] = i;
      switch (dir) {
        // up
        case 1: if (--y == min_y) { dir = 2; ++min_y; } break;
        // right
        case 2: if (++x == max_x) { dir = 3; --max_x; } break;
        // down
        case 3: if (++y == max_y) { dir = 4; --max_y; } break;
        // left
        case 4: if (--x == min_x) { dir = 1; ++min_x; } break;
      }
    }

    return ans;
  }
};

The post 花花酱 LeetCode 59. Spiral Matrix II appeared first on Huahua's Tech Road.

花花酱 LeetCode 1210. Minimum Moves to Reach Target with Rotations

zxi — Sun, 29 Sep 2019 07:58:00 +0000

In an n*n grid, there is a snake that spans 2 cells and starts moving from the top left corner at (0, 0) and (0, 1). The grid has empty cells represented by zeros and blocked cells represented by ones. The snake wants to reach the lower right corner at (n-1, n-2) and (n-1, n-1).

In one move the snake can:

Move one cell to the right if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
Move down one cell if there are no blocked cells there. This move keeps the horizontal/vertical position of the snake as it is.
Rotate clockwise if it’s in a horizontal position and the two cells under it are both empty. In that case the snake moves from (r, c) and (r, c+1) to (r, c) and (r+1, c).
Rotate counterclockwise if it’s in a vertical position and the two cells to its right are both empty. In that case the snake moves from (r, c) and (r+1, c) to (r, c) and (r, c+1).

Return the minimum number of moves to reach the target.

If there is no way to reach the target, return -1.

Example 1:

Input: grid = [[0,0,0,0,0,1],
               [1,1,0,0,1,0],
               [0,0,0,0,1,1],
               [0,0,1,0,1,0],
               [0,1,1,0,0,0],
               [0,1,1,0,0,0]]
Output: 11
Explanation:
One possible solution is [right, right, rotate clockwise, right, down, down, down, down, rotate counterclockwise, right, down].

Example 2:

Input: grid = [[0,0,1,1,1,1],
               [0,0,0,0,1,1],
               [1,1,0,0,0,1],
               [1,1,1,0,0,1],
               [1,1,1,0,0,1],
               [1,1,1,0,0,0]]
Output: 9

Constraints:

2 <= n <= 100
0 <= grid[i][j] <= 1
It is guaranteed that the snake starts at empty cells.

Solution1: BFS

Time complexity: O(n^2)
Space complexity: O(n^2)

C++

// Author: Huahua, 48 ms, 18.1 MB
class Solution {
public:
  inline int pos(int x, int y) {
    return y * 100 + x;
  }
  
  inline int encode(int p1, int p2) {
    return (p1 << 16) | p2;
  }
  
  int minimumMoves(vector>& grid) {    
    int n = grid.size();
    queue> q;
    unordered_set seen;
    q.push({pos(0, 0), pos(1, 0)}); // tail, head
    seen.insert(encode(pos(0, 0), pos(1, 0)));
    int steps = 0;
    auto valid = [&](int x, int y) {
      bool v = x >= 0 && x < n && y >= 0 && y < n && !grid[y][x];      
      return v;
    };
    while (!q.empty()) {
      int size = q.size();
      while (size--) {
        auto p = q.front(); q.pop();
        int y0 = p.first / 100;
        int x0 = p.first % 100;
        int y1 = p.second / 100;
        int x1 = p.second % 100;
                        
        if (x0 == n - 2 && y0 == n - 1 &&
            x1 == n - 1 && y1 == n - 1) {
          return steps;
        }
        
        bool h = y0 == y1;        
        
        for (int i = 0; i < 3; ++i) {
          int tx0 = x0;
          int ty0 = y0;
          int tx1 = x1;
          int ty1 = y1;
          int rx = x0;
          int ry = y0;
          switch (i) {
            case 0: // down              
              ++ty0;
              ++ty1;
              break;
            case 1: // right
              ++tx0;
              ++tx1;
              break;
            case 2: // rotate              
              ++rx;
              ++ry;
              if (h) { // clockwise 
                --tx1;
                ++ty1;
              } else { // counterclockwise  
                ++tx1;
                --ty1;
              }
              break;
          }                    
          if (!valid(tx0, ty0) || !valid(tx1, ty1) || !valid(rx, ry)) continue;          
          int key = encode(pos(tx0, ty0), pos(tx1, ty1));
          if (seen.count(key)) continue;
          seen.insert(key);
          q.push({pos(tx0, ty0), pos(tx1, ty1)});
        }
      }
      ++steps;
    }
    return -1;
  }
};

Solution 2: DP

dp[i][j].first = min steps to reach i,j (tail pos) facing right
dp[i][j].second = min steps to reach i, j (tail pos) facing down
ans = dp[n][n-1].first

Time complexity: O(n^2)
Space complexity: O(n^2)

C++

// Author: Huahua, 16 ms, 12.1MB
class Solution {
public:
  int minimumMoves(vector>& grid) {
    constexpr int kInf = 1e9;
    const int n = grid.size();
    vector>> dp(n + 1, 
                                      vector>(n + 1, {kInf, kInf}));
    dp[0][1].first = dp[1][0].first = -1;
    for (int i = 1; i <= n; ++i)
      for (int j = 1; j <= n; ++j) {
        bool h = false;
        bool v = false;
        if (!grid[i - 1][j - 1] && j < n && !grid[i - 1][j]) {
          dp[i][j].first = min(dp[i - 1][j].first, dp[i][j - 1].first) + 1;
          h = true;          
        }
        if (!grid[i - 1][j - 1] && i < n && !grid[i][j - 1]) {
          dp[i][j].second = min(dp[i - 1][j].second, dp[i][j - 1].second) + 1;
          v = true;          
        }
        if (v && j < n && !grid[i][j])
            dp[i][j].second = min(dp[i][j].second, dp[i][j].first + 1);
        if (h && i < n && !grid[i][j])
            dp[i][j].first = min(dp[i][j].first, dp[i][j].second + 1);        
      }      
    return dp[n][n - 1].first >= kInf ? -1 : dp[n][n - 1].first;
  }
};

The post 花花酱 LeetCode 1210. Minimum Moves to Reach Target with Rotations appeared first on Huahua's Tech Road.

花花酱 LeetCode 1190. Reverse Substrings Between Each Pair of Parentheses

zxi — Sun, 15 Sep 2019 22:16:24 +0000

Given a string s that consists of lower case English letters and brackets.

Reverse the strings in each pair of matching parentheses, starting from the innermost one.

Your result should not contain any bracket.

Example 1:

Input: s = "(abcd)"
Output: "dcba"

Example 2:

Input: s = "(u(love)i)"
Output: "iloveu"

Example 3:

Input: s = "(ed(et(oc))el)"
Output: "leetcode"

Example 4:

Input: s = "a(bcdefghijkl(mno)p)q"
Output: "apmnolkjihgfedcbq"

Constraints:

0 <= s.length <= 2000
s only contains lower case English characters and parentheses.
It’s guaranteed that all parentheses are balanced.

Solution: Stack

Use a stack of strings to track all the active strings.
Iterate over the input string:
1. Whenever there is a ‘(‘, push an empty string to the stack.
2. Whenever this is a ‘)’, pop the top string and append the reverse of it to the new stack top.
3. Otherwise, append the letter to the string on top the of stack.

Once done, the (only) string on the top of the stack is the answer.

Time complexity: O(n^2)
Space complexity: O(n)

C++

// Author: Huahua
class Solution {
public:
  string reverseParentheses(string s) {
    stack st;
    st.push("");
    for (char c : s) {
      if (c == '(') st.push("");
      else if (c != ')') st.top() += c;
      else {
        string t = st.top(); st.pop();
        st.top().insert(end(st.top()), rbegin(t), rend(t));
      }
    }
    return st.top();
  }
};

The post 花花酱 LeetCode 1190. Reverse Substrings Between Each Pair of Parentheses appeared first on Huahua's Tech Road.

花花酱 LeetCode 5. Longest Palindromic Substring

zxi — Wed, 12 Sep 2018 07:45:12 +0000

Problem

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

Solution: DP

Try all possible i and find the longest palindromic string whose center is i (odd case) and i / i + 1 (even case).

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua, 16 ms, 8.7 MB
class Solution {
public:
  string longestPalindrome(string s) {
    const int n = s.length();
    auto getLen = [&](int l, int r) {
      while (l >= 0 && r < n 
             && s[l] == s[r]) {
        --l;
        ++r;
      }
      return r - l - 1;
    };
    int len = 0;
    int start = 0;
    for (int i = 0; i < n; ++i) {
      int cur = max(getLen(i, i), 
                    getLen(i, i + 1));
      if (cur > len) {
        len = cur;
        start = i - (len - 1) / 2;
      }
    }
    return s.substr(start, len);
  }
};

Java

// Author: Huahua, 6 ms， 36.5 MB
class Solution {
  public String longestPalindrome(String s) {
    int len = 0;
    int start = 0;
    for (int i = 0; i < s.length(); ++i) {
      int cur = Math.max(getLen(s, i, i), 
                         getLen(s, i, i + 1));
      if (cur > len) {
        len = cur;
        start = i - (cur - 1) / 2;
      }
    }
    return s.substring(start, start + len);
  }
  
  private int getLen(String s, int l, int r) {
    while (l >= 0 && r < s.length() 
           && s.charAt(l) == s.charAt(r)) {
      --l;
      ++r;
    }
    return r - l - 1;
  }
}

Python3

# Author: Huahua, 812 ms, 12.7MB
class Solution:
  def longestPalindrome(self, s: str) -> str:
    n = len(s)
    def getLen(l, r):
      while l >= 0 and r < n and s[l] == s[r]:
        l -= 1
        r += 1
      return r - l - 1
    
    start = 0
    length = 0    
    for i in range(n):      
      cur = max(getLen(i, i),
                getLen(i, i + 1))
      if cur <= length: continue
      length = cur
      start = i - (cur - 1) // 2
    return s[start : start + length]

The post 花花酱 LeetCode 5. Longest Palindromic Substring appeared first on Huahua's Tech Road.