Hard Archives - Huahua's Tech Road

花花酱 LeetCode 282. Expression Add Operators

zxi — Wed, 31 Jan 2018 07:00:21 +0000

题目大意：给你一个字符串，让你在数字之间加上+,-,*使得等式的值等于target。让你输出所有满足条件的表达式。

Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.

Examples:

"123", 6 -> ["1+2+3", "1*2*3"] 
"232", 8 -> ["2*3+2", "2+3*2"]
"105", 5 -> ["1*0+5","10-5"]
"00", 0 -> ["0+0", "0-0", "0*0"]
"3456237490", 9191 -> []

Slides:

Solution 1: DFS

Time complexity: O(4^n)

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

C++

// Author: Huahua
// Running time: 128 ms (<79.97%)
class Solution {
public:
  vector addOperators(string num, int target) {
    vector ans;
    dfs(num, target, 0, "", 0, 0, &ans);
    return ans;
  }
private:
  void dfs(const string& num, const int target,  // input
           int pos, const string& exp, long prev, long curr, // state
           vector* ans) {  // output
    if (pos == num.length()) {
      if (curr == target) ans->push_back(exp);
      return;
    }
    
    for (int l = 1; l <= num.size() - pos; ++l) {
      string t = num.substr(pos, l);    
      if (t[0] == '0' && t.length() > 1) break; // 0X...
      long n = std::stol(t);
      if (n > INT_MAX) break;
      if (pos == 0) {
        dfs(num, target, l, t, n, n, ans);
        continue;
      }
      dfs(num, target, pos + l, exp + '+' + t, n, curr + n, ans);
      dfs(num, target, pos + l, exp + '-' + t, -n, curr - n, ans);
      dfs(num, target, pos + l, exp + '*' + t, prev * n, curr - prev + prev * n, ans);
    }    
  }
};

C++ / SC O(n)

// Author: Huahua
// Running time: 13 ms (< 99.14%)
class Solution {
public:
  vector addOperators(string num, int target) {
    vector ans;
    string exp(num.length() * 2, '\0');    
    dfs(num, target, 0, exp, 0, 0, 0, &ans);
    return ans;
  }
private:
  void dfs(const string& num, const int target,
           int pos, string& exp, int len, long prev, long curr,
           vector* ans) {    
    if (pos == num.length()) {      
      if (curr == target) ans->push_back(exp.substr(0, len));
      return;
    }
    
    long n = 0;
    int s = pos;
    int l = len;
    if (s != 0) ++len;    
    while (pos < num.size()) {      
      n = n * 10 + (num[pos] - '0');
      if (num[s] == '0' && pos - s > 0) break; // 0X... invalid number
      if (n > INT_MAX) break; // too long
      exp[len++] = num[pos++];
      if (s == 0) {
        dfs(num, target, pos, exp, len, n, n, ans);
        continue;
      }
      exp[l] = '+'; dfs(num, target, pos, exp, len, n, curr + n, ans);
      exp[l] = '-'; dfs(num, target, pos, exp, len, -n, curr - n, ans);
      exp[l] = '*'; dfs(num, target, pos, exp, len, prev * n, curr - prev + prev * n, ans);
    }
  }
};

Java

// Author: Huahua
// Running time: 16 ms (<99.17%)
class Solution {
  private List ans;
  private char[] num;
  private char[] exp;
  private int target;
  
  public List addOperators(String num, int target) {
    this.num = num.toCharArray();
    this.ans = new ArrayList<>();
    this.target = target;
    this.exp = new char[num.length() * 2];
    dfs(0, 0, 0, 0);
    return ans;
  }
  
  private void dfs(int pos, int len, long prev, long curr) {
    if (pos == num.length) {      
      if (curr == target)
        ans.add(new String(exp, 0, len));
      return;
    }
    
    int s = pos;
    int l = len;
    if (s != 0) ++len;
    
    long n = 0;
    while (pos < num.length) {
      if (num[s] == '0' && pos - s > 0) break; // 0X...
      n = n * 10 + (int)(num[pos] - '0');      
      if (n > Integer.MAX_VALUE) break; // too long
      exp[len++] = num[pos++]; // copy exp
      if (s == 0) {
        dfs(pos, len, n, n);
        continue;
      }
      exp[l] = '+'; dfs(pos, len, n, curr + n);
      exp[l] = '-'; dfs(pos, len, -n, curr - n);
      exp[l] = '*'; dfs(pos, len, prev * n, curr - prev + prev * n);
    }
  }
}

The post 花花酱 LeetCode 282. Expression Add Operators appeared first on Huahua's Tech Road.

花花酱 LeetCode 480. Sliding Window Median

zxi — Sun, 28 Jan 2018 08:56:53 +0000

题目大意：让你求移动窗口的中位数。

Problem:

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:

[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Your job is to output the median array for each window in the original array.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position                Median
---------------               -----
[1  3  -1] -3  5  3  6  7       1
 1 [3  -1  -3] 5  3  6  7       -1
 1  3 [-1  -3  5] 3  6  7       -1
 1  3  -1 [-3  5  3] 6  7       3
 1  3  -1  -3 [5  3  6] 7       5
 1  3  -1  -3  5 [3  6  7]      6

Therefore, return the median sliding window as [1,-1,-1,3,5,6].

Note:
You may assume k is always valid, ie: k is always smaller than input array’s size for non-empty array.

Solution 0: Brute Force

Time complexity: O(n*klogk) TLE 32/42 test cases passed

Solution 1: Insertion Sort

Time complexity: O(k*logk + (n – k + 1)*k)

Space complexity: O(k)

C++ / vector

// Author: Huahua
// Running time: 99 ms
class Solution {
public:
  vector medianSlidingWindow(vector& nums, int k) {    
    vector ans;
    if (k == 0) return ans;
    vector window(nums.begin(), nums.begin() + k - 1);
    std::sort(window.begin(), window.end());
    for (int i = k - 1; i < nums.size(); ++i) {
      window.push_back(nums[i]);
      auto it = prev(window.end(), 1);
      auto const insertion_point = 
              std::upper_bound(window.begin(), it, *it);      
      std::rotate(insertion_point, it, it + 1);          
      ans.push_back((static_cast(window[k / 2]) + window[(k - 1) / 2]) / 2);
      window.erase(std::find(window.begin(), window.end(), nums[i - k + 1]));      
    }
    return ans;
  }
};

C++ / vector + binary_search for deletion.

// Author: Huahua
// Running time: 84 ms
class Solution {
public:
  vector medianSlidingWindow(vector& nums, int k) {    
    vector ans;
    if (k == 0) return ans;
    vector window(nums.begin(), nums.begin() + k - 1);
    std::sort(window.begin(), window.end());
    for (int i = k - 1; i < nums.size(); ++i) {
      window.push_back(nums[i]);
      auto it = prev(window.end(), 1);
      auto const insertion_point = 
              std::upper_bound(window.begin(), it, *it);      
      std::rotate(insertion_point, it, it + 1);          
      ans.push_back((static_cast(window[k / 2]) + window[(k - 1) / 2]) / 2);
      window.erase(std::lower_bound(window.begin(), window.end(), nums[i - k + 1]));      
    }
    return ans;
  }
};

Java

// Author: Huahua
// Running time: 60 ms
class Solution {
  public double[] medianSlidingWindow(int[] nums, int k) {
    if (k == 0) return new double[0];
    double[] ans = new double[nums.length - k + 1];
    int[] window = new int[k];
    for (int i = 0; i < k; ++i) 
      window[i] = nums[i];
    Arrays.sort(window);
    for (int i = k; i <= nums.length; ++i) {
      ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;
      if (i == nums.length) break;
      remove(window, nums[i - k]);
      insert(window, nums[i]);
    }
    return ans;
  }
  
  // Insert val into window, window[k - 1] is empty before inseration
  private void insert(int[] window, int val) {
    int i = 0;
    while (i < window.length - 1 && val > window[i]) ++i;
    int j = window.length - 1;
    while (j > i) window[j] = window[--j];
    window[j] = val;
  }
  
  // Remove val from window and shrink it.
  private void remove(int[] window, int val) {
    int i = 0;
    while (i < window.length && val != window[i]) ++i;
    while (i < window.length - 1) window[i] = window[++i];
  }
}

Java / Binary Search

// Author: Huahua
// Running time: 47 ms (<98.96%)
class Solution {
  public double[] medianSlidingWindow(int[] nums, int k) {
    if (k == 0) return new double[0];
    double[] ans = new double[nums.length - k + 1];
    int[] window = new int[k];
    for (int i = 0; i < k; ++i) 
      window[i] = nums[i];
    Arrays.sort(window);
    for (int i = k; i <= nums.length; ++i) {
      ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;
      if (i == nums.length) break;
      remove(window, nums[i - k]);
      insert(window, nums[i]);
    }
    return ans;
  }
  
  // Insert val into window, window[k - 1] is empty before inseration
  private void insert(int[] window, int val) {
    int i = Arrays.binarySearch(window, val);
    if (i < 0) i = - i - 1;    
    int j = window.length - 1;
    while (j > i) window[j] = window[--j];
    window[j] = val;
  }
  
  // Remove val from window and shrink it.
  private void remove(int[] window, int val) {
    int i = Arrays.binarySearch(window, val);
    while (i < window.length - 1) window[i] = window[++i];
  }
  
  
}

Python

"""
Author: Huahua
Running time: 161 ms (< 93.75%)
"""
class Solution:
  def medianSlidingWindow(self, nums, k):
    if k == 0: return []
    ans = []
    window = sorted(nums[0:k])
    for i in range(k, len(nums) + 1):
      ans.append((window[k // 2] + window[(k - 1) // 2]) / 2.0)
      if i == len(nums): break
      index = bisect.bisect_left(window, nums[i - k])
      window.pop(index)      
      bisect.insort_left(window, nums[i])
    return ans

Solution 2: BST

// Author: Huahua
// Running time: 68 ms
class Solution {
public:
  vector medianSlidingWindow(vector& nums, int k) {    
    vector ans;
    if (k == 0) return ans;
    multiset window(nums.begin(), nums.begin() + k);
    auto mid = next(window.begin(), (k - 1) / 2);    
    for (int i = k; i <= nums.size(); ++i) {
      ans.push_back((static_cast(*mid) + 
                     *next(mid, (k + 1) % 2)) / 2.0);
      if (i == nums.size()) break;
      
      window.insert(nums[i]);
      if (nums[i] < *mid) --mid; 
      if (nums[i - k] <= *mid) ++mid;
      window.erase(window.lower_bound(nums[i - k])); 
    }
    return ans;
  }
};

Related Problems:

The post 花花酱 LeetCode 480. Sliding Window Median appeared first on Huahua's Tech Road.

花花酱 LeetCode 759. Employee Free Time

zxi — Tue, 09 Jan 2018 02:11:26 +0000

题目大意：给你每个员工的日历，让你找出所有员工都有空的时间段。

Problem:

We are given a list schedule of employees, which represents the working time for each employee.

Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.

Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.

Example 1:

Input: schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]]
Output: [[3,4]]
Explanation:
There are a total of three employees, and all common
free time intervals would be [-inf, 1], [3, 4], [10, inf].
We discard any intervals that contain inf as they aren't finite.

Example 2:

Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]
Output: [[5,6],[7,9]]

(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2, and schedule[0][0][0] is not defined.)

Also, we wouldn’t include intervals like [5, 5] in our answer, as they have zero length.

Note:

schedule and schedule[i] are lists with lengths in range [1, 50].
0 <= schedule[i].start < schedule[i].end <= 10^8.

Idea:

Merge Intervals (virtually)

Solution:

C++

Time complexity: O(nlogn)

Space complexity: O(n)

n is the total number of intervals, n <= 2500

// Author: Huahua
// Running time: 81 ms
class Solution {
public:
    vector employeeFreeTime(vector>& schedule) {
      vector all;
      for (const auto intervals : schedule)
        all.insert(all.end(), intervals.begin(), intervals.end());
      std::sort(all.begin(), all.end(), 
                [](const Interval& a, const Interval& b){
                  return a.start < b.start;
                });
      vector ans;
      int end = all.front().end;
      for (const Interval& busy : all) {
        if (busy.start > end) 
          ans.emplace_back(end, busy.start);  
        end = max(end, busy.end);
      }
      return ans;
    }
};

Related Problems:

The post 花花酱 LeetCode 759. Employee Free Time appeared first on Huahua's Tech Road.

花花酱 LeetCode 752. Open the Lock

zxi — Mon, 25 Dec 2017 17:13:30 +0000

Problem:

You have a lock in front of you with 4 circular wheels. Each wheel has 10 slots: '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'. The wheels can rotate freely and wrap around: for example we can turn '9' to be '0', or '0' to be '9'. Each move consists of turning one wheel one slot.

The lock initially starts at '0000', a string representing the state of the 4 wheels.

You are given a list of deadends dead ends, meaning if the lock displays any of these codes, the wheels of the lock will stop turning and you will be unable to open it.

Given a target representing the value of the wheels that will unlock the lock, return the minimum total number of turns required to open the lock, or -1 if it is impossible.

Example 1:

Input: deadends = ["0201","0101","0102","1212","2002"], target = "0202"
Output: 6
Explanation:
A sequence of valid moves would be "0000" -> "1000" -> "1100" -> "1200" -> "1201" -> "1202" -> "0202".
Note that a sequence like "0000" -> "0001" -> "0002" -> "0102" -> "0202" would be invalid,
because the wheels of the lock become stuck after the display becomes the dead end "0102".

Example 2:

Input: deadends = ["8888"], target = "0009"
Output: 1
Explanation:
We can turn the last wheel in reverse to move from "0000" -> "0009".

Example 3:

Input: deadends = ["8887","8889","8878","8898","8788","8988","7888","9888"], target = "8888"
Output: -1
Explanation:
We can't reach the target without getting stuck.

Example 4:

Input: deadends = ["0000"], target = "8888"
Output: -1

Note:

The length of deadends will be in the range [1, 500].
target will not be in the list deadends.
Every string in deadends and the string target will be a string of 4 digits from the 10,000 possibilities '0000' to '9999'.

题目大意：

给你一个4位密码锁，0可以转到1和9，1可以转到0和2，。。。，9可以转到0和8。

另外给你一些死锁的密码，比如1234，一但转到任何一个死锁的密码，锁就无法再转动了。

给你一个目标密码，问你最少要转多少次才能从0000转到目标密码。

Solution:

C++

// Author: Huahua
// Runtime: 133 ms
class Solution {
public:
  int openLock(vector& deadends, string target) {
    const string start = "0000";
    unordered_set dead(deadends.begin(), deadends.end());
    if (dead.count(start)) return -1;
    if (start == target) return 0;
    
    queue q;
    unordered_set visited{start};
    
    int steps = 0;
    q.push(start);
    while (!q.empty()) {
      ++steps;
      const int size = q.size();
      for (int i = 0; i < size; ++i) {
        const string curr = q.front(); 
        q.pop();
        for (int i = 0; i < 4; ++i)
          for (int j = -1; j <= 1; j += 2) {
            string next = curr;
            next[i] = (next[i] - '0' + j + 10) % 10 + '0';
            if (next == target) return steps;
            if (dead.count(next) || visited.count(next)) continue; 
            q.push(next);
            visited.insert(next);
          }
      }
    }
    
    return -1;
  }
};

C++ / Bidirectional BFS

// Author: Huahua
// Runtime: 32 ms
class Solution {
public:
  int openLock(vector& deadends, string target) {
    const string start = "0000";
    unordered_set dead(deadends.begin(), deadends.end());
    if (dead.count(start)) return -1;
    if (target == start) return 0;
    
    queue q1;
    queue q2;
    unordered_set v1{start};
    unordered_set v2{target};
    
    int s1 = 0;
    int s2 = 0;
    q1.push(start);
    q2.push(target);
    while (!q1.empty() && !q2.empty()) {      
      if (!q1.empty()) ++s1;
      const int size = q1.size();
      for (int i = 0; i < size; ++i) {
        const string curr = q1.front(); 
        q1.pop();
        for (int i = 0; i < 4; ++i)
          for (int j = -1; j <= 1; j += 2) {
            string next = curr;
            next[i] = (next[i] - '0' + j + 10) % 10 + '0';
            if (v2.count(next)) return s1 + s2;
            if (dead.count(next) || v1.count(next)) continue; 
            q1.push(next);
            v1.insert(next);
          }
      }
      swap(q1, q2);
      swap(v1, v2);
      swap(s1, s2);
    }
    
    return -1;
  }    
};

C++ / Bidirectional BFS / int state / Array

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
  int openLock(vector& deadends, string target) {
    constexpr int kMaxN = 10000;
    const vector bases{1, 10, 100, 1000};
    const int start = 0;
    const int goal = stoi(target);
    
    queue q1;
    queue q2;
    vector v1(kMaxN, 0);
    vector v2(kMaxN, 0);  
    for (const string& deadend : deadends)
        v1[stoi(deadend)] = v2[stoi(deadend)] = -1;
    
    if (v1[start] == -1) return -1;
    if (start == goal) return 0;
    
    v1[start] = 1;
    v2[goal] = 1;
    
    int s1 = 0;
    int s2 = 0;
    q1.push(start);
    q2.push(goal);
    while (!q1.empty() && !q2.empty()) {      
      if (!q1.empty()) ++s1;
      const int size = q1.size();
      for (int i = 0; i < size; ++i) {
        const int curr = q1.front(); 
        q1.pop();
        for (int i = 0; i < 4; ++i) {
          int r = (curr / bases[i]) % 10;
          for (int j = -1; j <= 1; j += 2) {
            const int next = curr + ((r + j + 10) % 10 - r) * bases[i];
            if (v2[next] == 1) return s1 + s2;
            if (v1[next]) continue;            
            q1.push(next);
            v1[next] = 1;
          }
        }
      }
      swap(q1, q2);
      swap(v1, v2);
      swap(s1, s2);
    }    
    return -1;
  }
};

