Maximum Points You Can Obtain from Cards

There are several cards arranged in a row, and each card has an associated number of points The points are given in the integer array cardPoints.

In one step, you can take one card from the beginning or from the end of the row. You have to take exactly k cards.

Your score is the sum of the points of the cards you have taken.

Given the integer array cardPoints and the integer k, return the maximum score you can obtain.

Example 1:

Input: cardPoints = [1,2,3,4,5,6,1], k = 3
Output: 12
Explanation: After the first step, your score will always be 1. However, choosing the rightmost card first will maximize your total score. The optimal strategy is to take the three cards on the right, giving a final score of 1 + 6 + 5 = 12.

Example 2:

Input: cardPoints = [2,2,2], k = 2
Output: 4
Explanation: Regardless of which two cards you take, your score will always be 4.

Example 3:

Input: cardPoints = [9,7,7,9,7,7,9], k = 7
Output: 55
Explanation: You have to take all the cards. Your score is the sum of points of all cards.

Example 4:

Input: cardPoints = [1,1000,1], k = 1
Output: 1
Explanation: You cannot take the card in the middle. Your best score is 1. 

Example 5:

Input: cardPoints = [1,79,80,1,1,1,200,1], k = 3
Output: 202

Constraints:

• 1 <= cardPoints.length <= 10^5
• 1 <= cardPoints[i] <= 10^4
• 1 <= k <= cardPoints.length

思路：用记忆化搜索dp来做，O(N^2) ，不能通过；注意base case是k ==1, Math.max(cardPoints[start], cardPoints[end]);

class Solution {
    public int maxScore(int[] A, int k) {
        int n = A.length;
        Integer[][] cache = new Integer[n][n];
        return dfs(A, 0, n - 1, k, cache);
    }
    
    private int dfs(int[] A, int start, int end, int k, Integer[][] cache) {
        if(start > end) {
            return 0;
        }
        if(k == 1) {
            return Math.max(A[start], A[end]);
        }
        if(cache[start][end] != null) {
            return cache[start][end];
        }
        int value = Math.max(dfs(A, start + 1, end, k - 1, cache) + A[start],
                            dfs(A, start, end - 1, k - 1, cache) + A[end]);
        cache[start][end] = value;
        return cache[start][end];
    }
}

 思路2：这个取值是头跟尾巴，那么可以发现没有取走的数，是个连续的区间，而且是个滑动窗口；逆向思维；

我求得totalsum之后，可以去掉没有取走的区间的sum，就是我取的sum；没有取走的sum，可以由滑动窗口求得；O(N)

class Solution {
    public int maxScore(int[] A, int k) {
        int totalsum = 0;
        for(int num: A) {
            totalsum += num;
        }
        int res = 0;
        int n = A.length;
        int j = 0;
        int cursum = 0;
        int count = 0;
        for(int i = 0; i < n; i++) {
            // move j;
            while(j < n && count < n - k) {
                cursum += A[j];
                count++;
                j++;
            }
            
            // update res;
            if(count == n - k) {
                res = Math.max(res, totalsum - cursum);
            }
            
            // move i;
            cursum -= A[i];
            count--;
        }
        return res;
    }
}