update leetcode

Author: intfloat

leetcode/1BitAnd2BitCharacters.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+ bool isOneBitCharacter(vector<int>& bits) {
+ bool res = true;
+ int ptr = 0;
+ while (ptr < bits.size()) {
+ if (bits[ptr] == 0) {
+ res = true;
+ ++ptr;
+ } else {
+ res = false;
+ ptr += 2;
+ }
+ }
+ return res;
+ }
+};

leetcode/BestTimeBuySellStockTransactionFee.cpp

@@ -0,0 +1,15 @@
+class Solution {
+public:
+ int maxProfit(vector<int>& prices, int fee) {
+ int sz = prices.size();
+ vector<int> dp_has(sz + 1, 0);
+ vector<int> dp_no(sz + 1, 0);
+ dp_has[0] = -100000;
+ for (int i = 1; i <= prices.size(); ++i) {
+ dp_has[i] = max(dp_has[i - 1], dp_no[i - 1] - prices[i - 1] - fee);
+ dp_no[i] = max(dp_no[i - 1], dp_has[i - 1] + prices[i - 1]);
+ }
+
+ return max(dp_has[sz], dp_no[sz]);
+ }
+};

leetcode/BinarySearch.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+ int search(vector<int>& nums, int target) {
+ int l = 0;
+ int r = (int)nums.size() - 1;
+ while (l < r) {
+ int mid = (l + r) / 2;
+ if (nums[mid] < target) {
+ l = mid + 1;
+ } else if (nums[mid] > target) {
+ r = mid - 1;
+ } else {
+ return mid;
+ }
+ }
+ if (l > r || nums[l] != target) return -1;
+ return l;
+ }
+};

leetcode/DesignHashMap.cpp

@@ -0,0 +1,92 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node {
+ int key;
+ int val;
+ Node* next;
+ Node(int k, int v): key(k), val(v), next(NULL) {}
+};
+
+class MyHashMap {
+private:
+ vector<Node*> table;
+ int get_hash(int key) {
+ int ret = key % table.size();
+ if (ret < 0) {
+ return ret + table.size();
+ } else {
+ return ret;
+ }
+ }
+public:
+ /** Initialize your data structure here. */
+ MyHashMap() {
+ table.resize(9997);
+ }
+
+ /** value will always be non-negative. */
+ void put(int key, int value) {
+ int h = get_hash(key);
+ Node* ptr = table[h];
+ if (ptr == NULL) {
+ table[h] = new Node(key, value);
+ return;
+ }
+ Node* last = NULL;
+ while (ptr != NULL) {
+ if (ptr->key == key) {
+ ptr->val = value;
+ return;
+ }
+ last = ptr;
+ ptr = ptr->next;
+ }
+ last->next = new Node(key, value);
+ }
+
+ /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
+ int get(int key) {
+ int h = get_hash(key);
+ Node* ptr = table[h];
+ while (ptr != NULL) {
+ if (ptr->key == key) return ptr->val;
+ ptr = ptr->next;
+ }
+ return -1;
+ }
+
+ /** Removes the mapping of the specified value key if this map contains a mapping for the key */
+ void remove(int key) {
+ if (get(key) == -1) return;
+
+ int h = get_hash(key);
+ Node* ptr = table[h];
+ if (ptr->key == key) {
+ table[h] = ptr->next;
+ return;
+ }
+ Node* last = NULL;
+ while (ptr != NULL) {
+ if (ptr->key == key) {
+ last->next = ptr->next;
+ return;
+ }
+ last = ptr;
+ ptr = ptr->next;
+ }
+ }
+};
+
+/**
+ * Your MyHashMap object will be instantiated and called as such:
+ * MyHashMap* obj = new MyHashMap();
+ * obj->put(key,value);
+ * int param_2 = obj->get(key);
+ * obj->remove(key);
+ */
+
+int main() {
+ MyHashMap solution;
+ return 0;
+}

leetcode/DesignHashset.cpp

@@ -0,0 +1,85 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node {
+ int val;
+ Node* next;
+ Node(int v): val(v), next(NULL) {}
+};
+
+class MyHashSet {
+private:
+ vector<Node*> table;
+
+ int get_hash(int key) {
+ int ret = key % table.size();
+ if (ret < 0) {
+ return ret + table.size();
+ } else {
+ return ret;
+ }
+ }
+public:
+ /** Initialize your data structure here. */
+ MyHashSet() {
+ table.resize(9997);
+ }
+
+ void add(int key) {
+ if (contains(key)) {
+ return;
+ }
+
+ int h = get_hash(key);
+ Node* ptr = table[h];
+ if (ptr == NULL) {
+ table[h] = new Node(key);
+ return;
+ }
+ while (ptr->next != NULL) ptr = ptr->next;
+ ptr->next = new Node(key);
+ }
+
+ void remove(int key) {
+ if (!contains(key)) {
+ return;
+ }
+
+ int h = get_hash(key);
+ Node* prev = table[h];
+ if (prev->val == key) {
+ table[h] = prev->next;
+ return;
+ }
+ Node* ptr = prev->next;
+ while (ptr->val != key) {
+ ptr = ptr->next;
+ prev = prev->next;
+ }
+ prev->next = ptr->next;
+ }
+
+ /** Returns true if this set contains the specified element */
+ bool contains(int key) {
+ int h = get_hash(key);
+ Node* ptr = table[h];
+ while (ptr != NULL) {
+ if (ptr->val == key) return true;
+ ptr = ptr->next;
+ }
+ return false;
+ }
+};
+
+int main() {
+ Solution solution;
+ return 0;
+}
+
+/**
+ * Your MyHashSet object will be instantiated and called as such:
+ * MyHashSet* obj = new MyHashSet();
+ * obj->add(key);
+ * obj->remove(key);
+ * bool param_3 = obj->contains(key);
+ */