Java

// Author: Huahua
// Runtime: 132 ms
class Solution {
  public int openLock(String[] deadends, String target) {
    String start = "0000";
    Set dead = new HashSet();
    for (String d: deadends) dead.add(d);
    if (dead.contains(start)) return -1;

    Queue queue = new LinkedList();
    queue.offer(start);        

    Set visited = new HashSet();
    visited.add(start);

    int steps = 0;
    while (!queue.isEmpty()) {
      ++steps;
      int size = queue.size();
      for (int s = 0; s < size; ++s) {
        String node = queue.poll();
        for (int i = 0; i < 4; ++i) {
          for (int j = -1; j <= 1; j += 2) {
            char[] chars = node.toCharArray();
            chars[i] = (char)(((chars[i] - '0') + j + 10) % 10 + '0');
            String next = new String(chars);
            if (next.equals(target)) return steps;
            if (dead.contains(next) || visited.contains(next))
                continue;
            visited.add(next);
            queue.offer(next);
          }
        }
      }
    }
    return -1;
  }
}

Python

"""
Author: Huahua
Runtime: 955 ms
"""
class Solution:
    def openLock(self, deadends, target):
        from collections import deque
        deads = set(deadends)
        start = '0000'
        if start in deads: return -1
        q = deque([(start, 0)])        
        visited = set(start)        
        while q:                
            node, step = q.popleft()
            for i in range(0, 4):
                for j in [-1, 1]:
                    nxt = node[:i] + str((int(node[i]) + j + 10) % 10) + node[i+1:]
                    if nxt == target: return step + 1
                    if nxt in deads or nxt in visited: continue
                    q.append((nxt, step + 1))
                    visited.add(nxt)
        return -1

Python / Int state

