Posts tagged as “counting”

花花酱 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

Given a positive integer n, return the number of all possible attendance records with length n, which will be regarded as rewardable. The answer may be very large, return it after mod 10⁹ + 7.

A student attendance record is a string that only contains the following three characters:

‘A’ : Absent.
‘L’ : Late.
‘P’ : Present.

A record is regarded as rewardable if it doesn’t contain more than one ‘A’ (absent) or more than two continuous ‘L’ (late).

Example 1:

Input: n = 2
Output: 8 
Explanation:
There are 8 records with length 2 will be regarded as rewardable:
"PP" , "AP", "PA", "LP", "PL", "AL", "LA", "LL"
Only "AA" won't be regarded as rewardable owing to more than one absent times.

Note: The value of n won’t exceed 100,000.

Solution

C++

DFS w/ memorization (stack overflow)

class Solution {

public:

int checkRecord(int n) {

m_ = vector<vector<int>>(n + 1, vector<int>(6, 0));

if (n >= 100000) return 0;

return dfs(n, 1, 2);

}

private:

vector<vector<int>> m_;

// number of solutions of using at most A As and L Ls

long dfs(int n, int A, int L) {

if (n == 0) return 1;

int key = A * 3 + L;

if (m_[n][key]) return m_[n][key];

long ans = 0;

ans += dfs(n - 1, A, 2); // 'P', reset number of Ls

if (A > 0)

ans += dfs(n - 1, A - 1, 2); // 'A', reset number of Ls

if (L > 0)

ans += dfs(n - 1, A, L - 1); // 'L'

return m_[n][key] = (ans % 1000000007);

}

};

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua

// Running time: 129 ms

class Solution {

public:

int checkRecord(int n) {

constexpr int kMod = 1000000007;

vector<long> dp(6, 1);

for (int i = 1; i <= n; ++i) {

vector<long> tmp(6);

for (int A = 0; A <= 1; ++A)

for (int L = 0; L <= 2; ++L) {

const int key = getKey(A, L);

tmp[key] += dp[getKey(A, 2)];

if (A > 0) tmp[key] += dp[getKey(A - 1, 2)];

if (L > 0) tmp[key] += dp[getKey(A, L - 1)];

tmp[key] %= kMod;

}

dp.swap(tmp);

}

return dp[5];

}

private:

inline int getKey(int A, int L) { return A * 3 + L; }

};

花花酱 LeetCode 383. Ransom Note

By zxi on March 15, 2018

题目大意：给你一个字符串，问能否用它其中的字符组成另外一个字符串，每个字符只能使用一次。

Problem:

Given an arbitrary ransom note string and another string containing letters from all the magazines, write a function that will return true if the ransom note can be constructed from the magazines ; otherwise, it will return false.

Each letter in the magazine string can only be used once in your ransom note.

Note:
You may assume that both strings contain only lowercase letters.

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

Solution: HashTable

Time complexity: O(n + m)

Space complexity: O(128)

C++

// Author: Huahua

// Running time: 24 ms

class Solution {

public:

bool canConstruct(string ransomNote, string magazine) {

vector<int> counts(128, 0);

for (const char c : magazine)

++counts[c];

for (const char c : ransomNote)

if (--counts[c] < 0) return false;

return true;

}

};

// Author: Huahua

// Running time: 9 ms (beats 100%)

static int x=[](){

std::ios::sync_with_stdio(false);

cin.tie(NULL);

return 0;

}();

class Solution {

public:

bool canConstruct(const string& ransomNote, const string& magazine) {

vector<int> counts(128, 0);

for (const char c : magazine)

++counts[c];

for (const char c : ransomNote)

if (--counts[c] < 0) return false;

return true;

}

};

Python3

"""

Author: Huahua

Running time: 64 ms

"""

class Solution:

def canConstruct(self, ransomNote, magazine):

return not collections.Counter(ransomNote) - collections.Counter(magazine);

花花酱 LeetCode 575. Distribute Candies

By zxi on March 5, 2018

题目大意：有一些不同种类的糖果，男生女生各得一半数量的糖果，问女生最多可能得到多少种不同种类的糖果。

Given an integer array with even length, where different numbers in this array represent different kinds of candies. Each number means one candy of the corresponding kind. You need to distribute these candies equally in number to brother and sister. Return the maximum number of kinds of candies the sister could gain.

