题意：

给你一个整数数组 arr 和一个整数 d 。每一步你可以从下标 i 跳到：

i + x ，其中 i + x < arr.length 且 0 < x <= d 。
i - x ，其中 i - x >= 0 且 0 < x <= d 。
除此以外，你从下标 i 跳到下标 j 需要满足：arr[i] > arr[j] 且 arr[i] > arr[k] ，
其中下标 k 是所有 i 到 j 之间的数字（更正式的，min(i, j) < k < max(i, j)）。

你可以选择数组的任意下标开始跳跃。请你返回你 最多 可以访问多少个下标。

请注意，任何时刻你都不能跳到数组的外面。

数据范围:
1 <= arr.length <= 1000
1 <= arr[i] <= 10^5
1 <= d <= arr.length

解法：

容易发现在点x上时,一定只能往<a[x]的位置跳,

令f[i]为从点i开始跳的最大次数,
那么f[i]=max{f[j]}+1.其中j是可以跳的位置,
由于n<=1e3,因此可以值即枚举j进行转移,
复杂度O(n^2),我代码写的记忆化搜索.

code：

class Solution {
public:
    vector<int>a;
    int f[1111];
    int n,d;
    int dp(int x){
        if(f[x]!=-1)return f[x];
        f[x]=1;
        int ma=-1;
        for(int i=x-1;i>=x-d&&i>=0;i--){
            ma=max(ma,a[i]);
            if(ma>=a[x])break;
            f[x]=max(f[x],dp(i)+1);
        }
        ma=-1;
        for(int i=x+1;i<=x+d&&i<n;i++){
            ma=max(ma,a[i]);
            if(ma>=a[x])break;
            f[x]=max(f[x],dp(i)+1);
        }
        return f[x];
    }
    int maxJumps(vector<int>& aa, int dd) {
        //init
        memset(f,-1,sizeof f);
        a=aa;
        d=dd;
        n=a.size();
        //
        int ans=0;
        for(int i=0;i<n;i++){
            ans=max(ans,dp(i));
        }
        return ans;
    }
};

---