leetcode笔记—String

3. Longest Substring Without Repeating Characters (medium)

最长的无重复的子字符串

Given a string, find the length of the longest substring without repeating characters.

Examples:

Given "abcabcbb", the answer is "abc", which the length is 3.

Given "bbbbb", the answer is "b", with the length of 1.

Given "pwwkew", the answer is "wke", with the length of 3. Note that the answer must be a substring, "pwke" is a subsequence and not a substring.

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        vector<int> dict(256, -1);
        int start = -1, res = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (dict[s[i]] > start)
                start = dict[s[i]];
            res = max(res, i - start);
            dict[s[i]] = i;
        }
        return res;
    }
};

 

---

5. Longest Palindromic Substring (medium)

最长的对称子字符串

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

Input: "babad"

Output: "bab"

Note: "aba" is also a valid answer.
 

Example:

Input: "cbbd"

Output: "bb"

class Solution {
public:
    string longestPalindrome(string s) {
        string res;
        int cnt = 0;
        for (int i = 0; i < s.size();) {
            int left = i, right = i;
            while (right + 1 < s.size() && s[right + 1] == s[i])
                ++right;
            i = right + 1;
            while (left > 0 && right < s.size() - 1 && s[left - 1] == s[right + 1]) {
                --left;
                ++right;
            }
            if (right - left + 1 > cnt) {
                cnt = right - left + 1;
                res = s.substr(left, cnt);
            }
        }
        return res;
    }
};

 

---

6. ZigZag Conversion (medium)

以zigzag顺序重排字符串

The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)

P   A   H   N
A P L S I I G
Y   I   R
And then read line by line: "PAHNAPLSIIGYIR"
Write the code that will take a string and make this conversion given a number of rows:

string convert(string text, int nRows);
convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".

// numRows == 1时，不能加减
class Solution {
public:
    string convert(string s, int numRows) {
        if (1 == numRows) return s;                // 
        vector<string> tmp(numRows, "");
        for (int i = 0, j = 0, step = 1; i < s.size(); j += step) {
            tmp[j].push_back(s[i++]);
            if (j == 0) step = 1;
            else if (j == numRows - 1) step = -1;
        }
        for (int i = 1; i < numRows; ++i)
            tmp[0] += tmp[i];
        return tmp[0];
    }
};

 

---

8. String to Integer (atoi) (medium)

字符串转数字

Implement atoi to convert a string to an integer.

Hint: Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the possible input cases.

Notes: It is intended for this problem to be specified vaguely (ie, no given input specs). You are responsible to gather all the input requirements up front.

Update (2015-02-10):
The signature of the C++ function had been updated. If you still see your function signature accepts a const char * argument, please click the reload button  to reset your code definition.

spoilers alert... click to show requirements for atoi.

Requirements for atoi:
The function first discards as many whitespace characters as necessary until the first non-whitespace character is found. Then, starting from this character, takes an optional initial plus or minus sign followed by as many numerical digits as possible, and interprets them as a numerical value.

The string can contain additional characters after those that form the integral number, which are ignored and have no effect on the behavior of this function.

If the first sequence of non-whitespace characters in str is not a valid integral number, or if no such sequence exists because either str is empty or it contains only whitespace characters, no conversion is performed.

If no valid conversion could be performed, a zero value is returned. If the correct value is out of the range of representable values, INT_MAX (2147483647) or INT_MIN (-2147483648) is returned.

class Solution {
public:
    int myAtoi(string str) {
        long res = 0;
        int i = 0, sign = 1;
        while (i < str.size() && str[i] == ' ')
            ++i;
        if (str[i] == '+' || str[i] == '-')
            sign = str[i++] == '+' ? 1 : -1;
        for (; i < str.size() && str[i] >= '0' && str[i] <='9'; ++i) {
            res = res*10 + str[i] - '0';
            if (res*sign > INT_MAX)
                return INT_MAX;
            else if (res*sign < INT_MIN)
                return INT_MIN;
        }
        return (int)(res*sign);
    }
};

 

---

10. Regular Expression Matching (hard) #

正则表达式匹配：.和*

 

---

12. Integer to Roman (medium)

数字转罗马数字

Given an integer, convert it to a roman numeral.

Input is guaranteed to be within the range from 1 to 3999.

class Solution {
public:
    string intToRoman(int num) {
        string M[] = {"", "M", "MM", "MMM"};
        string C[] = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
        string X[] = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
        string I[] = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
        return M[num/1000] + C[(num%1000)/100] + X[(num%100)/10] + I[num%10];
    }
};

 

---

13. Roman to Integer (easy)

罗马数字转普通数字

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

class Solution {
public:
    int romanToInt(string s) {
        unordered_map<char, int> T = { { 'I' , 1 },
                                     { 'V' , 5 },
                                     { 'X' , 10 },
                                     { 'L' , 50 },
                                     { 'C' , 100 },
                                     { 'D' , 500 },
                                     { 'M' , 1000 } };
        int sum = T[s.back()];
        for (int i = s.length() - 2; i >= 0; --i)  {
            if (T[s[i]] < T[s[i + 1]])
                sum -= T[s[i]];
            else
                sum += T[s[i]];
        }
        return sum;
    }
};

 

---

14. Longest Common Prefix (easy)

最长的公共前缀

Write a function to find the longest common prefix string amongst an array of strings.

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        if (strs.empty()) return "";
        string str1 = strs[0];
        for (int i = 1; i < strs.size(); ++i) {
            string str2 = strs[i];
            int index = 0;
            for (; str1[index] == str2[index]; ++index);
            str1 = str1.substr(0, index);
        }
        return str1;
    }
};

 

---

17. Letter Combinations of a Phone Number (medium) #

手机键盘输入组合

Given a digit string, return all possible letter combinations that the number could represent.

A mapping of digit to letters (just like on the telephone buttons) is given below.



Input:Digit string "23"
Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
Note:
Although the above answer is in lexicographical order, your answer could be in any order you want.

class Solution {
public:
    vector<string> letterCombinations(string digits) {
        if (digits.empty()) return vector<string>();
        vector<string> keyBoard  = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
        vector<string> res;
        res.push_back("");
        for (auto num : digits) {
            vector<string> tmp;
            for (auto cur : res) {
                for (auto newChar : keyBoard[num - '0'])
                    tmp.push_back(cur + newChar);
            }
            res.swap(tmp);
        }
        return res;
    }
};

 

---

20. Valid Parentheses (easy)

判断()[]{}格式

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for (auto c : s) {
            if (c == '(')
                st.push(')');
            else if (c == '[')
                st.push(']');
            else if (c == '{')
                st.push('}');
            else if (!st.empty() && st.top() == c)
                st.pop();
            else
                return false;
        }
        return st.empty();
    }
};

 

---

22. Generate Parentheses (medium) #

n个括号对的所有组合

Given n pairs of parentheses, write a function to generate all combinations of well-formed parentheses.

For example, given n = 3, a solution set is:

[
  "((()))",
  "(()())",
  "(())()",
  "()(())",
  "()()()"
]

class Solution {
public:
    vector<string> generateParenthesis(int n) {
        vector<string> res;
        string tmp;
        helper(res, tmp, n, 0);
        return res;
    }
    void helper(vector<string>& res, string tmp, int left, int right) {
        if (left == 0 && right == 0) {
            res.push_back(tmp);
            return;
        }
        if (left > 0)
            helper(res, tmp + "(", left - 1, right + 1);
        if (right > 0)
            helper(res, tmp + ")", left, right - 1);
    }
};

 

---

28. Implement strStr() (easy)

字符串查找

Implement strStr().

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2
Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle.empty())
            return 0;
        int res, i, j;
        for (res = 0; res <= (int)haystack.size() - (int)needle.size(); ++res) {
            for (i = res, j = 0; j < needle.size() && haystack[i] == needle[j]; ++i, ++j);
            if (j == needle.size())
                return res;
        }
        return -1;
    }
};

 

---

30. Substring with Concatenation of All Words (hard) #

查找字符串，子串为words的组合

You are given a string, s, and a list of words, words, that are all of the same length. Find all starting indices of substring(s) in s that is a concatenation of each word in words exactly once and without any intervening characters.

For example, given:
s: "barfoothefoobarman"
words: ["foo", "bar"]

You should return the indices: [0,9].
(order does not matter).

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        vector<int> res;
        if (words.empty())
            return res;
        int length = words[0].size(), words_length = length*words.size();
        unordered_map<string, int> mp;
        for (string word : words)
            ++mp[word];
        for (int i = 0; i <= (int)s.size() - words_length; ++i) {
            unordered_map<string, int> tmp_mp(mp);
            int index = i;
            while (index < i + words_length) {
                string word = s.substr(index, length);
                if (tmp_mp.find(word) != tmp_mp.end() && tmp_mp[word] > 0)
                    --tmp_mp[word];
                else
                    break;
                index += length;
            }
            if (index == i + words_length)
                res.push_back(i);
        }
        return res;
    }
};

 

---

32. Longest Valid Parentheses (hard) #

最长的有效括号

 

---

38. Count and Say (easy)

数字字符串描述

The count-and-say sequence is the sequence of integers with the first five terms as following:

1.     1
2.     11
3.     21
4.     1211
5.     111221
1 is read off as "one 1" or 11.
11 is read off as "two 1s" or 21.
21 is read off as "one 2, then one 1" or 1211.
Given an integer n, generate the nth term of the count-and-say sequence.

Note: Each term of the sequence of integers will be represented as a string.

