Medium Archives - Huahua's Tech Road

花花酱 LeetCode 769. Max Chunks To Make Sorted

zxi — Sat, 03 Feb 2018 04:55:32 +0000

题目大意：给你一个0 ~ n-1的排列，问你最多能分成几组，每组分别排序后能够组成0 ~ n-1。

Given an array arr that is a permutation of [0, 1, ..., arr.length - 1], we split the array into some number of “chunks” (partitions), and individually sort each chunk. After concatenating them, the result equals the sorted array.

What is the most number of chunks we could have made?

Example 1:

Input: arr = [4,3,2,1,0]
Output: 1
Explanation:
Splitting into two or more chunks will not return the required result.
For example, splitting into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.

Example 2:

Input: arr = [1,0,2,3,4]
Output: 4
Explanation:
We can split into two chunks, such as [1, 0], [2, 3, 4].
However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.

Note:

arr will have length in range [1, 10].
arr[i] will be a permutation of [0, 1, ..., arr.length - 1].

Solution 1: Max so far / Set

Time complexity: O(nlogn)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 3 ms
class Solution {
public:
  int maxChunksToSorted(vector& arr) {
    int ans = 0;
    set s;
    for (int i = 0; i < arr.size(); ++i) {
      s.insert(arr[i]);
      if (*s.rbegin() == i) ++ans;
    }
    return ans;
  }
};

Solution 2: Max so far

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int maxChunksToSorted(vector& arr) {
    int ans = 0;
    int m = 0;
    for (int i = 0; i < arr.size(); ++i) {
      m = max(m, arr[i]);
      if (m == i) ++ans;
    }
    return ans;
  }
};

Java

// Author: Huahua
// Running time: 5 ms
class Solution {
  public int maxChunksToSorted(int[] arr) {
    int max = 0;
    int ans = 0;
    for (int i = 0; i < arr.length; ++i) {
      max = Math.max(max, arr[i]);
      if (max == i) ++ans;
    }
    return ans;
  }
}

Python3

"""
Author: Huahua
Running time: 53 ms
"""
class Solution:
  def maxChunksToSorted(self, arr):
    m = 0
    ans = 0
    for i, n in enumerate(arr):
      if n > m: m = n
      if m == i: ans += 1
    return ans

The post 花花酱 LeetCode 769. Max Chunks To Make Sorted appeared first on Huahua's Tech Road.

花花酱 LeetCode 763. Partition Labels

zxi — Fri, 26 Jan 2018 06:08:15 +0000

题目大意：把字符串分割成尽量多的不重叠子串，输出子串的长度数组。要求相同字符只能出现在一个子串中。

Problem:

A string S of lowercase letters is given. We want to partition this string into as many parts as possible so that each letter appears in at most one part, and return a list of integers representing the size of these parts.

Example 1:

Input: S = "ababcbacadefegdehijhklij"
Output: [9,7,8]
Explanation:
The partition is "ababcbaca", "defegde", "hijhklij".
This is a partition so that each letter appears in at most one part.
A partition like "ababcbacadefegde", "hijhklij" is incorrect, because it splits S into less parts.

Solution 0: Brute Force

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua
// Running time: 15 ms
class Solution {
public:
    vector partitionLabels(string S) {
      vector ans;
      size_t start = 0;
      size_t end = 0;
      for (size_t i = 0; i < S.size(); ++i) {
        end = max(end, S.find_last_of(S[i]));
        if (i == end) {
          ans.push_back(end - start + 1);
          start = end + 1;
        }
      }
      return ans;
    }
};

Python

"""
Author: Huahua
Running time : 48 ms
"""
class Solution:
  def partitionLabels(self, S):
    ans = []
    start, end = 0, 0
    for i in range(len(S)):
      end = max(end, S.rfind(S[i]))
      if i == end:
        ans.append(end - start + 1)
        start = end + 1
    return ans

Solution 1: Greedy

Time complexity: O(n)

Space complexity: O(26/128)

C++

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
    vector partitionLabels(string S) {
      vector last_index(128, 0);
      for (int i = 0; i < S.size(); ++i)
        last_index[S[i]] = i;
      vector ans;
      int start = 0;
      int end = 0;
      for (int i = 0; i < S.size(); ++i) {
        end = max(end, last_index[S[i]]);
        if (i == end) {
          ans.push_back(end - start + 1);
          start = end + 1;
        }
      }
      return ans;
    }
};

Java

// Author: Huahua
// Running time: 16 ms
class Solution {
  public List partitionLabels(String S) {
    int lastIndex[] = new int[128];
    for (int i = 0; i < S.length(); ++i)
      lastIndex[(int)S.charAt(i)] = i;
    List ans = new ArrayList<>();
    int start = 0;
    int end = 0;
    for (int i = 0; i < S.length(); ++i) {
      end = Math.max(end, lastIndex[(int)S.charAt(i)]);
      if (i == end) {
        ans.add(end - start + 1);
        start = end + 1;
      }
    }
    return ans;
  }
}

Python3

"""
Author: Huahua
Running time: 78 ms
"""
class Solution:
  def partitionLabels(self, S):
    last_index = {}
    for i, ch in enumerate(S):
      last_index[ch] = i
    start = end = 0
    ans = []
    for i, ch in enumerate(S):
      end = max(end, last_index[ch])
      if i == end:
        ans.append(end - start + 1)
        start = end + 1
    return ans

The post 花花酱 LeetCode 763. Partition Labels appeared first on Huahua's Tech Road.

花花酱 LeetCode 494. Target Sum

zxi — Wed, 10 Jan 2018 06:13:49 +0000

