push newest

Author: xwk1246

1047.remove-all-adjacent-duplicates-in-string.cpp

@@ -0,0 +1,40 @@
+#include <string>
+#include <stack>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+/*
+ * @lc app=leetcode id=1047 lang=cpp
+ *
+ * [1047] Remove All Adjacent Duplicates In String
+ */
+
+ // @lc code=start
+class Solution {
+public:
+    string removeDuplicates(string s) {
+        stack<char>s1;
+        string out;
+        for (auto i : s) {
+            if (!s1.empty() && s1.top() == i) {
+                s1.pop();
+            }
+            else {
+                s1.push(i);
+            }
+        }
+        while (!s1.empty()) {
+            out += s1.top();
+            s1.pop();
+        }
+        reverse(out.begin(), out.end());
+        return out;
+    }
+};
+// @lc code=end
+int main() {
+    Solution s1;
+    cout << s1.removeDuplicates("abbaca");
+    return 0;
+}
+

150.evaluate-reverse-polish-notation.cpp

@@ -0,0 +1,61 @@
+#include <vector>
+#include <cctype>
+#include <string>
+#include <stack>
+#include <iostream>
+using namespace std;
+/*
+ * @lc app=leetcode id=150 lang=cpp
+ *
+ * [150] Evaluate Reverse Polish Notation
+ */
+
+ // @lc code=start
+class Solution {
+public:
+    stack<int>s1;
+    int evalRPN(vector<string>& tokens) {
+        for (auto i : tokens) {
+            if (i == "+") {
+                int tmp = s1.top();
+                s1.pop();
+                int result = s1.top() + tmp;
+                s1.pop();
+                s1.push(result);
+            }
+            else if (i == "-") {
+                int tmp = s1.top();
+                s1.pop();
+                int result = s1.top() - tmp;
+                s1.pop();
+                s1.push(result);
+            }
+            else if (i == "*") {
+                int tmp = s1.top();
+                s1.pop();
+                int result = s1.top() * tmp;
+                s1.pop();
+                s1.push(result);
+            }
+            else if (i == "/") {
+                int tmp = s1.top();
+                s1.pop();
+                int result = s1.top() / tmp;
+                s1.pop();
+                s1.push(result);
+            }
+            else {
+                s1.push(stoi(i));
+            }
+        }
+        return s1.top();
+    }
+};
+// @lc code=end
+int main() {
+    Solution s1;
+    vector<string>input = { "10", "6","9","3", "+","-11","*","/","*","17","+","5","+" };
+    cout << s1.evalRPN(input);
+    return 0;
+}
+

225.implement-stack-using-queues.cpp

@@ -0,0 +1,74 @@
+#include <queue>
+#include <iostream>
+using namespace std;
+/*
+ * @lc app=leetcode id=225 lang=cpp
+ *
+ * [225] Implement Stack using Queues
+ */
+
+ // @lc code=start
+class MyStack {
+public:
+    queue<int>q1;
+    queue<int>q2;
+    /** Initialize your data structure here. */
+
+    MyStack() {
+
+    }
+
+    /** Push element x onto stack. */
+    void push(int x) {
+        q1.push(x);
+    }
+
+    /** Removes the element on top of the stack and returns that element. */
+    int pop() {
+        int tmp;
+        while ((int)q1.size() > 1) {
+            q2.push(q1.front());
+            q1.pop();
+        }
+        tmp = q1.front();
+        q1.pop();
+        while (!q2.empty()) {
+            q1.push(q2.front());
+            q2.pop();
+        }
+        return tmp;
+    }
+
+    /** Get the top element. */
+    int top() {
+        int tmp = pop();
+        q1.push(tmp);
+        return tmp;
+    }
+
+    /** Returns whether the stack is empty. */
+    bool empty() {
+        if (!q1.empty() || !q2.empty())return false;
+        return true;
+    }
+};
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack* obj = new MyStack();
+ * obj->push(x);
+ * int param_2 = obj->pop();
+ * int param_3 = obj->top();
+ * bool param_4 = obj->empty();
+ */
+ // @lc code=end
+int main() {
+    MyStack s;
+    s.push(1);
+    s.push(2);
+    cout << s.pop() << endl;
+    cout << s.top() << endl;
+
+    return 0;
+}
+

232.implement-queue-using-stacks.cpp

