Huahua's Tech Road

花花酱 LeetCode 380. Insert Delete GetRandom O(1)

By zxi on September 16, 2017

Problem:

Design a data structure that supports all following operations in average O(1) time.

insert(val): Inserts an item val to the set if not already present.
remove(val): Removes an item val from the set if present.
getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.

Idea:

Hashtable + array

Time complexity:

O(1)

Solution:

// Author: Huahua

// Running time: 49 ms

class RandomizedSet {

public:

/** Initialize your data structure here. */

RandomizedSet() {}

/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */

bool insert(int val) {

if(m_.count(val)) return false;

m_[val] = vals_.size();

vals_.push_back(val);

return true;

}

/** Removes a value from the set. Returns true if the set contained the specified element. */

bool remove(int val) {

if(!m_.count(val)) return false;

int index = m_[val];

m_[vals_.back()] = index;

m_.erase(val);

std::swap(vals_[index], vals_.back());

vals_.pop_back();

return true;

}

/** Get a random element from the set. */

int getRandom() {

int index = rand() % vals_.size();

return vals_[index];

}

private:

// val -> index in the array

unordered_map<int, int> m_;

vector<int> vals_;

};

Related Problems:

花花酱 LeetCode 673. Number of Longest Increasing Subsequence

By zxi on September 15, 2017

https://leetcode.com/problems/number-of-longest-increasing-subsequence

Problem:

Given an unsorted array of integers, find the number of longest increasing subsequence.

Example 1:

Input: [1,3,5,4,7]

Output: 2

Explanation: The two longest increasing subsequence are [1, 3, 4, 7] and [1, 3, 5, 7].

Example 2:

Input: [2,2,2,2,2]

Output: 5

Explanation: The length of longest continuous increasing subsequence is 1, and there are 5 subsequences' length is 1, so output 5.

Note: Length of the given array will be not exceed 2000 and the answer is guaranteed to be fit in 32-bit signed int.

Idea:

Dynamic programming

Solution1:

// Author: Huahua

// Running time: 82 ms

class Solution {

public:

int findNumberOfLIS(vector<int>& nums) {

int n = nums.size();

if (n == 0) return 0;

c_ = vector<int>(n, 0);

l_ = vector<int>(n, 0);

// Find the length LIS.

int max_len = 0;

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

max_len = max(max_len, len(nums, i));

// Checking all endings.

int ans = 0;

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

if (len(nums, i) == max_len)

ans += count(nums, i);

return ans;

}

private:

vector<int> c_; // c[i]: number of LIS ends with nums[i] / NLIS'

vector<int> l_; // l[i]: lengeh of LIS ends with nums[i] / LIS'

// Number of LIS ends with nums[n]

int count(const vector<int>& nums, int n) {

if (n == 0) return 1;

if (c_[n] > 0) return c_[n];

int total_count = 0;

int l = len(nums, n);

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

if (nums[n] > nums[i] && len(nums, i) == l-1)

total_count += count(nums, i);

if (total_count == 0)

total_count = 1;

return c_[n] = total_count;

}

// Length of LIS ends with nums[n]

int len(const vector<int>& nums, int n) {

if (n == 0) return 1;

if (l_[n] > 0) return l_[n];

int max_len = 1;

// Check every subarray

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

if (nums[n] > nums[i])

max_len = max(max_len, len(nums, i) + 1);

return l_[n] = max_len;

}

};

Solution2:

// Author: Huahua

// Running time: 33 ms