题目大意：给你一串数字，你可以在每个数字前放置+或-，问有多少种方法可以使得表达式的值等于target。You are given a list of non-negative integers, a1, a2, …, an, and a target, S. Now you have 2 symbols + and -. For each integer, you should choose one from + and - as its new symbol.

Find out how many ways to assign symbols to make sum of integers equal to target S.

Example 1:

Input: nums is [1, 1, 1, 1, 1], S is 3. 
Output: 5
Explanation: 

-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3

There are 5 ways to assign symbols to make the sum of nums be target 3.

Note:

The length of the given array is positive and will not exceed 20.
The sum of elements in the given array will not exceed 1000.
Your output answer is guaranteed to be fitted in a 32-bit integer.

Idea: DP

Solution 1: DP

Time complexity: O(n*sum)

Space complexity: O(n*sum)

C++

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
    int findTargetSumWays(vector& nums, int S) {
      const int n = nums.size();
      const int sum = std::accumulate(nums.begin(), nums.end(), 0);
      if (sum < S) return 0;
      const int offset = sum;
      // ways[i][j] means total ways to sum up to (j - offset) using nums[0] ~ nums[i - 1].
      vector> ways(n + 1, vector(sum + offset + 1, 0));
      ways[0][offset] = 1;
      for (int i = 0; i < n; ++i) {
        for (int j = nums[i]; j < 2 * sum + 1 - nums[i]; ++j)
          if (ways[i][j]) {
            ways[i + 1][j + nums[i]] += ways[i][j];
            ways[i + 1][j - nums[i]] += ways[i][j];
          }        
      }
      
      return ways.back()[S + offset];
    }
};

C++ SC O(n)

// Author: Huahua
// Running time: 12 ms
class Solution {
public:
    int findTargetSumWays(vector& nums, int S) {
      const int n = nums.size();
      const int sum = std::accumulate(nums.begin(), nums.end(), 0);
      if (sum < std::abs(S)) return 0;
      const int kOffset = sum;
      const int kMaxN = sum * 2 + 1;
      vector ways(kMaxN, 0);      
      ways[kOffset] = 1;
      for (int num : nums) {
        vector tmp(kMaxN, 0);
        for (int i = num; i < kMaxN - num; ++i)
          if (ways[i]) {
            tmp[i + num] += ways[i];
            tmp[i - num] += ways[i];
          }
        std::swap(ways, tmp);
      }      
      return ways[S + kOffset];
    }
};

Java

// Author: Huahua
// Running time: 28 ms
class Solution {
  public int findTargetSumWays(int[] nums, int S) {
    int sum = 0;
    for (final int num : nums)
      sum += num;
    if (sum < S) return 0;
    final int kOffset = sum;
    final int kMaxN = sum * 2 + 1;
    int[] ways = new int[kMaxN];
    ways[kOffset] = 1;
    for (final int num : nums) {      
      int[] tmp = new int[kMaxN];      
      for (int i = num; i < kMaxN - num; ++i) {
        tmp[i + num] += ways[i];
        tmp[i - num] += ways[i];
      }
      ways = tmp;
    }
    return ways[S + kOffset];
  }
}

C++ / V2

// Author: Huahua
// Running time: 17 ms
class Solution {
public:
    int findTargetSumWays(vector& nums, int S) {
      const int n = nums.size();
      const int sum = std::accumulate(nums.begin(), nums.end(), 0);
      if (sum < std::abs(S)) return 0;
      const int kOffset = sum;
      const int kMaxN = sum * 2 + 1;
      vector ways(kMaxN, 0);      
      ways[kOffset] = 1;
      for (int num : nums) {
        vector tmp(kMaxN, 0);
        for (int i = 0; i < kMaxN; ++i) {
          if (i + num < kMaxN) tmp[i] += ways[i + num];
          if (i - num >= 0)    tmp[i] += ways[i - num];
        }
        std::swap(ways, tmp);
      }
      return ways[S + kOffset];
    }
};

Solution 2: DFS

Time complexity: O(2^n)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 422 ms
class Solution {
public:
  int findTargetSumWays(vector& nums, int S) {
    const int sum = std::accumulate(nums.begin(), nums.end(), 0);
    if (sum < std::abs(S)) return 0;
    int ans = 0;
    dfs(nums, 0, S, ans);
    return ans;
  }
private:
  void dfs(const vector& nums, int d, int S, int& ans) {
    if (d == nums.size()) {
      if (S == 0) ++ans;
      return;
    }    
    dfs(nums, d + 1, S - nums[d], ans);
    dfs(nums, d + 1, S + nums[d], ans);
  }
};

Java

// Author: Huahua
// Running time: 615 ms
class Solution {
  private int ans;
  public int findTargetSumWays(int[] nums, int S) {
    int sum = 0;
    for (final int num : nums)
      sum += num;
    if (sum < Math.abs(S)) return 0;
    ans = 0;
    dfs(nums, 0, S);
    return ans;
  }
  
  private void dfs(int[] nums, int d, int S) {
    if (d == nums.length) {
      if (S == 0) ++ans;
      return;
    }
    dfs(nums, d + 1, S - nums[d]);
    dfs(nums, d + 1, S + nums[d]);
  }
}

Solution 3: Subset sum

Time complexity: O(n*sum)

Space complexity: O(sum)

C++ w/ copy