"""
Author: Huahua
Runtime: 568 ms
"""
class Solution:
    def openLock(self, deadends, target):
        from collections import deque
        bases = [1, 10, 100, 1000]
        deads = set(int(x) for x in deadends)
        start, goal = int('0000'), int(target)        
        if start in deads: return -1
        if start == goal: return 0
        q = deque([(start, 0)])
        visited = set([start])
        while q:   
            node, step = q.popleft()
            for i in range(0, 4):
                r = (node // bases[i]) % 10
                for j in [-1, 1]:
                    nxt = node + ((r + j + 10) % 10 - r) * bases[i]
                    if nxt == goal: return step + 1
                    if nxt in deads or nxt in visited: continue
                    q.append((nxt, step + 1))
                    visited.add(nxt)
        return -1

The post 花花酱 LeetCode 752. Open the Lock appeared first on Huahua's Tech Road.

花花酱 LeetCode 301. Remove Invalid Parentheses

zxi — Fri, 22 Dec 2017 00:23:07 +0000

Problem:

Remove the minimum number of invalid parentheses in order to make the input string valid. Return all possible results.

Note: The input string may contain letters other than the parentheses ( and ).

Examples:

"()())()" -> ["()()()", "(())()"]
"(a)())()" -> ["(a)()()", "(a())()"]
")(" -> [""]

题目大意：给你一个字符串，由”(” “)”和其他字符构成。让你删除数量最少的括号使得表达式合法（括号都匹配）。输出所有的合法表达式。

Idea:

Solution: DFS

C++

// Author: Huahua
// Runtime: 0 ms
class Solution {
public:
  vector removeInvalidParentheses(const string& s) {        
    int l = 0;
    int r = 0;

    for (const char ch : s) {
      l += (ch == '(');
      if (l == 0)
        r += (ch == ')');
      else
        l -= (ch == ')');
    }

    vector ans;
    dfs(s, 0, l, r, ans);
    return ans;
  }
private:
  bool isValid(const string& s) {
    int count = 0;
    for (const char ch : s) {
      if (ch == '(') ++count;
      if (ch == ')') --count;
      if (count < 0) return false;
    }
    return count == 0;
  }

  // l/r: number of left/right parentheses to remove.
  void dfs(const string& s, int start, int l, int r, vector& ans) {
    // Nothing to remove.
    if (l == 0 && r == 0) {
      if (isValid(s)) ans.push_back(s);
      return;
    }

    for (int i = start; i < s.length(); ++i) {
      // We only remove the first parenthes if there are consecutive ones to avoid duplications.
      if (i != start && s[i] == s[i - 1]) continue;

      if (s[i] == '(' || s[i] == ')') {
        string curr = s;
        curr.erase(i, 1);
        if (r > 0 && s[i] == ')') 
          dfs(curr, i, l, r - 1, ans);
        else if (l > 0 && s[i] == '(')
          dfs(curr, i, l - 1, r, ans);
      }
    }
  }
};

The post 花花酱 LeetCode 301. Remove Invalid Parentheses appeared first on Huahua's Tech Road.

花花酱 LeetCode 164. Maximum Gap

zxi — Mon, 11 Dec 2017 00:19:22 +0000

https://leetcode.com/problems/maximum-gap/description/

Problem:

Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

Try to solve it in linear time/space.

Return 0 if the array contains less than 2 elements.

You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.

题目大意:

给你一个没有排序的正整数数组。输出排序后，相邻元素的差的最大值(Max Gap)。需要在线性时间内解决。

Example:

Input: [5, 0, 4, 2, 12, 10]

Output: 5

Explanation:

Sorted: [0, 2, 4, 5, 10, 12]

max gap is 10 – 5 = 5

Idea:

Bucket sort. Use n buckets to store all the numbers. For each bucket, only track the min / max value.

桶排序。用n个桶来存放数字。对于每个桶，只跟踪存储最大值和最小值。

max gap must come from two “adjacent” buckets, b[i], b[j], j > i, b[i+1] … b[j – 1] must be empty.

max gap 只可能来自”相邻”的两个桶 b[i] 和 b[j], j > i, b[i] 和 b[j] 之间的桶（如果有）必须为空。

max gap = b[j].min – b[i].min

Time complexity: O(n)

时间复杂度: O(n)

Space complexity: O(n)

空间复杂度: O(n)

Solution:

C++

// Author: Huahua
// Runtime: 6 ms
class Solution {
public:
    int maximumGap(vector& nums) {
        const int n = nums.size();
        if (n <= 1) return 0;
        
        const auto mm = minmax_element(nums.begin(), nums.end());
        const int range = *mm.second - *mm.first;
        const int bin_size = range / n + 1;
        vector min_vals(n, INT_MAX);
        vector max_vals(n, INT_MIN);
        for (const int num : nums) {
            const int index = (num - *mm.first) / bin_size;
            min_vals[index] = min(min_vals[index], num);
            max_vals[index] = max(max_vals[index], num);
        }
        
        int max_gap = 0;
        int prev_max = max_vals[0];
        for (int i = 1; i < n; ++i) {
            if (min_vals[i] != INT_MAX) {
                max_gap = max(max_gap, min_vals[i] - prev_max);
                prev_max = max_vals[i];
            }
        }
        return max_gap;
    }
};

The post 花花酱 LeetCode 164. Maximum Gap appeared first on Huahua's Tech Road.

花花酱 LeetCode 732. My Calendar III

zxi — Thu, 07 Dec 2017 05:29:41 +0000

Problem:

link: https://leetcode.com/problems/my-calendar-iii/description/

Implement a MyCalendarThree class to store your events. A new event can always be added.

Your class will have one method, book(int start, int end). Formally, this represents a booking on the half open interval [start, end), the range of real numbers x such that start <= x < end.

A K-booking happens when K events have some non-empty intersection (ie., there is some time that is common to all K events.)

For each call to the method MyCalendar.book, return an integer K representing the largest integer such that there exists a K-booking in the calendar.

Your class will be called like this: MyCalendarThree cal = new MyCalendarThree();MyCalendarThree.book(start, end)

Example 1:

MyCalendarThree();
MyCalendarThree.book(10, 20); // returns 1
MyCalendarThree.book(50, 60); // returns 1
MyCalendarThree.book(10, 40); // returns 2
MyCalendarThree.book(5, 15); // returns 3
MyCalendarThree.book(5, 10); // returns 3
MyCalendarThree.book(25, 55); // returns 3
Explanation: 
The first two events can be booked and are disjoint, so the maximum K-booking is a 1-booking.
The third event [10, 40) intersects the first event, and the maximum K-booking is a 2-booking.
The remaining events cause the maximum K-booking to be only a 3-booking.
Note that the last event locally causes a 2-booking, but the answer is still 3 because
eg. [10, 20), [10, 40), and [5, 15) are still triple booked.

Note:

The number of calls to MyCalendarThree.book per test case will be at most 400.
In calls to MyCalendarThree.book(start, end), start and end are integers in the range [0, 10^9].

Idea:

Similar to LeetCode 731 My Calendar II Use an ordered / tree map to track the number of event at current time.

For a new book event, increase the number of events at start, decrease the number of events at end.

Scan the timeline to find the maximum number of events.

Solution 1: Count Boundaries

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua
// Runtime: 116 ms
class MyCalendarThree {
public:
    MyCalendarThree() {}
    
    int book(int start, int end) {
        ++deltas_[start];
        --deltas_[end];
        int ans = 0;
        int curr = 0;
        for (const auto& kv : deltas_)            
            ans = max(ans, curr += kv.second);
        return ans;
    }
private:
    map deltas_;
};

Solution 2

C++

// Author: Huahua
// Runtime: 66 ms
class MyCalendarThree {
public:
    MyCalendarThree() {
        counts_[INT_MIN] = 0;
        counts_[INT_MAX] = 0;
        max_count_ = 0;
    }
    
    int book(int start, int end) {        
        auto l = prev(counts_.upper_bound(start));   // l->first < start
        auto r = counts_.lower_bound(end);           // r->first >= end
        for (auto curr = l, next = curr; curr != r; curr = next) {
            ++next;
            
            if (next->first > end)
                counts_[end] = curr->second;
            
            if (curr->first <= start && next->first > start)
                max_count_ = max(max_count_, counts_[start] = curr->second + 1);            
            else
                max_count_ = max(max_count_, ++curr->second);
        }
        
        return max_count_;
    }
private:
    map counts_;
    int max_count_;
};

Solution 3: Segment Tree

C++

// Author: Huahua
// Runtime: 63 ms (<95.65%)
class MyCalendarThree {
public:
    MyCalendarThree(): max_count_(0) {
        root_.reset(new Node(0, 100000000, 0));        
    }
    
    int book(int start, int end) {
        Add(start, end, root_.get());
        return max_count_;
    }
private:
    struct Node {
        Node(int l, int r, int count):l(l), m(-1), r(r), count(count){}
        int l;
        int m;
        int r;
        int count;
        std::unique_ptr left;
        std::unique_ptr right;
    };
    
    void Add(int start, int end, Node* root) {
        if (root->m != -1) {
            if (end <= root->m) 
                Add(start, end, root->left.get());
            else if(start >= root->m)
                Add(start, end, root->right.get());
            else {
                Add(start, root->m, root->left.get());
                Add(root->m, end, root->right.get());
            }
            return;
        }
        
        if (start == root->l && end == root->r)
            max_count_ = max(max_count_, ++root->count);
        else if (start == root->l) {
            root->m = end;
            root->left.reset(new Node(start, root->m, root->count + 1));
            root->right.reset(new Node(root->m, root->r, root->count));
            max_count_ = max(max_count_, root->count + 1);
        } else if(end == root->r) {
            root->m = start;
            root->left.reset(new Node(root->l, root->m, root->count));
            root->right.reset(new Node(root->m, root->r, root->count + 1));
            max_count_ = max(max_count_, root->count + 1);
        } else {
            root->m = start;
            root->left.reset(new Node(root->l, root->m, root->count));
            root->right.reset(new Node(root->m, root->r, root->count));
            Add(start, end, root->right.get());
        }
    }
    
    std::unique_ptr root_;
    int max_count_;
};

Python3

"""
Author: Huahua
Runtime: 436 ms (<88.88%)
"""
class Node:
    def __init__(self, l, r, count):
        self.l = l
        self.m = -1
        self.r = r            
        self.count = count
        self.left = None
        self.right = None
            
class MyCalendarThree:        
    def __init__(self):
        self.root = Node(0, 10**9, 0)
        self.max = 0

    def book(self, start, end):
        self.add(start, end, self.root)
        return self.max
    
    def add(self, start, end, root):
        if root.m != -1:
            if end <= root.m: self.add(start, end, root.left)
            elif start >= root.m: self.add(start, end, root.right)
            else:
                self.add(start, root.m, root.left)
                self.add(root.m, end, root.right)
            return
        
        if start == root.l and end == root.r:
            root.count += 1
            self.max = max(self.max, root.count)
        elif start == root.l:
            root.m = end
            root.left = Node(start, root.m, root.count + 1)
            root.right = Node(root.m, root.r, root.count)
            self.max = max(self.max, root.count + 1)
        elif end == root.r:
            root.m = start;
            root.left = Node(root.l, root.m, root.count)
            root.right = Node(root.m, root.r, root.count + 1)
            self.max = max(self.max, root.count + 1)
        else:
            root.m = start
            root.left = Node(root.l, root.m, root.count)
            root.right = Node(root.m, root.r, root.count)
            self.add(start, end, root.right)

Related Problems:

The post 花花酱 LeetCode 732. My Calendar III appeared first on Huahua's Tech Road.

花花酱 LeetCode 312. Burst Balloons

zxi — Mon, 27 Nov 2017 16:42:23 +0000

Problem:

Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and rightthen becomes adjacent.

Find the maximum coins you can collect by bursting the balloons wisely.

Note:
(1) You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
(2) 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100

Example:

Given [3, 1, 5, 8]

Return 167

nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
   coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167

Idea

Solution1:

C++ / Recursion with memoization

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
    int maxCoins(vector& nums) {
        int n = nums.size();
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        
        // c[i][j] = maxCoins(nums[i:j+1])
        c_ = vector>(n+2, vector(n+2, 0));
        
        return maxCoins(nums, 1, n);
    }
private:
    int maxCoins(const vector& nums, const int i, const int j) {
        if(i>j) return 0;
        if(c_[i][j]>0) return c_[i][j];
        
        if(i==j) return nums[i-1]*nums[i]*nums[i+1];
        
        int ans=0;
        for(int k=i;k<=j;++k)
             ans=max(ans, maxCoins(nums,i,k-1) + nums[i-1]*nums[k]*nums[j+1] + maxCoins(nums, k+1, j));
        
        c_[i][j] = ans;
        
        return c_[i][j];
    }
    
    vector> c_;
};

