Posts tagged as “easy”

花花酱 LeetCode 566. Reshape the Matrix

By zxi on August 16, 2018

Problem

In MATLAB, there is a very useful function called ‘reshape’, which can reshape a matrix into a new one with different size but keep its original data.

You’re given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.

The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the ‘reshape’ operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

Example 1:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
Output: 
[[1,2,3,4]]
Explanation:
The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.

Example 2:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
Output: 
[[1,2],
 [3,4]]
Explanation:
There is no way to reshape a 2 * 2 matrix to a 2 * 4 matrix. So output the original matrix.

Note:

The height and width of the given matrix is in range [1, 100].
The given r and c are all positive.

Solution1: Brute Force

Time complexity: O(mn)

Space complexity: O(mn)

// Author: Huahua

// Running time: 32 ms

class Solution {

public:

vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {

if (nums.size() == 0) return nums;

int m = nums.size();

int n = nums[0].size();

if (m * n != r * c) return nums;

// new matrix r*c

vector<vector<int>> ans(r, vector<int>(c));

for(int i = 0; i < m * n;++i) {

int src_y = i / n;

int src_x = i % n;

int dst_y = i / c;

int dst_x = i % c;

ans[dst_y][dst_x] = nums[src_y][src_x];

}

return ans;

}

};

花花酱 LeetCode 455. Assign Cookies

By zxi on August 15, 2018

Problem

Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie. Each child i has a greed factor g_i, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size s_j. If s_j >= g_i, we can assign the cookie j to the child i, and the child i will be content. Your goal is to maximize the number of your content children and output the maximum number.

Note:
You may assume the greed factor is always positive.
You cannot assign more than one cookie to one child.

Example 1:

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

Output: 1

Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3. 
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
You need to output 1.

Example 2:

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

Output: 2

Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2. 
You have 3 cookies and their sizes are big enough to gratify all of the children, 
You need to output 2.

Solution: Greedy + Two Pointers

Time complexity: O(mlogm + nlogn)

Space complexity: O(1)

// Author: Huahua

// Running time: 28 ms

class Solution {

public:

int findContentChildren(vector<int>& g, vector<int>& s) {

sort(begin(g), end(g));

sort(begin(s), end(s));

int ans = 0;

int j = 0;

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

while (j < s.size() && s[j] < g[i]) {

++j;

}

if (j < s.size()) {

++ans;

++j;

continue;

}

return ans;

}

};

花花酱 LeetCode 888. Uncommon Words from Two Sentences

By zxi on August 12, 2018

Problem

We are given two sentences A and B. (A sentence is a string of space separated words. Each word consists only of lowercase letters.)

A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.

Return a list of all uncommon words.

You may return the list in any order.

Example 1:

Input: A = "this apple is sweet", B = "this apple is sour"
Output: ["sweet","sour"]

Example 2:

Input: A = "apple apple", B = "banana"
Output: ["banana"]

Note:

0 <= A.length <= 200
0 <= B.length <= 200
A and B both contain only spaces and lowercase letters.

Solution: HashTable

Time complexity: O(m+n)

Space complexity: O(m+n)

C++

class Solution {

public:

vector<string> uncommonFromSentences(string A, string B) {

istringstream ss(A + " " + B);

unordered_map<string, int> counts;

string s;

while (ss >> s) ++counts[s];

vector<string> ans;

for (const auto& p : counts)

if (p.second == 1)

ans.push_back(p.first);

return ans;

}

};

花花酱 LeetCode 707. Design Linked List

By zxi on August 9, 2018

Problem

Design your implementation of the linked list. You can choose to use the singly linked list or the doubly linked list. A node in a singly linked list should have two attributes: val and next. val is the value of the current node, and next is a pointer/reference to the next node. If you want to use the doubly linked list, you will need one more attribute prev to indicate the previous node in the linked list. Assume all nodes in the linked list are 0-indexed.

Implement these functions in your linked list class:

get(index) : Get the value of the index-th node in the linked list. If the index is invalid, return -1.
addAtHead(val) : Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
addAtTail(val) : Append a node of value val to the last element of the linked list.
addAtIndex(index, val) : Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
deleteAtIndex(index) : Delete the index-th node in the linked list, if the index is valid.

Example:

MyLinkedList linkedList = new MyLinkedList();

linkedList.addAtHead(1);

