二分难题 && deque

public class Solution {
    /**
     * @param x: An integer
     * @return: The sqrt of x
     */
    public int sqrt(int x) {
        // write your code here
        if(x==0){
            return 0;
        }
        
        long start =1;
        long end = x;
        
        while(start+1<end){
            long mid = start+(end-start)/2;
            if(mid*mid<x){
                start = mid;
            }else{
                end = mid;
            }
        }
        
        if(end*end<=x){
            return (int)end;
        }
        
        return (int)start;
    }
}

public class Solution {
    /**
     * @param x: a double
     * @return: the square root of x
     */
    public double sqrt(double x) {
        // write your code here
        double start =0;
        //如果x<1，那么右边界=1
        double end = Math.max(1,x);
        double diff = 1e-12;
        
        while(start+diff<end){
            double mid = start +(end-start)/2;
            if(mid*mid<x){
                start = mid;
            }else{
                end = mid;
            }
        }
        
        return start;
    }
}

public class Solution {
    /*
     * @param A: An integer matrix
     * @return: The index of the peak
     */
    public List<Integer> findPeakII(int[][] A) {
        // write your code here
        if(A==null|| A.length==0|| A[0].length==0){
            return new ArrayList<>();
        }
        
        int r = A.length;
        int c = A[0].length;
        
        int low =1;
        int high = r-2;
        List<Integer> ans = new ArrayList<>();
        
        while(low<=high){
            int mid = low +(high-low)/2;
            int col = maxForEachRow(mid,A);
            if(A[mid][col]<A[mid-1][col]){
                high = mid-1;
            }else if(A[mid][col]<A[mid+1][col]){
                low = mid+1;
            }else{
                ans.add(mid);
                ans.add(col);
                break;
            }
            
        }
        
        return ans;

    }
    
    private int maxForEachRow(int row,int[][] A){
        int col = 0;
        int max = A[row][0];
        for(int i=0;i<A[row].length;i++){
            if(A[row][i]>max){
                max = A[row][i];
                col = i;
            }    
        }
        
        return col;
    }
}

public class Solution {
    /**
     * @param L: Given n pieces of wood with length L[i]
     * @param k: An integer
     * @return: The maximum length of the small pieces
     */
    public int woodCut(int[] L, int k) {
        // write your code here
        if(L==null ||L.length ==0){
            return 0;
        }
        
        int l =0;
        int r =0;
        for(int len:L){
            r= Math.max(r,len);
        }
        
        while(l+1<r){
            int mid = l+ (r-l)/2;
            if(count(mid,L)>=k){
                l = mid;
            }else{
                r = mid;
            }
        }
        
        if(count(r,L)>=k){
            return r;
        }
        
        return l;
    }
    
    public int count(int len,int[] L){
        int sum =0;
        for(int wood:L){
            sum+=wood/len;
        }
        
        return sum;
    }
}

public class Solution {
    /**
     * @param pages: an array of integers
     * @param k: An integer
     * @return: an integer
     */
    public int copyBooks(int[] pages, int k) {
        // write your code here
        if(pages==null || pages.length==0){
            return 0;
        }
        
        int start = getMaxPages(pages);
        int end = getTotalPages(pages);
        
        while(start+1<end){
            int mid = start + (end-start)/2;
            if(countPeople(pages,mid)<=k){
                end = mid;
            }else{
                start = mid;
            }
        }
        
        if(countPeople(pages,start)<=k){
            return start;
        }
        return end;
    }
    
    public int getTotalPages(int[]pages){
        int sum =0;
        for(int i =0;i<pages.length;i++){
            sum+=pages[i];
        }
        return sum;
    }
    
    public int getMaxPages(int[] pages){
        int max =0;
        for(int i=0;i<pages.length;i++){
            max = Math.max(max,pages[i]);
        }
        return max;
    }
    
    public int countPeople(int[] pages,int min){
        int count =0;
        int sum = 0;
        for(int i =0;i<pages.length;i++){
            if(sum+pages[i]>min){
                count++;
                sum = pages[i];
            }else{
                sum+=pages[i];
            }
        }
        if(sum>0){
            count++;
        }
        return count;
    }
}

public class Solution {
    /**
     * @param n: An integer
     * @param times: an array of integers
     * @return: an integer
     */
    public int copyBooksII(int n, int[] times) {
        // write your code here
        if(times==null || times.length==0){
            return 0;
        }
        
        int start = getMin(times);
        int end = start*n;
        
        while(start+1<end){
            int mid = start +(end-start)/2;
            if(canCopy(times,n,mid)){
                end = mid;
            }else{
                start = mid;
            }
        }
        
        if(canCopy(times,n,start)){
            return start;
        }
        
        return end;
        
    }
    
