add 6 problems

Author: zhuli19901106

average-of-levels-in-binary-tree_1_AC.cpp

@@ -0,0 +1,62 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+#include <queue>
+#include <utility>
+using std::make_pair;
+using std::queue;
+using std::pair;
+
+class Solution {
+public:
+    vector<double> averageOfLevels(TreeNode* root) {
+        queue<pair<int, TreeNode *>> q;
+        vector<double> res;
+        vector<int> c;
+        
+        if (root == NULL) {
+            return res;
+        }
+        
+        pair<int, TreeNode *> p;
+        int dep;
+        TreeNode *node;
+        
+        q.push(make_pair(0, root));
+        while (!q.empty()) {
+            p = q.front();
+            q.pop();
+            
+            dep = p.first;
+            node = p.second;
+            while (res.size() <= dep) {
+                res.push_back(0);
+                c.push_back(0);
+            }
+            res[dep] += node->val;
+            c[dep] += 1;
+            
+            if (node->left != NULL) {
+                q.push(make_pair(dep + 1, node->left));
+            }
+            if (node->right != NULL) {
+                q.push(make_pair(dep + 1, node->right));
+            }
+        }
+        
+        int n = res.size();
+        int i;
+        for (i = 0; i < n; ++i) {
+            res[i] /= c[i];
+        }
+        c.clear();
+        
+        return res;
+    }
+};

decode-ways-ii_1_AC.cpp

@@ -0,0 +1,89 @@
+// Too ugly
+#include <cstdint>
+#include <string>
+#include <vector>
+using std::string;
+using std::vector;
+
+class Solution {
+public:
+    int numDecodings(string s) {
+        int ls = s.size();
+        if (ls == 0) {
+            return 0;
+        }
+        
+        vector<int64_t> v1(11, 0), v2(11, 0), v3(11, 0);
+        v1[10] = 1;
+        
+        int i;
+        char c1_start, c1_end, c1;
+        if (s[0] == '*') {
+            c1_start = '1';
+            c1_end = '9';
+        } else {
+            c1_start = c1_end = s[0];
+        }
+        for (c1 = c1_start; c1 > '0' && c1 <= c1_end; ++c1) {
+            v2[c1 - '0'] = 1 % MOD;
+            v2[10] = (v2[10] + 1) % MOD;
+        }
+        if (ls == 1) {
+            return v2[10];
+        }
+        
+        int j;
+        char c2_start, c2_end, c2;
+        for (i = 1; i < ls; ++i) {
+            c1 = s[i];
+            if (c1 == '*') {
+                c1_start = '1';
+                c1_end = '9';
+            } else {
+                c1_start = c1_end = c1;
+            }
+            
+            c2 = (i > 0 ? s[i - 1] : '0');
+            if (c2 == '*') {
+                c2_start = '1';
+                c2_end = '9';
+            } else {
+                c2_start = c2_end = c2;
+            }
+            
+            for (j = 0; j <= 10; ++j) {
+                v3[j] = 0;
+            }
+            for (c1 = c1_start; c1 <= c1_end; ++c1) {
+                for (c2 = c2_start; c2 <= c2_end; ++c2) {
+                    calc(v1, v2, v3, c1 - '0', c2 - '0');
+                }
+            }
+            v1 = v2;
+            v2 = v3;
+        }
+        
+        int64_t res = v3[10];
+        return res;
+    }
+private:
+    static const int64_t MOD = 1000000007;
+    static const int64_t LOW = 1;
+    static const int64_t HIGH = 26;
+    
+    void calc(vector<int64_t> &v1, vector<int64_t> &v2, vector<int64_t> &v3, int d1, int d2) {
+        int d = d1;
+        if (d >= LOW && d <= HIGH) {
+            v3[d1] = (v3[d1] + v2[d2]) % MOD;
+            v3[10] = (v3[10] + v2[d2]) % MOD;
+        }
+        
+        if (d2 != 0) {
+            d = d2 * 10 + d1;
+            if (d >= LOW && d <= HIGH) {
+                v3[d1] = (v3[d1] + v1[10]) % MOD;
+                v3[10] = (v3[10] + v1[10]) % MOD;
+            }
+        }
+    }
+};

largest-palindrome-product_1_AC.cpp

@@ -0,0 +1,75 @@
+/*
+// Calculate palindrome product for 2 n-digit numbers.
+#include <cmath>
+#include <cstdint>
+#include <iostream>
+using std::cin;
+using std::cout;
+using std::endl;
+using std::pow;
+
+int64_t getPal(int64_t n)
+{
+	const int R = 10;
+	
+	if (n <= 0) {
+		return 0;
+	}
+	int64_t n0 = n;
+	int64_t n1 = 0;
+	while (n > 0) {
+		n1 = n1 * R + (n % R);
+		n0 *= R;
+		n /= R;
+	}
+	return n0 + n1;
+}
+
+int64_t solve(int n)
+{
+	if (n == 1) {
+		return 9;
+	}
+	int64_t low, high;
+	int64_t num;
+	int64_t pal;
+	int64_t i;
+
+	low = (int64_t)pow(10, n - 1);
+	high = (int64_t)pow(10, n) - 1;
+	for (num = high; num >= low; --num) {
+		pal = getPal(num);
+		for (i = high; pal / i <= high && i >= low; --i) {
+			if (pal % i == 0) {
+				// cout << "(" << i << ", " << pal / i << ")";
+				return pal;
+			}
+		}
+	}
+	return 0;
+}
+
+int main()
+{
+	int n;
+	int64_t pal;
+	
+	for (n = 1; n <= 8; ++n) {
+		pal = solve(n);
+		cout << pal << ", ";
+	}
+	cout << endl;
+
+	return 0;
+}
+*/
+#include <cstdint>
+
+int64_t a[] = {9, 9009, 906609, 99000099, 9966006699, 999000000999, 99956644665999, 9999000000009999};
+
+class Solution {
+public:
+    int largestPalindrome(int n) {
+        return a[n - 1] % 1337;
+    }
+};

