每日算法刷题小结9.19

 思路：用一个pre数组保存字符前一次出现的位置，使用滑动窗口的思想，在遍历到一个字符前一次出现的位置大于left左窗口时，维护左窗口，并一直更新pre数组，维护最大的数据

public int lengthOfLongestSubstring(String s) {
        if(s.length()==0||s.length()==1) return s.length();
        char[] arr=s.toCharArray();
        int left=0;
        int right=1;
        int[] pre=new int[130];
        pre[arr[0]]=1;
        int max=0;
        while(right<arr.length){
            
            if(pre[arr[right]]>=left){
                left=pre[arr[right]];
                
            }
            pre[arr[right]]=right+1;
            max=Math.max(max,right-left+1);
           
            right++;
        }
        return max;
    }
}

 思路：单一个字符就是回文子串，当一个回文子串左边的和右边的字符相等时，那这个子串可以向两边扩展，因此使用dp数组来记录是否是回文子串，dp[i][j]：从i到j的字符串是否是回文子串，维护dp数组有以下规则：

i==j dp[i][j]=true,就是一个字符就是回文

arr[i]==arr[j]: j-i<3,dp[i][j]=true，就是aa这种情况

                      dp[i][j]=dp[i+1][j-1],就是向里面缩，因为字符相同，所以里面的是回文这个也是回文

class Solution {
    public  String longestPalindrome(String s) {
    //边界条件判断
    if (s.length() < 2)
        return s;
    //start表示最长回文串开始的位置，
    //maxLen表示最长回文串的长度
    int start = 0, maxLen = 1;
    int length = s.length();
    boolean[][] dp = new boolean[length][length];
    for (int right = 1; right < length; right++) {
        for (int left = 0; left < right; left++) {
            //如果两种字符不相同，肯定不能构成回文子串
            if (s.charAt(left) != s.charAt(right))
                continue;

            //下面是s.charAt(left)和s.charAt(right)两个
            //字符相同情况下的判断
            //如果只有一个字符，肯定是回文子串
            if (right == left) {
                dp[left][right] = true;
            } else if (right - left <= 2) {
                //类似于"aa"和"aba"，也是回文子串
                dp[left][right] = true;
            } else {
                //类似于"a******a"，要判断他是否是回文子串，只需要
                //判断"******"是否是回文子串即可
                dp[left][right] = dp[left + 1][right - 1];
            }
            //如果字符串从left到right是回文子串，只需要保存最长的即可
            if (dp[left][right] && right - left + 1 > maxLen) {
                maxLen = right - left + 1;
                start = left;
            }
        }
    }
    //截取最长的回文子串
    return s.substring(start, start + maxLen);
}
}

 代码很简短，但是细节较多，总体思想就是维护一个最小值和一个第二小值，如果数字大于第二小值就是存在，但是要注意维护第二小值的前提是第一小值存在，先维护最小，在维护第二小，一个数字只能决定一种，结合代码好好理解

class Solution {
    public boolean increasingTriplet(int[] nums) {
        if(nums.length<3) return false;
        int min=Integer.MAX_VALUE;//最小值
        int mid=Integer.MAX_VALUE;//第二小值
        for(int num:nums){
            if(num<=min){
                min=num;
            }
            else if(num<=mid){
                mid=num;
            }
            else return true;
        }
        return false;
    }
}