Example 1:

Input: 1
Output: "1"
Example 2:

Input: 4
Output: "1211"

class Solution {
public:
    string countAndSay(int n) {
        if (!n) return "";
        string res = "1";
        while (--n) {
            string new_str;
            for (int i = 0; i < res.size(); ++i) {
                int j = 1;
                while (i + 1 < res.size() && res[i + 1] == res[i]) {
                    ++i;
                    ++j;
                }
                new_str.push_back(j + '0');
                new_str.push_back(res[i]);
            }
            res = new_str;
        }
        return res;
    }
};

 

---

43. Multiply Strings (medium)

字符串代表的两个数相乘，返回字符串

Given two non-negative integers num1 and num2 represented as strings, return the product of num1 and num2.

Note:

The length of both num1 and num2 is < 110.
Both num1 and num2 contains only digits 0-9.
Both num1 and num2 does not contain any leading zero.
You must not use any built-in BigInteger library or convert the inputs to integer directly.

class Solution {
public:
    string multiply(string num1, string num2) {
        int m = num1.size(), n = num2.size(), cnt = 0;
        string res(m + n, '0');
        for (int i = m - 1; i >= 0; --i) {
            for (int j = n - 1; j >= 0; --j) {
                int tmp = (num1[i] - '0')*(num2[j] - '0') + res[i + j + 1] - '0';
                res[i + j + 1] = tmp%10 + '0';
                res[i + j] += tmp/10;
            }
        }
        for (; cnt < m + n - 1 && res[cnt] == '0'; ++cnt);
        return res.substr(cnt);
    }
};

 

---

44. Wildcard Matching (hard) #

通配正则表达式：*和?

Implement wildcard pattern matching with support for '?' and '*'.

'?' Matches any single character.
'*' Matches any sequence of characters (including the empty sequence).

The matching should cover the entire input string (not partial).

The function prototype should be:
bool isMatch(const char *s, const char *p)

Some examples:
isMatch("aa","a") → false
isMatch("aa","aa") → true
isMatch("aaa","aa") → false
isMatch("aa", "*") → true
isMatch("aa", "a*") → true
isMatch("ab", "?*") → true
isMatch("aab", "c*a*b") → false

// dp
class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size();
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false));
        dp[0][0] = true;
        for (int i = 1; i <= n && p[i - 1] == '*'; ++i)
            dp[0][i] = true;
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (s[i - 1] == p[j - 1] || p[j - 1] == '?')
                    dp[i][j] = dp[i - 1][j - 1];
                else if (p[j - 1] == '*')
                    dp[i][j] = dp[i][j - 1]||dp[i - 1][j];
                else
                    dp[i][j] = false;
            }
        }
        return dp[m][n];
    }
};

// reference
// i,j从前到后，当j==*时，记录位置，匹配不符合时j退回*的后一个位置；i在匹配时记录，不匹配时返回匹配的起始位置
class Solution {
public:
    bool isMatch(string s, string p) {
        int m = s.size(), n = p.size(), i = 0, j = 0, star = -1, ii;
        while (i < m) {
            if (s[i] == p[j] || p[j] == '?') {
                ++i; ++j;
            }
            else if (p[j] == '*') {
                star = j++;
                ii = i;
            }
            else if (star != -1){
                j = star + 1;
                i = ++ii;
            }
            else
                return false;
        }
        while (j < n && p[j] == '*')
            ++j;
        return j == n;
    }
};

 

---

49. Group Anagrams (medium)

字符串分组，组成元素一致的分为一组

Given an array of strings, group anagrams together.

For example, given: ["eat", "tea", "tan", "ate", "nat", "bat"], 
Return:

[
  ["ate", "eat","tea"],
  ["nat","tan"],
  ["bat"]
]
Note: All inputs will be in lower-case.

// 使用质数的乘积表示字符串
class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<int, vector<string>> mp;
        vector<vector<string>> res;
        int prime[26] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103};
        for (string str : strs) {
            int key = 1;
            for (auto c : str)
                key *= prime[c - 'a'];
            mp[key].push_back(str);
        }
        for (auto pair : mp)
            res.push_back(pair.second);
        return res;
    }
};

 

---

58. Length of Last Word (easy)

字符串中最后一个单词的长度

Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word in the string.

If the last word does not exist, return 0.

Note: A word is defined as a character sequence consists of non-space characters only.

Example:

Input: "Hello World"
Output: 5

class Solution {
public:
    int lengthOfLastWord(string s) {
        int res = 0, tail = s.size() - 1;
        while (tail >= 0 && s[tail] == ' ')
            --tail;
        while (tail >= 0 && s[tail--] != ' ')
            ++res;
        return res;
    }
};

 

---

65. Valid Number (hard)

判断字符串是不是一个数字（题不好，没仔细看）

Validate if a given string is numeric.

Some examples:
"0" => true
" 0.1 " => true
"abc" => false
"1 a" => false
"2e10" => true
Note: It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.

Update (2015-02-10):
The signature of the C++ function had been updated. If you still see your function signature accepts a const char * argument, please click the reload button  to reset your code definition.

// 去掉首尾空格后，匹配 [-+]?(([0-9]+(.[0-9]*)?)|.[0-9]+)(e[-+]?[0-9]+)?
class Solution {
public:
    bool isNumber(string s) {
        int head = 0, tail = s.size() - 1;
        while (s[head] == ' ') ++head;
        while (s[tail] == ' ') --tail;
        s = s.substr(head, tail - head + 1);
        bool pointSeen = false;
        bool eSeen = false;
        bool numberSeen = false;
        bool numberAfterE = true;
        for(int i = 0; i < s.size(); i++) {
            if ('0' <= s[i] && s[i] <= '9') {
                numberSeen = true;
                numberAfterE = true;
            }
            else if (s[i] == '.') {
                if(eSeen || pointSeen)
                    return false;
                pointSeen = true;
            }
            else if (s[i] == 'e') {
                if(eSeen || !numberSeen)
                    return false;
                numberAfterE = false;
                eSeen = true;
            }
            else if (s[i] == '-' || s[i] == '+')
            {
                if(i != 0 && s[i-1] != 'e')
                    return false;
            }
            else
                return false;
        }
        
        return numberSeen && numberAfterE;
    }
};

 

---

67. Add Binary (easy)

字符串表示的两个二进制数相加

Given two binary strings, return their sum (also a binary string).

For example,
a = "11"
b = "1"
Return "100".

class Solution {
public:
    string addBinary(string a, string b) {
        string res = "";
        int i = a.size() - 1, j = b.size() - 1, sum = 0;
        while (i >= 0 || j >= 0 || sum) {
            if (i >= 0)
                sum += a[i--] - '0';
            if (j >= 0)
                sum += b[j--] - '0';
            res.push_back((char)sum%2 + '0');
            sum = sum/2;
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

 

---

68. Text Justification (hard) #

文本两端对齐

Given an array of words and a length L, format the text such that each line has exactly L characters and is fully (left and right) justified.

You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly L characters.

Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.

For the last line of text, it should be left justified and no extra space is inserted between words.

For example,
words: ["This", "is", "an", "example", "of", "text", "justification."]
L: 16.

Return the formatted lines as:
[
   "This    is    an",
   "example  of text",
   "justification.  "
]
Note: Each word is guaranteed not to exceed L in length.

click to show corner cases.

Corner Cases:
A line other than the last line might contain only one word. What should you do in this case?
In this case, that line should be left-justified.

class Solution {
public:
    vector<string> fullJustify(vector<string>& words, int maxWidth) {
        vector<string> res;
        for (int i = 0, length, cnt; i < words.size(); i += cnt) {
            for (length = 0, cnt = 0; i + cnt < words.size() && length + words[i + cnt].size() + cnt <= maxWidth; ++cnt)
                length += words[i + cnt].size();
            string tmp(words[i]);
            for (int j = 1; j < cnt; ++j) {
                if (i + cnt == words.size())
                    tmp.push_back(' ');
                else
                    tmp.append(string((maxWidth - length)/(cnt - 1) + (j - 1 < (maxWidth - length)%(cnt - 1)), ' '));
                tmp.append(words[i + j]);
            }
            tmp.append(string(maxWidth - tmp.size(), ' '));
            res.push_back(tmp);
        }
        return res;
    }
};

 

---

71. Simplify Path (medium) #

简化unix路径文本

Given an absolute path for a file (Unix-style), simplify it.

For example,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"
click to show corner cases.

Corner Cases:
Did you consider the case where path = "/../"?
In this case, you should return "/".
Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".
In this case, you should ignore redundant slashes and return "/home/foo".

// 使用stringstream
class Solution {
public:
    string simplifyPath(string path) {
        stringstream ss(path);
        string tmp, res;
        vector<string> st;
        while (getline(ss, tmp, '/')) {
            if (tmp == "" || tmp == ".")
                continue;
            else if (tmp == ".." && !st.empty())
                st.pop_back();
            else if (tmp != "..")
                st.push_back(tmp);
        }
        for (string s : st)
            res += "/" + s;
        return res.empty() ? "/" : res;
    }
};

 

---

72. Edit Distance (hard)

一个word经过增、删、该，最少几步到另一个word

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

a) Insert a character
b) Delete a character
c) Replace a character

