update leetcode

Author: Liang Wang

leetcode/AverageOfLevelsInBinaryTree.cpp

@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ * int val;
+ * TreeNode *left;
+ * TreeNode *right;
+ * TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+ vector<double> averageOfLevels(TreeNode* root) {
+ vector<double> avg, sm;
+ vector<int> cnt;
+ queue<pair<TreeNode*, int> > q;
+ q.push({root, 0});
+ while (!q.empty()) {
+ pair<TreeNode*, int> ptl = q.front();
+ q.pop();
+ TreeNode* node = ptl.first;
+ int level = ptl.second;
+ if (level == sm.size()) {
+ sm.push_back(0.0);
+ cnt.push_back(0);
+ }
+ sm[level] += node->val;
+ ++cnt[level];
+ if (NULL != node->left) {
+ q.push({node->left, level+1});
+ }
+ if (NULL != node->right) {
+ q.push({node->right, level+1});
+ }
+ }
+ for (int i = 0; i < cnt.size(); ++i) {
+ avg.push_back(sm[i] / cnt[i]);
+ }
+ return avg;
+ }
+};

leetcode/DesignCircularDeque.cpp

@@ -0,0 +1,82 @@
+class MyCircularDeque {
+private:
+ vector<int> data;
+ int front, length;
+public:
+ /** Initialize your data structure here. Set the size of the deque to be k. */
+ MyCircularDeque(int k) {
+ data.resize(k);
+ front = length = 0;
+ }
+
+ /** Adds an item at the front of Deque. Return true if the operation is successful. */
+ bool insertFront(int value) {
+ if (isFull()) return false;
+ if (!isEmpty()) {
+ front = (front - 1 + data.size()) % data.size();
+ }
+ data[front] = value;
+ ++length;
+ return true;
+ }
+
+ /** Adds an item at the rear of Deque. Return true if the operation is successful. */
+ bool insertLast(int value) {
+ if (isFull()) return false;
+ int rear = isEmpty() ? front : (front + length) % data.size();
+ data[rear] = value;
+ ++length;
+ return true;
+ }
+
+ /** Deletes an item from the front of Deque. Return true if the operation is successful. */
+ bool deleteFront() {
+ if (isEmpty()) return false;
+ front = (front + 1) % data.size();
+ --length;
+ return true;
+ }
+
+ /** Deletes an item from the rear of Deque. Return true if the operation is successful. */
+ bool deleteLast() {
+ if (isEmpty()) return false;
+ --length;
+ return true;
+ }
+
+ /** Get the front item from the deque. */
+ int getFront() {
+ if (isEmpty()) return -1;
+ return data[front];
+ }
+
+ /** Get the last item from the deque. */
+ int getRear() {
+ if (isEmpty()) return -1;
+ int rear = (front + length - 1 + data.size()) % data.size();
+ return data[rear];
+ }
+
+ /** Checks whether the circular deque is empty or not. */
+ bool isEmpty() {
+ return length == 0;
+ }
+
+ /** Checks whether the circular deque is full or not. */
+ bool isFull() {
+ return length == data.size();
+ }
+};
+
+/**
+ * Your MyCircularDeque object will be instantiated and called as such:
+ * MyCircularDeque* obj = new MyCircularDeque(k);
+ * bool param_1 = obj->insertFront(value);
+ * bool param_2 = obj->insertLast(value);
+ * bool param_3 = obj->deleteFront();
+ * bool param_4 = obj->deleteLast();
+ * int param_5 = obj->getFront();
+ * int param_6 = obj->getRear();
+ * bool param_7 = obj->isEmpty();
+ * bool param_8 = obj->isFull();
+ */

leetcode/ExclusiveTimeOfFunctions.py

@@ -0,0 +1,20 @@
+class Solution:
+ def exclusiveTime(self, n: int, logs: List[str]) -> List[int]:
+ res = [0 for _ in range(n)]
+ stack = []
+ log_tp = []
+ for log in logs:
+ idx, cmd, tm = log.split(':')
+ idx, tm = int(idx), int(tm)
+ if cmd == 'end':
+ tm += 1
+ log_tp.append((idx, cmd, tm))
+ for i, (idx, cmd, tm) in enumerate(log_tp):
+ if cmd == 'start':
+ if stack:
+ res[stack[-1]] += tm - log_tp[i-1][2]
+ stack.append(idx)
+ elif cmd == 'end':
+ res[stack[-1]] += tm - log_tp[i-1][2]
+ stack.pop()
+ return res

