The tournament consists of multiple rounds (starting from round number 1). In each round, the ith player from the front of the row competes against the ith player from the end of the row, and the winner advances to the next round. When the number of players is odd for the current round, the player in the middle automatically advances to the next round.

• For example, if the row consists of players 1, 2, 4, 6, 7
  • Player 1 competes against player 7.
  • Player 2 competes against player 6.
  • Player 4 automatically advances to the next round.

After each round is over, the winners are lined back up in the row based on the original ordering assigned to them initially (ascending order).

The players numbered firstPlayer and secondPlayer are the best in the tournament. They can win against any other player before they compete against each other. If any two other players compete against each other, either of them might win, and thus you may choose the outcome of this round.

Given the integers n, firstPlayer, and secondPlayer, return an integer array containing two values, the earliest possible round number and the latest possible round number in which these two players will compete against each other, respectively.

Example 1:

Input: n = 11, firstPlayer = 2, secondPlayer = 4
Output: [3,4]
Explanation:
One possible scenario which leads to the earliest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 2, 3, 4, 5, 6, 11
Third round: 2, 3, 4
One possible scenario which leads to the latest round number:
First round: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
Second round: 1, 2, 3, 4, 5, 6
Third round: 1, 2, 4
Fourth round: 2, 4

Example 2:

Input: n = 5, firstPlayer = 1, secondPlayer = 5
Output: [1,1]
Explanation: The players numbered 1 and 5 compete in the first round.
There is no way to make them compete in any other round.

Constraints:

• 2 <= n <= 28
• 1 <= firstPlayer < secondPlayer <= n

Solution 1: Simulation using recursion

All possible paths,
Time complexity: O(n²*2ⁿ)
Space complexity: O(logn)

dfs(s, i, j, d) := let i battle with j at round d, given s (binary mask of dead players).

// Author: Huahua
class Solution {
public:
  vector<int> earliestAndLatest(int n, int a, int b) {
    vector<int> ans{INT_MAX, INT_MIN};    
    function<void(int, int, int, int)> dfs = [&](int s, int i, int j, int d) {
      while (i < j && s >> i & 1) ++i;
      while (i < j && s >> j & 1) --j;
      if (i >= j) {
        return dfs(s, 1, n, d + 1);
      } else if (i == a && j == b) {
        ans[0] = min(ans[0], d);
        ans[1] = max(ans[1], d);
      } else {
        if (i != a && i != b)
          dfs(s | (1 << i), i + 1, j - 1, d);
        if (j != a && j != b)
          dfs(s | (1 << j), i + 1, j - 1, d);
      }
    };
    dfs(0, 1, n, 1);
    return ans;
  }
};

The post 花花酱 LeetCode 1900. The Earliest and Latest Rounds Where Players Compete appeared first on Huahua's Tech Road.

• For example, "()1|1" and "(1)&()" are not valid while "1", "(((1))|(0))", and "1|(0&(1))" are valid expressions.

Return the minimum cost to change the final value of the expression.

• For example, if expression = "1|1|(0&0)&1", its value is 1|1|(0&0)&1 = 1|1|0&1 = 1|0&1 = 1&1 = 1. We want to apply operations so that the new expression evaluates to 0.

The cost of changing the final value of an expression is the number of operations performed on the expression. The types of operations are described as follows:

• Turn a '1' into a '0'.
• Turn a '0' into a '1'.
• Turn a '&' into a '|'.
• Turn a '|' into a '&'.

Note: '&' does not take precedence over '|' in the order of calculation. Evaluate parentheses first, then in left-to-right order.

Example 1:

Input: expression = "1&(0|1)"
Output: 1
Explanation: We can turn "1&(0|1)" into "1&(0&1)" by changing the '|' to a '&' using 1 operation.
The new expression evaluates to 0. 

Example 2:

<strong>Input:</strong> expression = "(0&amp;0)&amp;(0&amp;0&amp;0)"
<strong>Output:</strong> 3
<strong>Explanation:</strong> We can turn "(0<strong>&amp;0</strong>)<strong><u>&amp;</u></strong>(0&amp;0&amp;0)" into "(0<strong>|1</strong>)<strong>|</strong>(0&amp;0&amp;0)" using 3 operations.
The new expression evaluates to 1.

Example 3:

Input: expression = "(0|(1|0&1))"
Output: 1
Explanation: We can turn "(0|(1|0&1))" into "(0|(0|0&1))" using 1 operation.
The new expression evaluates to 0.

Constraints:

• 1 <= expression.length <= 105
• expression only contains '1','0','&','|','(', and ')'
• All parentheses are properly matched.
• There will be no empty parentheses (i.e: "()" is not a substring of expression).

