太阳之子的力扣之路 2021-11-05

一 每日一题：最长定差子序列 （动态规划）

此题的状态转移方程比较明显，难度相对来说比较简单。
length[arr[i]] =length[arr[i]-difference]+1 或者1

class Solution {
    public int longestSubsequence(int[] arr, int difference) {
        int result=0;
        HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
        for(int i=0;i<arr.length;i++){
            /*if(map.get(arr[i]-difference)!=null){
                map.put(arr[i],map.get(arr[i]-difference)+1);
            }
            else{
                map.put(arr[i],1);
            }*/
            map.put(arr[i],map.getOrDefault(arr[i]-difference,0)+1);
            result=Math.max(result,map.get(arr[i]));
        } 
        return result;  
    }
}
时间复杂度：O(n);

二，继续双指针 题目：在排序数组中查找元素的第一个和最后一个位置

很明显，这个题目遍历一遍就可以得到答案，但是利用左右双指针二分查找的办法，可以降低时间复杂度。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int result[]=new int[2];
        if(nums.length==1&&nums[0]==target){
            result[0]=0;
            result[1]=0;
            return result;
        }
        int leftresult=0;
        int rightresult=nums.length-1;
        int left=0;
        int right=rightresult;
        while(left<=right){
            int mid=left+(right-left)/2;
            if(nums[mid]>target){
                right=mid-1;
            }
            else if(nums[mid]<target){
                left=mid+1;
            }
            else{
                leftresult=mid;
                rightresult=mid;
                while(leftresult-1>=0&&nums[leftresult-1]==target){
                    leftresult--;
                }
                while(rightresult+1<nums.length&&nums[rightresult+1]==target){
                    rightresult++;
                }
                break;
            }
        }
        if(left>right){
            result[0]=-1;
            result[1]=-1;
            return result;
        }
        result[0]=leftresult;
        result[1]=rightresult;
        return result;
    }
}
//时间复杂度：O（logn）