Java

// Author: Huahua
class Solution {
  private int[][] memo;
  private int[] vals;
  public int maxCoins(int[] nums) {
    final int n = nums.length;
    vals = new int[n + 2];
    for (int i = 0; i < n; ++i) vals[i + 1] = nums[i];
    vals[0] = vals[n + 1] = 1;
    memo = new int[n + 2][n + 2];
    return maxCoins(1, n);
  }
  
  private int maxCoins(int i, int j) {
    if (i > j) return 0;
    if (i == j) return vals[i - 1] * vals[i] * vals[i + 1];
    if (memo[i][j] > 0) return memo[i][j];
    int ans = 0;
    for (int k = i; k <= j; ++k)
      ans = Math.max(ans, maxCoins(i, k - 1) + vals[i - 1] * vals[k] * vals[j + 1] + maxCoins(k + 1, j));
    memo[i][j] = ans;
    return memo[i][j];
  }
}

Solution2:

C++ / DP

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    int maxCoins(vector& nums) {
        int n = nums.size();
        nums.insert(nums.begin(), 1);
        nums.push_back(1);
        
        // c[i][j] = maxCoins(nums[i:j+1])
        vector> c(n+2, vector(n+2, 0));
        
        for(int l=1;l<=n;++l)
            for(int i=1;i<=n-l+1;++i) {
                int j=i+l-1;
                for(int k=i;k<=j;++k) {
                    c[i][j] = max(c[i][j], c[i][k-1] + nums[i-1]*nums[k]*nums[j+1] + c[k+1][j]);
                }
            }
        
        return c[1][n];
    }
};

Java / DP

Java

// Author: Huahua
class Solution {
  public int maxCoins(int[] nums) {
    final int n = nums.length;
    int[] vals = new int[n + 2];
    for (int i = 0; i < n; ++i) vals[i + 1] = nums[i];
    vals[0] = vals[n + 1] = 1;
    int[][] dp = new int[n + 2][n + 2];
    for (int l = 1; l <= n; ++l)
      for (int i = 1; i + l <= n + 1; ++i) {
        int j = i + l - 1;
        int best = 0;
        for (int k = i; k <= j; ++k)
          best = Math.max(best, 
                          dp[i][k - 1] + vals[i - 1] * vals[k] * vals[j + 1] + dp[k + 1][j]);
        dp[i][j] = best;
      }
    return dp[1][n];        
  }
}

The post 花花酱 LeetCode 312. Burst Balloons appeared first on Huahua's Tech Road.

花花酱 LeetCode 639. Decode Ways II

zxi — Sun, 19 Nov 2017 03:53:39 +0000

Problem:

A message containing letters from A-Z is being encoded to numbers using the following mapping way:

'A' -> 1
'B' -> 2
...
'Z' -> 26

Beyond that, now the encoded string can also contain the character ‘*’, which can be treated as one of the numbers from 1 to 9.

Given the encoded message containing digits and the character ‘*’, return the total number of ways to decode it.

Also, since the answer may be very large, you should return the output mod 10⁹ + 7.

Example 1:

Input: "*"
Output: 9
Explanation: The encoded message can be decoded to the string:
"A", "B", "C", "D", "E", "F", "G", "H", "I".

Example 2:

Input: "1*"
Output: 9 + 9 = 18

Note:

The length of the input string will fit in range [1, 10⁵].
The input string will only contain the character ‘*’ and digits ‘0’ – ‘9’.

Idea:

Time complexity: O(n)

Space complexity: O(1)