Solution: DP, Recursion / Simulation w/ Stack

For each expression, stores the min cost to change value to 0 and 1.

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

class Solution {
public:
  int minOperationsToFlip(string expression) {
    stack<array<int, 3>> s;
    s.push({0, 0, 0});
    for (char e : expression) {
      if (e == '(')
        s.push({0, 0, 0});
      else if (e == '&' || e == '|')
        s.top()[2] = e;
      else {        
        if (isdigit(e)) s.push({e != '0', e != '1', 0});
        auto [r0, r1, _] = s.top(); s.pop();
        auto [l0, l1, op] = s.top(); s.pop();
        if (op == '&') {
          s.push({min(l0, r0),
                  min(l1 + r1, min(l1, r1) + 1),
                  0});
        } else if (op == '|') {
          s.push({min(l0 + r0, min(l0, r0) + 1),
                  min(l1, r1),
                  0});
        } else {
          s.push({r0, r1, 0});
        }
      }
    }
    return max(s.top()[0], s.top()[1]);
  }
};

The post 花花酱 LeetCode 1896. Minimum Cost to Change the Final Value of Expression appeared first on Huahua's Tech Road.

• If the current number of teams is even, each team gets paired with another team. A total of n / 2 matches are played, and n / 2 teams advance to the next round.
• If the current number of teams is odd, one team randomly advances in the tournament, and the rest gets paired. A total of (n - 1) / 2 matches are played, and (n - 1) / 2 + 1 teams advance to the next round.

Return the number of matches played in the tournament until a winner is decided.

Example 1:

Input: n = 7
Output: 6
Explanation: Details of the tournament: 
- 1st Round: Teams = 7, Matches = 3, and 4 teams advance.
- 2nd Round: Teams = 4, Matches = 2, and 2 teams advance.
- 3rd Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
Total number of matches = 3 + 2 + 1 = 6.

Example 2:

Input: n = 14
Output: 13
Explanation: Details of the tournament:
- 1st Round: Teams = 14, Matches = 7, and 7 teams advance.
- 2nd Round: Teams = 7, Matches = 3, and 4 teams advance.
- 3rd Round: Teams = 4, Matches = 2, and 2 teams advance.
- 4th Round: Teams = 2, Matches = 1, and 1 team is declared the winner.
Total number of matches = 7 + 3 + 2 + 1 = 13.

Constraints:

• 1 <= n <= 200

Solution: Simulation / Recursion

Time complexity: O(logn)
Space complexity: O(1)

// Ver 1
class Solution {
public:
  int numberOfMatches(int n) {
    int ans = 0;
    while (n > 1) {
      ans += n / 2 + (n & 1);
      n /= 2;
    }
    return ans;
  }
};
// Ver 2
class Solution {
public:
  int numberOfMatches(int n) {
    return n > 1 ? n / 2 + (n & 1) + numberOfMatches(n / 2) : 0;
  }
};

The post 花花酱 LeetCode 1688. Count of Matches in Tournament appeared first on Huahua's Tech Road.

The kingdom has a well-defined order of inheritance that consists of the king as the first member. Let’s define the recursive function Successor(x, curOrder), which given a person x and the inheritance order so far, returns who should be the next person after x in the order of inheritance.