class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<int> dp(word2.size() + 1);
        int pre = 0, tmp;
        for (int i = 0; i <= word2.size(); ++i)
            dp[i] = i;
        for (int i = 0; i < word1.size(); ++i) {
            pre = i;
            dp[0] = i + 1;
            for (int j = 0; j < word2.size(); ++j) {
                tmp = dp[j + 1];
                if (word1[i] == word2[j])
                    dp[j + 1] = pre;
                else
                    dp[j + 1] = min(dp[j], min(dp[j + 1], pre)) + 1;
                pre = tmp;
            }
        }
        return dp[word2.size()];
    }
};

 

---

76. Minimum Window Substring (hard) #

最小的包含某子串的窗口

Given a string S and a string T, find the minimum window in S which will contain all the characters in T in complexity O(n).

For example,
S = "ADOBECODEBANC"
T = "ABC"
Minimum window is "BANC".

Note:
If there is no such window in S that covers all characters in T, return the empty string "".

If there are multiple such windows, you are guaranteed that there will always be only one unique minimum window in S.

// 用count记录当前子串中缺少的元素个数，省去了每次验证map是否都小于0
class Solution {
public:
    string minWindow(string s, string t) {
        vector<int> mp(128, 0);
        for (auto c : t)
            ++mp[c];
        int begin = 0, end = 0, count = t.size(), length = INT_MAX, start = 0;
        while (end < s.size()) {
            if (mp[s[end++]]-- > 0)
                --count;
            while (count == 0) {
                if (length > end - begin)
                    length = end - (start = begin);
                if (++mp[s[begin++]] > 0)
                    ++count;
            }
        }
        return length == INT_MAX ? "" : s.substr(start, length);
    }
};

 

---

87. Scramble String (hard)

旋转单词：判断一个单词是否由另一个单词多次旋转得到

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

    great
   /    \
  gr    eat
 / \    /  \
g   r  e   at
           / \
          a   t
To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

    rgeat
   /    \
  rg    eat
 / \    /  \
r   g  e   at
           / \
          a   t
We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

    rgtae
   /    \
  rg    tae
 / \    /  \
r   g  ta  e
       / \
      t   a
We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if (s1 == s2)
            return true;
        int length = s1.size();
        if (length != s2.size())
            return false;
        vector<int> count(26, 0);
        for (int i = 0; i < length; ++i) {
            ++count[s1[i] - 'a'];
            --count[s2[i] - 'a'];
        }
        for (int c : count) {
            if (c != 0)
                return false;
        }
        for (int i = 1; i < length; ++i) {
            if ((isScramble(s1.substr(0,i), s2.substr(0,i)) && isScramble(s1.substr(i), s2.substr(i))) || \
                (isScramble(s1.substr(0,i), s2.substr(length-i)) && isScramble(s1.substr(i), s2.substr(0,length-i))))
                return true;
        }
        return false;
    }
};

 

---

91. Decode Ways (hard) #

把数字序号解析为字母的方式数量

A message containing letters from A-Z is being encoded to numbers using the following mapping:

'A' -> 1
'B' -> 2
...
'Z' -> 26
Given an encoded message containing digits, determine the total number of ways to decode it.

For example,
Given encoded message "12", it could be decoded as "AB" (1 2) or "L" (12).

The number of ways decoding "12" is 2.

// 1 类似“1502”这样的是不存在的；2 从前往后解析会出现res减小的情况，不易处理
class Solution {
public:
    int numDecodings(string s) {
        int n = s.size();
        if (n == 0)
            return 0;
        int res = s.back() == '0' ? 0 : 1, lst = 1, num = s.back() - '0', tmp = 0;
        for (int i = n - 2; i >= 0; --i) {
            tmp = res;
            if (s[i] == '0')
                res = 0;
            else if (num + (s[i] - '0')*10 <= 26)
                res += lst;
            lst = tmp;
            num = s[i] - '0';
        }
        return res;
    }
};

 

---

93. Restore IP Addresses (medium)

把字符串解析为IP地址

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example:
Given "25525511135",

return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        int length = s.size();
        vector<string> res;
        for (int i = 1; i < 4 && i < length - 2; ++i) {
            for (int j = i + 1; j < i + 4 && j < length - 1; ++j) {
                for (int k = j + 1; k < j + 4 && k < length; ++k) {
                    string str1 = s.substr(0, i);
                    string str2 = s.substr(i, j - i);
                    string str3 = s.substr(j, k - j);
                    string str4 = s.substr(k, length - k);
                    if (isValid(str1) && isValid(str2) && isValid(str3) && isValid(str4)) {
                        res.push_back(str1 + "." + str2 + "." + str3 + "." + str4);
                    }
                }
            }
        }
        return res;
    }
    bool isValid(string str) {
        if (str.size() > 3 || (str.size() > 1 && str[0] == '0') || stoi(str) > 255) return false;
        return true;
    }
};

 

---

97. Interleaving String (hard)

判断两个字符串是否能组合成另一个字符串

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example,
Given:
s1 = "aabcc",
s2 = "dbbca",

When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.

// 递归会有2%超时
class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int m = s1.size(), n = s2.size(), mn = s3.size();
        if (m + n != mn)
            return false;
        vector<vector<bool>> dp(m + 1, vector<bool>(n + 1, false));
        dp[0][0] = true;
        for (int j = 1; j <= n; ++j)
            dp[0][j] = s2[j - 1] == s3[j - 1] && dp[0][j - 1];
        for (int i = 1; i <= m; ++i) {
            dp[i][0] = s1[i - 1] == s3[i - 1] && dp[i - 1][0];
            for (int j = 1; j <= n; ++j) {
                dp[i][j] = (s1[i - 1] == s3[i + j - 1] && dp[i - 1][j]) || \
                           (s2[j - 1] == s3[i + j - 1] && dp[i][j - 1]);
            }
        }
        return dp[m][n];
    }
};

 

---

115. Distinct Subsequences (hard)

 一个string删除某些字母后得到另一个string的方式数量

Given a string S and a string T, count the number of distinct subsequences of S which equals T.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ACE" is a subsequence of "ABCDE" while "AEC" is not).

Here is an example:
S = "rabbbit", T = "rabbit"

Return 3.

class Solution {
public:
    int numDistinct(string s, string t) {
        int m = s.size(), n = t.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        dp[0][0] = 1;
        for (int i = 1; i <= m; ++i) {
            for (int j = 0; j <= i && j <= n; ++j) {
                if (j > 0 && s[i - 1] == t[j - 1])
                    dp[i][j] += dp[i - 1][j - 1];
                if (j != i)
                    dp[i][j] += dp[i - 1][j];
            }
        }
        return dp[m][n];
    }
};

 

---

125. Valid Palindrome (easy)

判断回文

Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.

For example,
"A man, a plan, a canal: Panama" is a palindrome.
"race a car" is not a palindrome.

Note:
Have you consider that the string might be empty? This is a good question to ask during an interview.

For the purpose of this problem, we define empty string as valid palindrome.

class Solution {
public:
    bool isPalindrome(string s) {
        for (int left = 0, right = s.size() - 1; left < right; ++left, --right) {
            while (left < right && !isalnum(s[left])) ++left;
            while (left < right && !isalnum(s[right])) --right;
            if (toupper(s[left]) != toupper(s[right])) return false;
        }
        return true;
    }
};

 

---

126. Word Ladder II (hard) #

单词接龙，前后单词只有一个字母不同

 

---

151. Reverse Words in a String (medium)

反转string中的word，并去掉头尾空格

Given an input string, reverse the string word by word.

For example,
Given s = "the sky is blue",
return "blue is sky the".

Update (2015-02-12):
For C programmers: Try to solve it in-place in O(1) space.

click to show clarification.

Clarification:
What constitutes a word?
A sequence of non-space characters constitutes a word.
Could the input string contain leading or trailing spaces?
Yes. However, your reversed string should not contain leading or trailing spaces.
How about multiple spaces between two words?
Reduce them to a single space in the reversed string.

class Solution {
public:
    void reverseWords(string &s) {
        int length = s.size();
        reverse(s.begin(), s.end());
        int temp = 0, i = 0;
        for (int j = 0; j < length;) {
            while (j < length && s[j] == ' ') ++j;
            if (j == length) break;
            while (j < length && s[j] != ' ') s[i++] = s[j++];
            reverse(s.begin() + temp, s.begin() + i);
            s[i++] = ' ';
            temp = i;
        }
        if (i == 0) temp = 1;
        s.erase(s.begin() + temp - 1, s.end());
    }
};

 

---

165. Compare Version Numbers (medium)

版本大小判断

Compare two version numbers version1 and version2.
If version1 > version2 return 1, if version1 < version2 return -1, otherwise return 0.

You may assume that the version strings are non-empty and contain only digits and the . character.
The . character does not represent a decimal point and is used to separate number sequences.
For instance, 2.5 is not "two and a half" or "half way to version three", it is the fifth second-level revision of the second first-level revision.

Here is an example of version numbers ordering:

0.1 < 1.1 < 1.2 < 13.37

class Solution {
public:
    int compareVersion(string version1, string version2) {
        int num1, num2, i = 0, j = 0;
        while (i < version1.size() || j < version2.size()) {
            num1 = num2 = 0;
            while (i < version1.size() && version1[i] != '.')
                num1 = num1*10 + version1[i++] - '0';
            while (j < version2.size() && version2[j] != '.')
                num2 = num2*10 + version2[j++] - '0';
            if (num1 != num2)
                return num1 < num2 ? -1 : 1;
            ++i;++j;
        }
        return 0;
    }
};

 

---

214. Shortest Palindrome (hard) #

把字符串补成回文串，只能在字符串前面补