// Author: Huahua
// Running time: 7 ms
class Solution {
public:
    int findTargetSumWays(vector& nums, int S) {
      S = std::abs(S);      
      const int sum = std::accumulate(nums.begin(), nums.end(), 0);
      if (sum < S || (S + sum) % 2 != 0) return 0;
      const int target = (S + sum) / 2;
      vector dp(target + 1, 0);
      dp[0] = 1;
      for (int num : nums) {
        vector tmp(dp);
        for (int j = 0; j <= target - num; ++j)
          tmp[j + num] += dp[j];
        std::swap(dp, tmp);
      }
      
      return dp[target];
    }
};

C++ w/o copy

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
    int findTargetSumWays(vector& nums, int S) {
      S = std::abs(S);
      const int n = nums.size();
      const int sum = std::accumulate(nums.begin(), nums.end(), 0);
      if (sum < S || (S + sum) % 2 != 0) return 0;
      const int target = (S + sum) / 2;
      vector dp(target + 1, 0);
      dp[0] = 1;
      for (int num : nums)
        for (int j = target; j >= num; --j)
          dp[j] += dp[j - num];
      
      return dp[target];
    }
};

The post 花花酱 LeetCode 494. Target Sum appeared first on Huahua's Tech Road.

花花酱 LeetCode 322. Coin Change

zxi — Wed, 03 Jan 2018 03:50:16 +0000

题目大意：给你一些不同币值的硬币，问你最少需要多少个硬币才能组成amount，假设每种硬币有无穷多个。

Problem:

You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.

Example 1:
coins = [1, 2, 5], amount = 11
return 3 (11 = 5 + 5 + 1)

Example 2:
coins = [2], amount = 3
return -1.

Idea:

DP /knapsack

Solution1:

C++ / DP

Time complexity: O(n*amount^2)

Space complexity: O(amount)

// Author: Huahua
// Running time: 189 ms
class Solution {
public:
    int coinChange(vector& coins, int amount) {
        vector dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (auto coin : coins) {
            for (int i = amount - coin; i >= 0; --i)
                if (dp[i] != INT_MAX)
                    for (int k = 1; k * coin + i <= amount; ++k)
                        dp[i + k * coin] = min(dp[i + k * coin], dp[i] + k);
        }
        
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};

Solution2:

C++ / DP

Time complexity: O(n*amount)

Space complexity: O(amount)

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
    int coinChange(vector& coins, int amount) {
        // dp[i] = min coins to make up to amount i
        vector dp(amount + 1, INT_MAX);
        dp[0] = 0;
        for (int coin : coins) {
            for (int i = coin; i <= amount; ++i)
                if (dp[i - coin] != INT_MAX)  
                    dp[i] = min(dp[i], dp[i - coin] + 1);
        }
        
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};

Python3

"""
Author: Huahua
Running time: 632 ms beats 90.27%
"""
class Solution:
  def coinChange(self, coins, amount):
    INVALID = 2**32
    dp = [INVALID] * (amount + 1)
    dp[0] = 0
    for coin in coins:
      for i in range(coin, amount + 1):
        if dp[i - coin] >= dp[i]: continue
        dp[i] = dp[i - coin] + 1
    return -1 if dp[amount] == INVALID else dp[amount]

Solution3:

C++ / DFS

Time complexity: O(amount^n/(coin_0*coin_1*…*coin_n))

Space complexity: O(n)

// Author: Huahua
// Running time: 6 ms
class Solution {
public:
    int coinChange(vector& coins, int amount) {
        // Sort coins in desending order
        std::sort(coins.rbegin(), coins.rend());
        int ans = INT_MAX;
        coinChange(coins, 0, amount, 0, ans);
        return ans == INT_MAX ? -1 : ans;
    }
private:
    void coinChange(const vector& coins, 
                    int s, int amount, int count, int& ans) {
        if (amount == 0) {
            ans = min(ans, count);
            return;
        }
        
        if (s == coins.size()) return;
        
        const int coin = coins[s];                
        for (int k = amount / coin; k >= 0 && count + k < ans; k--)
            coinChange(coins, s + 1, amount - k * coin, count + k, ans);
    }    
};

Python3

"""
Author: Huahua
Running time: 200ms
"""
class Solution:
  def coinChange(self, coins, amount):
    coins.sort(reverse=True)
    INVALID = 10**10
    self.ans = INVALID
    def dfs(s, amount, count):      
      if amount == 0:
        self.ans = count
        return
      if s == len(coins): return
      