@@ -0,0 +1,67 @@
+#include <stack>
+using namespace std;
+/*
+ * @lc app=leetcode id=232 lang=cpp
+ *
+ * [232] Implement Queue using Stacks
+ */
+
+ // @lc code=start
+class MyQueue {
+public:
+    /** Initialize your data structure here. */
+    stack<int>sIn;
+    stack<int>sOut;
+    MyQueue() {
+    }
+    /** Push element x to the back of queue. */
+    void push(int x) {
+        sIn.push(x);
+    }
+
+    /** Removes the element from in front of queue and returns that element. */
+    int pop() {
+        int buf;
+        if (sOut.empty()) {
+            while (!sIn.empty()) {
+                sOut.push(sIn.top());
+                sIn.pop();
+            }
+            buf = sOut.top();
+            sOut.pop();
+            return buf;
+        }
+        else {
+            buf = sOut.top();
+            sOut.pop();
+            return buf;
+        }
+    }
+
+    /** Get the front element. */
+    int peek() {
+        int buf;
+        buf = pop();
+        sOut.push(buf);
+        return buf;
+    }
+
+    /** Returns whether the queue is empty. */
+    bool empty() {
+        if (!sIn.empty() || !sOut.empty()) {
+            return false;
+        }
+        return true;
+    }
+};
+
+/**
+ * Your MyQueue object will be instantiated and called as such:
+ * MyQueue* obj = new MyQueue();
+ * obj->push(x);
+ * int param_2 = obj->pop();
+ * int param_3 = obj->peek();
+ * bool param_4 = obj->empty();
+ */
+ // @lc code=end
+

239.sliding-window-maximum.cpp

@@ -0,0 +1,65 @@
+#include <vector>
+#include <deque>
+#include <iostream>
+using namespace std;
+/*
+ * @lc app=leetcode id=239 lang=cpp
+ *
+ * [239] Sliding Window Maximum
+ */
+
+ // @lc code=start
+class myqueue {
+public:
+    deque<int>data;
+    int push(int num) {
+        if (data.empty()) {
+            data.push_back(num);
+            return num;
+        }
+        while (!data.empty() && num > data.back()) {
+            data.pop_back();
+        }
+        data.push_back(num);
+        return num;
+    }
+    int pop(int num) {
+        if (data.front() == num) {
+            data.pop_front();
+        }
+        return num;
+    }
+    int max() {
+        return data.front();
+    }
+};
+class Solution {
+public:
+    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
+        myqueue mq;
+        vector<int> out;
+        int front = 0;
+        for (int i = 0; i < k; i++) {
+            mq.push(nums[i]);
+        }
+        out.push_back(mq.max());
+        for (int i = 0; i + k < nums.size(); i++) {
+            mq.pop(nums[i]);
+            mq.push(nums[i + k]);
+            out.push_back(mq.max());
+        }
+        return out;
+    }
+};
+// @lc code=end
+int main() {
+    Solution S1;
+    vector<int>nums = { 1,3,1,2,0,5 };
+    int k = 3;
+    auto tmp = S1.maxSlidingWindow(nums, k);
+    for (auto i : tmp) {
+        cout << i << endl;
+    }
+    return 0;
+}
+

459.repeated-substring-pattern.cpp

@@ -0,0 +1,40 @@
+#include <string>
+#include <iostream>
+using namespace std;
+
+/*
+ * @lc app=leetcode id=459 lang=cpp
+ *
+ * [459] Repeated Substring Pattern
+ */
+
+ // @lc code=start
+class Solution {
+public:
+    void buildNext(int* next, string s) {
+        int j = 0;
+        next[0] = 0;
+        for (int i = 1; i < s.length(); i++) {
+            while (j > 0 && s[i] != s[j]) {
+                j = next[j - 1];
+            }
+            if (s[i] == s[j])j++;
+            next[i] = j;
+        }
+
+    }
+    bool repeatedSubstringPattern(string s) {
+        int next[s.length()];
+        buildNext(next, s);
+        if (next[s.length() - 1] && s.length() % (s.length() - next[s.length() - 1]) == 0)return true;
+        return false;
+    }
+};
+// @lc code=end
+
+int main() {
+    Solution S1;
+    string s = "abac";
+    cout << S1.repeatedSubstringPattern(s);
+    return 0;
+}