LeetCode第六天

LeetCode第六天

只记录中高等难度的题（高等怕的很，暂时中等）

一、剑指Offer 48.最长不含重复字符的子字符串

剑指 Offer 48. 最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

暴力解法：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int max = -1;
		if (s.length() == 0) {
			max = 0;
		}
		String a = new String("");
		for (int i = 0;i < s.length();) {
			if (!a.contains(s.charAt(i)+"")) {
				a += s.charAt(i);
				i++;
			}
			else {
				for (int k = 0;k < a.length();k++) {
					if (a.charAt(k) == s.charAt(i)) {
						i = i - a.length() + 1;
						break;
					}
				}
				a = "";
			}
			if (max < a.length()) {
				max = a.length();
			}
        }
        return max;
    }
}

个人题解：

从头开始遍历字符串，用一个空字符串储存，遇到没有的就储存，遇到有的就遍历找它的位置，然后重置遍历的位置，同时更新目前的最大子字符串长度。

动态规划 + 线性遍历：

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> dic = new HashMap<>();
        int res = 0, tmp = 0;
        for(int j = 0; j < s.length(); j++) {
            int i = j - 1;
            while(i >= 0 && s.charAt(i) != s.charAt(j)) i--; // 线性查找 i
            tmp = tmp < j - i ? tmp + 1 : j - i; // dp[j - 1] -> dp[j]
            res = Math.max(res, tmp); // max(dp[j - 1], dp[j])
        }
        return res;
    }
}

题解地址：

https://leetcode.cn/problems/zui-chang-bu-han-zhong-fu-zi-fu-de-zi-zi-fu-chuan-lcof/solution/mian-shi-ti-48-zui-chang-bu-han-zhong-fu-zi-fu-d-9/

二、剑指Offer 04.二维数组中的查找

剑指 Offer 04. 二维数组中的查找

在一个 n * m 的二维数组中，每一行都按照从左到右 非递减 的顺序排序，每一列都按照从上到下 非递减 的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

示例:

现有矩阵 matrix 如下：

[
	[1,   4,  7, 11, 15],
	[2,   5,  8, 12, 19],
  	[3,   6,  9, 16, 22],
  	[10, 13, 14, 17, 24],
  	[18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

class Solution {
    public boolean findNumberIn2DArray(int[][] matrix, int target) {
        for (int i = matrix.length-1,j = 0;i >= 0 &&i < matrix.length && j >= 0 && j < matrix[0].length;) {
            if (matrix[i][j] == target) {
                return true;
            }
            if (matrix[i][j] < target) {
                j++;
            }
            else if (matrix[i][j] > target) {
                i--;
            }
        }
        return false;
    }
}

个人题解：

把矩阵当成一棵二叉树，右上角作为根节点，树中的每一个节点的右子树比节点大，左子树比节点小。

三、剑指 Offer 07. 重建二叉树

剑指 Offer 07. 重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

示例 1:

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]
示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if (preorder.length == 0) {
            return null;
        }
        else {
            TreeNode head = new TreeNode(preorder[0]);
            int k = 0;
            while (preorder[0] != inorder[k]) {
                k++;
            }
            int[] leftpreorder = new int[k];
            int[] leftinorder = new int[k];
            int[] rightpreorder = new int[preorder.length - k -1];
            int[] rightinorder = new int[preorder.length - k -1];
            for (int i = 0;i < leftpreorder.length;i++) {
                leftpreorder[i] = preorder[i+1];
                leftinorder[i] = inorder[i];
            }
            for (int i = 0;i < rightpreorder.length;i++) {
                rightpreorder[i] = preorder[i+1+leftpreorder.length];
                rightinorder[i] = inorder[i+1+leftpreorder.length];
            }
            head.left = buildTree(leftpreorder,leftinorder);
            head.right = buildTree(rightpreorder,rightinorder);
            return head;
        }
    }
}

个人题解：
递归。把左右子树的先序序列和中序序列分开，再在求解的时候再次调用函数，直到先序序列和中序序列都为空的时候表示所求的子树到了尽头。