      coin = coins[s]
      for k in range(amount // coin, -1, -1):
        if count + k >= self.ans: break
        dfs(s + 1, amount - k * coin, count + k)
    dfs(0, amount, 0)
    return -1 if self.ans == INVALID else self.ans

The post 花花酱 LeetCode 322. Coin Change appeared first on Huahua's Tech Road.

花花酱 LeetCode 652. Find Duplicate Subtrees

zxi — Sun, 31 Dec 2017 23:18:34 +0000

652. Find Duplicate SubtreesMedium730151FavoriteShare

Given a binary tree, return all duplicate subtrees. For each kind of duplicate subtrees, you only need to return the root node of any one of them.

Two trees are duplicate if they have the same structure with same node values.

Example 1:

The following are two duplicate subtrees:

2
/
4

and

Therefore, you need to return above trees’ root in the form of a list.

Solution 1: Serialization

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

C++

// Author: Huahua
// Runtime: 29 ms
class Solution {
public:
    vector findDuplicateSubtrees(TreeNode* root) {
        unordered_map counts;
        vector ans;
        serialize(root, counts, ans);
        return ans;
    }
private:
    string serialize(TreeNode* root, unordered_map& counts, vector& ans) {
        if (!root) return "#";
        string key = to_string(root->val) + "," 
                     + serialize(root->left, counts, ans) + "," 
                     + serialize(root->right, counts, ans);
        if (++counts[key] == 2)
            ans.push_back(root);
        return key;
    }
};

Solution 2: int id for each unique subtree

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

C++

// Author: Huahua
// Runtime: 8 ms
class Solution {
public:
  vector findDuplicateSubtrees(TreeNode* root) {
    unordered_map> counts;    
    vector ans;
    getId(root, counts, ans);
    return ans;
  }
private:
  int getId(TreeNode* root, 
            unordered_map>& counts,
            vector& ans) {
    if (!root) return 0;
    long key = (static_cast(static_cast(root->val)) << 32) +
               (getId(root->left, counts, ans) << 16) +
                getId(root->right, counts, ans);    
    auto& p = counts[key];
    if (p.second++ == 0)
      p.first = counts.size();    
    else if (p.second == 2)
      ans.push_back(root);
    return p.first;
  }
};

The post 花花酱 LeetCode 652. Find Duplicate Subtrees appeared first on Huahua's Tech Road.

花花酱 LeetCode 416. Partition Equal Subset Sum

zxi — Sun, 31 Dec 2017 22:41:36 +0000

题目大意：

给你一个正整数的数组，问你能否把元素划分成元素和相等的两组。

Problem:

Given a non-empty array containing only positive integers, find if the array can be partitioned into two subsets such that the sum of elements in both subsets is equal.

Note:

Each of the array element will not exceed 100.
The array size will not exceed 200.

Example 1:

Input: [1, 5, 11, 5]

Output: true

Explanation: The array can be partitioned as [1, 5, 5] and [11].

Example 2:

Input: [1, 2, 3, 5]

Output: false

Explanation: The array cannot be partitioned into equal sum subsets.

Idea:

DP 动态规划

Solution:

Time complexity: O(n*sum)

Space complexity: O(sum)

C++

// Author: Huahua
// Running time: 16 ms
class Solution {
public:
    bool canPartition(vector& nums) {
        const int sum = std::accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2 != 0) return false;
        vector dp(sum + 1, 0);
        dp[0] = 1;
        for (const int num : nums) {
            for (int i = sum; i >= 0; --i)
                if (dp[i]) dp[i + num] = 1;
            if (dp[sum / 2]) return true;
        }
        return false;
    }
};

The post 花花酱 LeetCode 416. Partition Equal Subset Sum appeared first on Huahua's Tech Road.

花花酱 LeetCode 377. Combination Sum IV

zxi — Sat, 16 Dec 2017 07:33:12 +0000

Problem:

Given an integer array with all positive numbers and no duplicates, find the number of possible combinations that add up to a positive integer target.

Example:

nums = [1, 2, 3]
target = 4

The possible combination ways are:
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)

Note that different sequences are counted as different combinations.

Therefore the output is 7.

题目大意：给你一些数和一个目标值，问使用这些数(每个数可以被使用任意次数)加起来等于目标值的组合（其实是不重复的排列）有多少种。

Idea:

Solution:

C++ / Recursion + Memorization

// Author: Huahua
// Runtime: 0 ms
class Solution {
public:
    int combinationSum4(vector& nums, int target) {
        m_ = vector(target + 1, -1);
        m_[0] = 1;
        return dp(nums, target);
    }    
private:
    int dp(const vector& nums, int target) {
        if (target < 0) return 0;
        if (m_[target] != -1) return m_[target];
        int ans = 0;
        for (const int num : nums)
            ans += dp(nums, target - num);
        return m_[target] = ans;
    }
    vector m_;
};

C++ / DP

// Author: Huahua
// Runtime: 3 ms
class Solution {
public:
    int combinationSum4(vector& nums, int target) {
        vector dp(target + 1, 0); // dp[i] # of combinations sum up to i
        dp[0] = 1;
        for (int i = 1; i <= target; ++i)
            for (const int num : nums)
                if (i - num >= 0)
                    dp[i] += dp[i - num];           
        return dp[target];
    }
};

Related Problems:

The post 花花酱 LeetCode 377. Combination Sum IV appeared first on Huahua's Tech Road.

花花酱 LeetCode 210. Course Schedule II

zxi — Thu, 14 Dec 2017 06:35:21 +0000

Problem

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]

4, [[1,0],[2,0],[3,1],[3,2]]

There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].

Note:

The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
You may assume that there are no duplicate edges in the input prerequisites.

题目大意：

给你一些课程和它的先修课程，让你输出修课顺序。如果无法修完所有课程，返回空数组。

Idea

Topological sorting

拓扑排序

Solution 1: Topological Sorting

Time complexity: O(V+E)

Space complexity: O(V+E)

C++

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
  vector findOrder(int numCourses, vector>& prerequisites) {
    vector> graph(numCourses);    
    for(const auto& p : prerequisites)
      graph[p.second].push_back(p.first);

    // states: 0 = unkonwn, 1 == visiting, 2 = visited
    vector v(numCourses, 0);
    vector ans;
    
    for (int i = 0; i < numCourses; ++i)
      if (dfs(i, graph, v, ans)) return {};

    std::reverse(ans.begin(), ans.end());
    return ans;
  }
private:
  bool dfs(int cur, vector>& graph, vector& v, vector& ans) {
    if (v[cur] == 1) return true;
    if (v[cur] == 2) return false;

    v[cur] = 1;
    
    for (const int t : graph[cur])
      if (dfs(t, graph, v, ans)) return true;
    
    v[cur] = 2;
    ans.push_back(cur);

    return false;
  }
};

Java

