摘水果(回溯or二分法)

力扣原题，java求解

 

解法一：回溯递归解决问题

思路：

已知路径上有n个水果，水果位置索引为{0, 1, ..., n-1}，假设人的位置索引为cur，表示人在第cur个水果的左侧，或startPos刚好和第cur个水果位置重合，若所有水果都在人的右侧，则人的位置索引为cur = n。

若cur=n则表示人只能向左走才能摘水果；

若cur=0则表示人只有向右走才能摘水果；

若cur为其他值，则表示，人既可以向左走摘水果，又可以向右走摘水果。

人摘水果的路线，要么是一直向一个方向走，要么是先向一个方向走，然后再向反方向走摘水果。

故而对于人而言，每走一步后，下一步都有两个选择，需要分别考虑两种情况，此处采用回溯递归的思路解决问题。

注：当问题规模较大时，此方法会超时

class Solution {
    
    int ini = 0;
    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
        int n = fruits.length;
        ini = k;
        int cur=0;
        for(int i=0; i<n; i++) {
            if(startPos <= fruits[i][0]) {
                cur=i;
                break;
            }
        }
        
        if(startPos > fruits[n-1][0]) {
            // 只能向左走
            return f(fruits,n-1,k-(startPos-fruits[n-1][0]),n, -1, false);
        }


        if(cur == 0) {
            // 只能向右走
            return f(fruits,0,k-(fruits[0][0]-startPos),n,1,false);
        }



        return Math.max(f(fruits, cur, k-(fruits[cur][0]-startPos), n, 1, true),
        f(fruits,cur-1,k-(startPos-fruits[cur-1][0]), n, -1, true));
    }


    // 当前方向q=-1向左走    flag判断是否能转向
    public int f(int[][] fruits, int i, int k, int n, int q, boolean flag) {
        
        if(k < 0 || i<0 || i>=n) {
            return 0;
        }
        int res = fruits[i][1];
        if(k == 0) {
            return res;
        } 

        // 不能转向
        if(!flag) {
            while(i+q>=0 && i+q<n && k >= Math.abs(fruits[i+q][0] - fruits[i][0])) {
                res += fruits[i+q][1];
                k -= Math.abs(fruits[i+q][0] - fruits[i][0]);
                i += q;
            }
            return res;
        }

        fruits[i][1] = 0;
        int res2=0;
        boolean isTure = 2*k>ini? true:false; // 若转向可以摘到水果则转向,否则不能转向
        if(i+q>=0 && i+q<n) {
            res2 = Math.max(f(fruits, i+q, k-Math.abs(fruits[i+q][0] - fruits[i][0]),n, q, isTure), res2);
        }
        if(i-q>=0 && i-q<n && isTure) {
            res2 = Math.max(f(fruits, i-q, k-Math.abs(fruits[i-q][0] - fruits[i][0]),n, -q, false), res2);
        }
        fruits[i][1] = res;
        return res+res2;
    }
}

解法二：二分查找

 

class Solution {
    public int maxTotalFruits(int[][] fruits, int startPos, int k) {
        int n = fruits.length;
        int[] sum = new int[n + 1];
        int[] indices = new int[n];
        sum[0] = 0;
        for (int i = 0; i < n; i++) {
            sum[i + 1] = sum[i] + fruits[i][1];
            indices[i] = fruits[i][0];
        }
        int ans = 0;
        for (int x = 0; x <= k / 2; x++) {
            /* 向左走 x 步，再向右走 k - x 步 */
            int y = k - 2 * x;
            int left = startPos - x;
            int right = startPos + y;
            int start = lowerBound(indices, 0, n - 1, left);
            int end = upperBound(indices, 0, n - 1, right);
            ans = Math.max(ans, sum[end] - sum[start]);
            /* 向右走 x 步，再向左走 k - x 步 */
            y = k - 2 * x;
            left = startPos - y;
            right = startPos + x;
            start = lowerBound(indices, 0, n - 1, left);
            end = upperBound(indices, 0, n - 1, right);
            ans = Math.max(ans, sum[end] - sum[start]);
        }
        return ans;
    }

    // 位于val右侧的第一个目标点(包括val)
    public int lowerBound(int[] arr, int left, int right, int val) {
        int res = right + 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] >= val) {
                res = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return res;
    }

    // 位于val右侧的第一个目标点(不包括val) 因为sum[val]不包括val
    public int upperBound(int[] arr, int left, int right, int val) {
        int res = right + 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] > val) {
                res = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return res;
    }
}