Given a string S, you are allowed to convert it to a palindrome by adding characters in front of it. Find and return the shortest palindrome you can find by performing this transformation.

For example:

Given "aacecaaa", return "aaacecaaa".

Given "abcd", return "dcbabcd".

Credits:
Special thanks to @ifanchu for adding this problem and creating all test cases. Thanks to @Freezen for additional test cases.

// 反转后查找最长的匹配字符串，kmp算法
class Solution {
public:
    string shortestPalindrome(string s) {
        string rev_s(s);
        reverse(rev_s.begin(), rev_s.end());
        string ss = s + "#" + rev_s;
        vector<int> kmp(ss.size(), 0);
        for (int i = 1, index = 0; i < ss.size(); ++i) {
            if (ss[i] == ss[index]) {
                kmp[i] = kmp[i - 1] + 1;
                ++index;
            }
            else {
                index = kmp[i - 1];
                while (index > 0 && ss[index] != ss[i])
                    index = kmp[index - 1];
                if (ss[index] == ss[i])
                    ++index;
                kmp[i] = index;
            }
        }
        return ss.substr(s.size() + 1, s.size() - kmp[ss.size() - 1]) + s;
    }
};

// 简化版
class Solution {
public:
    string shortestPalindrome(string s) {
        string rev_s(s);
        reverse(rev_s.begin(), rev_s.end());
        string ss = s + "#" + rev_s;
        vector<int> kmp(ss.size(), 0);
        for (int i = 1; i < ss.size(); ++i) {
            int index = kmp[i - 1];
            while (index > 0 && ss[index] != ss[i])
                index = kmp[index - 1];
            kmp[i] = (index += (ss[index] == ss[i]));
        }
        return ss.substr(s.size() + 1, s.size() - kmp[ss.size() - 1]) + s;
    }
};

 

---

227. Basic Calculator II (medium)

字符串计算器

Implement a basic calculator to evaluate a simple expression string.

The expression string contains only non-negative integers, +, -, *, / operators and empty spaces . The integer division should truncate toward zero.

You may assume that the given expression is always valid.

Some examples:
"3+2*2" = 7
" 3/2 " = 1
" 3+5 / 2 " = 5
Note: Do not use the eval built-in library function.

class Solution {
public:
    int calculate(string s) {
        vector<int> nums{0};
        int tmp = 0;
        char sign = '+';
        for (int i = 0; i <= s.size(); ++i) {
            if (i < s.size() && s[i] >= '0' && s[i] <= '9')
                tmp = tmp*10 + s[i] - '0';
            else if (i < s.size() && s[i] == ' ')
                continue;
            else {
                if (sign == '+')
                    nums.push_back(tmp);
                else if (sign == '-')
                    nums.push_back(-tmp);
                else if (sign == '*')
                    nums.back() = nums.back()*tmp;
                else if (sign == '/')
                    nums.back() = nums.back()/tmp;
                if (i < s.size())
                    sign = s[i];
                tmp = 0;
            }
        }
        return accumulate(nums.begin(), nums.end(), 0);
    }
};

 

---

273. Integer to English Words (hard)

数字用英文单词表示

Convert a non-negative integer to its english words representation. Given input is guaranteed to be less than 231 - 1.

For example,
123 -> "One Hundred Twenty Three"
12345 -> "Twelve Thousand Three Hundred Forty Five"
1234567 -> "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

// 没做
class Solution {
public:
    static string numberToWords(int n) {
        if(n == 0) return "Zero";
        else return int_string(n).substr(1);
    }
private:
    static const char * const below_20[];
    static const char * const below_100[];
    static string int_string(int n) {
        if(n >= 1000000000)   return int_string(n / 1000000000) + " Billion" + int_string(n - 1000000000 * (n / 1000000000));
        else if(n >= 1000000) return int_string(n / 1000000) + " Million" + int_string(n - 1000000 * (n / 1000000));
        else if(n >= 1000)    return int_string(n / 1000) + " Thousand" + int_string(n - 1000 * (n / 1000));
        else if(n >= 100)     return int_string(n / 100) + " Hundred" + int_string(n - 100 * (n / 100));
        else if(n >= 20)      return string(" ") + below_100[n / 10 - 2] + int_string(n - 10 * (n / 10));
        else if(n >= 1)       return string(" ") + below_20[n - 1];
        else return "";
    }
};

const char * const Solution::below_20[] =  {"One", "Two", "Three", "Four","Five","Six","Seven","Eight","Nine","Ten", "Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"};
const char * const Solution::below_100[] = {"Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};

 

---

336. Palindrome Pairs (hard) ###########################

能组成回文的字符串对

 

---

344. Reverse String (easy)

翻转字符串

Write a function that takes a string as input and returns the string reversed.

Example:
Given s = "hello", return "olleh".

class Solution {
public:
    string reverseString(string s) {
        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
            swap(s[i], s[j]);
        return s;
    }
};

 

---

345. Reverse Vowels of a String (easy)

翻转字符串中的元音字母

Write a function that takes a string as input and reverse only the vowels of a string.

Example 1:
Given s = "hello", return "holle".

Example 2:
Given s = "leetcode", return "leotcede".

Note:
The vowels does not include the letter "y".

class Solution {
public:
    string reverseVowels(string s) {
        bool m[255] = {0};
        string vowels = "aeiouAEIOU";
        for (auto c : vowels)
            m[c] = 1;
        for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
            while (i < s.size() && !m[s[i]])
                ++i;
            while (j > i && !m[s[j]])
                --j;
            if (i < j)
                swap(s[i], s[j]);
        }
        return s;
    }
};

 

---

383. Ransom Note (easy)

后面的字符串可否由前面的字符串加一些字母组成

Given an arbitrary ransom note string and another string containing letters from all the magazines, write a function that will return true if the ransom note can be constructed from the magazines ; otherwise, it will return false.

Each letter in the magazine string can only be used once in your ransom note.

Note:
You may assume that both strings contain only lowercase letters.

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> dict(26);
        for (auto m : magazine) dict[m - 'a']++;
        for (auto r : ransomNote)
            if (--dict[r - 'a'] < 0) return false;
        return true;
    }
};

 

---

385. Mini Parser (medium) #

解析字符串到对象

Given a nested list of integers represented as a string, implement a parser to deserialize it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

Note: You may assume that the string is well-formed:

String is non-empty.
String does not contain white spaces.
String contains only digits 0-9, [, - ,, ].
Example 1:

Given s = "324",

You should return a NestedInteger object which contains a single integer 324.
Example 2:

Given s = "[123,[456,[789]]]",

Return a NestedInteger object containing a nested list with 2 elements:

1. An integer containing value 123.
2. A nested list containing two elements:
    i.  An integer containing value 456.
    ii. A nested list with one element:
         a. An integer containing value 789.

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Constructor initializes an empty nested list.
 *     NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     NestedInteger(int value);
 *
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Set this NestedInteger to hold a single integer.
 *     void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     void add(const NestedInteger &ni);
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */
class Solution {
public:
    NestedInteger deserialize(string s) {
        auto isNumber = [](char c) {return (c == '-' || isdigit(c));};
        stack<NestedInteger> st;
        st.push(NestedInteger());
        for (auto it = s.begin(); it != s.end();) {
            auto c = *it;
            if (isNumber(c)) {
                auto it2 = find_if_not(it, s.end(), isNumber);
                int val = stoi(string(it, it2));
                st.top().add(NestedInteger(val));
                it = it2;
            }
            else {
                if (c == '[')
                    st.push(NestedInteger());
                else if (c == ']') {
                    NestedInteger tmp = st.top();
                    st.pop();
                    st.top().add(tmp);
                }
                ++it;
            }
        }
        return st.top().getList().front();
    }
};

 

---

387. First Unique Character in a String (easy)

第一个不重复的元素

Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.

Examples:

s = "leetcode"
return 0.

s = "loveleetcode",
return 2.
Note: You may assume the string contain only lowercase letters.

class Solution {
public:
    int firstUniqChar(string s) {
        int frq[26] = {0};
        for (auto c : s)
            ++frq[c - 'a'];
        for (int i = 0; i < s.size(); ++i) {
            if (frq[s[i] - 'a'] == 1)
                return i;
        }
        return -1;
    }
};

 

---

434. Number of Segments in a String (easy)

字符串中以空格分隔的块个数

Count the number of segments in a string, where a segment is defined to be a contiguous sequence of non-space characters.

Please note that the string does not contain any non-printable characters.

Example:

Input: "Hello, my name is John"
Output: 5

class Solution {
public:
    int countSegments(string s) {
        int res = 0;
        s.push_back(' ');
        for(int i = 1; i < s.size(); ++i)
          if(s[i] == ' ' && s[i-1] != ' ') ++res;
        return res;
    }
};

 

---

443. String Compression (easy)

字符串压缩，在原位置压缩，返回压缩后的大小

Given an array of characters, compress it in-place.

The length after compression must always be smaller than or equal to the original array.

Every element of the array should be a character (not int) of length 1.

After you are done modifying the input array in-place, return the new length of the array.


Follow up:
Could you solve it using only O(1) extra space?


Example 1:
Input:
["a","a","b","b","c","c","c"]

Output:
Return 6, and the first 6 characters of the input array should be: ["a","2","b","2","c","3"]

Explanation:
"aa" is replaced by "a2". "bb" is replaced by "b2". "ccc" is replaced by "c3".
Example 2:
Input:
["a"]

Output:
Return 1, and the first 1 characters of the input array should be: ["a"]

