36373839404142434445464748

#include <bits/stdc++.h>
using namespace std;

// Function to find the minimum cost to reach index 'ind' using at most 'k' jumps
int solveUtil(int ind, vector<int>& height, vector<int>& dp, int k) {
    // Base case: starting point has zero cost
    if (ind == 0) return 0;

    // Return already computed result
    if (dp[ind] != -1) return dp[ind];

    // Initialize minimum steps as large value
    int mmSteps = INT_MAX;

    // Try all possible jumps from 1 to k
    for (int j = 1; j <= k; j++) {
        // Ensure jump does not go out of bounds
        if (ind - j >= 0) {
            // Cost of taking the jump
            int jump = solveUtil(ind - j, height, dp, k) + abs(height[ind] - height[ind - j]);
            // Store the minimum cost
            mmSteps = min(jump, mmSteps);
        }
    }
    // Save the result in dp array
    return dp[ind] = mmSteps;
}

// Function to get minimum cost to reach end
int solve(int n, vector<int>& height, int k) {
    // DP array initialized to -1
    vector<int> dp(n, -1);
    // Start recursion from last index
    return solveUtil(n - 1, height, dp, k);
}

// Driver code
int main() {
    // Heights of stones
    vector<int> height{30, 10, 60, 10, 60, 50};
    int n = height.size();
    int k = 2;

    // Output the minimum cost
    cout << solve(n, height, k) << endl;
    return 0;
}

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253

import java.util.*;

class Solution {
    // Function to find the minimum cost to reach index 'ind' using at most 'k' jumps
    public int solveUtil(int ind, List<Integer> height, int[] dp, int k) {
        // Base case
        if (ind == 0) return 0;

        // Return already computed result
        if (dp[ind] != -1) return dp[ind];

        // Initialize minimum steps as large value
        int mmSteps = Integer.MAX_VALUE;

        // Try all possible jumps from 1 to k
        for (int j = 1; j <= k; j++) {
            // Ensure jump does not go out of bounds
            if (ind - j >= 0) {
                // Cost of taking the jump
                int jump = solveUtil(ind - j, height, dp, k) + Math.abs(height.get(ind) - height.get(ind - j));
                // Store the minimum cost
                mmSteps = Math.min(jump, mmSteps);
            }
        }
        // Save the result in dp array
        return dp[ind] = mmSteps;
    }

    // Function to get minimum cost to reach end
    public int solve(int n, List<Integer> height, int k) {
        // DP array initialized to -1
        int[] dp = new int[n];
        Arrays.fill(dp, -1);
        // Start recursion from last index