class Solution {

public:

int findNumberOfLIS(vector<int>& nums) {

int n = nums.size();

if (n == 0) return 0;

vector<int> c(n, 1);

vector<int> l(n, 1);

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

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

if (nums[i] > nums[j]) {

if (l[j] + 1 > l[i]) {

l[i] = l[j] + 1;

c[i] = c[j];

} else if (l[j] + 1 == l[i]) {

c[i] += c[j];

}

int max_len = *max_element(l.begin(), l.end());

int ans = 0;

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

if (l[i] == max_len)

ans += c[i];

return ans;

}

};

Related Problems:

花花酱 LeetCode 675. Cut Off Trees for Golf Event

By zxi on September 14, 2017

https://leetcode.com/problems/cut-off-trees-for-golf-event/

Problem:

You are asked to cut off trees in a forest for a golf event. The forest is represented as a non-negative 2D map, in this map:

0 represents the obstacle can’t be reached.
1 represents the ground can be walked through.
The place with number bigger than 1 represents a tree can be walked through, and this positive number represents the tree’s height.

You are asked to cut off all the trees in this forest in the order of tree’s height – always cut off the tree with lowest height first. And after cutting, the original place has the tree will become a grass (value 1).

You will start from the point (0, 0) and you should output the minimum steps you need to walk to cut off all the trees. If you can’t cut off all the trees, output -1 in that situation.

You are guaranteed that no two trees have the same height and there is at least one tree needs to be cut off.

Example 1:

Input:

[

[1,2,3],

[0,0,4],

[7,6,5]

]

Output: 6

Example 2:

Input:

[

[1,2,3],

[0,0,0],

[7,6,5]

]

Output: -1

Example 3:

Input:

[

[2,3,4],

[0,0,5],

[8,7,6]

]

Output: 6

Explanation: You started from the point (0,0) and you can cut off the tree in (0,0) directly without walking.

Hint: size of the given matrix will not exceed 50×50.

Idea:

Greedy + Shortest path

Identify and sort the trees by its heights, then find shortest paths between

0,0 to tree[1]
tree[1] to tree[2]
…
tree[n-1] to tree[n]

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

Space complexity: O(mn)

Solution:

// Author: Huahua

// Running time: 282 ms

class Solution {

public:

int cutOffTree(vector<vector<int>>& forest) {

m_ = forest.size();

n_ = forest[0].size();

// {height, x, y}

vector<tuple<int,int,int>> trees;

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

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

if (forest[y][x] > 1)

trees.emplace_back(forest[y][x], x, y);

// sort trees by height

sort(trees.begin(), trees.end());

int sx = 0;

int sy = 0;

int total_steps = 0;

// Move from current position to next tree to cut

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

int tx = get<1>(trees[i]);

int ty = get<2>(trees[i]);

int steps = BFS(forest, sx, sy, tx, ty);

if (steps == INT_MAX) return -1;

// Cut the tree, not necessary

forest[ty][tx] = 1;

total_steps += steps;

sx = tx;

sy = ty;

}

return total_steps;

}

private:

// min steps to go from (sx,sy) to (tx,ty) based on current map

// INT_MAX means not reachable

int BFS(const vector<vector<int>>& forest,

int sx, int sy,

int tx, int ty) {

static int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

auto visited = vector<vector<int>>(m_, vector<int>(n_, 0));

// {x, y}

queue<pair<int,int>> q;

q.emplace(sx, sy);

int steps = 0;

while (!q.empty()) {

int new_nodes = q.size();

while (new_nodes--) {

auto node = q.front();

q.pop();

const int cx = node.first;

const int cy = node.second;

// Found the shortest path

if (cx == tx && cy == ty)

return steps;

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

const int x = cx + dirs[i][0];

const int y = cy + dirs[i][1];

// Out of bound or unwalkable

if (x < 0 || x == n_

|| y < 0 || y == m_

|| !forest[y][x]

|| visited[y][x]) continue;

// Mark x, y as visited

visited[y][x] = 1;

q.emplace(x, y);

}

++steps;

}

// Impossible to reach

return INT_MAX;

}

int m_;

int n_;

};

花花酱 LeetCode 460. LFU Cache

By zxi on September 14, 2017

Problem:

Design and implement a data structure for Least Frequently Used (LFU) cache. It should support the following operations: get and put.

get(key) – Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
put(key, value) – Set or insert the value if the key is not already present. When the cache reaches its capacity, it should invalidate the least frequently used item before inserting a new item. For the purpose of this problem, when there is a tie (i.e., two or more keys that have the same frequency), the least recently used key would be evicted.

Follow up:
Could you do both operations in O(1) time complexity?

Example:

LFUCache cache = new LFUCache( 2 /* capacity */ );

cache.put(1, 1);

cache.put(2, 2);

cache.get(1); // returns 1

cache.put(3, 3); // evicts key 2

cache.get(2); // returns -1 (not found)

cache.get(3); // returns 3.

cache.put(4, 4); // evicts key 1.

cache.get(1); // returns -1 (not found)

cache.get(3); // returns 3

cache.get(4); // returns 4

Idea:

Hashtable + balanced search tree

Hashtable + double linked list

Solution 1: O(logc) c is the capacity

// Author: Huahua

// Running time: 99 ms

struct CacheNode {

int key;

int value;

int freq;

long tick;

// Defines the order, smaller one will be evicted first

bool operator <(const CacheNode& rhs) const {

if (freq < rhs.freq) return true;

if (freq == rhs.freq) return tick < rhs.tick;

return false;

}

};

class LFUCache {

public:

LFUCache(int capacity):capacity_(capacity), tick_(0) {}

int get(int key) {

auto it = m_.find(key);

if (it == m_.cend()) return -1;

int value = it->second.value;

touch(it->second);

return value;

}

void put(int key, int value) {

if (capacity_ == 0) return;

auto it = m_.find(key);

if (it != m_.cend()) {

// Key exists, update value and touch

it->second.value = value;

touch(it->second);

return;

}

if (m_.size() == capacity_) {

// Remove the first node in cache

const CacheNode& node = *cache_.cbegin();

m_.erase(node.key);

cache_.erase(node);

}

CacheNode node{key, value, 1, ++tick_};

m_[node.key] = node;

cache_.insert(node);

}

private:

void touch(CacheNode& node) {

cache_.erase(node); // log(capacity)

++node.freq;

node.tick = ++tick_;

cache_.insert(node); // log(capacity)

}

long tick_;

int capacity_;

unordered_map<int, CacheNode> m_;

set<CacheNode> cache_;

};

