求基于下一个更大数的最长跳跃序列高效优化方案

我已经思考该问题多日，虽有丰富经验仍未找到高效解决方案。给定数字序列，需计算每个数字的最长跳跃序列，规则如下：

• 仅能跳向比当前数字更大的数
• 跳跃的两个数字之间不能存在更大的数
• 仅允许从左向右跳跃

我已有如下慢实现，但需大幅提升速度：

private static List<Integer> slow(int[] numbers){

        int n = numbers.length;

        int initialJump = 0;
        int next = 0;

        List<Integer> list = new ArrayList<>();

        int counter = 0;
        int maxNum = Arrays.stream(numbers).max().getAsInt();
        for (int i = 0; i < n; i++) {
            initialJump = numbers[i];
            if (initialJump == maxNum) {
                list.add(0);
                continue;
            }
            for (int j = i + 1; j < n; j++) {
                next = numbers[j];
                if (initialJump < next) {
                    counter++;
                    initialJump = next;
                }
            }
            list.add(counter);
            counter = 0;
        }

        return list;
    }

示例如下：
输入：1 4 2 6 3 4
输出：2 1 1 0 1 0

解释：

Element 1:
    1 -> 4 -> 6 (2 jumps)
Element 2:
    4 -> 6 (1 jump)
Element 3:
    2 -> 6 (1 jump)
Element 4:
    6 (0 jumps)
Element 5:
    3 -> 4 (1 jump)
Element 6:
    4 -> (0 jumps)

请问有什么优化思路？我尝试了如下fast方法，但效果不佳：

private static List<Integer> fast(int[] numbers){
    int n = numbers.length;

    int[] jumplist = new int[n];

    int initialJump = 0;
    int count = 0;
    int maxNum = Arrays.stream(numbers).max().getAsInt();

    Map<Integer, Integer> map = new HashMap<>();

    for(int i=n-1; i>=0; i--) {
        if(i-1 >= 0 && map.get(i+1) != null && numbers[i+1] > numbers[i]){
            jumplist[i] = map.get(i+1)+1;
            continue;
        }

        initialJump = numbers[i];

        if (initialJump == maxNum) {
            jumplist[i] = 0;
            continue;
        }
        for(int j=i; j<n; j++) {
            if(initialJump < numbers[j]) {
                count++;
                initialJump = numbers[j];
                map.put(i,count);
            }
        }
        jumplist[i] = count;
        count = 0;
    }

    return Arrays.stream(jumplist).boxed().collect(Collectors.toList());
}

测试代码如下：

int randomLimit = 50000;
        Random random = new Random();
        List<Integer> randomList = new ArrayList<>();
        for (int i = 0; i < randomLimit; i++) {
            randomList.add(random.ints(0, randomLimit).findFirst().getAsInt());
        }
        System.out.println("Input: " + randomList.stream().limit(20).collect(Collectors.toList()));
        int[] randomArray = randomList.stream().mapToInt(i->i).toArray();

        Instant fastStarts = Instant.now();
        List<Integer> fastRes = fast(randomArray);
        System.out.println(fastRes.stream().limit(20).collect(Collectors.toList()));
        Instant fastEnds = Instant.now();
        System.out.println("fast: " + Duration.between(fastStarts, fastEnds).toMillis());

        Instant slowStarts = Instant.now();
        List<Integer> slowRes = slow(randomArray);
        System.out.println(slowRes.stream().limit(20).collect(Collectors.toList()));
        Instant slowEnds = Instant.now();
        System.out.println("slow: " + Duration.between(slowStarts, slowEnds).toMillis());

        if(slowRes.size() != fastRes.size()){
            System.out.println("Not Equal Result !!");
        }else {
            for (int i = 0; i < slowRes.size(); i++) {
                if (!slowRes.get(i).equals(fastRes.get(i))) {
                    System.out.println("Not Equal Result !!");
                    break;
                }
            }
        }

内容的提问来源于stack exchange，提问作者dimilalabar