Posts tagged as “medium”

花花酱 LeetCode 576. Out of Boundary Paths

By zxi on June 2, 2018

Problem

There is an m by n grid with a ball. Given the start coordinate (i,j) of the ball, you can move the ball to adjacent cell or cross the grid boundary in four directions (up, down, left, right). However, you can at most move N times. Find out the number of paths to move the ball out of grid boundary. The answer may be very large, return it after mod 10⁹ + 7.

Example 1:

Input:m = 2, n = 2, N = 2, i = 0, j = 0
Output: 6
Explanation:

Example 2:

Input:m = 1, n = 3, N = 3, i = 0, j = 1
Output: 12
Explanation:

Note:

Once you move the ball out of boundary, you cannot move it back.
The length and height of the grid is in range [1,50].
N is in range [0,50].

Solution

Time complexity: O(m*n + N * m * n)

Space complexity: O(N*m*n) -> O(m*n)

C++

// Author: Huahua

// Running time: 19 ms

class Solution {

public:

int findPaths(int m, int n, int N, int i, int j) {

constexpr int kMod = 1000000007;

vector<vector<vector<int>>> dp(N + 1, vector<vector<int>>(m, vector<int>(n, 0)));

vector<int> dirs{-1, 0, 1, 0, -1};

for (int s = 1; s <= N; ++s)

for (int y = 0; y < m; ++y)

for (int x = 0; x < n; ++x)

for (int d = 0; d < 4; ++d) {

int tx = x + dirs[d];

int ty = y + dirs[d + 1];

if (tx < 0 || ty < 0 || tx >= n || ty >= m)

dp[s][y][x] += 1;

else

dp[s][y][x] = (dp[s][y][x] + dp[s - 1][ty][tx]) % kMod;

}

return dp[N][i][j];

}

};

// Author: Huahua

// Running time: 16 ms

class Solution {

public:

int findPaths(int m, int n, int N, int i, int j) {

constexpr int kMod = 1000000007;

vector<vector<int>> dp(m, vector<int>(n, 0));

vector<int> dirs{-1, 0, 1, 0, -1};

for (int s = 1; s <= N; ++s) {

vector<vector<int>> tmp(m, vector<int>(n, 0));

for (int y = 0; y < m; ++y)

for (int x = 0; x < n; ++x)

for (int d = 0; d < 4; ++d) {

int tx = x + dirs[d];

int ty = y + dirs[d + 1];

if (tx < 0 || ty < 0 || tx >= n || ty >= m)

tmp[y][x] += 1;

else

tmp[y][x] = (tmp[y][x] + dp[ty][tx]) % kMod;

}

dp.swap(tmp);

}

return dp[i][j];

}

};

Recursion with memorization

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int findPaths(int m, int n, int N, int i, int j) {

m_ = m;

n_ = n;

dp_ = vector<vector<vector<int>>>(N + 1, vector<vector<int>>(m, vector<int>(n, INT_MIN)));

return paths(N, j, i);

}

private:

vector<vector<vector<int>>> dp_;

int m_;

int n_;

// number of paths starts from out-of-boundary to (x, y) by moving at most N steps.

int paths(int N, int x, int y) {

static vector<int> dirs{-1, 0, 1, 0, -1};

static const int kMod = 1000000007;

// Out of boundary, one path.

if (x < 0 || x >= n_ || y < 0 || y >= m_) return 1;

// Can not move but still in the grid, no path.

if (N == 0) return 0;

// Already computed.

if (dp_[N][y][x] != INT_MIN) return dp_[N][y][x];

dp_[N][y][x] = 0;

for (int d = 0; d < 4; ++d) {

int tx = x + dirs[d];

int ty = y + dirs[d + 1];

dp_[N][y][x] = (dp_[N][y][x] + paths(N - 1, tx, ty)) % kMod;

}

return dp_[N][y][x];

}

};

no loops

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int findPaths(int m, int n, int N, int i, int j) {

m_ = m;

n_ = n;

dp_ = vector<vector<vector<int>>>(N + 1, vector<vector<int>>(m, vector<int>(n, INT_MIN)));

return paths(N, j, i);

}

private:

vector<vector<vector<int>>> dp_;

int m_;

int n_;

// number of paths start from (x, y) and move at most N steps.

int paths(int N, int x, int y) {

static const int kMod = 1000000007;

if (x < 0 || x >= n_ || y < 0 || y >= m_) return 1;

if (N == 0) return 0;

if (dp_[N][y][x] != INT_MIN) return dp_[N][y][x];

long ans = 0;

ans += paths(N - 1, x + 1, y);

ans += paths(N - 1, x - 1, y);

ans += paths(N - 1, x, y + 1);

ans += paths(N - 1, x, y - 1);

ans %= kMod;

return dp_[N][y][x] = ans;

}

};

