一些leetcode算法题

Posted 2020-10-11 爱简单的Paul

DFS算法
思想：一直往深处走，直到找到解或者走不下去为止
DFS(dep,...) // dep代表目前DFS的深度
{
    if (找到解或者走不下去了){
       return;
    }
    枚举下种情况，DFS(dep + 1, ...)
}

DFS: 使用栈保存未被检测的节点，结点按照深度优先的次序被访问并依次压入栈中，并以相反的次序出栈进行新的检测
     类似于树的先根遍历，深搜的例子：走迷宫，没有办法用分身术来站在每一个走过的位置。
例子：
leetcode 394  

class Solution {
public:
     string DFS(string s, int &k){  // 在所有的层中是维护一个共同的索引值k
        string ans;  
        int cnt = 0; 
        while(k < s.size())  
        {  
            if(isdigit(s[k])){     // 判断是否是数字
                cnt = cnt * 10 + s[k++]-‘0‘;    //  如果是遇到100这样的数字，那么则需要这样处理
            }  
            else if(s[k]==‘[‘){  // 如果是左括号，则要进入下层递归
                string tem = DFS(s, ++k);      // 递归调用
                for(int i = 0; i < cnt; i++){
                     ans += tem; 
                } 
                cnt = 0;        // 
            }  
            else if(s[k]==‘]‘){  
                k++;  
                return ans;  
            }  
            else ans += s[k++];  // 若是普通数字就直接加上
        }  
        return ans;  
    }  
      
    string decodeString(string s){
        string res;
        int k = 0;
        return DFS(s, k);
    }
};



leetcode 467 Unique Substring in Wraparounding string

思路：这道题说有一个无限长的封装字符串，然后又给了我们另一
个字符串p，问我们p有多少非空子字符串在封装字符串中。我们通过
观察题目中的例子可以发现，由于封装字符串是26个字符按顺序无限
循环组成的，那么满足题意的p的子字符串要么是单一的字符，要么是
按字母顺序的子字符串。这道题遍历p的所有子字符串会TLE，因为如
果p很大的话，子字符串很多，会有大量的满足题意的重复子字符串，
必须要用到trick，而所谓技巧就是一般来说你想不到的方法。我们看
abcd这个字符串，以d结尾的子字符串有abcd, bcd, cd, d，那么我们
可以发现bcd或者cd这些以d结尾的字符串的子字符串都包含在abcd中，
那么我们知道以某个字符结束的最大字符串包含其他以该字符结束的字符
串的所有子字符串，说起来很拗口，但是理解了我上面举的例子就行。
那么题目就可以转换为分别求出以每个字符(a-z)为结束字符的最长连续
字符串就行了，我们用一个数组cnt记录下来，最后再求出数组cnt的所有
数字之和就是我们要的结果啦

class Solution {
public:
    int findSubstringInWraproundString(string p) { // 很有技巧的一个题
         vector<int> cnt(26, 0);    // 对应26个字母，注意vector的初始化
        int len = 0;
        for (int i = 0; i < p.size(); ++i) {
            if (i > 0 && (p[i] == p[i - 1] + 1 || p[i - 1] - p[i] == 25)) {
                ++len;
            } 
            else {
                len = 1;   // 若是不再连续就将len置1重新开始
            }
            cnt[p[i] - ‘a‘] = max(cnt[p[i] - ‘a‘], len);  // 用len的值更新cnt的值
        }
        return accumulate(cnt.begin(), cnt.end(), 0);    // 将cnt的所有的值累加起来
    }
};


leetcode 647. Palindromic Substrings 回文字串

题目：
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".

思路一：dp思想
参考链接：http://blog.csdn.net/lishichengyan/article/details/77103324
定义d[i][j]：若从i到j的字符串为回文，则为真（1），否则为假（0），那么d[i][j]为真的前提是：头尾两个字符串相同并且去掉头尾以后的字串也是
回文（即d[i+1][j-1]为真），这里面要注意特殊情况，即：去掉头尾以后为空串，所以如果j-i<3，并且头尾相等，也是回文的。

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size(), count = 0;
        vector<vector<int>> dp(n, vector<int> (n));   //二维vector初始化，打表
        for ( int end = 0; end < n; ++end ) {
            dp[end][end] = 1;                         // 每一个字符都是一个回文
            ++count;                         
            for ( int start = 0; start < end; ++start ) {
                if ( s[start] == s[end] && (start+1 >= end-1 || dp[start+1][end-1])) {
                    dp[start][end] = 1;
                    ++count;         // 有一个为真那么结果值就加一
                }
            }
        }
        return count;
    }
};

