Leetcode 5331 跳跃游戏 V

OJ

题意：
给定一个数组，数组的值代表一个矩形的高度，我们可以任意选择一个矩形当做起点，然后进行跳跃，每次跳跃的最远距离为d，可以向左或者向右跳，但是不能跳出数组。在一个位置上要想跳到另外一个位置，中间所有的矩形都要比起跳位置的矩形矮，且目标矩形也比起跳矩形矮，问最多访问多少个下标。

解：
一个动态规划的题，dp[i]表示在下标i位置最多能到达的下标数量，dp[i] = max(dp[k]+1,dp[i])，k代表当前i位置能到达的其他下标。看似都可以了，但是有个问题，我们如何保证dp[k]的值是已经求过了的？我们肯定不能按照顺序关系来求dp数组的值，因为每个值之间并不是顺序关系，而是高度关系。所以我们要保证矮的先求，排个序就搞定了。

public int maxJumps(int[] arr, int d) {
      int[] num = new int[arr.length];
      A[] as = new A[arr.length];
      for (int i = 0; i < num.length; i++) {
          as[i] = new A(i, arr[i]);
      }
      // 按照数据大小进行排序，但是记录了原下标位置
      Arrays.sort(as, Comparator.comparingInt(value -> value.data));
      int[] dp = new int[arr.length];
      Arrays.fill(dp, 1);
      int ans = 0;
      for (int i = 0; i < as.length; i++) {
          int index = as[i].index;
          for (int j = index - 1; j >= index - d; j--) {
              if (j < 0 || arr[index] <= arr[j]) {
                  break;
              }
              dp[index] = Math.max(dp[index], dp[j] + 1);
          }
          for (int j = index + 1; j <= index + d; j++) {
              if (j > arr.length - 1 || arr[index] <= arr[j]) {
                  break;
              }
              dp[index] = Math.max(dp[index], dp[j] + 1);
          }
          ans = Math.max(dp[index], ans);
      }
      return ans;
  }
// 一个用来存放原数组下标的类
  class A {
  	  // 原数组下标
      int index;
      int data;

      public A(int index, int data) {
          this.index = index;
          this.data = data;
      }
  }

当然也可以不进行排序，可以用DFS加记忆化解决，但是DP他不香吗