Explanation:
Nothing is replaced.
Example 3:
Input:
["a","b","b","b","b","b","b","b","b","b","b","b","b"]

Output:
Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"].

Explanation:
Since the character "a" does not repeat, it is not compressed. "bbbbbbbbbbbb" is replaced by "b12".
Notice each digit has it's own entry in the array.
Note:
All characters have an ASCII value in [35, 126].
1 <= len(chars) <= 1000.

class Solution {
public:
    int compress(vector<char>& chars) {
        int index = 0;
        for (int i = 0; i < chars.size(); ++i) {
            char cur = chars[i];
            int cnt = 1;
            while (i + 1 < chars.size() && chars[i + 1] == cur) {
                ++i;
                ++cnt;
            }
            chars[index++] = cur;
            if (cnt > 1) {
                string num = to_string(cnt);
                for (char n : num)
                    chars[index++] = n;
            }
        }
        return index;
    }
};

 

---

459. Repeated Substring Pattern (easy) #

判断字符串是否可拆分为多个相同的子串

Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.
Example 1:
Input: "abab"

Output: True

Explanation: It's the substring "ab" twice.
Example 2:
Input: "aba"

Output: False
Example 3:
Input: "abcabcabcabc"

Output: True

Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)

// KMP
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        int length = s.size();
        vector<int> dp(length, 0);
        for (int i = 1, j = 0; i < length;) {
            if (s[j] == s[i])
                dp[i++] = ++j;
            else if (j > 1)
                j = dp[j - 1];
            else
                ++i;
        }
        return dp[length - 1] && length%(length - dp[length - 1]) == 0;
    }
};

// 最后不能是ss.find(s, 1) >= 0。
// 
class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        if (s.size() < 2)
            return false;
        string ss = s + s;
        ss.pop_back();
        return ss.find(s, 1) != -1;
    }
};

 

---

468. Validate IP Address (medium) #

判断IP地址是否正确

Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.

IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots ("."), e.g.,172.16.254.1;

Besides, leading zeros in the IPv4 is invalid. For example, the address 172.16.254.01 is invalid.

IPv6 addresses are represented as eight groups of four hexadecimal digits, each group representing 16 bits. The groups are separated by colons (":"). For example, the address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a valid one. Also, we could omit some leading zeros among four hexadecimal digits and some low-case characters in the address to upper-case ones, so 2001:db8:85a3:0:0:8A2E:0370:7334 is also a valid IPv6 address(Omit leading zeros and using upper cases).

However, we don't replace a consecutive group of zero value with a single empty group using two consecutive colons (::) to pursue simplicity. For example, 2001:0db8:85a3::8A2E:0370:7334 is an invalid IPv6 address.

Besides, extra leading zeros in the IPv6 is also invalid. For example, the address 02001:0db8:85a3:0000:0000:8a2e:0370:7334 is invalid.

Note: You may assume there is no extra space or special characters in the input string.

Example 1:
Input: "172.16.254.1"

Output: "IPv4"

Explanation: This is a valid IPv4 address, return "IPv4".
Example 2:
Input: "2001:0db8:85a3:0:0:8A2E:0370:7334"

Output: "IPv6"

Explanation: This is a valid IPv6 address, return "IPv6".
Example 3:
Input: "256.256.256.256"

Output: "Neither"

Explanation: This is neither a IPv4 address nor a IPv6 address.

class Solution {
public:
    /*
    string validIPAddress(string IP) {
        string res[3] = {"IPv4", "IPv6", "Neither"};
        stringstream ss(IP);
        string block;
        int cnt;
        if (IP.substr(0, 4).find('.') != string::npos) {
            for (cnt = 0; getline(ss, block, '.'); ++cnt) {
                if (cnt >= 4 || !validIPv4(block))
                    return res[2];
            }
            return cnt == 4 ? res[0] : res[2];
        }
        else if (IP.substr(0, 5).find(':') != string::npos) {
            for (cnt = 0; getline(ss, block, ':'); ++cnt) {
                if (cnt >= 8 || !validIPv6(block))
                    return res[2];
            }
            return ss.eof() ? res[1] : res[2];
        }
        return res[2];
    }
    */
    
    string validIPAddress(string IP) {
        string ans[3] = {"IPv4", "IPv6", "Neither"};
        stringstream ss(IP);
        string block;
        // ipv4 candidate
        if (IP.substr(0, 4).find('.') != string::npos) {
            for (int i = 0; i < 4; i++) {
            if (!getline(ss, block, '.') || !validIPv4(block))
                   return ans[2];
            }
            return ss.eof() ? ans[0] : ans[2];
        }
        // ipv6 candidate
        else if (IP.substr(0, 5).find(':') != string::npos) {
            for (int i = 0; i < 8; i++) {
            if (!getline(ss, block, ':') || !validIPv6(block))
                return ans[2];
            }
            return ss.eof() ? ans[1] : ans[2];
        }
    
        return ans[2];
    }
    const string validIPv6Chars = "0123456789abcdefABCDEF";
    
    bool validIPv4(string& block) {
        int num = 0;
        if (block.size() > 0 && block.size() <= 3) {
            for (int i = 0; i < block.size(); i++) {
                char c = block[i];
                // special case: if c is a leading zero and there are characters left
                if (!isalnum(c) || (i == 0 && c == '0' && block.size() > 1))
                    return false;
                else {
                    num *= 10;
                    num += c - '0';
                }
            }
            return num <= 255;
        }
        return false;
    }
    
    bool validIPv6(string& block) {
        if (block.size() > 0 && block.size() <= 4) {
            for (int i = 0; i < block.size(); i++) {
                char c = block[i];
                if (validIPv6Chars.find(c) == string::npos)
                    return false;
            }
            return true;
        }
        return false;
    }
};

 

---

520. Detect Capital (easy)

判断单词的大小写是否符合格式

Given a word, you need to judge whether the usage of capitals in it is right or not.

We define the usage of capitals in a word to be right when one of the following cases holds:

All letters in this word are capitals, like "USA".
All letters in this word are not capitals, like "leetcode".
Only the first letter in this word is capital if it has more than one letter, like "Google".
Otherwise, we define that this word doesn't use capitals in a right way.
Example 1:
Input: "USA"
Output: True
Example 2:
Input: "FlaG"
Output: False
Note: The input will be a non-empty word consisting of uppercase and lowercase latin letters.

class Solution {
public:
    bool detectCapitalUse(string word) {
        if (word.size() <= 1)
            return true;
        bool lable = isCapital(word[0]) && isCapital(word[1]);
        for (int i = 1; i < word.size(); ++i) {
            if (isCapital(word[i]) != lable)
                return false;
        }
        return true;
    }
    bool isCapital(char c) {
        return c >= 'A' && c <= 'Z';
    }
};

 

---

521. Longest Uncommon Subsequence I (easy)

两个字符串，求最长的一个字符串：是其中一个的子串，但不是另一个的子串。

Given a group of two strings, you need to find the longest uncommon subsequence of this group of two strings. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.

A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.

The input will be two strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.

Example 1:
Input: "aba", "cdc"
Output: 3
Explanation: The longest uncommon subsequence is "aba" (or "cdc"), 
because "aba" is a subsequence of "aba", 
but not a subsequence of any other strings in the group of two strings. 
Note:

Both strings' lengths will not exceed 100.
Only letters from a ~ z will appear in input strings.

class Solution {
public:
    int findLUSlength(string a, string b) {
        return a == b ? -1 : max(a.size(), b.size());
    }
};

 

---

522. Longest Uncommon Subsequence II (medium) #

多个字符串，求最长的一个字符串：是其中一个的子串，但不是其他的子串。

Given a list of strings, you need to find the longest uncommon subsequence among them. The longest uncommon subsequence is defined as the longest subsequence of one of these strings and this subsequence should not be any subsequence of the other strings.

A subsequence is a sequence that can be derived from one sequence by deleting some characters without changing the order of the remaining elements. Trivially, any string is a subsequence of itself and an empty string is a subsequence of any string.

The input will be a list of strings, and the output needs to be the length of the longest uncommon subsequence. If the longest uncommon subsequence doesn't exist, return -1.

Example 1:
Input: "aba", "cdc", "eae"
Output: 3
Note:

All the given strings' lengths will not exceed 10.
The length of the given list will be in the range of [2, 50].

class Solution {
public:
    int findLUSlength(vector<string>& strs) {
        map<int, vector<string>> mp;
        unordered_set<string> seqs;
        bool first = true;
        for (auto str : strs)
            mp[str.size()].push_back(str);
        for (auto ptr = mp.rbegin(); ptr != mp.rend(); ++ptr) {
            auto& strVec = ptr -> second;
            for (string str : strVec) {
                if (count(strVec.begin(), strVec.end(), str) > 1 || findSet(str, seqs))
                    seqs.insert(str);
                else
                    return ptr -> first;
            }
        }
        return -1;
    }
    bool isSubseq(string s1, string s2) {
        int i = 0;
        for (char c : s2) {
            if (s1[i] == c)
                ++i;
        }
        return i == s1.size();
    }
    bool findSet(string s, unordered_set<string>& seqs) {
        for (string seq : seqs) {
            if (isSubseq(s, seq))
                return true;
        }
        return false;
    }
};

 使用lambda表达式和bind函数

