leedcode刷题--day8

28 最长回文子串

采用动态规划的方式

1. 首先如果子串长度为1的话，一定是回文子串
2. 如果子串长度为2，那如果第一个字母=第二个字母，即为回文子串
3. 如果bababd中babab为回文子串，那么除去左边界和右边界后的也是回文子串

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        n = len(s)
        if n < 2:
            return s
        
        max_len = 1
        begin = 0

    # 数组
        dp = [[False] * n for _ in range(n)]
    # 如果 i=i 一定是
        for i in range(n):
            dp[i][i] = True
    
        for L in range(2, n+1): #L表示当前回文子串长度
            for i in range(n): #当前的索引
                j = L + i - 1 #终止索引

                if j >= n:
                    break
                if s[i] != s[j]:
                    dp[i][j] = False
                else:
                    if j - i < 2:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i+1][j-1]  
                if dp[i][j] and j - i + 1 > max_len:
                    max_len = j - i + 1
                    begin = i
        return s[begin:begin+max_len]

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.length();
        if(n<2){
            return s;
        }
        int maxLen = 1;
        int begin = 0;
        vector<vector<int>>dp(n,vector<int>(n));

        for (int i = 0;i<n;i++){
            dp[i][i]=true;
        }

        for (int L = 2;L<=n;L++){
            for (int i=0;i<n;i++){
                int j = L+i-1;
                if(j>=n){
                    break;
                }
                if(s[i]!=s[j]){
                    dp[i][j]=false;
                }else{
                    if(j-i<3){
                        dp[i][j]=true;
                    }
                    else{
                        dp[i][j] = dp[i+1][j-1];
                    }
                  
                }
            
            if (dp[i][j] && (j-i+1)>maxLen){
                maxLen = j-i+1;
                begin =i;
            }
        }
    }
    return s.substr(begin,maxLen);
    }
};

29 二叉树

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> Optional[TreeNode]:
        #当前序遍历的左边界大于右边界时，说明当前子树为空，直接返回 None
        def myBuildTree(preorder_left:int,preorder_right:int,inorder_left:int,inorder_right:int):
            if preorder_left>preorder_right:
                return None 
            #前序遍历第一个节点即为根节点
            preorder_root = preorder_left
            #在中序遍历中定位根节点
            inorder_root = index[preorder[preorder_root]]

            #先把根节点建立出来
            root = TreeNode(preorder[preorder_root])
            #得到左子树节点数目
            size_left_subtree = inorder_root-inorder_left
            #递归构造左子树，并连接到根结点
            root.left = myBuildTree(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
            root.right = myBuildTree(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)

            return root

        n = len(preorder)
        index = {element: i for i,element in enumerate(inorder)}
        return myBuildTree(0,n-1,0,n-1)

1. 首先，先序遍历是中左右，中序是左中右
2. 然后根结点是先序的第一个，中序得到根节点的位置，然后看根节点左边和右边各几个节点。
3. 建立二叉树

class Solution {
private:
    unordered_map<int, int> index;

public:
    TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return nullptr;
        }
        
        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = index[preorder[preorder_root]];
        
        // 先把根节点建立出来
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        // 构造哈希映射，帮助我们快速定位根节点
        for (int i = 0; i < n; ++i) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
};

30 无重复字符的最长子串

要找出一个字符串中不含重复字符的最长子串的长度，可以使用滑动窗口算法。具体步骤如下：

1. 定义一个哈希表 char_index_map 用来存储字符及其在字符串中最后出现的位置。
2. 使用双指针 left 和 right 表示滑动窗口的左右边界，初始时两者都指向字符串开头。
3. 不断移动右指针 right，同时更新哈希表中字符的最新位置。
4. 如果发现当前字符在哈希表中已经存在，说明出现了重复字符，需要移动左指针 left 到重复字符的下一个位置。
5. 在移动过程中不断更新最长子串的长度。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        char_index_map={}
        max_length = 0
        left = 0
        #这里是字典，就是存储字符和它的位置
        for right in range(len(s)):
        #如果当前字符在char_index_map中，说明遇到了重复字符
            if s[right] in char_index_map:
                left = max(left,char_index_map[s[right]]+1)
            char_index_map[s[right]] = right
            max_length = max(max_length,right-left+1)
        return max_length