Solution 2: O(1)

// Author: Huahua

// Running time: 89 ms (beats 96.3%)

struct CacheNode {

int key;

int value;

int freq;

// pointer to the node in the list

list<int>::const_iterator it;

};

class LFUCache {

public:

LFUCache(int capacity): capacity_(capacity), min_freq_(0) {}

int get(int key) {

auto it = n_.find(key);

if (it == n_.cend()) return -1;

touch(it->second);

return it->second.value;

}

void put(int key, int value) {

if (capacity_ == 0) return;

auto it = n_.find(key);

if (it != n_.cend()) {

// Key already exists, update the value and touch it

it->second.value = value;

touch(it->second);

return;

}

if (n_.size() == capacity_) {

// No capacity, need to remove one entry that

// 1. has the lowest freq

// 2. least recently used if there are multiple ones

// Step 1: remove the element from min_freq_ list

const int key_to_evict = l_[min_freq_].back();

l_[min_freq_].pop_back();

// Step 2: remove the key from cache

n_.erase(key_to_evict);

}

// We know new item has freq of 1, thus set min_freq to 1

const int freq = 1;

min_freq_ = freq;

// Add the key to the freq list

l_[freq].push_front(key);

// Create a new node

n_[key] = {key, value, freq, l_[freq].cbegin()};

}

private:

void touch(CacheNode& node) {

// Step 1: update the frequency

const int prev_freq = node.freq;

const int freq = ++(node.freq);

// Step 2: remove the entry from old freq list

l_[prev_freq].erase(node.it);

if (l_[prev_freq].empty() && prev_freq == min_freq_) {

// Delete the list

l_.erase(prev_freq);

// Increase the min freq

++min_freq_;

}

// Step 4: insert the key into the front of the new freq list

l_[freq].push_front(node.key);

// Step 5: update the pointer

node.it = l_[freq].cbegin();

}

int capacity_;

int min_freq_;

// key -> CacheNode

unordered_map<int, CacheNode> n_;

// freq -> keys with freq

unordered_map<int, list<int>> l_;

};

花花酱 LeetCode 451. Sort Characters By Frequency

By zxi on September 13, 2017

Problem:

Given a string, sort it in decreasing order based on the frequency of characters.

Example 1:

Input:
“tree”

Output:
“eert”

Explanation:
‘e’ appears twice while ‘r’ and ‘t’ both appear once.
So ‘e’ must appear before both ‘r’ and ‘t’. Therefore “eetr” is also a valid answer.
Example 2:

Input:
“cccaaa”

Output:
“cccaaa”

Explanation:
Both ‘c’ and ‘a’ appear three times, so “aaaccc” is also a valid answer.
Note that “cacaca” is incorrect, as the same characters must be together.
Example 3:

Input:
“Aabb”

Output:
“bbAa”

Explanation:
“bbaA” is also a valid answer, but “Aabb” is incorrect.
Note that ‘A’ and ‘a’ are treated as two different characters.

Idea:

Counting sort

Solution 1:

Sort the string based on element frequency

// Author: Huahua

// Running time: 289 ms

class Solution {

public:

string frequencySort(string& s) {

array<int, 128> f{0};

for(char c:s) ++f[c];

sort(s.begin(), s.end(), [&f] (char a, char b) {

return f[a] > f[b] || (f[a] == f[b] && a > b);

});

return s;

}

};

// Author: Huahua

// Running time: 139 ms

class Solution {

public:

string frequencySort(string& s) {

map<char, int> f;

for(char c:s) ++f[c];

sort(s.begin(), s.end(), [&f] (char a, char b) {

return f[a] > f[b] || (f[a] == f[b] && a > b);

});

return s;

}

};

// Author: Huahua

// Running time: 29 ms

class Solution {

public:

string frequencySort(string& s) {

array<int, 128> f{0};

for(char c:s) ++f[c];

sort(s.begin(), s.end(), [&f] (char a, char b) {

return f[a] > f[b] || (f[a] == f[b] && a > b);

});

return s;

}

};

Solution 2:

Counting sort

// Author: Huahua

// Running time: 12 ms

class Solution {

public:

string frequencySort(const string& s) {

vector<int> f(128, 0);

for(char c:s) ++f[c];

vector<pair<int,char>> v;

for (int i = 0; i < 128; ++i) {

if (f[i] > 0) v.emplace_back(f[i], i);

}

sort(v.rbegin(), v.rend());

string ans;

for(const auto& kv : v) {

ans.append(kv.first, kv.second);

}

return ans;

}

};