LeetCode(字节10日)-0715

41. 缺失的第一个正数（困难）

思路：利用原有数组空间完成哈希，同时又不丢失原有数据。正常情况下，长度为 n 的数组中会存放 1-n 这 n 和数字，则下一个会是 n+1；如果有大于n 的数字存在，则保留；负数则会打成 n+1

标记的方式：对于出现了数字 n，会将 n-1 下标的数取相反数，这样既不影响原本数据的存储，又进行了哈希映射

class Solution {
    public int firstMissingPositive(int[] nums) {
        
        int n = nums.length;

        //  处理负数
        for(int i=0;i<n;i++)if(nums[i]<=0)nums[i] = n + 1;
        
        //  哈希标记
        for(int i=0;i<n;i++){
            int num = Math.abs(nums[i]);
            if(num<=n)nums[num-1] = - Math.abs(nums[num-1]);
        }

        //  一旦有一个大于 n 的数存在，则一定会有一个小于 n 的缺失，如果所有 1-n 都不缺失，则就是 n+1
        for(int i=0;i<n;i++)if(nums[i]>0)return i+1;

        return n+1;

    }
}

32. 最长有效括号(困难)

思路：一维 dp，对已经匹配成功的括号状态转移

class Solution {
    public int longestValidParentheses(String s) {
        
        int n = s.length();
        if(n==0)return 0;
        int dp[] = new int[n];
        dp[0] = 0;
        int max = 0;

        for(int i=1;i<n;i++){
            if(s.charAt(i)==')'){
                if(s.charAt(i-1)=='(')dp[i] = i-2>=0?dp[i-2]+2:2;
                
                else if(i-dp[i-1]-1 >=0 && s.charAt(i-dp[i-1]-1) == '('){  
                    dp[i] = i-dp[i-1]-2>=0?dp[i-dp[i-1]-2]+dp[i-1]+2:dp[i-1]+2;
                }

            }else dp[i] = 0;
            if(dp[i]>max)max = dp[i];
        }

        return max;
    }
}

977. 有序数组的平方(简单)

要求：O(n)时间复杂度，就是不能排序去做

思路：利用绝对值最小去找。

class Solution {
    public int[] sortedSquares(int[] nums) {

        int n = nums.length;
        int res[] = new int[n];
        int minid = 0;
        int it = 0;

        for(int i=0;i<n;i++)if(Math.abs(nums[i])<Math.abs(nums[minid]))minid = i;
        res[it++] = nums[minid]*nums[minid];

        int left = minid-1;
        int right = minid+1;
        while(left>=0&&right<n){
            if(Math.abs(nums[left])<Math.abs(nums[right])){
                res[it++] = nums[left]*nums[left];
                left--;
            }else{
                res[it++] = nums[right]*nums[right];
                right++;
            }
        }
        while(left>=0){
                res[it++] = nums[left]*nums[left];
                left--;
        }

        while(right<n){
                res[it++] = nums[right]*nums[right];
                right++;
        }
        

        return res;
    }
}