【每日一题Day60】LC1703得到连续 K 个 1 的最少相邻交换次数 | 中位数贪心

得到连续 K 个 1 的最少相邻交换次数【LC1703】

You are given an integer array, nums, and an integer k. nums comprises of only 0’s and 1’s. In one move, you can choose two adjacent indices and swap their values.

Return the minimum number of moves required so that nums has k consecutive 1’s.

太难了 终于想明白了

• 思路：我们需要将数组中的1移动成连续的k的1，并计算最少的移动次数，每次移动只能移动相邻的两个元素。假设第$i$个1的下标为$q_i$，我们需要将第一个1$q_0$移动至位置$x$，并移动第二个1$q_1$至$x+1$，所需要的移动次数总和为
  $$\sum _i^{i+k-1}|q_i-(x+i)|=\sum _i^{i+k-1}|(q_i-i)-x|=\sum _i^{i+k-1}|p_i-x|$$
  因此问题转变为计算所有$p_i$至$x$的距离和的最小值，贪心可得当$x$取$p_i$的中位数$p[(2i+k-1)/2]$时，距离之和最小。

  • 为什么？

    局部最优：$x$位于区间$[p[0],p[k-1]]$内部时【无论位于哪个位置】，到$p[0]$和$p[k-1]$的距离是定值$p[k-1]-p[0]$，因此应使$x$位于所有区间的内部即中位数，使$x$到所有区间的距离为定值，此时能够达到全局最优

    全局最优：所有$p_i$至$x$的距离和的最小值

  • 令中位数为$mid=(2i+k-1)/2$，那么此时的距离可计算得
    $$\begin{gathered} \sum _i^{k-1}|p_i-x|=\sum _{j=i}^{mid-1}(p_{mid}-p_j)+\sum _{j=mid+1}^{i+k-1}(p_j-p_{mid}) \\ =(mid-i)p_{mid}-\sum _{j=i}^{mid-1}{p}_j+\sum _{j=mid+1}^{i+k-1}{p}_j--(i+k-1-mid)p_{mid} \\ =(2(mid-i)-k+1)p_{mid}+\sum _{j=mid+1}^{i+k-1}{p}_j-\sum _{j=i}^{mid-1}{p}_j \end{gathered}$$

  • 枚举第$i$个1作为连续1的最左边那个1，求出此时的距离，返回最小距离即可

• 实现

  • 找到所有1的位置存储在List类型的变量loc中
  • 根据loc求出数组p
  • 求出p的前缀和数组pSum
  • 枚举最左边的1 求出最小值

  class Solution {
      public int minMoves(int[] nums, int k) {
          int n = nums.length;
          List<Integer> loc = new ArrayList<>();
          // 找到数组中1的位置
          for (int i = 0; i < n; i++){
              if (nums[i] == 1){
                  loc.add(i);
              }
          }
          // 求出p数组
          int m = loc.size();
          int[] p = new int[m];
          for (int i = 0; i < m; i++){
              p[i] = loc.get(i) - i;
          }
          // 前缀和数组
          int[] pSum = new int[m + 1];
          for (int i = 1; i <= m; i++){
              pSum[i] = pSum[i - 1] + p[i - 1];
          } 
          // 枚举左边的1 求出最小值      
          int ans = Integer.MAX_VALUE;
          for (int i = 0; i + k <= m; i++){
              int mid = (2 * i + k - 1) / 2;
              int temp = (2 * (mid - i) - k + 1) * p[mid] + pSum[i + k] - pSum[mid + 1] - (pSum[mid] - pSum[i]);
              ans = Math.min(ans, temp);
          }
          return ans;
      }
  }
  
  

  • 复杂度
    • 时间复杂度：$O(n+m)$，$n$为数组长度，$m$为数组中1的个数
    • 空间复杂度：$O(n+m)$

• 优化：直接求出数组p

  class Solution {
      public int minMoves(int[] nums, int k) {
          int n = nums.length;
          List<Integer> p = new ArrayList<>();
          // 求出p数组
          for (int i = 0; i < n; i++){
              if (nums[i] == 1){
                  p.add(i - p.size() );
              }
          }       
          int m = p.size();
          // 前缀和数组
          int[] pSum = new int[m + 1];
          for (int i = 1; i <= m; i++){
              pSum[i] = pSum[i - 1] + p.get(i - 1);
          } 
          // 枚举左边的1 求出最小值      
          int ans = Integer.MAX_VALUE;
          for (int i = 0; i + k <= m; i++){
              int mid = (2 * i + k - 1) / 2;
              int temp = (2 * (mid - i) - k + 1) * p.get(mid) + pSum[i + k] - pSum[mid + 1] - (pSum[mid] - pSum[i]);
              ans = Math.min(ans, temp);
          }
          return ans;
      }
  }