leetcode/DesignLinkedList.cpp

@@ -0,0 +1,122 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node {
+ int val;
+ Node* next;
+ Node(int v): val(v), next(NULL) {}
+};
+
+class MyLinkedList {
+private:
+ Node* head;
+ Node* tail;
+public:
+ /** Initialize your data structure here. */
+ MyLinkedList() {
+ head = tail = NULL;
+ }
+
+ /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
+ int get(int index) {
+ if (index < 0) return -1;
+
+ Node* ptr = head;
+ for (int i = 0; i < index && ptr != NULL; ++i) {
+ ptr = ptr->next;
+ }
+ return ptr == NULL ? -1 : ptr->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. */
+ void addAtHead(int val) {
+ if (head == NULL) {
+ head = new Node(val);
+ tail = head;
+ } else {
+ Node* nhead = new Node(val);
+ nhead->next = head;
+ head = nhead;
+ }
+ }
+
+ /** Append a node of value val to the last element of the linked list. */
+ void addAtTail(int val) {
+ if (tail == NULL) {
+ tail = new Node(val);
+ head = tail;
+ } else {
+ tail->next = new Node(val);
+ tail = tail->next;
+ }
+ }
+
+ /** 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. */
+ void addAtIndex(int index, int val) {
+ if (index == 0) {
+ addAtHead(val);
+ return;
+ }
+ Node* ptr = head;
+ for (int i = 0; i < index - 1; ++i) {
+ if (ptr == NULL || ptr->next == NULL) {
+ return;
+ }
+ ptr = ptr->next;
+ }
+ Node* node = new Node(val);
+ node->next = ptr->next;
+ ptr->next = node;
+ if (node->next == NULL) {
+ tail = node;
+ }
+ }
+
+ /** Delete the index-th node in the linked list, if the index is valid. */
+ void deleteAtIndex(int index) {
+ if (index < 0) return;
+ if (index == 0 && head != NULL) {
+ head = head->next;
+ if (head == NULL) {
+ tail = NULL;
+ }
+ return;
+ }
+
+ Node* ptr = head;
+ Node* last = NULL;
+ for (int i = 0; i < index; ++i) {
+ if (ptr == NULL || ptr->next == NULL) {
+ return;
+ }
+ last = ptr;
+ ptr = ptr->next;
+ }
+ last->next = ptr->next;
+ if (last->next == NULL) {
+ tail = last;
+ }
+ }
+};
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * MyLinkedList* obj = new MyLinkedList();
+ * int param_1 = obj->get(index);
+ * obj->addAtHead(val);
+ * obj->addAtTail(val);
+ * obj->addAtIndex(index,val);
+ * obj->deleteAtIndex(index);
+ */
+
+int main() {
+ int index = 0;
+ int val = 23;
+ MyLinkedList* obj = new MyLinkedList();
+ int param_1 = obj->get(index);
+ obj->addAtHead(val);
+ obj->addAtTail(val);
+ obj->addAtIndex(index,val);
+ obj->deleteAtIndex(index);
+ return 0;
+}

leetcode/KthLargestElementInStream.cpp

@@ -0,0 +1,15 @@
+class KthLargest {
+public:
+ KthLargest(int kvalue, vector<int>& nums) : k(kvalue) {
+ for(int i = 0; i < nums.size(); i++) add(nums[i]);
+ }
+
+ int add(int val) {
+ pq.push(val);
+ if(pq.size() > k) pq.pop();
+ return pq.top();
+ }
+private:
+ priority_queue<int, vector<int>, greater <int>> pq;
+ int k;
+};

leetcode/MinimumAsciiDeleteSumForTwoString.cpp

@@ -0,0 +1,23 @@
+class Solution {
+public:
+ int minimumDeleteSum(string s1, string s2) {
+ int sz1 = s1.size(), sz2 = s2.size();
+ vector<vector<int> > dp(sz1 + 1, vector<int>(sz2 + 1, 0));
+
+ for (int i = 1; i <= sz1; ++i) {
+ for (int j = 1; j <= sz2; ++j) {
+ if (s1[i - 1] == s2[j - 1]) {
+ dp[i][j] = dp[i - 1][j - 1] + s1[i - 1];
+ } else {
+ dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+ }
+ }
+ }
+
+ int res = 0;
+ for (int i = 0; i < sz1; ++i) res += s1[i];
+ for (int i = 0; i < sz2; ++i) res += s2[i];
+ res -= 2 * dp[sz1][sz2];
+ return res;
+ }
+};