Example 1:

Input: candies = [1,1,2,2,3,3]

Output: 3

Explanation:

There are three different kinds of candies (1, 2 and 3), and two candies for each kind.

Optimal distribution: The sister has candies [1,2,3] and the brother has candies [1,2,3], too.

The sister has three different kinds of candies.

Example 2:

Input: candies = [1,1,2,3]

Output: 2

Explanation: For example, the sister has candies [2,3] and the brother has candies [1,1].

The sister has two different kinds of candies, the brother has only one kind of candies.

Note:

The length of the given array is in range [2, 10,000], and will be even.
The number in given array is in range [-100,000, 100,000].

Solution 1: Greedy

Give all unique candies to sisters until they have n/2 candies.

Time complexity: O(n)

Space complexity: O(n)

C++ Hashset

// Author: Huahua

// Running time: 258 ms

class Solution {

public:

int distributeCandies(vector<int>& candies) {

unordered_set<int> kinds(candies.begin(), candies.end());

return min(kinds.size(), candies.size() / 2);

}

};

C++ Bitset

// Author: Huahua

// Running time: 195 ms (beats 97.61%)

class Solution {

public:

int distributeCandies(vector<int>& candies) {

constexpr int kMaxKinds = 200001;

constexpr int kOffset = 100000;

bitset<kMaxKinds> s;

for (int candy : candies)

if (!s.test(candy + kOffset))

s.set(candy + kOffset);

return std::min(s.count(), candies.size() / 2);

}

};

花花酱 LeetCode 518. Coin Change 2

By zxi on March 2, 2018

题目大意：给你一些硬币的面值，问使用这些硬币（无限多块）能够组成amount的方法有多少种。

You are given coins of different denominations and a total amount of money. Write a function to compute the number of combinations that make up that amount. You may assume that you have infinite number of each kind of coin.

Note: You can assume that

0 <= amount <= 5000
1 <= coin <= 5000
the number of coins is less than 500
the answer is guaranteed to fit into signed 32-bit integer

Example 1:

Input: amount = 5, coins = [1, 2, 5]

Output: 4

Explanation: there are four ways to make up the amount:

5=5

5=2+2+1

5=2+1+1+1

5=1+1+1+1+1

Example 2:

Input: amount = 3, coins = [2]

Output: 0

Explanation: the amount of 3 cannot be made up just with coins of 2.

Example 3:

1 2	Input: amount = 10, coins = [10] Output: 1

Idea: DP

Transition 1:

Let us use dp[i][j] to denote the number of ways to sum up to amount j using first i kind of coins.

dp[i][j] = dp[i – 1][j – coin] + dp[i – 1][j – 2* coin] + …

Time complexity: O(n*amount^2) TLE

Space complexity: O(n*amount) -> O(amount)

Transition 2:

Let us use dp[i] to denote the number of ways to sum up to amount i.

dp[i + coin] += dp[i]

Time complexity: O(n*amount)

Space complexity: O(amount)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int change(int amount, vector<int>& coins) {

vector<int> dp(amount + 1, 0);

dp[0] = 1;

for (const int coin : coins)

for (int i = 0; i <= amount - coin; ++i)

dp[i + coin] += dp[i];

return dp[amount];

}

};

Java

// Author: Huahua

// Running time: 7 ms

class Solution {

public int change(int amount, int[] coins) {

int[] dp = new int[amount + 1];

dp[0] = 1;

for (int coin : coins)

for (int i = 0; i <= amount - coin; ++i)

dp[i + coin] += dp[i];

return dp[amount];

}

Python

"""

Author: Huahua

Running time: 107 ms (beats 100%)

"""

class Solution(object):

def change(self, amount, coins):

dp = [1] + [0] * (amount);

for coin in coins:

for i in xrange(amount - coin + 1):

if dp[i]:

dp[i + coin] += dp[i]

return dp[amount]

Related Problems:

花花酱 LeetCode 322. Coin Change

Posts tagged as “counting”

花花酱 LeetCode 576. Out of Boundary Paths

Problem

Solution

Related Problems

花花酱 LeetCode 552. Student Attendance Record II

Problem

Solution

花花酱 LeetCode 383. Ransom Note

花花酱 LeetCode 575. Distribute Candies

花花酱 LeetCode 518. Coin Change 2