Posts published in “Hashtable”

花花酱 LeetCode 911. Online Election

By zxi on September 25, 2018

Problem

n an election, the i-th vote was cast for persons[i] at time times[i].

Now, we would like to implement the following query function: TopVotedCandidate.q(int t) will return the number of the person that was leading the election at time t.

Votes cast at time t will count towards our query. In the case of a tie, the most recent vote (among tied candidates) wins.

Example 1:

Input: ["TopVotedCandidate","q","q","q","q","q","q"], [[[0,1,1,0,0,1,0],[0,5,10,15,20,25,30]],[3],[12],[25],[15],[24],[8]]
Output: [null,0,1,1,0,0,1]
Explanation: 
At time 3, the votes are [0], and 0 is leading.
At time 12, the votes are [0,1,1], and 1 is leading.
At time 25, the votes are [0,1,1,0,0,1], and 1 is leading (as ties go to the most recent vote.)
This continues for 3 more queries at time 15, 24, and 8.

Note:

1 <= persons.length = times.length <= 5000
0 <= persons[i] <= persons.length
times is a strictly increasing array with all elements in [0, 10^9].
TopVotedCandidate.q is called at most 10000 times per test case.
TopVotedCandidate.q(int t) is always called with t >= times[0].

Solution: HashTable + Binary Search

Compute the leads for each t in times using a hash table.

binary search the upper bound of t, and return the lead of previous entry.

Time complexity: Constructor O(n), Query: O(logn)

Space complexity: O(n)

C++

// Author: Huahua

class TopVotedCandidate {

public:

TopVotedCandidate(vector<int> persons, vector<int> times) {

vector<int> votes(persons.size() + 1);

int last_lead = persons.front();

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

if (++votes[persons[i]] >= votes[last_lead])

last_lead = persons[i];

leads_[times[i]] = last_lead;

}

int q(int t) {

return prev(leads_.upper_bound(t))->second;

}

private:

map<int, int> leads_; // time -> lead

};

花花酱 LeetCode 13. Roman to Integer

By zxi on September 19, 2018

Problem

Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M.

Symbol       Value
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

For example, two is written as II in Roman numeral, just two one’s added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II.

Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used:

I can be placed before V (5) and X (10) to make 4 and 9.
X can be placed before L (50) and C (100) to make 40 and 90.
C can be placed before D (500) and M (1000) to make 400 and 900.

Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999.

Example 1:

Input: "III"
Output: 3

Example 2:

Input: "IV"
Output: 4

Example 3:

Input: "IX"
Output: 9

Example 4:

Input: "LVIII"
Output: 58
Explanation: C = 100, L = 50, XXX = 30 and III = 3.

Example 5:

Input: "MCMXCIV"
Output: 1994
Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.

Solution

accumulate the value of each letter.

If the value of current letter is greater than the previous one, deduct twice of the previous value.

e.g. IX, 1 + 10 – 2 * 1 = 9 instead of 1 + 10 = 11

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

int romanToInt(string s) {

map<char, int> m{{'I', 1}, {'V', 5},

{'X', 10}, {'L', 50},

{'C', 100}, {'D', 500},

{'M', 1000}};

int ans = 0;

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

ans += m[s[i]];

if (i > 0 && m[s[i]] > m[s[i - 1]])

ans -= 2 * m[s[i - 1]];

}

return ans;

}

};

Java

// Author: Huahua

class Solution {

private int v(char R) {

switch (R) {

case 'I' : return 1;

case 'V' : return 5;

case 'X' : return 10;

case 'L' : return 50;

case 'C' : return 100;

case 'D' : return 500;

case 'M' : return 1000;

default: break;

}

return 0;

}

public int romanToInt(String s) {

int ans = 0;

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

ans += v(s.charAt(i));

if ( i > 0 && v(s.charAt(i)) > v(s.charAt(i - 1)))

ans -= 2 * v(s.charAt(i - 1));

}

return ans;

}

Python3

class Solution:

def romanToInt(self, s):

m = {'I' : 1, 'V': 5, 'X': 10, 'L' : 50,

'C' : 100, 'D': 500, 'M': 1000}

ans = m[s[0]]

for c, p in zip(s[1:], s[0:-1]):

ans += m[c]

if m[c] > m[p]: ans -= 2 * m[p]

return ans

花花酱 LeetCode 904. Fruit Into Baskets

By zxi on September 15, 2018

Problem

In a row of trees, the i-th tree produces fruit with type tree[i].

You start at any tree of your choice, then repeatedly perform the following steps:

Add one piece of fruit from this tree to your baskets. If you cannot, stop.
Move to the next tree to the right of the current tree. If there is no tree to the right, stop.

Note that you do not have any choice after the initial choice of starting tree: you must perform step 1, then step 2, then back to step 1, then step 2, and so on until you stop.

You have two baskets, and each basket can carry any quantity of fruit, but you want each basket to only carry one type of fruit each.

