Example:

Input: 38
Output: 2 
Explanation: The process is like: 3 + 8 = 11, 1 + 1 = 2. 
             Since 2 has only one digit, return it.

Follow up:
Could you do it without any loop/recursion in O(1) runtime?

Solution 1: Simulation

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

// Author: Huahua
class Solution {
public:
  int addDigits(int num) {
    int n = num;
    while (n >= 10) {      
      int t = n;
      n = 0;
      while (t) {
        n += t % 10;
        t /= 10;
      }
    }
    return n;
  }
};

Solution 2: Math

https://en.wikipedia.org/wiki/Digital_root#Congruence_formula

Digit root = num % 9 if num % 9 != 0 else min(num, 9) e.g. 0 or 9

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

// Author: Huahua
class Solution {
public:
  int addDigits(int num) {    
    return num % 9 ? num % 9 : min(num, 9);
  }
};

The post 花花酱 LeetCode 258. Add Digits appeared first on Huahua's Tech Road.

Return the maximum number you can get by changing at most one digit (6 becomes 9, and 9 becomes 6).

Example 1:

Input: num = 9669
Output: 9969
Explanation: 
Changing the first digit results in 6669.
Changing the second digit results in 9969.
Changing the third digit results in 9699.
Changing the fourth digit results in 9666. 
The maximum number is 9969.

Example 2:

Input: num = 9996
Output: 9999
Explanation: Changing the last digit 6 to 9 results in the maximum number.

Example 3:

Input: num = 9999
Output: 9999
Explanation: It is better not to apply any change.

Constraints:

• 1 <= num <= 10^4
• num‘s digits are 6 or 9.

Solution: Greedy

Replace the highest 6 to 9, if no 6, return the original number.

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

// Author: Huahua
class Solution {
public:
  int maximum69Number (int num) {
    string s = to_string(num);
    for (int i = 0; i < s.length(); ++i) {
      if (s[i] == '6') {
        s[i] = '9';
        return stoi(s);
      }
    }
    return num;
  }
};

The post 花花酱 LeetCode 1323. Maximum 69 Number appeared first on Huahua's Tech Road.

• Jumbo Burger: 4 tomato slices and 1 cheese slice.
• Small Burger: 2 Tomato slices and 1 cheese slice.

Return [total_jumbo, total_small] so that the number of remaining tomatoSlices equal to 0 and the number of remaining cheeseSlices equal to 0. If it is not possible to make the remaining tomatoSlices and cheeseSlices equal to 0 return [].

Example 1:

Input: tomatoSlices = 16, cheeseSlices = 7
Output: [1,6]
Explantion: To make one jumbo burger and 6 small burgers we need 4*1 + 2*6 = 16 tomato and 1 + 6 = 7 cheese. There will be no remaining ingredients.

Example 2:

Input: tomatoSlices = 17, cheeseSlices = 4
Output: []
Explantion: There will be no way to use all ingredients to make small and jumbo burgers.

Example 3:

Input: tomatoSlices = 4, cheeseSlices = 17
Output: []
Explantion: Making 1 jumbo burger there will be 16 cheese remaining and making 2 small burgers there will be 15 cheese remaining.

Example 4:

Input: tomatoSlices = 0, cheeseSlices = 0
Output: [0,0]

Example 5:

Input: tomatoSlices = 2, cheeseSlices = 1
Output: [0,1]

Constraints:

• 0 <= tomatoSlices <= 10^7
• 0 <= cheeseSlices <= 10^7

Solution: Math

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

// Author: Huahua
class Solution {
public:
  vector<int> numOfBurgers(int T, int C) {
    // Jumbo = x, small = y
    // 4x + 2y = T
    // x + y = C
    // x = (T - 2C) / 2
    int x = T / 2 - C;
    int y = C - x;
    if (4 * x + 2 * y == T && x >= 0 && y >= 0) return {x, y};
    return {};
  }
};

The post 花花酱 1276. Number of Burgers with No Waste of Ingredients appeared first on Huahua's Tech Road.

Reverse bits of a given 32 bits unsigned integer.

Example 1:

Input: 00000010100101000001111010011100
Output: 00111001011110000010100101000000
Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.

Example 2:

Input: 11111111111111111111111111111101
Output: 10111111111111111111111111111111
Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10101111110010110010011101101001.

Note:

• Note that in some languages such as Java, there is no unsigned integer type. In this case, both input and output will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
• In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 2 above the input represents the signed integer -3 and the output represents the signed integer -1073741825.

Follow up:

If this function is called many times, how would you optimize it?

Solution: Bit operation

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

// Author: Huahua
class Solution {
public:
  uint32_t reverseBits(uint32_t n) {
    uint32_t ans = 0;
    for (int i = 0; i < 32; ++i) {
      ans <<= 1;
      ans |= n & 1;      
      n >>= 1;
    }
    return ans;
  }
};

The post 花花酱 LeetCode 190. Reverse Bits appeared first on Huahua's Tech Road.

Example 1:

Input: 
[
  [1,1,1],
  [1,0,1],
  [1,1,1]
]
Output: 
[
  [1,0,1],
  [0,0,0],
  [1,0,1]
]

Example 2:

Input: 
[
  [0,1,2,0],
  [3,4,5,2],
  [1,3,1,5]
]
Output: 
[
  [0,0,0,0],
  [0,4,5,0],
  [0,3,1,0]
]

Follow up:

• A straight forward solution using O(mn) space is probably a bad idea.
• A simple improvement uses O(m + n) space, but still not the best solution.
• Could you devise a constant space solution?

Solution 1

Use two arrays to track whether the i-th row / j-th column need to be zeroed.

Time complexity: O(mn)
Space complexity: O(m+n)

class Solution {
public:
  void setZeroes(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    vector<int> rows(m);
    vector<int> cols(n);
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        rows[i] |= (matrix[i][j] == 0);
        cols[j] |= (matrix[i][j] == 0);
      }
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (rows[i] || cols[j]) matrix[i][j] = 0;        
  }
};

Solution 2

Use the first row / first col to indicate whether the i-th row / j-th column need be zeroed.

class Solution {
public:
  void setZeroes(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    
    bool col0 = false;
    bool row0 = false;
    
    for (int i = 0; i < m; ++i) 
      col0 |= (matrix[i][0] == 0);
    for (int j = 0; j < n; ++j) 
      row0 |= (matrix[0][j] == 0);
    
    for (int i = 1; i < m; ++i)
      for (int j = 1; j < n; ++j)
        if (matrix[i][j] == 0)
          matrix[0][j] = matrix[i][0] = 0;      
    
    for (int i = 1; i < m; ++i)
      for (int j = 1; j < n; ++j)
        if (matrix[i][0] == 0 || matrix[0][j] == 0)
          matrix[i][j] = 0;
    
    if (row0)
      for (int j = 0; j < n; ++j) 
        matrix[0][j] = 0;
    
    if (col0)
      for (int i = 0; i < m; ++i) 
        matrix[i][0] = 0;
  }
};

The post 花花酱 LeetCode 73. Set Matrix Zeroes appeared first on Huahua's Tech Road.

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than or equal to the node’s key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
• Both the left and right subtrees must also be binary search trees.

For example:
Given BST [1,null,2,2],

1
    \
     2
    /
   2

return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

Solution1: Recursion w/ extra space

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  vector<int> findMode(TreeNode* root) {            
    inorder(root);    
    return ans_;
  }
private:
  int val_ = 0;
  int count_ = 0;  
  int max_count_ = 0;
  vector<int> ans_;
  
  void inorder(TreeNode* root) {
    if (root == nullptr) return;
    inorder(root->left);
    visit(root->val);
    inorder(root->right);
  }
  
  void visit(int val) {
    if (count_ > 0 && val == val_) {
      ++count_;   
    } else {
      val_ = val;
      count_ = 1;
    }
    
    if (count_ > max_count_) {
      max_count_ = count_;
      ans_.clear();
    }
    
    if (count_ == max_count_)
      ans_.push_back(val);
  }
};

Solution2: Recursion w/o extra space

Two passes. First pass to find the count of the mode, second pass to collect all the modes.

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua
// Running time: 8 ms
class Solution {
public:
  vector<int> findMode(TreeNode* root) {            
    inorder(root);    
    mode_count_ = max_count_;    
    count_ = 0;
    inorder(root);
    return ans_;
  }
private:
  int val_ = 0;
  int count_ = 0;
  int mode_count_ = INT_MAX;
  int max_count_ = 0;
  vector<int> ans_;
  