Solution:

C++

// Author: Huahua
// Runtime: 58 ms
class Solution {
public:
    int numDecodings(string s) {
        if (s.empty()) return 0;        
        //           dp[-1]  dp[0]
        long dp[2] = {1, ways(s[0])};
        for (int i = 1; i < s.length(); ++i) {
            long dp_i = ways(s[i]) * dp[1] + ways(s[i - 1], s[i]) * dp[0];
            dp_i %= kMod;
            dp[0] = dp[1];
            dp[1] = dp_i;
        }
        return dp[1];
    }
private:
    static constexpr int kMod = 1000000007;    
    
    int ways(char c) {
        if (c == '0') return 0;
        if (c == '*') return 9;
        return 1;
    }
    
    int ways(char c1, char c2) {
        if (c1 == '*' && c2 == '*') 
            return 15;
        if (c1 == '*') {
          return (c2 >= '0' && c2 <= '6') ? 2 : 1;
        } else if (c2 == '*') {
            switch (c1) {
                case '1': return 9;
                case '2': return 6;
                default: return 0;
            }
        } else {
            int prefix = (c1 - '0') * 10 + (c2 - '0');
            return prefix >= 10 && prefix <= 26;
        }        
    }
};

Related Problems:

[解题报告] LeetCode 91. Decode Ways

The post 花花酱 LeetCode 639. Decode Ways II appeared first on Huahua's Tech Road.

花花酱 LeetCode 726. Number of Atoms

zxi — Thu, 16 Nov 2017 06:09:20 +0000

Problem:

Given a chemical formula (given as a string), return the count of each atom.

An atomic element always starts with an uppercase character, then zero or more lowercase letters, representing the name.

1 or more digits representing the count of that element may follow if the count is greater than 1. If the count is 1, no digits will follow. For example, H2O and H2O2 are possible, but H1O2 is impossible.

Two formulas concatenated together produce another formula. For example, H2O2He3Mg4 is also a formula.

A formula placed in parentheses, and a count (optionally added) is also a formula. For example, (H2O2) and (H2O2)3 are formulas.

Given a formula, output the count of all elements as a string in the following form: the first name (in sorted order), followed by its count (if that count is more than 1), followed by the second name (in sorted order), followed by its count (if that count is more than 1), and so on.

Example 1:

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

Example 2:

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

Example 3:

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

Note:

All atom names consist of lowercase letters, except for the first character which is uppercase.
The length of formula will be in the range [1, 1000].
formula will only consist of letters, digits, and round parentheses, and is a valid formula as defined in the problem.

Idea:

Recursion

Time complexity: O(n)

