Huahua’s Tech Road

花花酱 LeetCode 1518. Water Bottles

By zxi on July 18, 2020

Given numBottles full water bottles, you can exchange numExchange empty water bottles for one full water bottle.

The operation of drinking a full water bottle turns it into an empty bottle.

Return the maximum number of water bottles you can drink.

Example 1:

Input: numBottles = 9, numExchange = 3
Output: 13
Explanation: You can exchange 3 empty bottles to get 1 full water bottle.
Number of water bottles you can drink: 9 + 3 + 1 = 13.

Example 2:

Input: numBottles = 15, numExchange = 4
Output: 19
Explanation: You can exchange 4 empty bottles to get 1 full water bottle. 
Number of water bottles you can drink: 15 + 3 + 1 = 19.

Example 3:

Input: numBottles = 5, numExchange = 5
Output: 6

Example 4:

Input: numBottles = 2, numExchange = 3
Output: 2

Constraints:

1 <= numBottles <= 100
2 <= numExchange <= 100

Solution: Simulation

Time complexity: O(logb/loge)?
Space complexity: O(1)

C++

class Solution {

public:

int numWaterBottles(int numBottles, int numExchange) {

int ans = 0;

while (numBottles <= numExchange) {

const int r = numBottles % numExchange;

ans += numBottles - r;

numBottles = r + numBottles / numExchange;

}

ans += numBottles;

return ans;

}

};

Java