  void inorder(TreeNode* root) {
    if (root == nullptr) return;
    inorder(root->left);
    visit(root->val);
    inorder(root->right);
  }
  
  void visit(int val) {
    if (count_ > 0 && val == val_) {
      ++count_;      
    } else {
      val_ = val;
      count_ = 1;
    }
    
    if (count_ > max_count_)
      max_count_ = count_;
    
    if (count_ == mode_count_)
      ans_.push_back(val);
  }
};

The post 花花酱 LeetCode 501. Find Mode in Binary Search Tree appeared first on Huahua's Tech Road.

Problem

题目大意：设计一种数据结构，支持inc/dec/getmaxkey/getminkey操作，必须都在O(1)时间内完成。

https://leetcode.com/problems/all-oone-data-structure/description/

Solution

Time complexity: O(1)

Space complexity: O(n), n = # of unique keys

// Author: Huahua
// Running time: 32 ms
class AllOne {
public:
  /** Initialize your data structure here. */
  AllOne() {}

  /** Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
  void inc(string key) {
    auto it = m_.find(key);
    
    if (it == m_.end()) {
      if (l_.empty() || l_.front().value != 1) 
        l_.push_front({1, {key}});
      else
        l_.front().keys.insert(key);
      m_[key] = l_.begin();
      return;
    }
    
    auto lit = it->second;
    
    auto nit = next(lit);
    if (nit == l_.end() || nit->value != lit->value + 1)
      nit = l_.insert(nit, {lit->value + 1, {}});
    nit->keys.insert(key);
    m_[key] = nit;
    
    remove(lit, key);
  }

  /** Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
  void dec(string key) {
    auto it = m_.find(key);
    if (it == m_.end()) return;
    
    auto lit = it->second;
        
    if (lit->value > 1) {
      auto pit = prev(lit);
      if (lit == l_.begin() || pit->value != lit->value - 1)
        pit = l_.insert(lit, {lit->value - 1, {}});
      pit->keys.insert(key);
      m_[key] = pit;
    } else {
      // value == 1, remove from the data structure
      m_.erase(key);
    }
    
    remove(lit, key);    
  }

  /** Returns one of the keys with maximal value. */
  string getMaxKey() {
    return l_.empty() ? "" : *l_.back().keys.cbegin();
  }

  /** Returns one of the keys with Minimal value. */
  string getMinKey() {
    return l_.empty() ? "" : *l_.front().keys.cbegin();
  }
private:
  struct Node {  
    int value;
    unordered_set<string> keys;
  };
  
  list<Node> l_;
  unordered_map<string, list<Node>::iterator> m_;
  
  // Remove from old node.
  void remove(list<Node>::iterator it, const string& key) {
    it->keys.erase(key);
    if (it->keys.empty())
      l_.erase(it);
  }
};

Related Problems

• [解题报告] LeetCode 460. LFU Cache 花花酱
• [解题报告] LeetCode 146. LRU Cache O(1)
• [解题报告] LeetCode 380. Insert Delete GetRandom O(1)
• [解题报告] LeetCode 381. Insert Delete GetRandom O(1) – Duplicates allowed