Problem

We have jobs: difficulty[i] is the difficulty of the ith job, and profit[i] is the profit of the ith job.

Now we have some workers. worker[i] is the ability of the ith worker, which means that this worker can only complete a job with difficulty at most worker[i].

Every worker can be assigned at most one job, but one job can be completed multiple times.

For example, if 3 people attempt the same job that pays $1, then the total profit will be $3. If a worker cannot complete any job, his profit is $0.

What is the most profit we can make?

Example 1:

Input: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Output: 100 
Explanation: Workers are assigned jobs of difficulty [4,4,6,6] and they get profit of [20,20,30,30] seperately.

Notes:

1 <= difficulty.length = profit.length <= 10000
1 <= worker.length <= 10000
difficulty[i], profit[i], worker[i] are in range [1, 10^5]

Solution 1: Sorting + Two pointers

Time complexity: O(nlogn + mlogm)

Space complexity: O(n)

// Author: Huahua

// Running time: 90 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

const int n = difficulty.size();

vector<pair<int, int>> jobs; // difficulty, profit

for (int i = 0; i < n; ++i)

jobs.emplace_back(difficulty[i], profit[i]);

std::sort(jobs.begin(), jobs.end());

std::sort(worker.begin(), worker.end());

int ans = 0;

int i = 0;

int best = 0;

for (int level : worker) {

while (i < n && level >= jobs[i].first)

best = max(best, jobs[i++].second);

ans += best;

}

return ans;

}

};

Solution 2: Bucket + Greedy

Key idea: for each difficulty D, find the most profit job whose requirement is <= D.

Three steps:

for each difficulty D, find the most profit job whose requirement is == D, best[D] = max{profit of difficulty D}.
if difficulty D – 1 can make more profit than difficulty D, best[D] = max(best[D], best[D – 1]).
The max profit each worker at skill level D can make is best[D].

Time complexity: O(n)

Space complexity: O(10000)

C++

// Author: Huahua

// Running time: 112 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

const int N = 100000;

// max profit at difficulty i

vector<int> max_profit(N + 1, 0);

for (int i = 0; i < difficulty.size(); ++i)

max_profit[difficulty[i]] = max(max_profit[difficulty[i]], profit[i]);

for (int i = 2; i <= N; ++i)

max_profit[i] = max(max_profit[i], max_profit[i - 1]);

int ans = 0;

for (int level : worker)

ans += max_profit[level];

return ans;

}

};

C++ using map

// Author: Huahua

// Running time: 112 ms

class Solution {

public:

int maxProfitAssignment(vector<int>& difficulty, vector<int>& profit, vector<int>& worker) {

map<int, int> bests;

for (int i = 0; i < difficulty.size(); ++i)

bests[difficulty[i]] = max(bests[difficulty[i]], profit[i]);

int best = 0;

for (auto it = bests.begin(); it != bests.end(); ++it)

it->second = best = max(it->second, best);

int ans = 0;

for (int level : worker)

ans += prev(bests.upper_bound(level))->second;

return ans;

}

};

花花酱 LeetCode 825. Friends Of Appropriate Ages

By zxi on April 29, 2018

Problem

Some people will make friend requests. The list of their ages is given and ages[i] is the age of the ith person.

Person A will NOT friend request person B (B != A) if any of the following conditions are true:

age[B] <= 0.5 * age[A] + 7
age[B] > age[A]
age[B] > 100 && age[A] < 100

Otherwise, A will friend request B.

Note that if A requests B, B does not necessarily request A. Also, people will not friend request themselves.

How many total friend requests are made?

Example 1:

Input: [16,16]
Output: 2
Explanation: 2 people friend request each other.

Example 2:

Input: [16,17,18]
Output: 2
Explanation: Friend requests are made 17 -> 16, 18 -> 17.

Example 3:

Input: [20,30,100,110,120]
Output: 
Explanation: Friend requests are made 110 -> 100, 120 -> 110, 120 -> 100.

Notes:

1 <= ages.length <= 20000.
1 <= ages[i] <= 120.

Solution: Hashtable

Count how many people at each age i.

Time complexity: O(n)

Space complexity: O(120)

C++

// Author: Huahua

// Running time: 39 ms

class Solution {

public:

int numFriendRequests(vector<int>& ages) {

const int kMaxAge = 120;

vector<int> counts(kMaxAge + 1, 0);

for (const int age : ages)

++counts[age];

int ans = 0;

for (int A = 1; A <= kMaxAge; ++A) {

for (int B = 0.5 * A + 7 + 1; B <= A; ++B)

ans += counts[A] * (counts[B] - (A == B));

}

return ans;

}

};