class Solution {
public:
    int findLUSlength(vector<string>& strs) {
        map<int, vector<string>> mp;
        unordered_set<string> seqs;
        auto isSubseq = [](string s1, string s2) {
            int i = 0;
            for (char c : s2) {
                if (s1[i] == c)
                    ++i;
            }
            return i == s1.size();
        };
        bool first = true;
        for (auto str : strs)
            mp[str.size()].push_back(str);
        for (auto ptr = mp.rbegin(); ptr != mp.rend(); ++ptr) {
            auto& strVec = ptr -> second;
            for (string str : strVec) {
                if (count(strVec.begin(), strVec.end(), str) > 1 || \
                    find_if(seqs.begin(), seqs.end(), bind(isSubseq, str, std::placeholders::_1)) != seqs.end())
                    seqs.insert(str);
                else
                    return ptr -> first;
            }
        }
        return -1;
    }
};

 

---

537. Complex Number Multiplication (medium)

复数表达式相乘

Given two strings representing two complex numbers.

You need to return a string representing their multiplication. Note i2 = -1 according to the definition.

Example 1:
Input: "1+1i", "1+1i"
Output: "0+2i"
Explanation: (1 + i) * (1 + i) = 1 + i2 + 2 * i = 2i, and you need convert it to the form of 0+2i.
Example 2:
Input: "1+-1i", "1+-1i"
Output: "0+-2i"
Explanation: (1 - i) * (1 - i) = 1 + i2 - 2 * i = -2i, and you need convert it to the form of 0+-2i.
Note:

The input strings will not have extra blank.
The input strings will be given in the form of a+bi, where the integer a and b will both belong to the range of [-100, 100]. And the output should be also in this form.

class Solution {
public:
    string complexNumberMultiply(string a, string b) {
        auto aPair = parse(a);
        auto bPair = parse(b);
        int m = aPair.first*bPair.first - aPair.second*bPair.second;
        int n = aPair.first*bPair.second + aPair.second*bPair.first;
        return to_string(m) + "+" + to_string(n) + "i";
    }
    pair<int, int> parse(string s) {
        int plusIndex = find_if(s.begin(), s.end(), [] (char c) {return c == '+';}) - s.begin();
        int a = stoi(s.substr(0, plusIndex + 1));
        int b = stoi(s.substr(plusIndex + 1));
        return {a, b};
    }
};

使用stringstream

class Solution {
public:
    string complexNumberMultiply(string a, string b) {
        int ra, ia, rb, ib;
        char buff;
        stringstream aa(a), bb(b), ans;
        aa >> ra >> buff >> ia >> buff;
        bb >> rb >> buff >> ib >> buff;
        ans << ra*rb - ia*ib << "+" << ra*ib + rb*ia << "i";
        return ans.str();
    }
};

 

---

539. Minimum Time Difference (medium)

所有列出时间之间的最小时间差

Given a list of 24-hour clock time points in "Hour:Minutes" format, find the minimum minutes difference between any two time points in the list.
Example 1:
Input: ["23:59","00:00"]
Output: 1
Note:
The number of time points in the given list is at least 2 and won't exceed 20000.
The input time is legal and ranges from 00:00 to 23:59.

class Solution {
public:
    int findMinDifference(vector<string>& timePoints) {
        vector<bool> mark(60*24, false);
        int minTime = INT_MAX, maxTime = -60*24, res = INT_MAX;
        for (string timePoint : timePoints) {
            int time = stoi(timePoint.substr(0, 2))*60 + stoi(timePoint.substr(3));
            if (mark[time])
                return 0;
            mark[time] = true;
        }
        for (int i = 0; i < 60*24; ++i) {
            if (!mark[i])
                continue;
            if (minTime == INT_MAX)
                minTime = i;
            res = min(res, i - maxTime);
            maxTime = i;
        }
        return min(res, 60*24 + minTime - maxTime);
    }
};

 

---

541. Reverse String II (easy)

翻转字符串，隔k个翻转k个

Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.
Example:
Input: s = "abcdefg", k = 2
Output: "bacdfeg"
Restrictions:
The string consists of lower English letters only.
Length of the given string and k will in the range [1, 10000]

class Solution {
public:
    string reverseStr(string s, int k) {
        int i = 0;
        while (i < s.size()) {
            if (i + k >= s.size())
                reverse(s.begin() + i, s.end());
            else
                reverse(s.begin() + i, s.begin() + i + k);
            i += k + k;
        }
        return s;
    }
};

 

---

551. Student Attendance Record I (easy)

学生考勤

You are given a string representing an attendance record for a student. The record only contains the following three characters:
'A' : Absent.
'L' : Late.
'P' : Present.
A student could be rewarded if his attendance record doesn't contain more than one 'A' (absent) or more than two continuous 'L' (late).

You need to return whether the student could be rewarded according to his attendance record.

Example 1:
Input: "PPALLP"
Output: True
Example 2:
Input: "PPALLL"
Output: False

class Solution {
public:
    bool checkRecord(string s) {
        int cntA = 0, cntL = 0;
        for (char c : s) {
            if (c == 'L')
                ++cntL;
            else
                cntL = 0;
            if (c == 'A')
                ++cntA;
            if (cntL > 2 || cntA > 1)
                return false;
        }
        return true;
    }
};

 

---

553. Optimal Division (medium)

连除表达式加括号，使结果最大

Given a list of positive integers, the adjacent integers will perform the float division. For example, [2,3,4] -> 2 / 3 / 4.

However, you can add any number of parenthesis at any position to change the priority of operations. You should find out how to add parenthesis to get the maximum result, and return the corresponding expression in string format. Your expression should NOT contain redundant parenthesis.

Example:
Input: [1000,100,10,2]
Output: "1000/(100/10/2)"
Explanation:
1000/(100/10/2) = 1000/((100/10)/2) = 200
However, the bold parenthesis in "1000/((100/10)/2)" are redundant, 
since they don't influence the operation priority. So you should return "1000/(100/10/2)". 

Other cases:
1000/(100/10)/2 = 50
1000/(100/(10/2)) = 50
1000/100/10/2 = 0.5
1000/100/(10/2) = 2
Note:

The length of the input array is [1, 10].
Elements in the given array will be in range [2, 1000].
There is only one optimal division for each test case.

class Solution {
public:
    string optimalDivision(vector<int>& nums) {
        if (nums.size() == 1)
            return to_string(nums[0]);
        if (nums.size() == 2)
            return to_string(nums[0]) + "/" + to_string(nums[1]);
        string res = to_string(nums[0]) + "/(" + to_string(nums[1]);
        for (int i = 2; i < nums.size(); ++i)
            res += "/" + to_string(nums[i]);
        return res + ")";
    }
};

 

---

556. Next Greater Element III (medium)

下一个更大的数，输入是int

Given a positive 32-bit integer n, you need to find the smallest 32-bit integer which has exactly the same digits existing in the integer n and is greater in value than n. If no such positive 32-bit integer exists, you need to return -1.

Example 1:

Input: 12
Output: 21
 

Example 2:

Input: 21
Output: -1

class Solution {
public:
    int nextGreaterElement(int n) {
        string str = to_string(n);
        int i = str.size() - 1, j = i;
        for (; i > 0 && str[i - 1] >= str[i]; --i);
        if (i == 0)
            return -1;
        for (--i; str[j] <= str[i]; --j);
        swap(str[i], str[j]);
        sort(str.begin() + i + 1, str.end());
        long long res = stoll(str);
        return res > INT_MAX ? -1 : res;
    }
};

 

---

557. Reverse Words in a String III (easy)

翻转字符串中的每个单词

Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

Example 1:
Input: "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"
Note: In the string, each word is separated by single space and there will not be any extra space in the string.

class Solution {
public:
    string reverseWords(string s) {
        for (int i = 0, j = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') {
                reverse(s.begin() + j, s.begin() + i);
                j = i + 1;
            }
        }
        return s;
    }
};

 

---

564. Find the Closest Palindrome (hard) # X

找到距离n最近的回文数

Given an integer n, find the closest integer (not including itself), which is a palindrome.

The 'closest' is defined as absolute difference minimized between two integers.

Example 1:
Input: "123"
Output: "121"
Note:
The input n is a positive integer represented by string, whose length will not exceed 18.
If there is a tie, return the smaller one as answer.

// 思路：取出数字的前一半，加-1，0，1，再和他的翻转组成回文
// 1：数字很大，需要stll
// 2：空字符串无法调用stll，需要单独处理10以下的数
// 3：如果共有奇数为，组合成回文时要去掉中间位
// 3：不能和原数字相同，所以999中99+1=100，组成10001；100中10-1=9，去掉中间为，最后为9.因此单独处理99..99和10..0的数
class Solution {
public:
    string nearestPalindromic(string n) {
        int length = n.size();
        long long numN = stoll(n);
        if (numN <= 10)
            return to_string(numN - 1);
        long long res = 0, delta = INT_MAX, prefix = stoll(n.substr(0, (length + 1)/2));
        vector<long long> items;
        for (int i = length; i >= length - 1; --i) {
            for (int j = 1; j >= -1; j -= 2)
                items.push_back(pow(10, i) + j);
        }
        for (long long i = prefix - 1; i <= prefix + 1; ++i) {
            string tmp = toPalindrome(to_string(i), length%2);
            items.push_back(stoll(tmp));
        }
        for (auto num : items) {
            long long deltaNum = abs(num - numN);
            if ((deltaNum != 0) && (deltaNum < delta || (deltaNum == delta && num < res))) {
                res = num;
                delta = deltaNum;
            }
        }
        return to_string(res);
    }
    string toPalindrome(string s, bool odd) {
        string cp(s);
        reverse(cp.begin(), cp.end());
        return odd ? s + cp.substr(1) : s + cp;
    }
};

 