// Author: Huahua
// Runtime: 83 ms
class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        ArrayList> graph = new ArrayList<>();
        
        for (int i = 0; i < numCourses; ++i)
            graph.add(new ArrayList());
        
        for (int i = 0; i < prerequisites.length; ++i) {
            int course = prerequisites[i][0];
            int prerequisite = prerequisites[i][1];            
            graph.get(course).add(prerequisite);
        }
        
        int[] visited = new int[numCourses];
        List ans = new ArrayList();
        Integer index = numCourses;
        for (int i = 0; i < numCourses; ++i)
            if (dfs(i, graph, visited, ans)) return new int[0];        
        
        return ans.stream().mapToInt(i->i).toArray();
    }
    
    private boolean dfs(int curr, ArrayList> graph, int[] visited, List ans) {
        if (visited[curr] == 1) return true;
        if (visited[curr] == 2) return false;
        
        visited[curr] = 1;
        for (int next : graph.get(curr))
            if (dfs(next, graph, visited, ans)) return true;
        
        visited[curr] = 2;
        ans.add(curr);
        
        return false;
    }    
}

花花酱 LeetCode 742. Closest Leaf in a Binary Tree

zxi — Wed, 13 Dec 2017 06:21:27 +0000

Problem:

Given a binary tree where every node has a unique value, and a target key k, find the value of the closest leaf node to target k in the tree.

Here, closest to a leaf means the least number of edges travelled on the binary tree to reach any leaf of the tree. Also, a node is called a leaf if it has no children.

In the following examples, the input tree is represented in flattened form row by row. The actual root tree given will be a TreeNode object.

Example 1:

Input:
root = [1, 3, 2], k = 1
Diagram of binary tree:
          1
         / \
        3   2

Output: 2 (or 3)

Explanation: Either 2 or 3 is the closest leaf node to the target of 1.

Example 2:

Input:
root = [1], k = 1
Output: 1

Explanation: The closest leaf node is the root node itself.

Example 3:

Input:
root = [1,2,3,4,null,null,null,5,null,6], k = 2
Diagram of binary tree:
             1
            / \
           2   3
          /
         4
        /
       5
      /
     6

Output: 3
Explanation: The leaf node with value 3 (and not the leaf node with value 6) is closest to the node with value 2.

Note:

root represents a binary tree with at least 1 node and at most 1000 nodes.
Every node has a unique node.val in range [1, 1000].
There exists some node in the given binary tree for which node.val == k.

题目大意:

给你一棵树，每个节点的值都不相同。

给定一个节点值，让你找到离这个节点距离最近的叶子节点的值。

Idea:

Shortest path from source to any leaf nodes in a undirected unweighted graph.

问题转换为在无向/等权重的图中找一条从起始节点到任意叶子节点最短路径。

Solution:

C++ / DFS + BFS

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
    int findClosestLeaf(TreeNode* root, int k) {
        graph_.clear();
        start_ = nullptr;
        buildGraph(root, nullptr, k);
        queue q;
        q.push(start_);
        unordered_set seen;
        while (!q.empty()) {
            int size = q.size();
            while (size-->0) {
                TreeNode* curr = q.front();
                q.pop();                
                seen.insert(curr);                
                if (!curr->left && !curr->right) return curr->val;
                for (TreeNode* node : graph_[curr])
                    if (!seen.count(node)) q.push(node);
            }
        }
        return 0;
    }
private:
    void buildGraph(TreeNode* node, TreeNode* parent, int k) {
        if (!node) return;
        if (node->val == k) start_ = node;
        if (parent) {
            graph_[node].push_back(parent);
            graph_[parent].push_back(node);
        }
        buildGraph(node->left, node, k);
        buildGraph(node->right, node, k);
    }
    
    unordered_map> graph_;
    TreeNode* start_;
};

The post 花花酱 LeetCode 742. Closest Leaf in a Binary Tree appeared first on Huahua's Tech Road.

花花酱 LeetCode 743. Network Delay Time

zxi — Wed, 13 Dec 2017 01:20:09 +0000

There are N network nodes, labelled 1 to N.

Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.

Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.

Note:

N will be in the range [1, 100].
K will be in the range [1, N].
The length of times will be in the range [1, 6000].
All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 1 <= w <= 100.

Idea:

Construct the graph and do a shortest path from K to all other nodes.

Solution 2:

C++ / Bellman-Ford

Time complexity: O(ne)

Space complexity: O(n)

// Author: Huahua
// Runtime: 92 ms
class Solution {
public:
    int networkDelayTime(vector>& times, int N, int K) {
        constexpr int MAX_TIME = 101 * 100;
        vector dist(N, MAX_TIME);
        dist[K - 1] = 0;
        for (int i = 1; i < N; ++i)
            for (const auto& time : times) {
                int u = time[0] - 1, v = time[1] - 1, w = time[2];
                dist[v] = min(dist[v], dist[u] + w);
            }
        int max_dist = *max_element(dist.begin(), dist.end());
        return max_dist == MAX_TIME ? -1 : max_dist;
    }
};

Solution3:

C++ / Floyd-Warshall

Time complexity: O(n^3)

Space complexity: O(n^2)