leetcode/MaximumAverageSubarrayI.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+ double findMaxAverage(vector<int>& nums, int k) {
+ int mx_sm = accumulate(nums.begin(), nums.begin() + k, 0);
+ int sm = mx_sm;
+ for (int i = k; i < nums.size(); ++i) {
+ sm += nums[i];
+ sm -= nums[i - k];
+ mx_sm = max(mx_sm, sm);
+ }
+ return 1.0 * mx_sm / k;
+ }
+};

leetcode/ShopingOffers.cpp

@@ -0,0 +1,55 @@
+class Solution {
+private:
+ vector<int> price;
+ vector<vector<int>> special;
+ map<int, int> dp;
+
+ int solve(vector<int>& cur_needs) {
+ int key = to_key(cur_needs);
+ if (dp.find(key) != dp.end()) {
+ return dp[key];
+ }
+ int val = 0;
+ for (int i = 0; i < price.size(); ++i) {
+ val += cur_needs[i] * price[i];
+ }
+ for (auto& s : special) {
+ if (ok(cur_needs, s)) {
+ for (int i = 0; i < cur_needs.size(); ++i) {
+ cur_needs[i] -= s[i];
+ }
+ int cost = solve(cur_needs) + s.back();
+ val = min(cost, val);
+ for (int i = 0; i < cur_needs.size(); ++i) {
+ cur_needs[i] += s[i];
+ }
+ }
+ }
+ dp[key] = val;
+ return val;
+ }
+
+ int to_key(vector<int>& v) {
+ int ret = 0;
+ for (int i = 0; i < v.size(); ++i) {
+ ret = ret * 10 + v[i];
+ }
+ return ret;
+ }
+ bool ok(vector<int>& needs, vector<int>& s) {
+ for (int i = 0; i < needs.size(); ++i) {
+ if (s[i] > needs[i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+public:
+ int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
+ this->price = price;
+ this->special = special;
+ dp.clear();
+ dp[0] = 0;
+ return solve(needs);
+ }
+};

leetcode/SolveTheEquation.cpp

@@ -0,0 +1,78 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define FOR(i, n) for (int i = 0; i < (int)n; ++i)
+typedef long long ll;
+typedef pair<int, int> pii;
+
+struct Term {
+ bool positive;
+ int coef;
+ bool has_x;
+ bool left;
+ bool has_digit;
+ Term(bool _left): positive(true), left(_left), has_x(false), coef(0), has_digit(false) {}
+};
+
+class Solution {
+public:
+ string solveEquation(string equation) {
+ bool left = true;
+ vector<Term> terms;
+ Term term(left);
+ FOR(i, equation.size()) {
+ char c = equation[i];
+ if (c == 'x') {
+ term.has_x = true;
+ } else if (c <= '9' && c >= '0') {
+ term.coef = term.coef * 10 + (c - '0');
+ term.has_digit = true;
+ } else if (c == '+' || c == '-') {
+ if (i > 0 && equation[i - 1] != '=') {
+ terms.push_back(term);
+ }
+ term = Term(left);
+ term.positive = (c == '+');
+ } else if (c == '=') {
+ terms.push_back(term);
+ left = false;
+ term = Term(left);
+ }
+ }
+ terms.push_back(term);
+
+ int x_coef = 0, num_coef = 0;
+ for (auto& t : terms) {
+ if (!t.has_digit) {
+ t.coef = 1;
+ }
+ if (!t.positive) {
+ t.coef = -t.coef;
+ t.positive = true;
+ }
+ if (t.has_x) {
+ x_coef += t.left ? t.coef : -t.coef;
+ } else {
+ num_coef += t.left ? -t.coef : t.coef;
+ }
+ }
+ if (x_coef == 0 && num_coef == 0) {
+ return "Infinite solutions";
+ } else if (x_coef == 0 && num_coef != 0) {
+ return "No solution";
+ } else {
+ return "x=" + to_string(num_coef / x_coef);
+ }
+ }
+};
+
+int main() {
+ Solution solution;
+ cout << solution.solveEquation("-x=1") << endl;
+ cout << solution.solveEquation("-x=-1") << endl;
+ cout << solution.solveEquation("x+5-3+x=6+x-2") << endl;
+ cout << solution.solveEquation("x=x") << endl;
+ cout << solution.solveEquation("2x=x") << endl;
+ cout << solution.solveEquation("2x+3x-6x=x+2") << endl;
+ cout << solution.solveEquation("x=x+2") << endl;
+ return 0;
+}