linkedList.addAtTail(3);

linkedList.addAtIndex(1, 2); // linked list becomes 1->2->3

linkedList.get(1); // returns 2

linkedList.deleteAtIndex(1); // now the linked list is 1->3

linkedList.get(1); // returns 3

Note:

All values will be in the range of [1, 1000].
The number of operations will be in the range of [1, 1000].
Please do not use the built-in LinkedList library.

Solution: Single linked list

Keep tracking head and tail of the list.

Time Complexity:

addAtHead, addAtTail O(1)

addAtIndex O(index)

deleteAtIndex O(index)

Space complexity: O(1)

C++

Tracking head/tail and size of the list.

// Author: Huahua

// Running time: 24 ms

class MyLinkedList {

public:

MyLinkedList(): head_(nullptr), tail_(nullptr), size_(0) {}

~MyLinkedList() {

Node* node = head_;

while (node) {

Node* cur = node;

node = node->next;

delete cur;

}

head_ = nullptr;

tail_ = nullptr;

}

int get(int index) {

if (index < 0 || index >= size_) return -1;

auto node = head_;

while (index--)

node = node->next;

return node->val;

}

void addAtHead(int val) {

head_ = new Node(val, head_);

if (size_++ == 0)

tail_ = head_;

}

void addAtTail(int val) {

auto node = new Node(val);

if (size_++ == 0) {

head_ = tail_ = node;

} else {

tail_->next = node;

tail_ = tail_->next;

}

void addAtIndex(int index, int val) {

if (index < 0 || index > size_) return;

if (index == 0) return addAtHead(val);

if (index == size_) return addAtTail(val);

Node dummy(0, head_);

Node* prev = &dummy;

while (index--) prev = prev->next;

prev->next = new Node(val, prev->next);

++size_;

}

void deleteAtIndex(int index) {

if (index < 0 || index >= size_) return;

Node dummy(0, head_);

Node* prev = &dummy;

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

prev = prev->next;

Node* node_to_delete = prev->next;

prev->next = prev->next->next;

if (index == 0) head_ = prev->next;

if (index == size_ - 1) tail_ = prev;

delete node_to_delete;

--size_;

}

private:

struct Node {

int val;

Node* next;

Node(int _val): Node(_val, nullptr) {}

Node(int _val, Node* _next): val(_val), next(_next) {}

};

Node* head_;

Node* tail_;

int size_;

};

// Author: Huahua

// Running time: 28 ms

class MyLinkedList {

public:

MyLinkedList(): head_(nullptr), tail_(nullptr), dummy_(0), size_(0) {}

~MyLinkedList() {

Node* node = head_;

while (node) {

Node* cur = node;

node = node->next;

delete cur;

}

head_ = nullptr;

tail_ = nullptr;

}

int get(int index) {

if (index < 0 || index >= size_) return -1;

return getNode(index)->val;

}

void addAtHead(int val) {

head_ = new Node(val, head_);

if (size_++ == 0)

tail_ = head_;

}

void addAtTail(int val) {

auto node = new Node(val);

if (size_++ == 0) {

head_ = tail_ = node;

} else {

tail_->next = node;

tail_ = tail_->next;

}

void addAtIndex(int index, int val) {

if (index < 0 || index > size_) return;

if (index == 0) return addAtHead(val);

if (index == size_) return addAtTail(val);

Node* prev = getNode(index - 1);

prev->next = new Node(val, prev->next);

++size_;

}

void deleteAtIndex(int index) {

if (index < 0 || index >= size_) return;

Node* prev = getNode(index - 1);

Node* node_to_delete = prev->next;

prev->next = node_to_delete->next;

if (index == 0) head_ = prev->next;

if (index == size_ - 1) tail_ = prev;

delete node_to_delete;

--size_;

}

private:

struct Node {

int val;

Node* next;

Node(int _val): Node(_val, nullptr) {}

Node(int _val, Node* _next): val(_val), next(_next) {}

};

Node* head_; // Does not own

Node* tail_; // Does not own

Node dummy_;

int size_;

Node* getNode(int index) {

dummy_.next = head_;

Node* n = &dummy_;

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

n = n->next;

return n;

}

};

Python3

"""

Author: Huahua

Running time: 132 ms

"""

class Node:

def __init__(self, val, _next=None):

self.val = val

self.next = _next

class MyLinkedList:

def __init__(self):

self.head = self.tail = None

self.size = 0

def getNode(self, index):

n = Node(0, self.head)

for i in range(index + 1):

n = n.next

return n

def get(self, index):

if index < 0 or index >= self.size: return -1

return self.getNode(index).val

def addAtHead(self, val):

n = Node(val, self.head)

self.head = n

if self.size == 0:

self.tail = n

self.size += 1

def addAtTail(self, val):

n = Node(val)

if self.size == 0:

self.head = self.tail = n

else:

self.tail.next = n

self.tail = n

self.size += 1

def addAtIndex(self, index, val):

if index < 0 or index > self.size: return

if index == 0: return self.addAtHead(val)

if index == self.size: return self.addAtTail(val)

prev = self.getNode(index - 1)

n = Node(val, prev.next)

prev.next = n

self.size += 1

def deleteAtIndex(self, index):

if index < 0 or index >= self.size: return

prev = self.getNode(index - 1)

prev.next = prev.next.next

if index == 0: self.head = prev.next

if index == self.size - 1: self.tail = prev

self.size -= 1

Java

// Author: Huahua

// Running time: 74 ms

class MyLinkedList {

class Node {

public int val;

public Node next;

public Node(int val) { this.val = val; this.next = null; }

public Node(int val, Node next) { this.val = val; this.next = next; }

}

private Node head;

private Node tail;

private int size;

public MyLinkedList() {

this.head = this.tail = null;

this.size = 0;

}

private Node getNode(int index) {

Node n = new Node(0, this.head);

while (index-- >= 0) {

n = n.next;

}

return n;

}

public int get(int index) {

if (index < 0 || index >= size) return -1;

return getNode(index).val;

}

public void addAtHead(int val) {

this.head = new Node(val, this.head);

if (this.size++ == 0)

this.tail = this.head;

}

public void addAtTail(int val) {

Node n = new Node(val);

if (this.size++ == 0)

this.head = this.tail = n;

else

this.tail = this.tail.next = n;

}

public void addAtIndex(int index, int val) {

if (index < 0 || index > this.size) return;

if (index == 0) { this.addAtHead(val); return; }

if (index == size) { this.addAtTail(val); return; }

Node prev = this.getNode(index - 1);

prev.next = new Node(val, prev.next);

++this.size;

}

public void deleteAtIndex(int index) {

if (index < 0 || index >= this.size) return;

Node prev = this.getNode(index - 1);

prev.next = prev.next.next;

if (index == 0) this.head = prev.next;

if (index == this.size - 1) this.tail = prev;

--this.size;

}

花花酱 LeetCode 189. Rotate Array

By zxi on August 6, 2018

Problem

Given an array, rotate the array to the right by k steps, where k is non-negative.

Example 1:

Input: [1,2,3,4,5,6,7] and k = 3 
Output: [5,6,7,1,2,3,4]
Explanation: rotate 1 steps to the right: [7,1,2,3,4,5,6] rotate 2 steps to the right: [6,7,1,2,3,4,5] 
rotate 3 steps to the right: [5,6,7,1,2,3,4]

Example 2:

Input:[-1,-100,3,99] and k = 2 
Output: [3,99,-1,-100] 
Explanation: rotate 1 steps to the right: [99,-1,-100,3] rotate 2 steps to the right: [3,99,-1,-100]

Note:

Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
Could you do it in-place with O(1) extra space?

Solution 1: Simulate rotation with three reverses.

If k >= n, rotating k times has the same effect as rotating k % n times.

[1,2,3,4,5,6,7], K = 3

[5,6,7,1,2,3,4]

We can simulate the rotation with three reverses.

reverse the whole array O(n) [7,6,5,4,3,2,1]
reverse the left part 0 ~ k – 1 O(k) [5,6,7,4,3,2,1]
reverse the right part k ~ n – 1 O(n-k) [5,6,7,1,2,3,4]

Time complexity: O(n)

Space complexity: O(1) in-place

C++

class Solution {

public:

void rotate(vector<int>& nums, int k) {

if (nums.empty()) return;

k %= nums.size();

if (k == 0) return;

reverse(begin(nums), end(nums));

reverse(begin(nums), begin(nums) + k);

reverse(begin(nums) + k, end(nums));

}

};