shopping-offers_1_AC.cpp

@@ -0,0 +1,65 @@
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
+        int n = price.size();
+        int m = 1;
+        int i;
+        for (i = 0; i < n; ++i) {
+            m *= (needs[i] + 1);
+        }
+        
+        vector<int> dp(m, -1);
+        dp[0] = 0;
+        
+        vector<int> normal(n, 0);
+        vector<int> v(n);
+        for (i = 0; i < n; ++i) {
+            normal[i] = 1;
+            knapsack(0, v, normal, needs, dp, price[i]);
+            normal[i] = 0;
+        }
+        
+        int ns = special.size();
+        for (i = 0; i < ns; ++i) {
+            knapsack(0, v, special[i], needs, dp, special[i][n]);
+        }
+        
+        int res = dp[m - 1];
+        dp.clear();
+        v.clear();
+        
+        return res;
+    }
+private:
+    void knapsack(int cnt, vector<int> &v, const vector<int> &offer, const vector<int> &needs, vector<int> &dp, int pr) {
+        if (cnt == needs.size()) {
+            int idx = vtoi(v, needs);
+            int idx1 = idx - vtoi(offer, needs);
+            
+            if (dp[idx1] != -1 && (dp[idx] == -1 || dp[idx] > dp[idx1] + pr)) {
+                dp[idx] = dp[idx1] + pr;
+            }
+            return;
+        }
+        
+        int i;
+        for (i = offer[cnt]; i <= needs[cnt]; ++i) {
+            v[cnt] = i;
+            knapsack(cnt + 1, v, offer, needs, dp, pr);
+            v[cnt] = 0;
+        }
+    }
+    
+    int vtoi(const vector<int> &v, const vector<int> &needs) {
+        int n = needs.size();
+        int i;
+        int idx = 0;
+        for (i = 0; i < n; ++i) {
+            idx = idx * (needs[i] + 1) + v[i];
+        }
+        return idx;
+    }
+};

single-element-in-a-sorted-array_1_AC.cpp

@@ -0,0 +1,27 @@
+#include <vector>
+using std::vector;
+
+class Solution {
+public:
+    int singleNonDuplicate(vector<int>& nums) {
+        auto &a = nums;
+        int n = a.size();
+        
+        int ll = 0;
+        int rr = n - 1;
+        int mm;
+        
+        while (ll <= rr) {
+            mm = ll + (rr - ll >> 2 << 1);
+            if (mm + 1 <= n - 1 && a[mm] == a[mm + 1]) {
+                ll = mm + 2;
+            } else if (mm - 1 >= 0 && a[mm] == a[mm - 1]) {
+                rr = mm - 2;
+            } else {
+                return a[mm];
+            }
+        }
+        // not supposed to be here
+        return -1;
+    }
+};

solve-the-equation_1_AC.cpp

@@ -0,0 +1,58 @@
+#include <string>
+using std::string;
+
+class Solution {
+public:
+    string solveEquation(string equation) {
+        auto &s = equation;
+        int ls = s.size();
+        
+        int pe = s.find('=');
+        string s1 = s.substr(0, pe);
+        string s2 = s.substr(pe + 1, ls - pe - 1);
+        
+        int a1, b1;
+        parse(s1, a1, b1);
+        int a2, b2;
+        parse(s2, a2, b2);
+        
+        if (a1 != a2) {
+            return "x=" + to_string((b2 - b1) / (a1 - a2));
+        } else if (b1 == b2) {
+            return string("Infinite solutions");
+        } else {
+            return string("No solution");
+        }
+    }
+private:
+    void parse(string s, int &a, int &b) {
+        if (s[0] != '+' && s[0] != '-') {
+            s = '+' + s;
+        }
+        
+        string ss = "";
+        int ls = s.size();
+        int i;
+        int sign;
+        int coef;
+        
+        i = 0;
+        a = 0;
+        b = 0;
+        while (i < ls) {
+            sign = (s[i++] == '-' ? -1 : +1);
+            while (i < ls && s[i] != '+' && s[i] != '-') {
+                ss.push_back(s[i++]);
+            }
+            if (sscanf(ss.data(), "%d", &coef) != 1) {
+                coef = 1;
+            }
+            if (ss.back() == 'x') {
+                a += sign * coef;
+            } else {
+                b += sign * coef;
+            }
+            ss.clear();
+        }
+    }
+};