2021-06-05

1.leetcode852. 山脉数组的峰顶索引

class Solution {
    public int peakIndexInMountainArray(int[] arr) {
         int l = 0 ;
        int r = arr.length - 1;
        int ans = -1;
        while ( l < r )
        {
            int mid = l + ((r-l) >> 1);
            if(arr[mid] < arr[mid+1])//下x 上坡 去左边
            {
//                ans = mid + 1;
                l = mid + 1;
            // }else if(arr[mid - 1] > arr[mid]){
            //     l = mid ;
            }else{
                r = mid;
            }
        }
        return l;
    }
}

2.leetcode1337. 矩阵中战斗力最弱的 K 行

遍历将每行第一个0的下标存在flag数组中 再将其存储在二维数组matrix里使用Arrays.sort和Comparator将其按照相等时根据行数排序 之后输出到ans中

public int[] kWeakestRows2(int[][] mat, int k) {
        int m = mat.length;//行数
        int n = mat[0].length;//列数
        int[] flag = new int[m];
        for (int i = 0; i < m ;i++) {
            int j = 0;
            while (j <n && mat[i][j] != 0)
            {
                j++;
            }
            flag[i] = j;
        }

        int[][] matrix = new int[m][2];
        for (int i = 0; i < m; i++) {

            matrix[i][0] = i;
            matrix[i][1] = flag[i];
        }
        Arrays.sort(matrix, (a, b) -> a[1] == b[1] ? a[0] - b[0] : a[1] - b[1]);
      
        int[] ans = new int[k];
        for (int i = 0; i < k; i++) {
            ans[i] = matrix[i][0];
        }
        return ans;
    }

遍历的过程可以使用二分简化

    public int[] kWeakestRows(int[][] mat, int k) {
        int m = mat.length;//行数
        int n = mat[0].length;//列数
 
        int[][] matrix = new int[m][2];
        for (int i = 0; i < m; i++) {

            matrix[i][0] = i;
            matrix[i][1] = binarySearch(mat[i]);
        }


        Arrays.sort(matrix, (a, b) -> a[1] == b[1] ? a[0] - b[0] : a[1] - b[1]);
   
        int[] ans = new int[k];

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

    public static int binarySearch(int[] arr) {
        //第一个就是平民直接返回
        if (arr[0] == 0) {
            return 0;
        }
        int left = 0, right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            //是平民 且上一个是军人
            if (arr[mid] == 0 && arr[mid - 1] == 1) {
                return mid;
            } else if (arr[mid] > 0) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return arr.length;
    }

3.leetcode605. 种花问题

分情况讨论

• 在两朵花之间种
  假设左右两朵花分别位于i、j位置 那么起码他们之间要有三个及三个位置以上才能种花，即 j-i>= 4 那么可以种花的位置就有p = j-i-3个 当p为奇数最多可以种( p+1 ) / 2 当p为偶数最多可以种p / 2 个 整数触发1会弃掉 所以这种情况可以种j-i-2朵花

• 在最左边的花左边种
  l/2

• 在最右边的花右边种
  m-r-1

class Solution {
    public boolean canPlaceFlowers(int[] flowerbed, int n) {
        int count = 0;
        int m = flowerbed.length;
        int prev = -1;
        for (int i = 0; i < m; i++) {
            if(flowerbed[i] == 1)
            {
                if(prev < 0)
                {
                    count += i/2;
                }else{
                    count += (i - prev - 2 )  /  2;
                }
                prev = i;
            }
        }
        if(prev < 0)//完全没种 全是0
        {
            count += (m+1)/2;
        }else {
            count += (m - prev - 1 ) / 2 ;
        }
        return count >= n;
    }
}

4.leetcode189. 旋转数组

首先不考虑空间复杂度的解法

class Solution {
    public void rotate(int[] nums, int k) {
         int[] help = new int[nums.length];
        
        
        for (int i = 0; i < nums.length; i++) {
            help[(i+k)%nums.length] = nums[i];
        }

        for (int i = 0; i < nums.length; i++) {
            nums[i] = help[i];
        }
    }
}

使用额外变量

    public void rotate2(int[] nums, int k) {

//        int help;
        int n = nums.length;
        k = k % n;
        int count = gcd(k, n);
        for (int start = 0; start < count; start++) {
//            int prev = nums[];
//
//            help = nums[i] ;
//            nums[(i+k)%nums.length] = help;
//            help
            int current = start;//目前交换的值
            int prev = nums[start];//之前的值
            do {
                int next = (current + k ) % n ;
                int temp = nums[next];
                nums[next] = prev;
                prev = temp;
                current = next;
            }while (start != current);

        }
    }
    public int gcd(int x, int y) {
        return y > 0 ? gcd(y, x % y) : x;
    }

5.leetcode122. 买卖股票的最佳时机 II

class Solution {
    public int maxProfit(int[] prices) {
             int pointer =  0 ;
        int sum = 0;
        while (pointer < prices.length - 1)
        {
            int next = pointer + 1;
            if(prices[next] >= prices[pointer])
            {
                sum += prices[next] - prices[pointer];
                pointer++;
            }else {
                pointer++;
            }
        }
        return sum;
    }
}

6.leetcode455. 分发饼干

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int sum = 0;
        Arrays.sort(g);
        Arrays.sort(s);
        // Integer[] s2 =new Integer[s.length];
//        Arrays.sort(s2, Collections.reverseOrder());
//        Arrays.sort(s2, (a,b)->b-a);
        // for (int i = 0; i < s.length; i++) {
        //     s[i] = s2[i];
        // }
        int j = 0;
        for (int i = 0; i < g.length&&j < s.length; i++) {//for越界条件只有一个
//            for (int j = 0; j < s.length; j++) {

//            if( j < s.length  && g[i] <= s[j])
//            {
//                sum++;
//                // j++;
//            }
                //i要一直等到s[j]的值>= 它
            while (j < s.length && g[i] > s[j])
            {
                j++;
            }
            if(j < s.length)
            {
                sum++;
            }
            j++;
        }
        return sum;
    }
}

7.leetcode921使括号有效的最少添加

public int minAddToMakeValid(String s) {
        char[] chars = s.toCharArray();
        int count = 0;
        int i = 0;
        while ( i < chars.length && chars[i] != '(' ) {
            i++;
        }
        count += i;
//        if(i!=0)
//            count++;

        int leftCount = 0;
        while ( i < chars.length){
            if (chars[i] == '(')
                leftCount++;
            if (chars[i] == ')')
                if(leftCount <= 0){
                    count++;
                }else {
                    leftCount--;
                }
        }
        return count+leftCount;
    }

8.leetcode714. 买卖股票的最佳时机含手续费

  public int maxProfit(int[] prices, int fee) {
        int buy = prices[0] + fee;
        int profit = 0;
        for (int i = 0; i < prices.length; i++) {
            if(buy > prices[i] + fee){
                buy = prices[i] + fee;
            } else if(prices[i] > buy)
            {
                profit += prices[i] - buy;
                buy = prices[i];
            }
        }
        return profit;
    }
    ```