花花酱 LeetCode 822. Card Flipping Game

By zxi on April 29, 2018

Problem

题目大意：每张牌的正反面各印着一个数，你可以随便翻牌。找出一个最小的数使得其他牌当前正面的数值都不和它相等。

On a table are N cards, with a positive integer printed on the front and back of each card (possibly different).

We flip any number of cards, and after we choose one card.

If the number X on the back of the chosen card is not on the front of any card, then this number X is good.

What is the smallest number that is good? If no number is good, output 0.

Here, fronts[i] and backs[i] represent the number on the front and back of card i.

A flip swaps the front and back numbers, so the value on the front is now on the back and vice versa.

Example:

Input: fronts = [1,2,4,4,7], backs = [1,3,4,1,3]
Output: 2
Explanation: If we flip the second card, the fronts are [1,3,4,4,7] and the backs are [1,2,4,1,3]. We choose the second card, which has number 2 on the back, and it isn't on the front of any card, so 2 is good.

Note:

1 <= fronts.length == backs.length <= 1000.
1 <= fronts[i] <= 2000.
1 <= backs[i] <= 2000.

Solution: Hashset

C++

// Author: Huahua

// Running time: 23 ms

class Solution {

public:

int flipgame(vector<int>& fronts, vector<int>& backs) {

unordered_set<int> same;

for (int i = 0; i < fronts.size(); ++i)

if (fronts[i] == backs[i])

same.insert(fronts[i]);

int ans = INT_MAX;

for (int v : fronts)

if (v < ans && !same.count(v)) ans = v;

for (int v : backs)

if (v < ans && !same.count(v)) ans = v;

return ans == INT_MAX ? 0 : ans;

}

};

花花酱 LeetCode 823. Binary Trees With Factors

By zxi on April 29, 2018

Problem

题目大意：给你一些可以重复使用的数字问能够构成多少种不同的特殊二叉树（根结点的值需为子节点值的乘积）。

https://leetcode.com/problems/binary-trees-with-factors/description/

Given an array of unique integers, each integer is strictly greater than 1.

We make a binary tree using these integers and each number may be used for any number of times.

Each non-leaf node’s value should be equal to the product of the values of it’s children.

How many binary trees can we make? Return the answer modulo 10 ** 9 + 7.

Example 1:

Input: A = [2, 4]
Output: 3 Explanation: We can make these trees: [2], [4], [4, 2, 2]

Example 2:

Input: A = [2, 4, 5, 10]
Output: 7
Explanation: We can make these trees: [2], [4], [5], [10], [4, 2, 2], [10, 2, 5], [10, 5, 2].

Note:

1 <= A.length <= 1000.
2 <= A[i] <= 10 ^ 9.

Solution: DP

Use dp[i] to denote the number of valid binary trees using the first i + 1 smallest elements and roots at A[i].

dp[i] = sum(dp[j] * dp[i/j]), 0 <= j < i, A[i] is a factor of A[j] and A[i] / A[j] also in A.

      A[i]
     /    \
 A[j]  (A[i]/A[j])
  / \     / \
 .....   .....

ans = sum(dp[i]), for all possible i.

Time complexity: O(n^2)

Space complexity: O(n^2)

C++

// Author: Huahua

// Running time: 53 ms

class Solution {

public:

int numFactoredBinaryTrees(vector<int>& A) {

constexpr long kMod = 1000000007;

std::sort(A.begin(), A.end());

unordered_map<int, long> dp;

for (int i = 0; i < A.size(); ++i) {

dp[A[i]] = 1;

for (int j = 0; j < i; ++j)

if (A[i] % A[j] == 0 && dp.count(A[i] / A[j]))

dp[A[i]] += (dp[A[j]] * dp[A[i] / A[j]]) % kMod;

}

long ans = 0;

for (const auto& kv : dp)

ans += kv.second;

return ans % kMod;

}

};

Posts tagged as “medium”

花花酱 LeetCode 576. Out of Boundary Paths

Problem

Solution

Related Problems

花花酱 LeetCode 826. Most Profit Assigning Work

Problem

Solution 1: Sorting + Two pointers

Solution 2: Bucket + Greedy

花花酱 LeetCode 825. Friends Of Appropriate Ages

Problem

Solution: Hashtable

花花酱 LeetCode 822. Card Flipping Game

Problem

Solution: Hashset

花花酱 LeetCode 823. Binary Trees With Factors

Problem

Solution: DP