What is the total amount of fruit you can collect with this procedure?

Example 1:

Input: [1,2,1]
Output: 3
Explanation: We can collect [1,2,1].

Example 2:

Input: [0,1,2,2]
Output: 3
Explanation: We can collect [1,2,2].
If we started at the first tree, we would only collect [0, 1].

Example 3:

Input: [1,2,3,2,2]
Output: 4
Explanation: We can collect [2,3,2,2].
If we started at the first tree, we would only collect [1, 2].

Example 4:

Input: [3,3,3,1,2,1,1,2,3,3,4]
Output: 5
Explanation: We can collect [1,2,1,1,2].
If we started at the first tree or the eighth tree, we would only collect 4 fruits.

Note:

1 <= tree.length <= 40000
0 <= tree[i] < tree.length

Solution: Hashtable + Sliding window

Time complexity: O(n)

Space complexity: O(1)

Keep track of the last index of each element. If a third type of fruit comes in, the new window starts after the fruit with smaller last index. Otherwise extend the current window.

[1 3 1 3 1 1] 4 1 4 … <- org window, 3 has a smaller last index than 1.

1 3 1 3 [1 1 4] 1 4 … <- new window

C++

// Author: Huahua, 144 ms

class Solution {

public:

int totalFruit(vector<int>& tree) {

map<int, int> idx; // {fruit -> last_index}

int ans = 0;

int cur = 0;

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

int f = tree[i];

if (!idx.count(f)) {

if (idx.size() == 2) {

auto it1 = begin(idx);

auto it2 = next(it1);

if (it1->second > it2->second) swap(it1, it2);

cur = i - it1->second - 1;

idx.erase(it1);

}

idx[f] = i;

ans = max(++cur, ans);

}

return ans;

}

};

花花酱 LeetCode 3. Longest Substring Without Repeating Characters

By zxi on September 11, 2018

Problem

Given a string, find the length of the longest substring without repeating characters.

Example 1:

Input: "abcabcbb"
Output: 3 
Explanation: The answer is "abc", with the length of 3.

Example 2:

Input: "bbbbb"
Output: 1
Explanation: The answer is "b", with the length of 1.

Example 3:

Input: "pwwkew"
Output: 3
Explanation: The answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

Solution: HashTable + Sliding Window

Using a hashtable to remember the last index of every char. And keep tracking the starting point of a valid substring.

start = max(start, last[s[i]] + 1)

ans = max(ans, i – start + 1)

Time complexity: O(n)

Space complexity: O(128)

C++

// Author: Huahua

class Solution {

public:

int lengthOfLongestSubstring(string s) {

const int n = s.length();

int ans = 0;

vector<int> idx(128, -1);

for (int i = 0, j = 0; j < n; ++j) {

i = max(i,idx[s[j]] + 1);

ans = max(ans, j - i + 1);

idx[s[j]] = j;

}

return ans;

}

};

Java

// Author: Huahua

class Solution {

public int lengthOfLongestSubstring(String s) {

int[] last = new int[128];

Arrays.fill(last, -1);

int start = 0;

int ans = 0;

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

if (last[s.charAt(i)] != -1)

start = Math.max(start, last[s.charAt(i)] + 1);

last[s.charAt(i)] = i;

ans = Math.max(ans, i - start + 1);

}

return ans;

}

Python3

# Author: Huahua

class Solution:

def lengthOfLongestSubstring(self, s):

last = [-1] * 128

ans = 0

start = 0

for i, ch in enumerate(s):

if last[ord(ch)] != -1:

start = max(start, last[ord(ch)] + 1)

ans = max(ans, i - start + 1)

last[ord(ch)] = i

return ans

花花酱 LeetCode 888. Fair Candy Swap

By zxi on August 19, 2018

Problem

Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.

Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total amount of candy. (The total amount of candy a person has is the sum of the sizes of candy bars they have.)

Return an integer array ans where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.

If there are multiple answers, you may return any one of them. It is guaranteed an answer exists.

Example 1:

Input: A = [1,1], B = [2,2]
Output: [1,2]

Example 2:

Input: A = [1,2], B = [2,3]
Output: [1,2]

Example 3:

Input: A = [2], B = [1,3]
Output: [2,3]

Example 4:

Input: A = [1,2,5], B = [2,4]
Output: [5,4]

Note:

1 <= A.length <= 10000
1 <= B.length <= 10000
1 <= A[i] <= 100000
1 <= B[i] <= 100000
It is guaranteed that Alice and Bob have different total amounts of candy.
It is guaranteed there exists an answer.

Solution: HashTable

Time complexity: O(A+B)

Space complexity: O(B)

Clean version

// Author: Huahua

// Running time: 132 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = accumulate(begin(B), end(B), 0);

unordered_set<int> s(begin(B), end(B));

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};

Faster version

// Author: Huahua

// Running time: 68 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = 0;

unordered_set<int> s;

for (int b : B) {

sum_b += b;

s.insert(b);

}

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};