前言

• 分割字符串的最大得分
• 可获得的最大点数
• 对角线遍历II
• 带限制的字序列和

分割字符串的最大得分

• 题目连接
• 解释：
  要求我们将所给字符串分成左右两段，使得左段中0的数目加上右段中1的数目之和尽可能的大。
• 解题思路
  首先统计字符串中0的数目和1的数目,然后遍历字符串，计算在i位置上时， [0,i]中0的数目和[i+1, n)中1的数目总和，计算公式如下

• 其中score为在i位置进行分割时的得分，zero表示到i位置时0的数目，one表示整个字符串中1的数目。

• 代码

class Solution {
    public int maxScore(String s) {
        int one = 0;
        for (char c : s.toCharArray()) {
            if (c == '1') one++;
        }
        int zero = 0, ans = 0;
        int n = s.length();
        
        // 注意左右两段均不能为空
        for (int i = 0; i < n-1; i++) {
            if (s.charAt(i) == '0') zero++;
            int cur = zero + one-(i+1-zero);
            ans = Math.max(ans, cur);
        }
        return ans;
    }
}

• 复杂度分析：
  时间复杂度: 遍历一遍字符串的开销，每次计算时间复杂度
  空间复杂度: 未使用额外空间

可获得的最大点数

• 题目链接
• 解释：
  每次从一个数组的头部或尾部取出一个数字，最多可取k次，求所取数字和的最大值。
• 解题思路：
  因为每次只能从该数组的头部或尾部取一个数字，因此最终会剩余一个长度为n-k的连续子数组(n为)，要想所取数字和尽可能大，则剩余的子数组和则需要尽可能小，因此题目转化为求一个长度为n-k的连续子数组的最小值，为此我们可以简单枚举所有长度为n-k区间，而每个区间和由可以利用前缀和数组简单的计算出。

class Solution {
    public int maxScore(int[] cardPoints, int k) {
        int n = cardPoints.length;
        int[] sum = new int[n+1];
        
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i-1] + cardPoints[i-1];
        }
        
        int minv = Integer.MAX_VALUE;
        for (int i = 0; i <= n-(n-k); i++) {
            minv = Math.min(minv, sum[i+n-k]-sum[i]);
        }
        return sum[n]-minv;
    }
}

• 复杂度分析
• 时间复杂度:
• 空间复杂度: ，记录前缀和数组所占用的空间。

对角线遍历II

• 题目链接

• 解释：
  按照如下的次序遍历该二维矩阵中的元素

  
  
  遍历规则

注意到该矩阵没行元素数量不一，最多行列，但是最多只有10^5个元素，因此我们必须只能遍历存在的元素，并为每个元素确定它所在结果数组中的具体位置。根据观察易发现如下规律

1. 在同一斜对角线上的元素，其所在行x与所在列y之和相同
2. 在同一斜对角线上的元素，按照所在行x由大到小排序
   基于上述两点，我们可以先遍历该不规则二维矩阵，统计每个数字的所在行x和所在列y，再按照上述规则排序即可。

• 代码

class Solution {
    public int[] findDiagonalOrder(List<List<Integer>> nums) {
        int n = nums.size();
        List<Point> arr = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int j = nums.get(i).size();
            for (int t = 0; t < j; t++) {
                arr.add(new Point(i, t, nums.get(i).get(t)));
            }
        }
        Collections.sort(arr, (o1,o2)->((o1.x+o1.y)==(o2.x+o2.y)?(o2.x-o1.x):((o1.x+o1.y)-(o2.x+o2.y))));
        int[] ans = new int[arr.size()];
        for (int i = 0; i < arr.size(); i++)
            ans[i] = arr.get(i).val;
        return ans;
    }
}
class Point {
    int x,  y, val;
    public Point(int x, int y, int val) {
        this.x = x;
        this.y = y;
        this.val = val;
    }
}

• 算法复杂度
  时间复杂度: 其中为二维矩阵中元素个数，开销来自于排序操作。
  空间复杂度： 其中为二维矩阵中元素个数。

带限制的子序列和

• 题目链接

• 解释：
  题目要求我们找出一个和最大的子序列，且子序列中任意2个相邻元素在原数组中的位置距离不超过k。

• 分析：
  动态规划的方法

1. 设为以位置为结束并包含了nums[i]这个元素的满足条件的子序列最大和。
2. 则易得动态转移方程为：

根据以上两点我们可以容易的实现一个时间复杂度为的解法，其中为数组中元素总数，考虑到和的取值上限均到达了，该方法会超时。

• 优化
  根据动态转移方程可以发现，为了计算出，我们仅需要知道到中的最大值，当计算完成后，不再需要，成为了一个新的需要考虑的元素，也就是说我们要在数组上维护一个大小为的窗口，并在窗口前移的过程中更新窗口中的最大值。为了使得获取窗口中最大值的速度尽可能快，我们可以用一个双端队列来维护更新操作

1. 队列的队首为当前窗口中的最大值
2. 当前窗口中的元素数量到达k时，再加入新元素前，要移除一个最早加入的元素，也就是，若与当前队首元素相同，则移除队首元素，否则说明此时并不在窗口中（即在下面的插入操作中被淘汰掉），则不做任何操作
3. 把新计算出的加入到窗口中去，具体操作是和队尾元素比较，若比当前队尾元素大，则把当前队尾元素淘汰掉，否则将加入到队尾。

• 代码

class Solution {
    public int constrainedSubsetSum(int[] nums, int k) {
        int n = nums.length, ans = Integer.MIN_VALUE;;
        int[] dp = new int[n];
        
        LinkedList<Integer> que = new LinkedList<>();
        
        for (int i = 0; i < n; i++) {
            int maxv = Math.max(0,que.peekFirst()==null?0:que.peekFirst());
            dp[i] = nums[i] + maxv;
            if (i >= k && que.peekFirst()==dp[i-k]) que.pollFirst();
            while (!que.isEmpty() && dp[i] > que.peekLast()) que.pollLast();
            que.addLast(dp[i]);
            ans = Math.max(dp[i], ans);
        }
        return ans;
    }
}

• 复杂度分析
  时间复杂度：
  空间复杂度：