2021-05-29LC “阿里题库” 33. 搜索旋转排序数组 11. 盛最多水的容器 46. 全排列

/*因为要求时间复杂度为O(logn)，空间复杂度O(1)因为我们可以直接想到二分查找法
二分查找法就是找中间值，然后让目标值和中心值所在的元素值比较
但是这个数组不是有序的，或许说部分有序的，一个数组分成两个有序的部分
-------------------------------------------------------------------------------------------
注意：二分查找的核心思想！！！！！！！！！！！！！！！！
找中间值mid，然后和target比较，但是前提是数组有序！！！！！！！！！！
当数组不有序时！！！！！我们需要判断mid在哪个有序的子数组中,以及while(l<=r)不是while(l<r)
*/
class Solution {
    public int search(int[] nums, int target) {
        int n = nums.length;
        if(n == 0)
            return -1;
        if(n == 1)
            return nums[0] == target ? 0  : -1;
        //数组大于等于，我们进行搜索
        int l = 0 , r = n - 1;
        while(l <= r){
            //找中间值
            int mid = (l+r)/2;
            //然后target和nums[mid]比较
            //首先相等的情况
            if(nums[mid] == target){
                return mid;
            }
            //因为我们这个数组是两个有序小数组，所以先判断nums[mid]在哪一个有序数组，然后进一步用二分查找法
            if(nums[0] > nums[mid]){ //判断在第二个序列然后用target和其比较
                if(nums[mid]<target && target <= nums[n-1]){
                    l = mid + 1; 
                }else{
                    r = mid - 1;
                }
            }else{
                if(target < nums[mid] && target>=nums[0]){
                    r = mid - 1;
                }else{
                    l = mid + 1;
                }
            }
        }
        return -1;
    }
}

//第一种方法，双重for循环，我记得会超时，所以不再写
/*
通过左右指针判断，通过一个变量存储水的面记 areaMax = Integer.MIN_VALUE
然后做右指针记录数值，往里面遍历，如果高变大了我们重新求面积，如果没有变大，则直接略过
时间复杂度O(n) 空间复杂度O(1)
*/
class Solution {
    public int maxArea(int[] height) {
        int l = 0 , r  = height.length-1;
        int maxArea = (r-l) * Math.min(height[l] , height[r]);
        while(l<r){
            if(height[l]<height[r]){
                l++;
            }else{
                r--;
            }
            maxArea = Math.max(maxArea , (r-l)*Math.min(height[l],height[r]));
        }
        return maxArea;
    }
}

//优化算法
class Solution {
    public int maxArea(int[] height) {
        int l = 0 , r  = height.length-1 ,  maxArea = 0;
        while(l<r){
           maxArea = height[l] > height[r] ?  Math.max(maxArea , (r-l)*height[r--]) : Math.max(maxArea , (r-l)*height[l++]);
        }
        return maxArea;
    }
}

//“回溯法”+dfs，我们要找出所有的排列，所以要用到“回溯法”思想，相应的用dfs
class Solution {
    public List<List<Integer>> permute(int[] nums) {
        //求数组长度
        int len = nums.length;  //因为题目中给了长度限制，可知不会为0
        //设返回的数组
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        //每一次求得的数组，用队列表示
        Deque<Integer> path = new ArrayDeque<>(len);
        //通过标识符进行判断
        boolean[] isUsed = new boolean[len];
        //然后进行dfs
        dfs(res , path , nums , isUsed , 0 , len);
        return res;
    }
    public void dfs(List<List<Integer>> list , Deque<Integer> path ,int[] nums, boolean[] isUsed ,int depth , int len){
        if(depth==len){
            list.add(new ArrayList<Integer>(path));
            return;
        }
        for(int i=0 ; i<len ; i++){
            if(!isUsed[i]){
                path.addLast(nums[i]);
                isUsed[i] = true;
                dfs(list , path , nums , isUsed , depth+1 , len);
                isUsed[i] = false;
                path.removeLast();
            }
        }
    }
}