The post 花花酱 LeetCode 432. All O`one Data Structure appeared first on Huahua's Tech Road.

https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/description/

Problem:

Design a data structure that supports all following operations in average O(1) time.

Note: Duplicate elements are allowed.

1. insert(val): Inserts an item val to the collection.
2. remove(val): Removes an item val from the collection if present.
3. getRandom: Returns a random element from current collection of elements. The probability of each element being returned is linearly related to the number of same value the collection contains.

Idea:

Hashtable + array

Solution:

// Author: Huahua
// Running time: 49 ms
class RandomizedCollection {
public:
    /** Initialize your data structure here. */
    RandomizedCollection() {}
    
    /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
    bool insert(int val) {        
        m_[val].push_back(vals_.size());
        vals_.emplace_back(val, m_[val].size() - 1);
        return m_[val].size() == 1u;
    }
    
    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
    bool remove(int val) {
        if (!m_.count(val)) return false;
        int index_to_evict = m_[val].back();
        const auto& last_entry = vals_.back();
        
        // Update index
        m_[last_entry.first][last_entry.second] = index_to_evict;
        
        // Swap vals
        swap(vals_.back(), vals_[index_to_evict]);
        
        // Clenup
        vals_.pop_back();        
        m_[val].pop_back();
        if (m_[val].empty()) m_.erase(val);
        
        return true;
    }
    
    /** Get a random element from the collection. */
    int getRandom() {
        return vals_[rand() % vals_.size()].first;
    }
private:
    // val -> indices array: indices in vals_
    unordered_map<int, vector<int>> m_;
    // {val, index in the indices array}
    vector<pair<int,int>> vals_;
};

Java

// Author: Huahua
// Running time: 122 ms (<94.53%)
class RandomizedCollection {
  class Entry {
    public int value;
    public int index;
    public Entry(int val, int idx) {
      value = val;
      index = idx;
    }
  }
  
  private Map<Integer, List<Integer>> m;
  private List<Entry> vals;
  private Random rand;

  /** Initialize your data structure here. */
  public RandomizedCollection() {
    m = new HashMap<>();
    vals = new ArrayList<>();
    rand = new Random();
  }

  /** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. */
  public boolean insert(int val) {    
    List<Integer> l = m.getOrDefault(val, new ArrayList<Integer>());
    l.add(vals.size());
    m.put(val, l);
    vals.add(new Entry(val, l.size() - 1));
    return l.size() == 1;
  }

  /** Removes a value from the collection. Returns true if the collection contained the specified element. */
  public boolean remove(int val) {    
    if (!m.containsKey(val)) return false;
    List<Integer> l = m.get(val);
    int index_to_evict = l.get(l.size() - 1);
    Entry last_entry = vals.get(vals.size() - 1);

    // Update index
    m.get(last_entry.value).set(last_entry.index, index_to_evict);

    // Swap vals
    vals.set(index_to_evict, last_entry);    

    // Cleanup
    vals.remove(vals.size() - 1);
    l.remove(l.size() - 1);
    if (l.size() == 0) m.remove(val);

    return true;
  }

  /** Get a random element from the collection. */
  public int getRandom() {    
    return vals.get(rand.nextInt(vals.size())).value;
  }
}

Related Problems:

• [解题报告] LeetCode 380. Insert Delete GetRandom O(1)
• [解题报告] LeetCode 460. LFU Cache O(1)
• [解题报告] LeetCode 146. LRU Cache O(1)
• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)

The post 花花酱 LeetCode 381. Insert Delete GetRandom O(1) – Duplicates allowed appeared first on Huahua's Tech Road.

Problem:

Design a data structure that supports all following operations in average O(1) time.

1. insert(val): Inserts an item val to the set if not already present.
2. remove(val): Removes an item val from the set if present.
3. getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.

Idea:

Hashtable + array

Time complexity:

O(1)

Solution:

// Author: Huahua
// Running time: 49 ms
class RandomizedSet {
public:
    /** Initialize your data structure here. */
    RandomizedSet() {}
    
    /** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
    bool insert(int val) {
        if(m_.count(val)) return false;
        m_[val] = vals_.size();
        vals_.push_back(val);
        return true;
    }
    
    /** Removes a value from the set. Returns true if the set contained the specified element. */
    bool remove(int val) {
        if(!m_.count(val)) return false;
        int index = m_[val];
        m_[vals_.back()] = index;
        m_.erase(val);
        std::swap(vals_[index], vals_.back());
        vals_.pop_back();
        return true;
    }
    
    /** Get a random element from the set. */
    int getRandom() {
        int index = rand() % vals_.size();
        return vals_[index];
    }
private:
    // val -> index in the array
    unordered_map<int, int> m_;
    vector<int> vals_;
};

Related Problems:

• LeetCode 381. Insert Delete GetRandom O(1) – Duplicates allowed
• [解题报告] LeetCode 460. LFU Cache O(1)
• [解题报告] LeetCode 146. LRU Cache O(1)
• [解题报告] LeetCode 295. Find Median from Data Stream O(logn) + O(1)

The post 花花酱 LeetCode 380. Insert Delete GetRandom O(1) appeared first on Huahua's Tech Road.