class Solution {

public int numWaterBottles(int numBottles, int numExchange) {

int ans = 0;

while (numBottles <= numExchange) {

final int r = numBottles % numExchange;

ans += numBottles - r;

numBottles = r + numBottles / numExchange;

}

ans += numBottles;

return ans;

}

Python3

class Solution:

def numWaterBottles(self, numBottles: int, numExchange: int) ->; int:

ans = 0

while numBottles <= numExchange:

r = numBottles % numExchange

ans += numBottles - r

numBottles = r + numBottles // numExchange

ans += numBottles

return ans

Why grid[y][x] instead of grid[x][y]?

By zxi on July 17, 2020

If you don’t like grid[y][x], you can use grid[r][c] instead.

C++

#include <iostream>

using namespace std;

int main(int argc, char** argv) {

constexpr int kRows = 2;

constexpr int kCols = 3;

int arr[kRows][kCols] = {{1,2,3},{4,5,6}};

for (int r = 0; r < kRows; ++r) {

for (int c = 0; c < kCols; ++c)

cout << arr[r][c] << " ";

cout << endl;

}

for (int r = 0; r < kRows; ++r)

for (int c = 0; c < kCols; ++c)

cout << &(arr[r][c]) - &(arr[0][0]) << " ";

return 0;

}

// Output:

// 1 2 3

// 4 5 6

// 0 1 2 3 4 5

花花酱 LeetCode 1510. Stone Game IV

By zxi on July 17, 2020

Alice and Bob take turns playing a game, with Alice starting first.

Initially, there are n stones in a pile. On each player’s turn, that player makes a move consisting of removing any non-zero square number of stones in the pile.

Also, if a player cannot make a move, he/she loses the game.

Given a positive integer n. Return True if and only if Alice wins the game otherwise return False, assuming both players play optimally.

Example 1:

Input: n = 1
Output: true
Explanation: Alice can remove 1 stone winning the game because Bob doesn't have any moves.

Example 2:

Input: n = 2
Output: false
Explanation: Alice can only remove 1 stone, after that Bob removes the last one winning the game (2 -> 1 -> 0).

Example 3:

Input: n = 4
Output: true
Explanation: n is already a perfect square, Alice can win with one move, removing 4 stones (4 -> 0).

Example 4:

Input: n = 7
Output: false
Explanation: Alice can't win the game if Bob plays optimally.
If Alice starts removing 4 stones, Bob will remove 1 stone then Alice should remove only 1 stone and finally Bob removes the last one (7 -> 3 -> 2 -> 1 -> 0). 
If Alice starts removing 1 stone, Bob will remove 4 stones then Alice only can remove 1 stone and finally Bob removes the last one (7 -> 6 -> 2 -> 1 -> 0).

Example 5:

Input: n = 17
Output: false
Explanation: Alice can't win the game if Bob plays optimally.

Constraints:

1 <= n <= 10^5

Solution: Recursion w/ Memoization / DP

Let win(n) denotes whether the current play will win or not.
Try all possible square numbers and see whether the other player will lose or not.
win(n) = any(win(n – i*i) == False) ? True : False
base case: win(0) = False

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

C++

class Solution {

public:

bool winnerSquareGame(int n) {

vector<int> cache(n + 1, 0); // 0:Unknown, 1:Win, -1:Lose

function<int(int)> win = [&](int n) -> int {

if (n == 0) return -1;

if (cache[n]) return cache[n];

for (int i = sqrt(n); i >= 1; --i)

if (win(n - i * i) < 0) return cache[n] = 1;

return cache[n] = -1;

};

return win(n) > 0;

}

};

Java

class Solution {

private int[] cache;

public boolean winnerSquareGame(int n) {

this.cache = new int[n + 1];

return this.win(n) > 0;

}

private int win(int n) {

if (n == 0) return -1;

if (this.cache[n] != 0) return this.cache[n];

for (int i = (int)Math.sqrt(n); i >= 1; --i)

if (win(n - i * i) < 0)

return this.cache[n] = 1;

return this.cache[n] = -1;

}

Python3

class Solution:

def winnerSquareGame(self, n: int) -> bool:

dp = [None] * (n + 1)

dp[0] = False

for i in range(0, n):

if dp[i]: continue

for j in range(1, n + 1):

if i + j * j > n: break

dp[i + j * j] = True

return dp[n]

花花酱 LeetCode 1512. Number of Good Pairs

By zxi on July 16, 2020

Given an array of integers nums.

A pair (i,j) is called good if nums[i] == nums[j] and i < j.

Return the number of good pairs.

Example 1:

Input: nums = [1,2,3,1,1,3]
Output: 4
Explanation: There are 4 good pairs (0,3), (0,4), (3,4), (2,5) 0-indexed.

Example 2:

Input: nums = [1,1,1,1]
Output: 6
Explanation: Each pair in the array are good.

Example 3:

Input: nums = [1,2,3]
Output: 0

Constraints:

1 <= nums.length <= 100
1 <= nums[i] <= 100

Solution 1: Brute Force

Enumerate all the pairs.

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

C++

class Solution {

public:

int numIdenticalPairs(vector<int>& nums) {

int ans = 0;

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

for (int j = i + 1; j < nums.size(); ++j)

ans += nums[i] == nums[j];

return ans;

}

};

Java

class Solution {

public int numIdenticalPairs(int[] nums) {

int ans = 0;

for (int i = 0; i < nums.length; ++i)

for (int j = i + 1; j < nums.length; ++j)

if (nums[i] == nums[j]) ++ans;

return ans;

}

Python3

class Solution:

def numIdenticalPairs(self, nums: List[int]) -> int:

n = len(nums)

ans = 0

for i in range(n):

for j in range(i + 1, n):

if nums[i] == nums[j]: ans += 1

return ans

Solution 2: Hashtable

Store the frequency of each number so far, when we have a number x at pos j, and it appears k times before. Then we can form additional k pairs.

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

C++

// Author: Huahua

class Solution {

public:

int numIdenticalPairs(vector<int>& nums) {

int ans = 0;

vector<int> f(101);

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

ans += f[nums[i]]++;

return ans;

}

};

Java

// Author: Huahua

class Solution {

public int numIdenticalPairs(int[] nums) {

int ans = 0;

int[] f = new int[101];

for (int i = 0; i < nums.length; ++i)

ans += f[nums[i]]++;

return ans;

}

Python3

# Author: Huahua

class Solution:

def numIdenticalPairs(self, nums: List[int]) -> int:

f = defaultdict(int)

ans = 0

for x in nums:

ans += f[x]

f[x] += 1

return ans

花花酱 LeetCode 1514. Path with Maximum Probability

By zxi on July 11, 2020

You are given an undirected weighted graph of n nodes (0-indexed), represented by an edge list where edges[i] = [a, b] is an undirected edge connecting the nodes a and b with a probability of success of traversing that edge succProb[i].

Given two nodes start and end, find the path with the maximum probability of success to go from start to end and return its success probability.

If there is no path from start to end, return 0. Your answer will be accepted if it differs from the correct answer by at most 1e-5.

Example 1:

Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.2], start = 0, end = 2
Output: 0.25000
Explanation: There are two paths from start to end, one having a probability of success = 0.2 and the other has 0.5 * 0.5 = 0.25.

Example 2:

Input: n = 3, edges = [[0,1],[1,2],[0,2]], succProb = [0.5,0.5,0.3], start = 0, end = 2
Output: 0.30000

Example 3:

Input: n = 3, edges = [[0,1]], succProb = [0.5], start = 0, end = 2
Output: 0.00000
Explanation: There is no path between 0 and 2.

Constraints:

2 <= n <= 10^4
0 <= start, end < n
start != end
0 <= a, b < n
a != b
0 <= succProb.length == edges.length <= 2*10^4
0 <= succProb[i] <= 1
There is at most one edge between every two nodes.

Solution: Dijkstra’s Algorithm

max(P1*P2*…*Pn) => max(log(P1*P2…*Pn)) => max(log(P1) + log(P2) + … + log(Pn) => min(-(log(P1) + log(P2) … + log(Pn)).

Thus we can convert this problem to the classic single source shortest path problem that can be solved with Dijkstra’s algorithm.

Time complexity: O(ElogV)
Space complexity: O(E+V)

C++

// Author: Huahua

class Solution {

public:

double maxProbability(int n, vector<vector<int>>& edges,

vector<double>& succProb, int start, int end) {

vector<vector<pair<int, double>>> g(n); // u -> {v, -log(w)}

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

const double w = -log(succProb[i]);

g[edges[i][0]].emplace_back(edges[i][1], w);

g[edges[i][1]].emplace_back(edges[i][0], w);

}

vector<double> dist(n, FLT_MAX);

priority_queue<pair<double, int>> q;

q.emplace(-0.0, start);

vector<int> seen(n);

while (!q.empty()) {

const double d = -q.top().first;

const int u = q.top().second;

q.pop();

seen[u] = 1;

if (u == end) return exp(-d);

for (const auto& [v, w] : g[u]) {

if (seen[v] || d + w > dist[v]) continue;

q.emplace(-(dist[v] = d + w), v);

}

return 0;

}

};

Java

// Author: Huahua

import java.util.AbstractMap;

class Solution {

public double maxProbability(int n, int[][] edges, double[] succProb, int start, int end) {

var g = new ArrayList<List<Map.Entry<Integer, Double>>>();

for (int i = 0; i < n; ++i) g.add(new ArrayList<Map.Entry<Integer, Double>>());

for (int i = 0; i < edges.length; ++i) {

g.get(edges[i][0]).add(new AbstractMap.SimpleEntry<>(edges[i][1], -Math.log(succProb[i])));

g.get(edges[i][1]).add(new AbstractMap.SimpleEntry<>(edges[i][0], -Math.log(succProb[i])));

}

var seen = new boolean[n];

var dist = new double[n];

Arrays.fill(dist, Double.MAX_VALUE);

seen[start] = true;

dist[start] = 0.0;

// {u, dist[u]}

var q = new PriorityQueue<Map.Entry<Integer, Double>>(Map.Entry.comparingByValue());

q.offer(new AbstractMap.SimpleEntry<>(start, 0.0));

while (!q.isEmpty()) {

var node = q.poll();

final int u = node.getKey();

if (u == end) return Math.exp(-dist[end]);

seen[u] = true;

for (var e : g.get(u)) {

final int v = e.getKey();

final double w = e.getValue();

if (seen[v] || dist[u] + w > dist[v]) continue;

dist[v] = dist[u] + w;

q.offer(new AbstractMap.SimpleEntry<>(v, dist[v]));

}

return 0;

}

Python3

# Author: Huahua

class Solution:

def maxProbability(self, n: int, edges: List[List[int]],

succProb: List[float], start: int, end: int) -> float:

g = [[] for _ in range(n)]

for i, e in enumerate(edges):

g[e[0]].append((e[1], -math.log(succProb[i])))

g[e[1]].append((e[0], -math.log(succProb[i])))

seen = [False] * n

dist = [float('inf')] * n

dist[start] = 0.0

q = [(dist[start], start)]

while q:

_, u = heapq.heappop(q)

if seen[u]: continue

seen[u] = True

if u == end: return math.exp(-dist[u])

for v, w in g[u]:

if seen[v] or dist[u] + w > dist[v]: continue

dist[v] = dist[u] + w

heapq.heappush(q, (dist[v], v))

return 0

Huahua's Tech Road

花花酱 LeetCode 1518. Water Bottles

Solution: Simulation

C++

Java

Python3

Why grid[y][x] instead of grid[x][y]?

C++

花花酱 LeetCode 1510. Stone Game IV

Solution: Recursion w/ Memoization / DP

C++

Java

Python3

花花酱 LeetCode 1512. Number of Good Pairs

Solution 1: Brute Force

C++

Java

Python3

Solution 2: Hashtable

C++

Java

Python3

花花酱 LeetCode 1514. Path with Maximum Probability

Solution: Dijkstra’s Algorithm

C++

Java

Python3