题意是给你一个字符串，求它有多少个回文子串。注意回文子字符串有奇数和偶数两种形式，1，奇数
以字符串每一个字符为回文中心，然后向两边扩散，求以每个中心获得的回文子串个数，然后加起来。
2. 偶数。把每个i位置作为最中间两个字符的左边那个，即i,i+1两个数是回文中心。把奇数和偶数的情况加起来就是
结果
思路二： 使用从 中心向外扩展的方法，注意回文的字符串个数为奇数或者偶数的时候

class Solution {
public:
    int helper(string s, int start, int end){
        int res = 0;
        int len = s.size();
        while (start >= 0 && end <= len && s[start] == s[end]){
            res++;
            start--;
            end++;
        }
        return res;
    }
    int countSubstrings(string s) {
        int len = s.size(), cnt = 0;
        for (int i = 0; i < len; i++){
            cnt += helper(s, i, i);   // 回文为奇数的时候
            cnt += helper(s, i, i + 1); // 回文为偶数的时候
        }
        return cnt;
    }
};

Leetcode 682. Baseball Game

You‘re now a baseball game point recorder.

Given a list of strings, each string can be one of the 4 following types:

Integer (one round‘s score): Directly represents the number of points you get in this round.
"+" (one round‘s score): Represents that the points you get in this round are the sum of the last two valid round‘s points.
"D" (one round‘s score): Represents that the points you get in this round are the doubled data of the last valid round‘s points.
"C" (an operation, which isn‘t a round‘s score): Represents the last valid round‘s points you get were invalid and should be removed.
Each round‘s operation is permanent and could have an impact on the round before and the round after.

You need to return the sum of the points you could get in all the rounds.

Example 1:
Input: ["5","2","C","D","+"]
Output: 30
Explanation: 
Round 1: You could get 5 points. The sum is: 5.
Round 2: You could get 2 points. The sum is: 7.
Operation 1: The round 2‘s data was invalid. The sum is: 5.  
Round 3: You could get 10 points (the round 2‘s data has been removed). The sum is: 15.
Round 4: You could get 5 + 10 = 15 points. The sum is: 30.

Example 2:
Input: ["5","-2","4","C","D","9","+","+"]
Output: 27
Explanation: 
Round 1: You could get 5 points. The sum is: 5.
Round 2: You could get -2 points. The sum is: 3.
Round 3: You could get 4 points. The sum is: 7.
Operation 1: The round 3‘s data is invalid. The sum is: 3.  
Round 4: You could get -4 points (the round 3‘s data has been removed). The sum is: -1.
Round 5: You could get 9 points. The sum is: 8.
Round 6: You could get -4 + 9 = 5 points. The sum is 13.
Round 7: You could get 9 + 5 = 14 points. The sum is 27.

Solution:

class Solution {
public:
    int calPoints(vector<string>& ops) {
        int res = 0;
        int len = ops.size();
        vector<int> data; 
        for (int i = 0; i < len; i++){
           if (ops[i] == "C"){
               int tmp1 = data.back();
               data.pop_back();
               res -= tmp1;
           }else if(ops[i] == "D"){
               int tmp0 = 2 * data.back();
               data.push_back(tmp0);
               res += tmp0;
           }else if (ops[i] == "+"){
               int tmp2 = data.back();
               int tmp3 = data[data.size() - 2];
               data.push_back(tmp2 + tmp3);
               res += (tmp2 + tmp3);
           }else{
               int tmp = stoi(ops[i]);
               data.push_back(tmp);
               res += tmp;
           }
            
        }
        return res;
    }
};

leetcode 3. Longest Substring Without Repeating Characters
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.

最笨的方法：o(n^2):
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int res = 0, maxtmp;
        set<char> substr;
        int len = s.size();
        if (len == 1){
            res  = 1;
            return res;
        }
        for (int i = 0; i < len; i++){
            substr.insert(s[i]);
            maxtmp = 1;
            for (int j = i + 1; j < len; j++){
                if (substr.find(s[j]) != substr.end()){
                    break;
                }
                else{ 
                    substr.insert(s[j]);
                    maxtmp++;
                }
            }
            substr.clear();
            res = max(res, maxtmp);
        }
        return res;
    }
};

Leetcode 257. Binary Tree Paths

Given a binary tree, return all root-to-leaf paths.

For example, given the following binary tree:

   1
 /   2     3
   5
All root-to-leaf paths are:

["1->2->5", "1->3"]

/**
 * 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:
    void helper(TreeNode* root, string path, vector<string> &result){
        if (!root->left && !root -> right){               // 注意这里判断的条件是叶子节点的时候
            result.push_back(path);
            return;
        }
        
        if (root -> left){
            helper(root -> left, path + "->" + to_string(root->left->val), result);
        }
        if (root -> right){
            helper(root -> right, path + "->" + to_string(root->right->val), result);
        }  
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        if (!root){
            return result;
        }
        helper(root, to_string(root->val), result);
        return result;
    }
};