---

583. Delete Operation for Two Strings (medium)

两个字符串总共去掉多少个字符可以使他们相同

Given two words word1 and word2, find the minimum number of steps required to make word1 and word2 the same, where in each step you can delete one character in either string.

Example 1:
Input: "sea", "eat"
Output: 2
Explanation: You need one step to make "sea" to "ea" and another step to make "eat" to "ea".
Note:
The length of given words won't exceed 500.
Characters in given words can only be lower-case letters.

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (word1[i - 1] == word2[j - 1])
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
        return m + n - 2*dp[m][n];
    }
};

 

---

591. Tag Validator (hard)

太长，没看！

Given a string representing a code snippet, you need to implement a tag validator to parse the code and return whether it is valid. A code snippet is valid if all the following rules hold:

The code must be wrapped in a valid closed tag. Otherwise, the code is invalid.
A closed tag (not necessarily valid) has exactly the following format : <TAG_NAME>TAG_CONTENT</TAG_NAME>. Among them, <TAG_NAME> is the start tag, and </TAG_NAME> is the end tag. The TAG_NAME in start and end tags should be the same. A closed tag is valid if and only if the TAG_NAME and TAG_CONTENT are valid.
A valid TAG_NAME only contain upper-case letters, and has length in range [1,9]. Otherwise, the TAG_NAME is invalid.
A valid TAG_CONTENT may contain other valid closed tags, cdata and any characters (see note1) EXCEPT unmatched <, unmatched start and end tag, and unmatched or closed tags with invalid TAG_NAME. Otherwise, the TAG_CONTENT is invalid.
A start tag is unmatched if no end tag exists with the same TAG_NAME, and vice versa. However, you also need to consider the issue of unbalanced when tags are nested.
A < is unmatched if you cannot find a subsequent >. And when you find a < or </, all the subsequent characters until the next > should be parsed as TAG_NAME (not necessarily valid).
The cdata has the following format : <![CDATA[CDATA_CONTENT]]>. The range of CDATA_CONTENT is defined as the characters between <![CDATA[ and the first subsequent ]]>.
CDATA_CONTENT may contain any characters. The function of cdata is to forbid the validator to parse CDATA_CONTENT, so even it has some characters that can be parsed as tag (no matter valid or invalid), you should treat it as regular characters.
Valid Code Examples:
Input: "<DIV>This is the first line <![CDATA[<div>]]></DIV>"

Output: True

Explanation: 

The code is wrapped in a closed tag : <DIV> and </DIV>. 

The TAG_NAME is valid, the TAG_CONTENT consists of some characters and cdata. 

Although CDATA_CONTENT has unmatched start tag with invalid TAG_NAME, it should be considered as plain text, not parsed as tag.

So TAG_CONTENT is valid, and then the code is valid. Thus return true.


Input: "<DIV>>>  ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>"

Output: True

Explanation:

We first separate the code into : start_tag|tag_content|end_tag.

start_tag -> "<DIV>"

end_tag -> "</DIV>"

tag_content could also be separated into : text1|cdata|text2.

text1 -> ">>  ![cdata[]] "

cdata -> "<![CDATA[<div>]>]]>", where the CDATA_CONTENT is "<div>]>"

text2 -> "]]>>]"


The reason why start_tag is NOT "<DIV>>>" is because of the rule 6.
The reason why cdata is NOT "<![CDATA[<div>]>]]>]]>" is because of the rule 7.
Invalid Code Examples:
Input: "<A>  <B> </A>   </B>"
Output: False
Explanation: Unbalanced. If "<A>" is closed, then "<B>" must be unmatched, and vice versa.

Input: "<DIV>  div tag is not closed  <DIV>"
Output: False

Input: "<DIV>  unmatched <  </DIV>"
Output: False

Input: "<DIV> closed tags with invalid tag name  <b>123</b> </DIV>"
Output: False

Input: "<DIV> unmatched tags with invalid tag name  </1234567890> and <CDATA[[]]>  </DIV>"
Output: False

Input: "<DIV>  unmatched start tag <B>  and unmatched end tag </C>  </DIV>"
Output: False
Note:
For simplicity, you could assume the input code (including the any characters mentioned above) only contain letters, digits, '<','>','/','!','[',']' and ' '.

 

---

606. Construct String from Binary Tree (easy)

把二叉树转换为（）描述的字符串

You need to construct a string consists of parenthesis and integers from a binary tree with the preorder traversing way.

The null node needs to be represented by empty parenthesis pair "()". And you need to omit all the empty parenthesis pairs that don't affect the one-to-one mapping relationship between the string and the original binary tree.

Example 1:
Input: Binary tree: [1,2,3,4]
       1
     /   \
    2     3
   /    
  4     

Output: "1(2(4))(3)"

Explanation: Originallay it needs to be "1(2(4)())(3()())", 
but you need to omit all the unnecessary empty parenthesis pairs. 
And it will be "1(2(4))(3)".
Example 2:
Input: Binary tree: [1,2,3,null,4]
       1
     /   \
    2     3
     \  
      4 

Output: "1(2()(4))(3)"

Explanation: Almost the same as the first example, 
except we can't omit the first parenthesis pair to break the one-to-one mapping relationship between the input and the output.

/**
 * 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:
    string tree2str(TreeNode* t) {
        if (t == NULL)
            return "";
        if (t -> left == NULL && t -> right == NULL)
            return to_string(t -> val);
        else if (t -> right)
            return to_string(t -> val) + "(" + tree2str(t -> left) + ")(" + tree2str(t -> right) + ")";
        else
            return to_string(t -> val) + "(" + tree2str(t -> left) + ")";
    }
};

 

---

609. Find Duplicate File in System (medium)

把内容相同的文件合并到一起

(使用stringstream)

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.

A group of duplicate files consists of at least two files that have exactly the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt ... fn.txt with content f1_content, f2_content ... fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

"directory_path/file_name.txt"

Example 1:
Input:
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
Output:  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]
Note:
No order is required for the final output.
You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
The number of files given is in the range of [1,20000].
You may assume no files or directories share the same name in the same directory.
You may assume each given directory info represents a unique directory. Directory path and file info are separated by a single blank space.
Follow-up beyond contest:
Imagine you are given a real file system, how will you search files? DFS or BFS?
If the file content is very large (GB level), how will you modify your solution?
If you can only read the file by 1kb each time, how will you modify your solution?
What is the time complexity of your modified solution? What is the most time-consuming part and memory consuming part of it? How to optimize?
How to make sure the duplicated files you find are not false positive?

class Solution {
public:
    vector<vector<string>> findDuplicate(vector<string>& paths) {
        unordered_map<string, vector<string>> mp;
        for (string path : paths) {
            stringstream ss(path);
            string dir, s;
            getline(ss, dir, ' ');
            while (getline(ss, s, ' ')) {
                int left = s.find('('), right = s.find(')');
                string fileName = s.substr(0, left);
                string content = s.substr(left + 1, right - left - 1);
                mp[content].push_back(dir + "/" + fileName);
            }
        }
        vector<vector<string>> res;
        for (auto m : mp)
            if (m.second.size() > 1)
                res.push_back(m.second);
        return res;
    }
};

 

---

632. Smallest Range (hard) #

包含所有数组中至少一个元素的最小区间

You have k lists of sorted integers in ascending order. Find the smallest range that includes at least one number from each of the k lists.

We define the range [a,b] is smaller than range [c,d] if b-a < d-c or a < c if b-a == d-c.

Example 1:
Input:[[4,10,15,24,26], [0,9,12,20], [5,18,22,30]]
Output: [20,24]
Explanation: 
List 1: [4, 10, 15, 24,26], 24 is in range [20,24].
List 2: [0, 9, 12, 20], 20 is in range [20,24].
List 3: [5, 18, 22, 30], 22 is in range [20,24].
Note:
The given list may contain duplicates, so ascending order means >= here.
1 <= k <= 3500
-105 <= value of elements <= 105.
For Java users, please note that the input type has been changed to List<List<Integer>>. And after you reset the code template, you'll see this point.

// 类似k个归并排序，priority_queue中包含所有数组中的元素，只需要每次判断最大值和最小值之间的差是不是最小。
// 重载运算符必须用struct，最小堆要用大于号。
struct smaller {
    bool operator()(pair<int, int>& a, pair<int, int>& b) {
        return a.first > b.first;
    }
};

class Solution {
public:
    vector<int> smallestRange(vector<vector<int>>& nums) {
        int m = nums.size(), pqMax = INT_MIN;
        priority_queue<pair<int, int>, vector<pair<int, int>>, smaller> pq;
        vector<int> index(m, 1);
        for (int i = 0; i < m; ++i) {
            pq.push({nums[i][0], i});
            pqMax = max(pqMax, nums[i][0]);
        }
        vector<int> res = {pq.top().first, pqMax};
        int size = res[1] - res[0];
        while (1) {
            int k = pq.top().second;
            pq.pop();
            if (index[k] == nums[k].size())
                return res;
            pqMax = max(pqMax, nums[k][index[k]]);
            pq.push({nums[k][index[k]++], k});
            if (pqMax - pq.top().first < size) {
                size = pqMax - pq.top().first;
                res = {pq.top().first, pqMax};
            }
        }
        return res;
    }
};

 

---

635. Design Log Storage System (medium)

设计log存储系统

You are given several logs that each log contains a unique id and timestamp. Timestamp is a string that has the following format: Year:Month:Day:Hour:Minute:Second, for example, 2017:01:01:23:59:59. All domains are zero-padded decimal numbers.

Design a log storage system to implement the following functions:

void Put(int id, string timestamp): Given a log's unique id and timestamp, store the log in your storage system.

int[] Retrieve(String start, String end, String granularity): Return the id of logs whose timestamps are within the range from start to end. Start and end all have the same format as timestamp. However, granularity means the time level for consideration. For example, start = "2017:01:01:23:59:59", end = "2017:01:02:23:59:59", granularity = "Day", it means that we need to find the logs within the range from Jan. 1st 2017 to Jan. 2nd 2017.

Example 1:
put(1, "2017:01:01:23:59:59");
put(2, "2017:01:01:22:59:59");
put(3, "2016:01:01:00:00:00");
retrieve("2016:01:01:01:01:01","2017:01:01:23:00:00","Year"); // return [1,2,3], because you need to return all logs within 2016 and 2017.
retrieve("2016:01:01:01:01:01","2017:01:01:23:00:00","Hour"); // return [1,2], because you need to return all logs start from 2016:01:01:01 to 2017:01:01:23, where log 3 is left outside the range.
Note:
There will be at most 300 operations of Put or Retrieve.
Year ranges from [2000,2017]. Hour ranges from [00,23].
Output for Retrieve has no order required.

#include <string>
#include <cstdio>
#include <iostream>
#include <vector>
#include <math.h> 
#include <numeric>
#include <unordered_map>
using namespace std;


class LogSystem {
public:
    LogSystem() {
        
    }
    
    void put(int id, string timestamp) {
        storage[id] = put_vector(timestamp);
    }
    
    vector<int> retrieve(string s, string e, string gra) {
        vector<int> res;
        vector<string> start = put_vector(s);
        vector<string> end = put_vector(e);
        int granularity;
        if (gra == "Year") granularity = 1;
        else if (gra == "Month") granularity = 2;
        else if (gra == "Day") granularity = 3;
        else if (gra == "Hour") granularity = 4;
        else if (gra == "Minute") granularity = 5;
        else if (gra == "Second") granularity = 6;
        for (auto st : storage) {
            bool pass = true;
            for (int i = 0; i < granularity; ++i) {
                if (st.second[i] != start[i]) {
                    pass = st.second[i] > start[i];
                    break;
                }
            }
            for (int i = 0; pass == true && i < granularity; ++i) {
                if (st.second[i] != end[i]) {
                    pass = st.second[i] < end[i];
                    break;
                }
            }
            if (pass == true) res.push_back(st.first);
        }
        return res;
    }

    vector<string> put_vector(string& timestamp) {
        vector<string> v(6);
        stringstream ss(timestamp);
        for (int i = 0; i < 6; ++i)
            getline(ss, v[i], ':');
        return v;
    }

private:
    unordered_map<int, vector<string>> storage;
};

/**
 * Your LogSystem object will be instantiated and called as such:
 * LogSystem obj = new LogSystem();
 * obj.put(id,timestamp);
 * vector<int> param_2 = obj.retrieve(s,e,gra);
 */