// Author: Huahua
// Runtime: 92 ms
class Solution {
public:
    int networkDelayTime(vector>& times, int N, int K) {
        vector> d(N, vector(N, -1));
        
        for (auto time : times)   
            d[time[0] - 1][time[1] - 1] = time[2];
        
        for (int i = 0; i < N; ++i)
            d[i][i] = 0;
        
        for (int k = 0; k < N; ++k)
            for (int i = 0; i < N; ++i)
                for (int j = 0; j < N; ++j)
                    if (d[i][k] >= 0 && d[k][j] >= 0)
                        if (d[i][j] < 0 || d[i][j] > d[i][k] + d[k][j])
                            d[i][j] = d[i][k] + d[k][j];
        
        int ans = INT_MIN;        
        
        for (int i = 0; i < N; ++i) {
            if (d[K - 1][i] < 0) return -1;
            ans = max(ans, d[K - 1][i]);
        }
        
        return ans;
    }
};

// Author: Huahua
// Runtime: 89 ms
class Solution {
public:
    int networkDelayTime(vector>& times, int N, int K) {
        constexpr int MAX_TIME = 101 * 100;
        vector> d(N, vector(N, MAX_TIME));
        
        for (auto time : times)   
            d[time[0] - 1][time[1] - 1] = time[2];
        
        for (int i = 0; i < N; ++i)
            d[i][i] = 0;
        
        for (int k = 0; k < N; ++k)
            for (int i = 0; i < N; ++i)
                for (int j = 0; j < N; ++j)                    
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
        
        int max_time = *max_element(d[K - 1].begin(), d[K - 1].end());        
        return max_time >= MAX_TIME ? - 1 : max_time;
    }
};

The post 花花酱 LeetCode 743. Network Delay Time appeared first on Huahua's Tech Road.

花花酱 LeetCode 740. Delete and Earn

zxi — Wed, 06 Dec 2017 05:40:51 +0000

Problem:

Given an array nums of integers, you can perform operations on the array.

In each operation, you pick any nums[i] and delete it to earn nums[i] points. After, you must delete everyelement equal to nums[i] - 1 or nums[i] + 1.

You start with 0 points. Return the maximum number of points you can earn by applying such operations.

Example 1:

Input: nums = [3, 4, 2]
Output: 6
Explanation: 
Delete 4 to earn 4 points, consequently 3 is also deleted.
Then, delete 2 to earn 2 points. 6 total points are earned.

Example 2:

Input: nums = [2, 2, 3, 3, 3, 4]
Output: 9
Explanation: 
Delete 3 to earn 3 points, deleting both 2's and the 4.
Then, delete 3 again to earn 3 points, and 3 again to earn 3 points.
9 total points are earned.

Note:

The length of nums is at most 20000.
Each element nums[i] is an integer in the range [1, 10000].

Idea:

Reduce the problem to House Robber Problem

Key observations: If we take nums[i]

We can safely take all of its copies.
We can’t take any of copies of nums[i – 1] and nums[i + 1]

This problem is reduced to 198 House Robber.

Houses[i] has all the copies of num whose value is i.

[3 4 2] -> [0 2 3 4], rob([0 2 3 4]) = 6

[2, 2, 3, 3, 3, 4] -> [0 2*2 3*3 4], rob([0 2*2 3*3 4]) = 9

Time complexity: O(n+r) reduction + O(r) solving rob = O(n + r)

Space complexity: O(r)

r = max(nums) – min(nums) + 1

Time complexity: O(n + r)

Space complexity: O(r)

Solution:

// Author: Huahua
// Runtime: 6 ms
class Solution {
public:
    int deleteAndEarn(vector& nums) {
        if (nums.empty()) return 0;
        const auto range = minmax_element(nums.begin(), nums.end());
        const int l = *(range.first);
        const int r = *(range.second);        
        vector points(r - l + 1, 0);
        for (const int num : nums)
            points[num - l] += num;
        return rob(points);
    }
private:
    // From LeetCode 198. House Robber
    int rob(const vector& nums) {
        int dp2 = 0;
        int dp1 = 0;
        for (int i = 0; i < nums.size() ; ++i) {
            int dp = max(dp2 + nums[i], dp1);
            dp2 = dp1;
            dp1 = dp;
        }
        return dp1;
    }
};

Related Problem:

花花酱 LeetCode 198. House Robber

The post 花花酱 LeetCode 740. Delete and Earn appeared first on Huahua's Tech Road.

花花酱 LeetCode 735. Asteroid Collision

zxi — Mon, 04 Dec 2017 00:30:46 +0000

Problem:

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input: 
asteroids = [5, 10, -5]
Output: [5, 10]
Explanation: 
The 10 and -5 collide resulting in 10.  The 5 and 10 never collide.

Example 2:

Input: 
asteroids = [8, -8]
Output: []
Explanation: 
The 8 and -8 collide exploding each other.

Example 3:

Input: 
asteroids = [10, 2, -5]
Output: [10]
Explanation: 
The 2 and -5 collide resulting in -5.  The 10 and -5 collide resulting in 10.

Example 4:

Input: 
asteroids = [-2, -1, 1, 2]
Output: [-2, -1, 1, 2]
Explanation: 
The -2 and -1 are moving left, while the 1 and 2 are moving right.
Asteroids moving the same direction never meet, so no asteroids will meet each other.

Note:

The length of asteroids will be at most 10000.
Each asteroid will be a non-zero integer in the range [-1000, 1000]..

Idea:

Simulation

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

Solution:

C ++

// Author: Huahua
// Runtime: 22 ms
class Solution {
public:
    vector asteroidCollision(vector& asteroids) {
        vector s;
        for (int i = 0 ; i < asteroids.size(); ++i) {
            const int size = asteroids[i];
            if (size > 0) { // To right, OK
                s.push_back(size);
            } else {
                // To left
                if (s.empty() || s.back() < 0) // OK when all are negtives
                    s.push_back(size);
                else if (abs(s.back()) <= abs(size)) {
                    // Top of the stack is going right.
                    // Its size is less than the current one.
                    
                    // The current one still alive!
                    if (abs(s.back()) < abs(size)) --i;
                    
                    s.pop_back(); // Destory the top one moving right
                }                    
            }
        }
        
        // s must look like [-s1, -s2, ... , si, sj, ...]
        return s;
    }
};