Space complexity: O(n)

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 countOfAtoms(const string& formula, int& i) {
        map 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 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 countOfAtoms(char[] f) {
        Map ans = new TreeMap();
        while (i != f.length) {
            if (f[i] == '(') {
                ++i;
                Map tmp = countOfAtoms(f);
                int count = getCount(f);
                for (Map.Entry 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.

花花酱 LeetCode 321. Create Maximum Number

zxi — Tue, 14 Nov 2017 16:21:18 +0000

Problem:

Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits. You should try to optimize your time and space complexity.

Example 1:

nums1 = [3, 4, 6, 5]
nums2 = [9, 1, 2, 5, 8, 3]
k = 5
return [9, 8, 6, 5, 3]

Example 2:

nums1 = [6, 7]
nums2 = [6, 0, 4]
k = 5
return [6, 7, 6, 0, 4]

Example 3:

nums1 = [3, 9]
nums2 = [8, 9]
k = 3
return [9, 8, 9]

题目大意：给你两个数字数组和k，返回从两个数组中选取k个数字能够组成的最大值。

Idea: Greedy + DP

Solution:

Time complexity: O(k * (n1+n2)^2)

Space complexity: O(n1+n2)

C++

// Author: Huahua
// Runtime: 26 ms
class Solution {
public:
    vector maxNumber(vector& nums1, vector& nums2, int k) {
        vector ans;
        const int n1 = nums1.size();
        const int n2 = nums2.size();
        for (int i = max(0, k - n2); i <= min(k, n1); ++i)
            ans = max(ans, maxNumber(maxNumber(nums1, i), 
                                     maxNumber(nums2, k - i)));
        return ans;
    }
private:    
    vector maxNumber(const vector& nums, int k) {
        vector ans(k);                
        int j = 0;
        for (int i = 0; i < nums.size(); ++i) {
            while (j > 0 && nums[i] > ans[j - 1] 
                   && nums.size() - i > k - j) --j;
            if (j < k) ans[j++] = nums[i];
        }
        return ans;
    }
    
    vector maxNumber(const vector& nums1, const vector& nums2) {
        vector ans(nums1.size() + nums2.size());
        auto s1 = nums1.cbegin();
        auto e1 = nums1.cend();
        auto s2 = nums2.cbegin();
        auto e2 = nums2.cend();        
        int index = 0;
        while (s1 != e1 || s2 != e2)
            ans[index++] = 
              lexicographical_compare(s1, e1, s2, e2) ? *s2++ : *s1++;
        return ans;
    }
};

Java

// Author: Huahua
// Runtime: 18 ms
class Solution {
    public int[] maxNumber(int[] nums1, int[] nums2, int k) {
        int[] best = new int[0];
        for (int i = Math.max(0, k - nums2.length); 
                 i <= Math.min(k, nums1.length); ++i)            
            best = max(best, 0, 
                       maxNumber(maxNumber(nums1, i), 
                                 maxNumber(nums2, k - i)), 0);
        return best;
    }
    
    private int[] maxNumber(int[] nums, int k) {
        int[] ans = new int[k];
        int j = 0;
        for (int i = 0; i < nums.length; ++i) {
            while (j > 0 && nums[i] > ans[j - 1] 
                && nums.length - i > k - j) --j;
            if (j < k)
                ans[j++] = nums[i];
        }        
        return ans;
    }
    
    private int[] maxNumber(int[] nums1, int[] nums2) {
        int[] ans = new int[nums1.length + nums2.length];
        int s1 = 0;
        int s2 = 0;
        int index = 0;
        while (s1 != nums1.length || s2 != nums2.length)
            ans[index++] = max(nums1, s1, nums2, s2) == nums1 ? 
                           nums1[s1++] : nums2[s2++];
        return ans;
    }
    
    private int[] max(int[] nums1, int s1, int[] nums2, int s2) {
        for (int i = s1; i < nums1.length; ++i) {
            int j = s2 + i - s1;
            if (j >= nums2.length) return nums1;
            if (nums1[i] < nums2[j]) return nums2;
            if (nums1[i] > nums2[j]) return nums1;
        }
        return nums2;
    }
}

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

花花酱 LeetCode 4. Median of Two Sorted Arrays

zxi — Wed, 08 Nov 2017 16:33:09 +0000

题目大意：求两个已经排序的数组的中位数（如果合并后）。

Problem:

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

Idea:

Binary Search

Time complexity: O(log(min(n1,n2)))

Space complexity: O(1)

Solution: Binary Search

C++

// Author: Huahua
// Runtime: 52 ms
class Solution {
public:
    double findMedianSortedArrays(vector& nums1, vector& nums2) {
        const int n1 = nums1.size();
        const int n2 = nums2.size();
        // Make sure n1 <= n2
        if (n1 > n2) return findMedianSortedArrays(nums2, nums1);
        
        const int k = (n1 + n2 + 1) / 2;

        int l = 0;
        int r = n1;
               
        while (l < r) {
            const int m1 = l + (r - l) / 2;
            const int m2 = k - m1;
            if (nums1[m1] < nums2[m2 - 1])
                l = m1 + 1;
            else
                r = m1;
        }
        
        const int m1 = l;
        const int m2 = k - l;
        
        const int c1 = max(m1 <= 0 ? INT_MIN : nums1[m1 - 1], 
                           m2 <= 0 ? INT_MIN : nums2[m2 - 1]);

        if ((n1 + n2) % 2 == 1)
            return c1;    
        
        const int c2 = min(m1 >= n1 ? INT_MAX : nums1[m1], 
                           m2 >= n2 ? INT_MAX : nums2[m2]);
                
        return (c1 + c2) * 0.5;
    }
};

Java

// Author: Huahua
// Runtime: 66 ms
class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        if (n1 > n2) 
            return findMedianSortedArrays(nums2, nums1);
        
        int k = (n1 + n2 + 1) / 2;
        int l = 0;
        int r = n1;
               
        while (l < r) {
            int m1 = l + (r - l) / 2;
            int m2 = k - m1;
            if (nums1[m1] < nums2[m2 - 1])
                l = m1 + 1;
            else
                r = m1;
        }
        
        int m1 = l;
        int m2 = k - l;
        
        int c1 = Math.max(m1 <= 0 ? Integer.MIN_VALUE : nums1[m1 - 1], 
                          m2 <= 0 ? Integer.MIN_VALUE : nums2[m2 - 1]);

        if ((n1 + n2) % 2 == 1)
            return c1;    
        
        int c2 = Math.min(m1 >= n1 ? Integer.MAX_VALUE : nums1[m1], 
                          m2 >= n2 ? Integer.MAX_VALUE : nums2[m2]);
                
        return (c1 + c2) * 0.5;
    }
}

花花酱 LeetCode 719. Find K-th Smallest Pair Distance

zxi — Sun, 29 Oct 2017 20:14:10 +0000

题目大意：给你一个数组，返回所有数对中，绝对值差第k小的值。

Problem:

Given an integer array, return the k-th smallest distance among all the pairs. The distance of a pair (A, B) is defined as the absolute difference between A and B.

Example 1:

Input:
nums = [1,3,1]
k = 1
Output: 0 
Explanation:
Here are all the pairs:
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
Then the 1st smallest distance pair is (1,1), and its distance is 0.

Note:

2 <= len(nums) <= 10000.
0 <= nums[i] < 1000000.
1 <= k <= len(nums) * (len(nums) - 1) / 2.

Idea

Bucket sort

Binary search / dp

Solution

C++ / binary search

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    int smallestDistancePair(vector& nums, int k) {
        std::sort(nums.begin(), nums.end());
        int n = nums.size();
        int l = 0;
        int r = nums.back() - nums.front();
        while (l <= r) {
            int cnt = 0;
            int j = 0;
            int m = l + (r - l) / 2;
            for (int i = 0; i < n; ++i) {
                while (j < n && nums[j] - nums[i] <= m) ++j;
                cnt += j - i - 1;
            }
            cnt >= k ? r = m - 1 : l = m + 1;
        }        
        return l;
    }
};

C++ / bucket sort w/ vector O(n^2)

// Author: Huahua
// Runtime: 549 ms
class Solution {
public:
    int smallestDistancePair(vector& nums, int k) {
        std::sort(nums.begin(), nums.end());
        const int N = nums.back();
        vector count(N + 1, 0);        
        const int n = nums.size();
        for (int i = 0; i < n; ++i)
            for (int j = i + 1; j < n; ++j)
               ++count[nums[j] - nums[i]];
        for (int i = 0; i <= N; ++i) {
            k -= count[i];
            if (k <= 0) return i;
        }
        return 0;
    }
};

Related Problems:

The post 花花酱 LeetCode 719. Find K-th Smallest Pair Distance appeared first on Huahua's Tech Road.

花花酱 LeetCode 699. Falling Squares

zxi — Wed, 25 Oct 2017 03:09:00 +0000

题目大意：方块落下后会堆叠在重叠的方块之上，问每一块方块落下之后最高的方块的高度是多少？

Problem:

On an infinite number line (x-axis), we drop given squares in the order they are given.

The i-th square dropped (positions[i] = (left, side_length)) is a square with the left-most point being positions[i][0] and sidelength positions[i][1].

The square is dropped with the bottom edge parallel to the number line, and from a higher height than all currently landed squares. We wait for each square to stick before dropping the next.

The squares are infinitely sticky on their bottom edge, and will remain fixed to any positive length surface they touch (either the number line or another square). Squares dropped adjacent to each other will not stick together prematurely.

Return a list ans of heights. Each height ans[i] represents the current highest height of any square we have dropped, after dropping squares represented by positions[0], positions[1], ..., positions[i].

Example 1:

Input: [[1, 2], [2, 3], [6, 1]]
Output: [2, 5, 5]
Explanation:

After the first drop of 
positions[0] = [1, 2]:
_aa
_aa
-------
The maximum height of any square is 2.


After the second drop of 
positions[1] = [2, 3]:
__aaa
__aaa
__aaa
_aa__
_aa__
--------------
The maximum height of any square is 5.  
The larger square stays on top of the smaller square despite where its center
of gravity is, because squares are infinitely sticky on their bottom edge.


After the third drop of 
positions[1] = [6, 1]:
__aaa
__aaa
__aaa
_aa
_aa___a
--------------
The maximum height of any square is still 5.

Thus, we return an answer of 
[2, 5, 5]

Example 2:

Input: [[100, 100], [200, 100]]
Output: [100, 100]
Explanation: Adjacent squares don't get stuck prematurely - only their bottom edge can stick to surfaces.

Note:

1 <= positions.length <= 1000.
1 <= positions[i][0] <= 10^8.
1 <= positions[i][1] <= 10^6.

Idea:

Range query with map

Solution:

C++ map

// Author: Huahua
// Runtime: 29 ms
class Solution {
public:
    vector fallingSquares(vector>& positions) {
        vector ans;
        map, int> b; // {{start, end}, height}        
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int size = kv.second;
            int end = start + size;
            // first range intersect with new_interval
            auto it = b.upper_bound({start, end});
            if (it != b.begin()) {
                auto it2 = it;
                if ((--it2)->first.second > start) it = it2;
            }
            
            int baseHeight = 0;
            vector> ranges;
            while (it != b.end() && it->first.first < end) {
                const int s = it->first.first;
                const int e = it->first.second;
                const int h = it->second;
                if (s < start) ranges.emplace_back(s, start, h);
                if (e > end) ranges.emplace_back(end, e, h);
                // max height of intesected ranges
                baseHeight = max(baseHeight, h);
                it = b.erase(it);
            }
            
            int newHeight = size + baseHeight;
            
            b[{start, end}] = newHeight;
            
            for (const auto& range: ranges)
                b[{get<0>(range), get<1>(range)}] = get<2>(range);
            
            maxHeight = max(maxHeight, newHeight);            
            ans.push_back(maxHeight);
        }
        return ans;
    }
};

C++ vector without merge

// Author: Huahua
// Runtime: 46 ms
class Solution {
public:
    vector fallingSquares(vector>& positions) {
        vector ans;
        vector intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start)             
                    continue;
                baseHeight = max(baseHeight, interval.height);
            }
            int height = kv.second + baseHeight;
            intervals.push_back(Interval(start, end, height));
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

C++ / vector with merge (slower)

// Author: Huahua
// Runtime: 86 ms
class Solution {
public:
    vector fallingSquares(vector>& positions) {
        vector ans;
        vector intervals;
        int maxHeight = INT_MIN;
        for (const auto& kv: positions) {
            vector tmp;
            int start = kv.first;
            int end = start + kv.second;            
            int baseHeight = 0;
            for (const Interval& interval : intervals) {
                if (interval.start >= end || interval.end <= start) {
                    tmp.push_back(interval);                
                    continue;
                }
                baseHeight = max(baseHeight, interval.height);
                if (interval.start < start || interval.end > end)
                    tmp.push_back(interval);
            }
            int height = kv.second + baseHeight;
            tmp.push_back(Interval(start, end, height));
            intervals.swap(tmp);
            maxHeight = max(maxHeight, height);
            ans.push_back(maxHeight);
        }
        return ans;
    }
private:
    struct Interval {
        int start;
        int end;
        int height;
        Interval(int start, int end, int height) 
            : start(start), end(end), height(height) {}
    };
};

Related Problems:

[解题报告] LeetCode 715. Range Module
[解题报告] LeetCode 218. The Skyline Problem
[解题报告] LeetCode 57. Insert Interval

The post 花花酱 LeetCode 699. Falling Squares appeared first on Huahua's Tech Road.

花花酱 LeetCode 715. Range Module

zxi — Sun, 22 Oct 2017 23:29:45 +0000

Problem:

A Range Module is a module that tracks ranges of numbers. Your task is to design and implement the following interfaces in an efficient manner.

addRange(int left, int right) Adds the half-open interval [left, right), tracking every real number in that interval. Adding an interval that partially overlaps with currently tracked numbers should add any numbers in the interval [left, right) that are not already tracked.
queryRange(int left, int right) Returns true if and only if every real number in the interval [left, right) is currently being tracked.
removeRange(int left, int right) Stops tracking every real number currently being tracked in the interval [left, right).

Example 1:

addRange(10, 20): null
removeRange(14, 16): null
queryRange(10, 14): true (Every number in [10, 14) is being tracked)
queryRange(13, 15): false (Numbers like 14, 14.03, 14.17 in [13, 15) are not being tracked)
queryRange(16, 17): true (The number 16 in [16, 17) is still being tracked, despite the remove operation)

Note:

A half open interval [left, right) denotes all real numbers left <= x < right.
0 < left < right < 10^9 in all calls to addRange, queryRange, removeRange.
The total number of calls to addRange in a single test case is at most 1000.
The total number of calls to queryRange in a single test case is at most 5000.
The total number of calls to removeRange in a single test case is at most 1000.

Idea:

map / ordered ranges

Solution:

C++ / vector

// Author: Huahua
// Runtime: 276 ms
class RangeModule {
public:
    RangeModule() {}
    
    void addRange(int left, int right) {
        vector> new_ranges;
        bool inserted = false;
        for (const auto& kv : ranges_) {            
            if (kv.first > right && !inserted) {
                new_ranges.emplace_back(left, right);
                inserted = true;
            }
            if (kv.second < left || kv.first > right) { 
                new_ranges.push_back(kv);
            } else {
                left = min(left, kv.first);
                right = max(right, kv.second);
            }
        }       
        if (!inserted) new_ranges.emplace_back(left, right);       
        ranges_.swap(new_ranges);
    }
    
    bool queryRange(int left, int right) {
        const int n = ranges_.size();
        int l = 0;
        int r = n - 1;
        // Binary search
        while (l <= r) {
            int m = l + (r - l) / 2;
            if (ranges_[m].second < left)
                l = m + 1;
            else if (ranges_[m].first > right)
                r = m - 1;
            else
                return ranges_[m].first <= left && ranges_[m].second >= right;
        }
        return false;
    }
    
    void removeRange(int left, int right) {
        vector> new_ranges;        
        for (const auto& kv : ranges_) {
            if (kv.second <= left || kv.first >= right) {
                new_ranges.push_back(kv);
            } else {
                if (kv.first < left)
                    new_ranges.emplace_back(kv.first, left);
                if (kv.second > right)
                    new_ranges.emplace_back(right, kv.second);
            }        
        }
        ranges_.swap(new_ranges);
    }
    vector> ranges_;
};

C++ / map

// Author: Huahua
// Runtime: 199 ms
class RangeModule {
public:
    RangeModule() {}
    
    void addRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // At least one range overlapping with [left, right)
        if (l != r) {
            // Merge intervals into [left, right)
            auto last = r; --last;
            left = min(left, l->first);            
            right = max(right, last->second);
            // Remove all overlapped ranges
            ranges_.erase(l, r);
        }
        // Add a new/merged range
        ranges_[left] = right;
    }
    
    bool queryRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // No overlapping range
        if (l == r) return false;
        return l->first <= left && l->second >= right;
    }
    
    void removeRange(int left, int right) {
        IT l, r;
        getOverlapRanges(left, right, l, r);
        // No overlapping range
        if (l == r) return;
        auto last = r; --last;
        int start = min(left, l->first);        
        int end = max(right, last->second);
        // Delete overlapping ranges        
        ranges_.erase(l, r);
        if (start < left) ranges_[start] = left;
        if (end > right) ranges_[right] = end;
    }