    public int getMin(int[] times){
        int min = Integer.MAX_VALUE;
        for(int t:times){
            min = Math.min(t,min);
        }
        return min;
    }
    
    public boolean canCopy(int[] times,int n,int time){
        int sum = 0;
        for(int t:times){
            sum += time/t;
        }
        
        return sum>=n;
    }
}

public class Solution {
    /**
     * @param dividend: the dividend
     * @param divisor: the divisor
     * @return: the result
     */
    public int divide(int dividend, int divisor) {
        // Note: 在这里必须先取long再abs，否则int的最小值abs后也是原值
        long a = Math.abs((long)dividend);
        long b = Math.abs((long)divisor);
        
        long ret =0;
         // 这里必须是= 因为相等时也可以减
        while(a>=b){
            for(long deduce = b,cnt=1;deduce<=a;deduce<<=1,cnt<<=1){
                a = a-deduce;
                ret+=cnt;
            }
        }
        
        // 获取符号位。根据除数跟被除数的关系来定
        // bug 4: out of range:
         /*
         Input:    -2147483648, -1
         Output:    -2147483648
         Expected:    2147483647
         */
         ret = ((dividend > 0) ^ (divisor > 0)) ? -ret: ret;
         //另一种写法
         //ret = ((((dividend ^ divisor) >> 31) & 1) == 1) ? -ret: ret;
         
         if (ret > Integer.MAX_VALUE || ret < Integer.MIN_VALUE) {
             return Integer.MAX_VALUE;
         } else {
             return (int)ret;
         }
    }
}

public class Solution {
    /**
     * @param nums: an array with positive and negative numbers
     * @param k: an integer
     * @return: the maximum average
     */
    public double maxAverage(int[] nums, int k) {
        // write your code here
        if(nums==null || nums.length ==0){
            return 0d;
        }
        
        double end =Double.MIN_VALUE;
        double start = Double.MAX_VALUE;
        for(int num:nums){
            end = Math.max(end,num);
            start = Math.min(start,num);
        }
        
        double diff = 1e-6;
        
        while(start+diff<end){
            double mid = start + (end-start)/2;
            if(hasAverage(nums,k,mid)){
                start = mid;
            }else{
                end = mid;
            }
        }
        
        if(hasAverage(nums,k,end)){
            return end;
        }
        
        return start;
    }
    
    public boolean hasAverage(int[] nums, int k,double aver){
        double preMin =0;
        double preSum =0;
        double sum =0;
        for(int i=0;i<k;i++){
            sum+=nums[i]-aver;
        }
        if(sum>=0){
            return true;
        }
        
        for(int i=k;i<nums.length;i++){
            preSum += nums[i-k]-aver;
            preMin= Math.min(preSum,preMin);
            sum+= nums[i]-aver;
            
            if(sum-preMin>=0){
                return true;
            }
        }
        
        return false;
    }
}

public class Solution {
    /**
     * @param nums: an array containing n + 1 integers which is between 1 and n
     * @return: the duplicate one
     */
    public int findDuplicate(int[] nums) {
        // write your code here
        int l = 1;
        int r = nums.length-1;
        
        while(l+1<r){
            int mid = l +(r-l)/2;
            if(count(nums,mid)<=mid){
                l = mid;
            }else{
                r = mid;
            }
        }
        
        if(count(nums,l)>l){return l;}
        return r;
    }
    
    //<=mid的数字个数
    private int count(int[] nums,int mid){
        int cnt =0;
        for(int item:nums){
            if(item<=mid){
                cnt++;
            }
        }
        return cnt;
    }
}

public class Solution {
    /**
     * @param nums: A list of integers.
     * @param k: An integer
     * @return: The maximum number inside the window at each moving.
     */
    public List<Integer> maxSlidingWindow(int[] nums, int k) {
        // write your code here
        List<Integer> res = new ArrayList<>();
        if(nums==null || nums.length<k){
            return res;
        }
        
        //queue中记录下标
        Deque<Integer> queue = new LinkedList<>();
        
        for(int i=0;i<nums.length;i++){
            while(!queue.isEmpty() && nums[i]>nums[queue.peekLast()]){
                queue.pollLast();
            }
            queue.offer(i);
            
            if(i>=k-1){
                res.add(nums[queue.peekFirst()]);
                if(i-k+1==queue.peekFirst()){
                    queue.pollFirst();
                }
            }
            
        }
        
        return res;
    
    }

}