The post 花花酱 LeetCode 735. Asteroid Collision appeared first on Huahua's Tech Road.

花花酱 LeetCode 737. Sentence Similarity II

zxi — Tue, 28 Nov 2017 23:04:19 +0000

Problem:

Given two sentences words1, words2 (each represented as an array of strings), and a list of similar word pairs pairs, determine if two sentences are similar.

For example, words1 = ["great", "acting", "skills"] and words2 = ["fine", "drama", "talent"] are similar, if the similar word pairs are pairs = [["great", "good"], ["fine", "good"], ["acting","drama"], ["skills","talent"]].

Note that the similarity relation is transitive. For example, if “great” and “good” are similar, and “fine” and “good” are similar, then “great” and “fine” are similar.

Similarity is also symmetric. For example, “great” and “fine” being similar is the same as “fine” and “great” being similar.

Also, a word is always similar with itself. For example, the sentences words1 = ["great"], words2 = ["great"], pairs = [] are similar, even though there are no specified similar word pairs.

Finally, sentences can only be similar if they have the same number of words. So a sentence like words1 = ["great"] can never be similar to words2 = ["doubleplus","good"].

Note:

The length of words1 and words2 will not exceed 1000.
The length of pairs will not exceed 2000.
The length of each pairs[i] will be 2.
The length of each words[i] and pairs[i][j] will be in the range [1, 20].

题目大意：

给你两个句子（由单词数组表示）和一些近义词对，问你这两个句子是否相似，即每组相对应的单词都要相似。

注意相似性可以传递，比如只给你”great”和”fine”相似、”fine”和”good”相似，能推断”great”和”good”也相似。

Idea:

DFS / Union Find

Solution1:

Time complexity: O(|Pairs| * |words1|)

Space complexity: O(|Pairs|)

C++ / DFS

// Author: Huahua
// Runtime: 346 ms
class Solution {
public:
    bool areSentencesSimilarTwo(vector& words1, vector& words2, vector>& pairs) {
        if (words1.size() != words2.size()) return false;
        
        g_.clear();
        
        for (const auto& p : pairs) {
            g_[p.first].insert(p.second);
            g_[p.second].insert(p.first);
        }
        
        unordered_set visited;
        
        for (int i = 0; i < words1.size(); ++i) {
            visited.clear();
            if (!dfs(words1[i], words2[i], visited)) return false;
        }
        
        return true;
    }
private:
    bool dfs(const string& src, const string& dst, unordered_set& visited) {
        if (src == dst) return true;
        visited.insert(src);
        for (const auto& next : g_[src]) {
            if (visited.count(next)) continue;
            if (dfs(next, dst, visited)) return true;
        }
        return false;
    }
    unordered_map> g_;
};

Time complexity: O(|Pairs| + |words1|)

Space complexity: O(|Pairs|)

C++ / DFS Optimized

// Author: Huahua
// Runtime 229 ms
class Solution {
public:
    bool areSentencesSimilarTwo(vector& words1, vector& words2, vector>& pairs) {
        if (words1.size() != words2.size()) return false;
        
        g_.clear();
        ids_.clear();
        
        for (const auto& p : pairs) {
            g_[p.first].insert(p.second);
            g_[p.second].insert(p.first);
        }        
        
        int id = 0;
        
        for (const auto& p : pairs) {
            if(!ids_.count(p.first)) dfs(p.first, ++id);
            if(!ids_.count(p.second)) dfs(p.second, ++id);
        }
        
        for (int i = 0; i < words1.size(); ++i) {
            if (words1[i] == words2[i]) continue;
            auto it1 = ids_.find(words1[i]);
            auto it2 = ids_.find(words2[i]);
            if (it1 == ids_.end() || it2 == ids_.end()) return false;
            if (it1->second != it2->second) return false;
        }
        
        return true;
    }
private:
    bool dfs(const string& curr, int id) {
        ids_[curr] = id;        
        for (const auto& next : g_[curr]) {
            if (ids_.count(next)) continue;
            if (dfs(next, id)) return true;
        }
        return false;
    }
    
    unordered_map ids_;
    unordered_map> g_;
};

Solution2:

Time complexity: O(|Pairs| + |words1|)

Space complexity: O(|Pairs|)

C++ / Union Find

// Author: Huahua
// Runtime: 219 ms
class UnionFindSet {
public:
    bool Union(const string& word1, const string& word2) {
        const string& p1 = Find(word1, true);
        const string& p2 = Find(word2, true);
        if (p1 == p2) return false;        
        parents_[p1] = p2;
        return true;
    }
    
    const string& Find(const string& word, bool create = false) {
        if (!parents_.count(word)) {
            if (!create) return word;
            return parents_[word] = word;
        }
        
        string w = word;
        while (w != parents_[w]) {
            parents_[w] = parents_[parents_[w]];
            w = parents_[w];
        }
        
        return parents_[w];
    }
private:
    unordered_map parents_;
};

class Solution {
public:
    bool areSentencesSimilarTwo(vector& words1, vector& words2, vector>& pairs) {
        if (words1.size() != words2.size()) return false;
        
        UnionFindSet s;
        for (const auto& pair : pairs)
            s.Union(pair.first, pair.second);
        
        for (int i = 0; i < words1.size(); ++i) 
            if (s.Find(words1[i]) != s.Find(words2[i])) return false;
        
        return true;
    }
};

