update leetcode

Author: intfloat

leetcode/LicenseKeyFormatting.cpp

@@ -0,0 +1,31 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ string licenseKeyFormatting(string S, int K) {
+ reverse(S.begin(), S.end());
+ string res;
+ int cur = 0;
+ for (int i = 0; i < S.size(); ++i) {
+ if (S[i] == '-') {
+ continue;
+ } else if (S[i] <= 'z' && S[i] >= 'a') {
+ res.push_back(S[i] - 'a' + 'A');
+ } else {
+ res.push_back(S[i]);
+
+ }
+ ++cur;
+ if (cur == K) {
+ res.push_back('-');
+ cur = 0;
+ }
+ }
+ if (res.back() == '-') {
+ res.pop_back();
+ }
+ reverse(res.begin(), res.end());
+ return res;
+ }
+};

leetcode/MagicalString.cpp

@@ -0,0 +1,28 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ int magicalString(int n) {
+ string digits = "122";
+ int ptr = 2, filler = 1;
+ while (digits.size() < n) {
+ for (int i = 0; i < digits[ptr] - '0'; ++i) {
+ digits.push_back('0' + filler);
+ }
+ ++ptr;
+ filler = (filler == 1) ? 2 : 1;
+ }
+ int res = 0;
+ for (int i = 0; i < n; ++i) {
+ res += digits[i] == '1';
+ }
+ return res;
+ }
+};
+
+int main() {
+ Solution sol;
+ cout << sol.magicalString(7) << endl;
+ return 0;
+}

leetcode/MaxConsecutiveOnes.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+ int findMaxConsecutiveOnes(vector<int>& nums) {
+ int res = 0;
+ int ptr = 0;
+ while (ptr < nums.size()) {
+ if (nums[ptr] == 1) {
+ int end = ptr + 1;
+ while (end < nums.size() && nums[end] == 1) ++end;
+ res = max(res, end - ptr);
+ ptr = end + 1;
+ } else {
+ ++ptr;
+ }
+ }
+ return res;
+ }
+};

leetcode/MedianSlidingWindow.cpp

@@ -0,0 +1,48 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ vector<double> medianSlidingWindow(vector<int>& nums, int k) {
+ vector<double> res;
+ if (nums.empty()) {
+ return res;
+ }
+ multiset<int> left, right;
+ for (int i = 0; i < (int)nums.size(); ++i) {
+ if (left.empty() || nums[i] <= *left.rbegin()) {
+ left.insert(nums[i]);
+ } else {
+ right.insert(nums[i]);
+ }
+ if (i >= k) {
+ auto it = left.find(nums[i - k]);
+ if (it != left.end()) {
+ left.erase(it);
+ } else {
+ right.erase(right.find(nums[i - k]));
+ }
+ }
+ int expected_size = (left.size() + right.size()) / 2;
+ while ((int)right.size() < expected_size) {
+ right.insert(*left.rbegin());
+ auto it = left.end();
+ --it;
+ left.erase(it);
+ }
+ while ((int)right.size() > expected_size) {
+ left.insert(*right.begin());
+ right.erase(right.begin());
+ }
+ if (i < k - 1) {
+ continue;
+ }
+ if (k % 2 == 1) {
+ res.push_back(*left.rbegin() * 1.0);
+ } else {
+ res.push_back(*left.rbegin() * 0.5 + *right.begin() * 0.5);
+ }
+ }
+ return res;
+ }
+};

leetcode/MinimumGeneticMutation.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+ int minMutation(string start, string end, vector<string>& bank) {
+ const char genes[4] = {'A', 'C', 'G', 'T'};
+ set<string> visited, bank_set;
+ for (int i = 0; i < bank.size(); ++i) {
+ bank_set.insert(bank[i]);
+ }
+ queue<pair<string, int> > q;
+ q.push({start, 0});
+ visited.insert(start);
+ while (!q.empty()) {
+ pair<string, int> tp = q.front();
+ q.pop();
+ string cur = tp.first;
+ int step = tp.second;
+ for (int i = 0; i < 8; ++i) {
+ char c = cur[i];
+ for (int j = 0; j < 4; ++j) {
+ if (genes[j] != c) {
+ cur[i] = genes[j];
+ if (visited.find(cur) != visited.end() || bank_set.find(cur) == bank_set.end()) {
+ continue;
+ }
+ if (cur == end) {
+ return step + 1;
+ }
+ q.push({cur, step + 1});
+ visited.insert(cur);
+ }
+ }
+ cur[i] = c;
+ }
+ }
+ return -1;
+ }
+};

leetcode/PredictTheWinner.cpp

@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ bool PredictTheWinner(vector<int>& nums) {
+ int sz = nums.size();
+ vector<vector<int> > player1(sz, vector<int>(sz + 1));
+ vector<vector<int>> player2(sz, vector<int>(sz + 1));
+ for (int len = 1; len <= sz; ++len) {
+ for (int i = 0; i + len <= sz; ++i) {
+ int sum = accumulate(nums.begin() + i, nums.begin() + i + len, 0);
+ // for player1
+ if (len == 1) {
+ player1[i][len] = nums[i];
+ } else {
+ player1[i][len] = max(sum - player2[i + 1][len - 1], sum - player2[i][len - 1]);
+ }
+ // for player 2
+ if (len == 1) {
+ player2[i][len] = nums[i];
+ } else {
+ player2[i][len] = max(sum - player1[i + 1][len - 1], sum - player1[i][len - 1]);
+ }
+ }
+ }
+ return player1[0][sz] * 2 >= accumulate(nums.begin(), nums.end(), 0);
+ }
+};

leetcode/TotalHammingDistance.cpp

@@ -0,0 +1,22 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution {
+public:
+ int totalHammingDistance(vector<int>& nums) {
+ int res = 0;
+ for (int i = 0; i < 32; ++i) {
+ int zeros = 0, ones = 0, mask = (1 << i);
+ for (auto n : nums) {
+ if (mask & n) ++ones;
+ else ++zeros;
+ }
+ res += ones * zeros;
+ }
+ return res;
+ }
+};
+
+int main() {
+ return 0;
+}