private:
    typedef map::iterator IT;
    map ranges_;
    void getOverlapRanges(int left, int right, IT& l, IT& r) {
        l = ranges_.upper_bound(left);
        r = ranges_.upper_bound(right);
        if (l != ranges_.begin())
            if ((--l)->second < left) l++;
    }
};

Related Problems:

The post 花花酱 LeetCode 715. Range Module appeared first on Huahua's Tech Road.

Hard Archives - Huahua's Tech Road

花花酱 LeetCode 282. Expression Add Operators

Solution 1: DFS

C++

C++ / SC O(n)

Java

花花酱 LeetCode 480. Sliding Window Median

花花酱 LeetCode 759. Employee Free Time

花花酱 LeetCode 752. Open the Lock

花花酱 LeetCode 301. Remove Invalid Parentheses

Solution: DFS

C++

花花酱 LeetCode 164. Maximum Gap

花花酱 LeetCode 732. My Calendar III

Solution 1: Count Boundaries

C++

Solution 2

C++

Solution 3: Segment Tree

C++

Python3

花花酱 LeetCode 312. Burst Balloons

Java

Java

花花酱 LeetCode 639. Decode Ways II

花花酱 LeetCode 726. Number of Atoms

花花酱 LeetCode 321. Create Maximum Number

Idea: Greedy + DP

Solution:

C++

Java

花花酱 LeetCode 4. Median of Two Sorted Arrays

Solution: Binary Search

C++

Java

Related Problem:

花花酱 LeetCode 719. Find K-th Smallest Pair Distance

花花酱 LeetCode 699. Falling Squares

花花酱 LeetCode 715. Range Module