C++ / Union Find, Optimized

// Author: Huahua
// Runtime: 175 ms (< 98.45%)
class UnionFindSet {
public:
    UnionFindSet(int n) {
        parents_ = vector(n + 1, 0);
        ranks_ = vector(n + 1, 0);
        
        for (int i = 0; i < parents_.size(); ++i)
            parents_[i] = i;
    }
    
    bool Union(int u, int v) {
        int pu = Find(u);
        int pv = Find(v);
        if (pu == pv) return false;
        
        if (ranks_[pu] > ranks_[pv]) {
            parents_[pv] = pu;
        } else if (ranks_[pv] > ranks_[pu]) {
            parents_[pu] = pv;
        } else {
            parents_[pu] = pv;
            ++ranks_[pv];
        }

        return true;
    }
    
    int Find(int id) {        
        if (id != parents_[id])
            parents_[id] = Find(parents_[id]);        
        return parents_[id];
    }
    
private:
    vector parents_;
    vector ranks_;
};

class Solution {
public:
    bool areSentencesSimilarTwo(vector& words1, vector& words2, vector>& pairs) {
        if (words1.size() != words2.size()) return false;
        
        UnionFindSet s(pairs.size() * 2);
        
        unordered_map indies; // word to index
        
        for (const auto& pair : pairs) {
            int u = getIndex(pair.first, indies, true);
            int v = getIndex(pair.second, indies, true);
            s.Union(u, v);
        }
        
        for (int i = 0; i < words1.size(); ++i) {
            if (words1[i] == words2[i]) continue;
            int u = getIndex(words1[i], indies);
            int v = getIndex(words2[i], indies);
            if (u < 0 || v < 0) return false;
            if (s.Find(u) != s.Find(v)) return false;
        }
        
        return true;
    }
private:
    int getIndex(const string& word, unordered_map& indies, bool create = false) {
        auto it = indies.find(word);
        if (it == indies.end()) {
            if (!create) return INT_MIN;
            int index = indies.size();
            indies.emplace(word, index);
            return index;
        }
        
        return it->second;
    }
};

Related Problems:

The post 花花酱 LeetCode 737. Sentence Similarity II appeared first on Huahua's Tech Road.

花花酱 LeetCode 64. Minimum Path Sum

zxi — Tue, 28 Nov 2017 06:33:06 +0000

Problem:

Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path.

Note: You can only move either down or right at any point in time.

Example 1:

[[1,3,1],
 [1,5,1],
 [4,2,1]]

Given the above grid map, return 7. Because the path 1→3→1→1→1 minimizes the sum.

Idea:

Solution 1:

C++ / Recursion with memoization

Time complexity: O(mn)

Space complexity: O(mn)

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    int minPathSum(vector>& grid) {
        int m = grid.size();
        if (m == 0) return 0;
        int n = grid[0].size();
        
        s_ = vector>(m, vector(n, 0));
        
        return minPathSum(grid, n - 1, m - 1, n, m);
    }    
private:
    long minPathSum(const vector>& grid, 
                   int x, int y, int n, int m) {        
        if (x == 0 && y == 0) return grid[y][x];
        if (x < 0 || y < 0) return INT_MAX;
        if (s_[y][x] > 0) return s_[y][x];
        
        int ans = grid[y][x] + min(minPathSum(grid, x - 1, y, n, m),
                                   minPathSum(grid, x, y - 1, n, m));
        return s_[y][x] = ans;
    }
    
    vector> s_;
};

Solution 2:

C++ / DP

Time complexity: O(mn)

Space complexity: O(1)

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    int minPathSum(vector>& grid) {
        int m = grid.size();
        if (m == 0) return 0;
        int n = grid[0].size();
        
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j) {
                if (i == 0 && j == 0) continue;
                if (i == 0) 
                    grid[i][j] += grid[i][j - 1];
                else if (j == 0)
                    grid[i][j] += grid[i - 1][j];
                else
                    grid[i][j] += min(grid[i][j - 1], grid[i - 1][j]);
            }
        
        return grid[m - 1][n - 1];
    }    
};

Related Problems:

[解题报告] LeetCode 113. Path Sum II

The post 花花酱 LeetCode 64. Minimum Path Sum appeared first on Huahua's Tech Road.

花花酱 LeetCode 113. Path Sum II

zxi — Tue, 28 Nov 2017 05:14:24 +0000

Problem:

Given a binary tree and a sum, find all root-to-leaf paths where each path’s sum equals the given sum.

For example:
Given the below binary tree and sum = 22,

5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

return

[
   [5,4,11,2],
   [5,8,4,5]
]

Idea:

Recursion

Solution:

C++

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    vector> pathSum(TreeNode* root, int sum) {
        vector> ans;
        vector curr;
        pathSum(root, sum, curr, ans);
        return ans;
    }
private:
    void pathSum(TreeNode* root, int sum, vector& curr, vector>& ans) {
        if(root==nullptr) return;
        if(root->left==nullptr && root->right==nullptr) {
            if(root->val == sum) {
                ans.push_back(curr);
                ans.back().push_back(root->val);
            }
            return;
        }
        
        curr.push_back(root->val);
        int new_sum = sum - root->val;
        pathSum(root->left, new_sum, curr, ans);
        pathSum(root->right, new_sum, curr, ans);
        curr.pop_back();
    }
};

Related Problems:

The post 花花酱 LeetCode 113. Path Sum II appeared first on Huahua's Tech Road.