Successor(x, curOrder):
    if x has no children or all of x's children are in curOrder:
        if x is the king return null
        else return Successor(x's parent, curOrder)
    else return x's oldest child who's not in curOrder

For example, assume we have a kingdom that consists of the king, his children Alice and Bob (Alice is older than Bob), and finally Alice’s son Jack.

1. In the beginning, curOrder will be ["king"].
2. Calling Successor(king, curOrder) will return Alice, so we append to curOrder to get ["king", "Alice"].
3. Calling Successor(Alice, curOrder) will return Jack, so we append to curOrder to get ["king", "Alice", "Jack"].
4. Calling Successor(Jack, curOrder) will return Bob, so we append to curOrder to get ["king", "Alice", "Jack", "Bob"].
5. Calling Successor(Bob, curOrder) will return null. Thus the order of inheritance will be ["king", "Alice", "Jack", "Bob"].

Using the above function, we can always obtain a unique order of inheritance.

Implement the ThroneInheritance class:

• ThroneInheritance(string kingName) Initializes an object of the ThroneInheritance class. The name of the king is given as part of the constructor.
• void birth(string parentName, string childName) Indicates that parentName gave birth to childName.
• void death(string name) Indicates the death of name. The death of the person doesn’t affect the Successor function nor the current inheritance order. You can treat it as just marking the person as dead.
• string[] getInheritanceOrder() Returns a list representing the current order of inheritance excluding dead people.

Example 1:

Input
["ThroneInheritance", "birth", "birth", "birth", "birth", "birth", "birth", "getInheritanceOrder", "death", "getInheritanceOrder"]
[["king"], ["king", "andy"], ["king", "bob"], ["king", "catherine"], ["andy", "matthew"], ["bob", "alex"], ["bob", "asha"], [null], ["bob"], [null]]
Output
[null, null, null, null, null, null, null, ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"], null, ["king", "andy", "matthew", "alex", "asha", "catherine"]]
Explanation
ThroneInheritance t= new ThroneInheritance("king"); // order: king
t.birth("king", "andy"); // order: king > andy
t.birth("king", "bob"); // order: king > andy > bob
t.birth("king", "catherine"); // order: king > andy > bob > catherine
t.birth("andy", "matthew"); // order: king > andy > matthew > bob > catherine
t.birth("bob", "alex"); // order: king > andy > matthew > bob > alex > catherine
t.birth("bob", "asha"); // order: king > andy > matthew > bob > alex > asha > catherine
t.getInheritanceOrder(); // return ["king", "andy", "matthew", "bob", "alex", "asha", "catherine"]
t.death("bob"); // order: king > andy > matthew > bob > alex > asha > catherine
t.getInheritanceOrder(); // return ["king", "andy", "matthew", "alex", "asha", "catherine"]

Constraints:

• 1 <= kingName.length, parentName.length, childName.length, name.length <= 15
• kingName, parentName, childName, and name consist of lowercase English letters only.
• All arguments childName and kingName are distinct.
• All name arguments of death will be passed to either the constructor or as childName to birth first.
• For each call to birth(parentName, childName), it is guaranteed that parentName is alive.
• At most 105 calls will be made to birth and death.
• At most 10 calls will be made to getInheritanceOrder.

Solution: HashTable + DFS

Record :
1. mapping from parent to children (ordered)
2. who has dead

Time complexity: getInheritanceOrder O(n), other O(1)
Space complexity: O(n)

// Author: Huahua
class ThroneInheritance {
public:
  ThroneInheritance(string kingName): king_(kingName) {
    m_[kingName] = {};
  }

  void birth(string parentName, string childName) {
    m_[parentName].push_back(childName);
  }

  void death(string name) {
    dead_.insert(name);
  }

  vector<string> getInheritanceOrder() {
    vector<string> ans;
    function<void(const string&)> dfs = [&](const string& name) {
      if (!dead_.count(name)) ans.push_back(name);
      for (const string& child: m_[name]) dfs(child);
    };
    dfs(king_);
    return ans;
  }
private:  
  string king_;  
  unordered_map<string, vector<string>> m_; // parent -> list[children]
  unordered_set<string> dead_;
};

# Author: Huahua
class ThroneInheritance:
  def __init__(self, kingName: str):
    self.kingName = kingName
    self.family = defaultdict(list)    
    self.dead = set()

  def birth(self, parentName: str, childName: str) -> None:
    self.family[parentName].append(childName)

  def death(self, name: str) -> None:
    self.dead.add(name)

  def getInheritanceOrder(self) -> List[str]:
    order = []
    def dfs(name: str):
      if name not in self.dead: order.append(name)
      for child in self.family[name]: dfs(child)
    dfs(self.kingName)
    return order

The post 花花酱 LeetCode 1600. Throne Inheritance appeared first on Huahua's Tech Road.

For example, given nums = [2,1,3], we will have 2 as the root, 1 as a left child, and 3 as a right child. The array [2,3,1] also yields the same BST but [3,2,1] yields a different BST.

Return the number of ways to reorder nums such that the BST formed is identical to the original BST formed from nums.

Since the answer may be very large, return it modulo 10^9 + 7.

Example 1:

Input: nums = [2,1,3]
Output: 1
Explanation: We can reorder nums to be [2,3,1] which will yield the same BST. There are no other ways to reorder nums which will yield the same BST.

Example 2:

Input: nums = [3,4,5,1,2]
Output: 5
Explanation: The following 5 arrays will yield the same BST: 
[3,1,2,4,5]
[3,1,4,2,5]
[3,1,4,5,2]
[3,4,1,2,5]
[3,4,1,5,2]

Example 3:

Input: nums = [1,2,3]
Output: 0
Explanation: There are no other orderings of nums that will yield the same BST.

Example 4:

Input: nums = [3,1,2,5,4,6]
Output: 19

Example 5:

Input: nums = [9,4,2,1,3,6,5,7,8,14,11,10,12,13,16,15,17,18]
Output: 216212978
Explanation: The number of ways to reorder nums to get the same BST is 3216212999. Taking this number modulo 10^9 + 7 gives 216212978.

Constraints:

• 1 <= nums.length <= 1000
• 1 <= nums[i] <= nums.length
• All integers in nums are distinct.

Solution: Recursion + Combinatorics

For a given root (first element of the array), we can split the array into left children (nums[i] < nums[0]) and right children (nums[i] > nums[0]). Assuming there are l nodes for the left and r nodes for the right. We have C(l + r, l) different ways to insert l elements into a (l + r) sized array. Within node l / r nodes, we have ways(left) / ways(right) different ways to re-arrange those nodes. So the total # of ways is:
C(l + r, l) * ways(l) * ways(r)
Don’t forget to minus one for the final answer.

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

class Solution {
public:
  int numOfWays(vector<int>& nums) {
    const int n = nums.size();
    const int kMod = 1e9 + 7;
    vector<vector<int>> cnk(n + 1, vector<int>(n + 1, 1));    
    for (int i = 1; i <= n; ++i)      
      for (int j = 1; j < i; ++j)
        cnk[i][j] = (cnk[i - 1][j] + cnk[i - 1][j - 1]) % kMod;    
    function<int(vector<int>)> trees = [&](const vector<int>& nums) {
      const int n = nums.size();
      if (n <= 2) return 1;
      vector<int> left;
      vector<int> right;
      for (int i = 1; i < nums.size(); ++i)
        if (nums[i] < nums[0]) left.push_back(nums[i]);
        else right.push_back(nums[i]);
      long ans = cnk[n - 1][left.size()];
      ans = (ans * trees(left)) % kMod;      
      ans = (ans * trees(right)) % kMod;      
      return static_cast<int>(ans);
    };
    return trees(nums) - 1;
  } 
};

class Solution:
  def numOfWays(self, nums: List[int]) -> int:
    def ways(nums):
      if len(nums) <= 2: return 1
      l = [x for x in nums if x < nums[0]]
      r = [x for x in nums if x > nums[0]]
      return comb(len(l) + len(r), len(l)) * ways(l) * ways(r)
    return (ways(nums) - 1) % (10**9 + 7)

The post 花花酱 LeetCode 1569. Number of Ways to Reorder Array to Get Same BST appeared first on Huahua's Tech Road.

The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .

Example 1:

Input: "1 + 1"
Output: 2

Example 2:

Input: " 2-1 + 2 "
Output: 3

Example 3:

Input: "(1+(4+5+2)-3)+(6+8)"
Output: 23

Note:

• You may assume that the given expression is always valid.
• Do not use the eval built-in library function.

Solution: Recursion

Make a recursive call when there is an open parenthesis and return if there is close parenthesis.

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

// Author: Huahua
class Solution {
public:
  int calculate(string s) {    
    function<int(int&)> eval = [&](int& pos) {
      int ret = 0;
      int sign = 1;
      int val = 0;
      while (pos < s.size()) {
        const char ch = s[pos];
        if (isdigit(ch)) {
          val = val * 10 + (s[pos++] - '0');
        } else if (ch == '+' || ch == '-') {
          ret += sign * val;
          val = 0;
          sign = ch == '+' ? 1 : -1;
          ++pos;
        } else if (ch == '(') {
          val = eval(++pos);
        } else if (ch == ')') {          
          ++pos;
          break;
        } else {
          ++pos;
        }
      }
      return ret += sign * val;
    };
    int pos = 0;
    return eval(pos);
  }
};

# Author: Huahua
class Solution:
  def calculate(self, s: str) -> int:
    self.pos = 0    
    def eval():
      val = 0
      sign = 1
      ret = 0
      while self.pos < len(s):
        ch = s[self.pos]
        if ch == ' ':
          self.pos += 1
        elif ch == '(':
          self.pos += 1
          val = eval()
        elif ch == ')':
          self.pos += 1
          ret += sign * val
          return ret
        elif ch == '+' or ch == '-':
          ret += sign * val
          val = 0
          sign = 1 if ch == '+' else -1
          self.pos += 1
        else:
          val = val * 10 + (ord(ch) - ord('0'))
          self.pos += 1
      ret += val * sign
      return ret
    return eval()

The post 花花酱 LeetCode 224. Basic Calculator appeared first on Huahua's Tech Road.

Alex and Lee continue their games with piles of stones.  There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].  The objective of the game is to end with the most stones. 

Alex and Lee take turns, with Alex starting first.  Initially, M = 1.

On each player’s turn, that player can take all the stones in the first X remaining piles, where 1 <= X <= 2M.  Then, we set M = max(M, X).

The game continues until all the stones have been taken.

Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.

Example 1:

Input: piles = [2,7,9,4,4]
Output: 10
Explanation:  If Alex takes one pile at the beginning, Lee takes two piles, then Alex takes 2 piles again. Alex can get 2 + 4 + 4 = 10 piles in total. If Alex takes two piles at the beginning, then Lee can take all three piles left. In this case, Alex get 2 + 7 = 9 piles in total. So we return 10 since it's larger. 

Constraints:

• 1 <= piles.length <= 100
• 1 <= piles[i] <= 10 ^ 4

Solution: Recursion + Memoization

def solve(s, m) = max diff score between two players starting from s for the given M.

cache[s][M] = max{sum(piles[s:s+x]) – solve(s+x, max(x, M)}, 1 <= x <= 2*M, s + x <= n

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

// Author: Huahua, 12 ms / 9.7 MB
class Solution {
public:
  int stoneGameII(vector<int>& piles) {
    const int n = piles.size();
    unordered_map<int, int> cache;
    // Maximum diff starting from piles[s] given M.
    function<int(int, int)> solve = [&](int s, int M) {
      if (s >= n) return 0;
      const int key = (s << 8) | M;
      if (cache.count(key)) return cache[key];
      int best = INT_MIN;
      int curr = 0;
      for (int x = 1; x <= 2 * M; ++x) {
        if (s + x > n) break;
        curr += piles[s + x - 1];
        best = max(best, curr - solve(s + x, max(x, M)));
      }
      return cache[key] = best;
    };    
    int total = accumulate(begin(piles), end(piles), 0);
    return  (total + solve(0, 1)) / 2;
  }
};

The post 花花酱 LeetCode 1140. Stone Game II appeared first on Huahua's Tech Road.

Return the result of evaluating a given boolean expression, represented as a string.

An expression can either be:

• "t", evaluating to True;
• "f", evaluating to False;
• "!(expr)", evaluating to the logical NOT of the inner expression expr;
• "&(expr1,expr2,...)", evaluating to the logical AND of 2 or more inner expressions expr1, expr2, ...;
• "|(expr1,expr2,...)", evaluating to the logical OR of 2 or more inner expressions expr1, expr2, ...

Example 1:

Input: expression = "!(f)"
Output: true

Example 2:

Input: expression = "|(f,t)"
Output: true

Example 3:

Input: expression = "&(t,f)"
Output: false

Example 4:

Input: expression = "|(&(t,f,t),!(t))"
Output: false

Solution: Recursion

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

// Author: Huahua
class Solution {
public:
  bool parseBoolExpr(string expression) {
    int s = 0;
    return parse(expression, s);
  }
private:  
  bool parse(const string& exp, int& s) {
    char ch = exp[s++];    
    if (ch == 't') return true;      
    if (ch == 'f') return false;
    if (ch == '!') {
      bool ans = !parse(exp, ++s);
      ++s;
      return ans;
    } 
    bool is_and = (ch == '&');
    bool ans = is_and;
    ++s;
    while (true) {
      if (is_and) ans &= parse(exp, s);
      else ans |= parse(exp, s);
      if (exp[s++] == ')') break;
    }
    return ans;
  }
};

class Solution {
  private int s;
  private char[] exp;
  public boolean parseBoolExpr(String expression) {
    exp = expression.toCharArray();
    s = 0;
    return parse() == 1;
  }
      
  private int parse() {
    char ch = exp[s++];
    if (ch == 't') return 1;
    if (ch == 'f') return 0;
    if (ch == '!') {
      ++s;
      int ans = 1 - parse();
      ++s;
      return ans;
    }
    boolean is_and = (ch == '&');
    int ans = is_and ? 1 : 0;
    ++s;
    while (true) {
      if (is_and) ans &= parse();
      else ans |= parse();
      if (exp[s++] == ')') break;
    }
    return ans;
  }
}

The post 花花酱 LeetCode 1106. Parsing A Boolean Expression appeared first on Huahua's Tech Road.

The encoding rule is: k[encoded_string], where the encoded_string inside the square brackets is being repeated exactly k times. Note that k is guaranteed to be a positive integer.

You may assume that the input string is always valid; No extra white spaces, square brackets are well-formed, etc.

Furthermore, you may assume that the original data does not contain any digits and that digits are only for those repeat numbers, k. For example, there won’t be input like 3a or 2[4].

Examples:

s = "3[a]2[bc]", return "aaabcbc".
s = "3[a2[c]]", return "accaccacc".
s = "2[abc]3[cd]ef", return "abcabccdcdcdef".

Solution 1: Recursion

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

// Author: Huahua, 4ms
class Solution {
public:
  string decodeString(string s) {
    if (s.empty()) return "";    
    string ans;
    int i = 0;
    int n = s.length();
    int c = 0;
    while (isdigit(s[i]) && i < n) 
      c = c * 10 + (s[i++] - '0');
    
    int j = i;
    if (i < n && s[i] == '[') {      
      int open = 1;
      while (++j < n && open) {
        if (s[j] == '[') ++open;
        if (s[j] == ']') --open;
      }
    } else {
      while (j < n && isalpha(s[j])) ++j;
    }    
    
    // "def2[ac]" => "def" + decodeString("2[ac]")
    //  |  |
    //  i  j
    if (i == 0)
      return s.substr(0, j) + decodeString(s.substr(j));
    
    // "3[a2[c]]ef", ss = decodeString("a2[c]") = "acc"
    //   |      |
    //   i      j
    string ss = decodeString(s.substr(i + 1, j - i - 2));    
    while (c--)
      ans += ss;
    // "3[a2[c]]ef", ans = "abcabcabc", ans += decodeString("ef")
    ans += decodeString(s.substr(j));
    return ans;
  }
};

The post 花花酱 LeetCode 394. Decode String appeared first on Huahua's Tech Road.

题目大意：两个人从1到M中每次取出一个数加到当前的总和上，第一个达到或超过T的人获胜。问你第一个玩家能不能获胜。

In the “100 game,” two players take turns adding, to a running total, any integer from 1..10. The player who first causes the running total to reach or exceed 100 wins.

What if we change the game so that players cannot re-use integers?

For example, two players might take turns drawing from a common pool of numbers of 1..15 without replacement until they reach a total >= 100.

Given an integer maxChoosableInteger and another integer desiredTotal, determine if the first player to move can force a win, assuming both players play optimally.

You can always assume that maxChoosableInteger will not be larger than 20 and desiredTotal will not be larger than 300.

Example

Input:
maxChoosableInteger = 10
desiredTotal = 11

Output:
false

Explanation:
No matter which integer the first player choose, the first player will lose.
The first player can choose an integer from 1 up to 10.
If the first player choose 1, the second player can only choose integers from 2 up to 10.
The second player will win by choosing 10 and get a total = 11, which is >= desiredTotal.
Same with other integers chosen by the first player, the second player will always win.

Solution: Recursion with memoization 

Time complexity: O(2^M)

Space complexity: O(2^M)

C++

// Author: Huahua
// Running time: 19 ms (<98.70%)
class Solution {
public:
  bool canIWin(int M, int T) {
    const int sum = M * (M + 1) / 2;
    if (sum < T) return false;
    if (T <= 0) return true;
    m_ = vector<char>(1 << M, 0);
    return canIWin(M, T, 0);
  }
private:
  vector<char> m_; // 0: unknown, 1: won, -1: lost
  bool canIWin(int M, int T, int state) {
    if (T <= 0) return false;
    if (m_[state]) return m_[state] == 1;
    for (int i = 0; i < M; ++i) {
      if (state & (1 << i)) continue; // number i used      
      // The next player can not win, current player wins
      if (!canIWin(M, T - (i + 1), state | (1 << i))) 
        return m_[state] = 1;
    }
    // Current player loses.
    m_[state] = -1;
    return false;
  }
};

Java

// Author: Huahua
// Running time: 20 ms
class Solution {
  private byte[] m_;
  public boolean canIWin(int M, int T) {
    int sum = M * (M + 1) / 2;
    if (sum < T) return false;
    if (T <= 0) return true;
    m_ = new byte[1 << M];
    return canIWin(M, T, 0);
  }
  
  private boolean canIWin(int M, int T, int state) {
    if (T <= 0) return false;
    if (m_[state] != 0) return m_[state] == 1;
    
    for (int i = 0; i < M; ++i) {
      if ((state & (1 << i)) > 0) continue;
      if (!canIWin(M, T - (i + 1), state | (1 << i))) {
        m_[state] = 1;
        return true;
      }
    }
    m_[state] = -1;
    return false;
  }    
}

Python3

"""
Author: Huahua
Running time: 706 ms
"""
class Solution:
  def canIWin(self, M, T):
    def win(M, T, m, state):
      if T <= 0: return False
      if m[state] != 0: return m[state] == 1
      for i in range(M):
        if (state & (1 << i)) > 0: continue
        if not win(M, T - i - 1, m, state | (1 << i)):
          m[state] = 1
          return True
      m[state] = -1
      return False
    
    s = M * (M + 1) / 2
    if s < T: return False
    if T <= 0: return True
    if s == T: return (M % 2) == 1
    
    m = [0] * (1 << M)
    return win(M, T, m, 0)

The post 花花酱 LeetCode 464. Can I Win appeared first on Huahua's Tech Road.

Problem:

You are given a string expression representing a Lisp-like expression to return the integer value of.

The syntax for these expressions is given as follows.

• An expression is either an integer, a let-expression, an add-expression, a mult-expression, or an assigned variable. Expressions always evaluate to a single integer.
• (An integer could be positive or negative.)
• A let-expression takes the form (let v1 e1 v2 e2 ... vn en expr), where let is always the string "let", then there are 1 or more pairs of alternating variables and expressions, meaning that the first variable v1is assigned the value of the expression e1, the second variable v2 is assigned the value of the expression e2, and so on sequentially; and then the value of this let-expression is the value of the expression expr.
• An add-expression takes the form (add e1 e2) where add is always the string "add", there are always two expressions e1, e2, and this expression evaluates to the addition of the evaluation of e1 and the evaluation of e2.
• A mult-expression takes the form (mult e1 e2) where mult is always the string "mult", there are always two expressions e1, e2, and this expression evaluates to the multiplication of the evaluation of e1 and the evaluation of e2.
• For the purposes of this question, we will use a smaller subset of variable names. A variable starts with a lowercase letter, then zero or more lowercase letters or digits. Additionally for your convenience, the names “add”, “let”, or “mult” are protected and will never be used as variable names.
• Finally, there is the concept of scope. When an expression of a variable name is evaluated, within the context of that evaluation, the innermost scope (in terms of parentheses) is checked first for the value of that variable, and then outer scopes are checked sequentially. It is guaranteed that every expression is legal. Please see the examples for more details on scope.

Evaluation Examples:

Input: (add 1 2)
Output: 3

Input: (mult 3 (add 2 3))
Output: 15

Input: (let x 2 (mult x 5))
Output: 10

Input: (let x 2 (mult x (let x 3 y 4 (add x y))))
Output: 14
Explanation: In the expression (add x y), when checking for the value of the variable x,
we check from the innermost scope to the outermost in the context of the variable we are trying to evaluate.
Since x = 3 is found first, the value of x is 3.

Input: (let x 3 x 2 x)
Output: 2
Explanation: Assignment in let statements is processed sequentially.

Input: (let x 1 y 2 x (add x y) (add x y))
Output: 5
Explanation: The first (add x y) evaluates as 3, and is assigned to x.
The second (add x y) evaluates as 3+2 = 5.

Input: (let x 2 (add (let x 3 (let x 4 x)) x))
Output: 6
Explanation: Even though (let x 4 x) has a deeper scope, it is outside the context
of the final x in the add-expression.  That final x will equal 2.

Input: (let a1 3 b2 (add a1 1) b2) 
Output 4
Explanation: Variable names can contain digits after the first character.

Note:

• The given string expression is well formatted: There are no leading or trailing spaces, there is only a single space separating different components of the string, and no space between adjacent parentheses. The expression is guaranteed to be legal and evaluate to an integer.
• The length of expression is at most 2000. (It is also non-empty, as that would not be a legal expression.)
• The answer and all intermediate calculations of that answer are guaranteed to fit in a 32-bit integer.

Idea:

Recursive parsing

Time complexity: O(n^2) in worst case O(n) in practice

Space complexity: O(n)

// Author: Huahua
// Runtime: 3 ms
class Solution {
public:
    int evaluate(string expression) {        
        scopes_.clear();
        int pos = 0;
        return eval(expression, pos);
    }
private:
    int eval(const string& s, int& pos) {
        scopes_.push_front(unordered_map<string, int>());
        int value = 0; // The return value of current expr        
        if (s[pos] == '(') ++pos;

        // command, variable or number
        const string token = getToken(s, pos);

        if (token == "add") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 + v2;
        } else if (token == "mult") {
            int v1 = eval(s, ++pos);
            int v2 = eval(s, ++pos);
            value = v1 * v2;
        } else if (token == "let") {
            string var;
            // expecting " var1 exp1 var2 exp2 ... last_expr)"
            while (s[pos] != ')') {
                ++pos;
                // Must be last_expr
                if (s[pos] == '(') {
                    value = eval(s, ++pos);
                    break;
                }                
                // Get a token, could be "x" or "-12" for last_expr
                var = getToken(s, pos);                
                // End of let, var is last_expr
                if (s[pos] == ')') {
                    if (isalpha(var[0]))
                        value = getValue(var);
                    else
                        value = stoi(var);
                    break;
                }
                // x -12 -> set x to -12 and store in the current scope and take it as the current return value
                value = scopes_.front()[var] = eval(s, ++pos);
            }
        } else if (isalpha(token[0])) {            
            value = getValue(token); // symbol
        } else {            
            value = std::stoi(token); // number
        }
        if (s[pos] == ')') ++pos;        
        scopes_.pop_front();        
        return value;
    }
    
    int getValue(const string& symbol) {
        for (const auto& scope : scopes_)        
            if (scope.count(symbol)) return scope.at(symbol);
        return 0;
    }
    
    // Get a token from current pos.
    // "let x" -> "let"
    // "-12 (add x y)" -> "-12"
    string getToken(const string& s, int& pos) {        
        string token;
        while (pos < s.length()) {            
            if (s[pos] == ')' || s[pos] == ' ') break;
            token += s[pos++];
        }
        return token;
    }
    
    deque<unordered_map<string, int>> scopes_; 
};

The post 花花酱 LeetCode 736. Parse Lisp Expression appeared first on Huahua's Tech Road.

Input: 
formula = "H2O"
Output: "H2O"
Explanation: 
The count of elements are {'H': 2, 'O': 1}.

Input: 
formula = "Mg(OH)2"
Output: "H2MgO2"
Explanation: 
The count of elements are {'H': 2, 'Mg': 1, 'O': 2}.

Input: 
formula = "K4(ON(SO3)2)2"
Output: "K4N2O14S4"
Explanation: 
The count of elements are {'K': 4, 'N': 2, 'O': 14, 'S': 4}.

Solution:

C++

// Author: Huahua
// Runtime: 3 ms
class Solution {
public:
    string countOfAtoms(const string& formula) {
        int i = 0;
        string ans;
        for (const auto& kv : countOfAtoms(formula, i)) {
            ans += kv.first;
            if (kv.second > 1) ans += std::to_string(kv.second);
        }
        return ans;
    }
private:    
    map<string, int> countOfAtoms(const string& formula, int& i) {
        map<string, int> counts;
        while (i != formula.length()) {
            if (formula[i] == '(') {                
                const auto& tmp_counts = countOfAtoms(formula, ++i);
                const int count = getCount(formula, i);
                for (const auto& kv : tmp_counts)
                    counts[kv.first] += kv.second * count;
            } else if (formula[i] == ')') {
                ++i;
                return counts;
            } else {
                const string& name = getName(formula, i);
                counts[name] += getCount(formula, i);
            }
        }
        return counts;
    }
    
    string getName(const string& formula, int& i) {
        string name;
        while (isalpha(formula[i]) 
           && (name.empty() || islower(formula[i]))) name += formula[i++];
        return name;
    }
    
    int getCount(const string& formula, int& i) {
        string count_str;
        while (isdigit(formula[i])) count_str += formula[i++];
        return count_str.empty() ? 1 : std::stoi(count_str);
    }    
};

Java

// Author: Huahua
// Runtime: 13 ms
class Solution {
    private int i;    
    public String countOfAtoms(String formula) {
        StringBuilder ans = new StringBuilder();
        i = 0;
        Map<String, Integer> counts = countOfAtoms(formula.toCharArray());
        for (String name: counts.keySet()) {
            ans.append(name);
            int count = counts.get(name);
            if (count > 1) ans.append("" + count);
        }
        return ans.toString();
    }
    
    private Map<String, Integer> countOfAtoms(char[] f) {
        Map<String, Integer> ans = new TreeMap<String, Integer>();
        while (i != f.length) {
            if (f[i] == '(') {
                ++i;
                Map<String, Integer> tmp = countOfAtoms(f);
                int count = getCount(f);
                for (Map.Entry<String, Integer> entry : tmp.entrySet())
                    ans.put(entry.getKey(), 
                            ans.getOrDefault(entry.getKey(), 0) 
                            + entry.getValue() * count);
            } else if (f[i] == ')') {
                ++i;
                return ans;
            } else {
                String name = getName(f);
                ans.put(name, ans.getOrDefault(name, 0) + getCount(f));
            }
        }
        return ans;
    }
    
    private String getName(char[] f) {
        String name = "" + f[i++];
        while (i < f.length && 'a' <= f[i] && f[i] <= 'z') name += f[i++];
        return name;
    }
    
    private int getCount(char[] f) {
        int count = 0;
        while (i < f.length && '0' <= f[i] && f[i] <= '9') {
            count = count * 10 + (f[i] - '0');
            ++i;
        }
        return count == 0 ? 1 : count;
    }
}

The post 花花酱 LeetCode 726. Number of Atoms appeared first on Huahua's Tech Road.