int main(int argc, char const *argv[])
{
    LogSystem ss;
    ss.put(4, "2004:10:25:13:49:48");
    ss.put(6, "2004:10:04:21:49:49");
    ss.put(10, "2005:01:17:23:36:39");
    vector<int> test = ss.retrieve("2004:09:23:19:31:46", "2005:10:27:16:51:21", "Year");
    cout << test[0] << endl;
    return 0;
}

 

---

647. Palindromic Substrings (medium)

 子串中有多少是回文的。

Given a string, your task is to count how many palindromic substrings in this string.

The substrings with different start indexes or end indexes are counted as different substrings even they consist of same characters.

Example 1:
Input: "abc"
Output: 3
Explanation: Three palindromic strings: "a", "b", "c".
Example 2:
Input: "aaa"
Output: 6
Explanation: Six palindromic strings: "a", "a", "a", "aa", "aa", "aaa".
Note:
The input string length won't exceed 1000.

class Solution {
public:
    int countSubstrings(string s) {
        int res = 0;
        for (int i = 0; i < s.size(); ++i) {
            valid(s, i, i, res);
            valid(s, i, i + 1, res);
        }
        return res;
    }
    void valid(string& s, int i, int j, int& cnt) {
        while (i >= 0 && j < s.size() && s[i] == s[j]) {
            ++cnt;
            --i;
            ++j;
        }
    }
};

 

---

657. Judge Route Circle (easy)

判断机器人是否走回到原点

Initially, there is a Robot at position (0, 0). Given a sequence of its moves, judge if this robot makes a circle, which means it moves back to the original place.

The move sequence is represented by a string. And each move is represent by a character. The valid robot moves are R (Right), L (Left), U (Up) and D (down). The output should be true or false representing whether the robot makes a circle.

Example 1:
Input: "UD"
Output: true
Example 2:
Input: "LL"
Output: false

class Solution {
public:
    bool judgeCircle(string moves) {
        int U = 0, L = 0;
        for (char move : moves) {
            if (move == 'U')
                ++U;
            else if (move == 'D')
                --U;
            else if (move == 'L')
                ++L;
            else if (move == 'R')
                --L;
        }
        return U == 0 && L == 0;
    }
};

 

---

678. Valid Parenthesis String (medium) #

判断string中的小括号是否匹配，'*'可以代表任意一个或空。

Given a string containing only three types of characters: '(', ')' and '*', write a function to check whether this string is valid. We define the validity of a string by these rules:

Any left parenthesis '(' must have a corresponding right parenthesis ')'.
Any right parenthesis ')' must have a corresponding left parenthesis '('.
Left parenthesis '(' must go before the corresponding right parenthesis ')'.
'*' could be treated as a single right parenthesis ')' or a single left parenthesis '(' or an empty string.
An empty string is also valid.
Example 1:
Input: "()"
Output: True
Example 2:
Input: "(*)"
Output: True
Example 3:
Input: "(*))"
Output: True
Note:
The string size will be in the range [1, 100].

// 左括号计数不再是一个值，而是一个范围
class Solution {
public:
    bool checkValidString(string s) {
        int lower = 0, upper = 0;
        for (char c : s) {
            if (c=='(') {
                lower++;
                upper++;
            }
            else if (c==')') {
                lower--;               
                upper--;
            }
            else { // * encountered
                lower--;
                upper++;
            }
            lower = max(lower, 0);
            if (upper<0) // unmatched ')' found in the middle of string
                return false;
        }
        return lower==0;
    }
};

// left和star分别记录'('和'*'的个数，最后比较'('和'*'的个数；
// 但存在'('在'*'右边的情况，因此用cnt记录'('和'*'后面的'('的个数。
class Solution {
public:
    bool checkValidString(string s) {
        int left = 0, star = 0, cnt = 0;
        for (char c : s) {
            if (c == '('){
                if (left == 0)
                    star = 0;
                ++left;
            }
            else if (c == ')') {
                if (left > 0)
                    --left;
                else if (star > 0)
                    --star;
                else
                    return false;
            }
            else
                ++star;
            cnt = c == '(' ? cnt + 1 : cnt - 1;
            cnt = max(cnt, 0);
        }
        return star >= left && cnt == 0;
    }
};

 

---

680. Valid Palindrome II (easy)

允许删除最多一个字母，判断string是否是回文

Given a non-empty string s, you may delete at most one character. Judge whether you can make it a palindrome.

Example 1:
Input: "aba"
Output: True
Example 2:
Input: "abca"
Output: True
Explanation: You could delete the character 'c'.
Note:
The string will only contain lowercase characters a-z. The maximum length of the string is 50000.

class Solution {
public:
    bool validPalindrome(string s) {
        for (int i = 0, j = s.size() - 1; i < j; ++i, --j) {
            if (s[i] != s[j])
                return valid(s, i + 1, j) || valid(s, i, j - 1);
        }
        return true;
    }
    bool valid(string s, int i, int j) {
        while (i < j) {
            if (s[i++] != s[j--])
                return false;
        }
        return true;
    }
};

 

---

696. Count Binary Substrings (easy)

0和1的个数相同的子串个数，（0或1必须连续）

Give a string s, count the number of non-empty (contiguous) substrings that have the same number of 0's and 1's, and all the 0's and all the 1's in these substrings are grouped consecutively.

Substrings that occur multiple times are counted the number of times they occur.

Example 1:
Input: "00110011"
Output: 6
Explanation: There are 6 substrings that have equal number of consecutive 1's and 0's: "0011", "01", "1100", "10", "0011", and "01".

Notice that some of these substrings repeat and are counted the number of times they occur.

Also, "00110011" is not a valid substring because all the 0's (and 1's) are not grouped together.
Example 2:
Input: "10101"
Output: 4
Explanation: There are 4 substrings: "10", "01", "10", "01" that have equal number of consecutive 1's and 0's.
Note:

s.length will be between 1 and 50,000.
s will only consist of "0" or "1" characters.

class Solution {
public:
    int countBinarySubstrings(string s) {
        int cnt1 = 1, cnt2 = 0, res = 0;
        for (int i = 0; i < s.size(); ++i) {
            for (char c = s[i]; i + 1 < s.size() && c == s[i + 1]; ++i)
                ++cnt1;
            res += min(cnt1, cnt2);
            cnt2 = cnt1;
            cnt1 = 1;
        }
        return res;
    }
};

 

 

 

 

 

p