二分查找变形（查找无序数组的峰值）

二分查找无序数组的峰值

162. 寻找峰值

​

class Solution {
    /**
    寻找峰值
     */
            
    public int findPeakElement(int[] nums) {
        int res = Integer.MIN_VALUE;

        int len = nums.length;

        // 边界条件
        if(len == 1){
            return 0;
        }
        // 查找算法
        
        return binarySearch(0,len-1,nums);

    }
    /**
    二分法
    就是去找最大值

    如果 [mid] <[mid+1]   选择向右的方向  寻找最大值 left = mid +1
    如果 [mid] >[mid+1]   选择向左的方向  寻找最大值 right = mid
    
     */

    public int binarySearch(int left,int right,int nums[]){

        while(left<right){
            int mid = (left+right)/2;
            // [low.... mid....high]
            if(nums[mid]>nums[mid+1]){
                // [low.... mid. mid+1...high]
                //向左寻找最大值
                right = mid;
            }else{
                //这个是小于的情况 [low.... mid. mid+1...high]
                //就沿着向后找一个最大的，就是我不管前面有没有最大的
                left = mid+1;
            }
        }
        return left;
        
    }

}

678. 有效的括号字符串

​ 难点在于*可以被看做)或者( 或者一般字符。

​ 贪心算法，以left“(”的数量为切入点。

class Solution {
    /**
    “（”作为入手点，“*”可以为“（”
    因此 可以设置两个变量 maxleft 和 minleft  

    如果发现
     */
    public boolean checkValidString(String s) {
        char[] cs = s.toCharArray();

        int maxleft = 0;
        int minleft = 0;

        for(char c:cs){
            if(c =='('){
                //得到一个left
                minleft++;
                maxleft++;
            }else if(c ==')'){
                maxleft--;
                minleft = Math.max(minleft-1,0);
                if(maxleft<0){
                    return false;
                }
            }else{
                // 如果为“*”那么默认和一个left抵消，或者默认为一个left
                minleft = Math.max(minleft-1,0);
                maxleft++;
            }
        }     

        if(minleft ==0) return true;

        return false;

    }
}

1894. 找到需要补充粉笔的学生编号

执行用时：2 ms, 在所有 Java 提交中击败了59.65%的用户

内存消耗：54.2 MB, 在所有 Java 提交中击败了67.70%的用户

class Solution {
    /**
    
     */
    public int chalkReplacer(int[] chalk, int k) {
        
        long sum=0;
        

        for(int chal:chalk){
            sum+=chal;
        }

        long temp = k%sum;
        if(temp==0) return 0;

        for(int i =0;i<chalk.length;i++){
            if(temp<chalk[i]){
                return i;
            }
            temp -= chalk[i];
        }
        return -1;

    }
}

剑指 Offer 40. 最小的k个数

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {

        int[] res = new int[k];

        Arrays.sort(arr);

        for(int i = 0;i<k;i++){
            res[i] = arr[i];
        }
        return res;

    }
}

手写快排

class Solution {
    /**
    如果面试的话，给30分钟的应该手写快排
     */

    int[] arr;
    public int[] getLeastNumbers(int[] arr, int k) {
        int[] res = new int[k];
        this.arr = arr;

        int len = arr.length;

        quickSort(0,len-1);

        for(int i = 0;i<k;i++){
            res[i] = arr[i];
        }
        return res;
        

    }
    public void quickSort(int left,int right){

        if(left<right){
            int partitionIndex = patition(left,right);
            quickSort(left,partitionIndex-1);
            quickSort(partitionIndex+1,right);
        }

    }
    public void swap(int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    //实现分治思想      就是小于selectNum的数放到左边
    //{{小于选取值的数},arr[pivot],{大于选取的数}}
    public int patition(int low,int high){
        int pivot = low;
        int index = low+1;

        for(int i= index;i<=high;i++){
            //找到就放到次最左边
            if(arr[i]<arr[pivot]){
                swap(i,index);
                index++;
            }
        }
        //最后放到中间区域 为index-1;
        swap(pivot,index-1);

        return index -1;



    }
}

leetcode周赛（前两道刷过了）

2000. 反转单词前缀

​ 简单题没有碰到问题，不过翻转算法思考时间过长。

class Solution {
    /*
    "abcdefd"
    "dbcaefd"
    "dcbaefd"
    "dcbaefd"
    */
    char[] cs;
    public String reversePrefix(String word, char ch) {
        this.cs = word.toCharArray();
        //边界条件，找是否存在
        int index = findIndex(ch);
        if(index==-1)return word;
        
        //翻转字符串
        
        int i =0,j = index;
        while(j>0&&i<j){
            swap(i,j);
            i++;
            j--;
        }
        
        String res = new String(cs);
        
        return res;
        

    }
    
    public int findIndex(char ch){
        int index = -1;
        
        for(int i = 0;i<cs.length;i++){
            if(cs[i] == ch){
                return i;
            }
        }
        
        
        return index;
    }
    
    public void swap(int i,int j){
        
        char temp = cs[i];
        cs[i] = cs[j];
        cs[j] = temp;
                
        
    }
}

5868. 可互换矩形的组数

​ 解题思路没有问题，但是在数据类型上花费了太多时间，调整好刷题心态，多参加力扣周赛！！！

执行用时: 42 ms

内存消耗: 85.6 MB

class Solution {
    /*
    n = 3,3 = 3*2/2
    n = 4,6 = 4*3/2
    */
    public long interchangeableRectangles(int[][] rectangles) {
        
        long res =0;
        
        Map<Double,Long> map = new HashMap<>();
        
        for(int[] rectangle:rectangles){
            double temp1 = rectangle[0];
            double temp2 = rectangle[1];
            double temp = temp1/temp2;
            
            Long in = map.get(temp);
            
            if(in == null){
                map.put(temp,(long)1);
            }else{
                map.put(temp,(long)(in+1));
            }  
        }
        
        //遍历map 求res
        for(Map.Entry<Double,Long> entry:map.entrySet()){
            long n = entry.getValue();
            if(n!=1){
                long count = n*(n-1);   
                res+=(count/2);
            }
      
        }
        
        return res;

    }
}