HACKTOBERFEST-2022

DP/1340-JUMP GAME V SOLUTION.txt

@@ -0,0 +1,34 @@
+class Solution {
+public:int d;
+    int max(int a,int b){
+        return a>b?a:b;
+    }
+    int fun(vector< int>&v,int i,vector< int>&dp){
+        if(i>=v.size()||i<0)return 0;
+        if(dp[i]!=-1)return dp[i];
+        int res=0;
+        int j;
+        for(j=i+1;j<v.size()&&v[j]<v[i]&&j<=i+d;j++){
+        res=max(res,1+fun(v,j,dp));
+        }
+        for(j=i-1;j>=0&&v[j]<v[i]&&j>=i-d;j--){
+        res=max(res,1+fun(v,j,dp));
+        }
+        return dp[i]=res;
+
+
+    }
+
+
+    int maxJumps(vector<int>& arr,int d1) {
+       // vector<int>val,a;
+        d=d1;
+
+
+        int ans=0;vector<int>dp(arr.size(),-1);
+      for(int i=0;i<arr.size();i++){
+        ans=max(ans,fun(arr,i,dp));
+      }
+        return ans+1;
+    }
+};

DP/1340-JUMP GAME V.txt

@@ -0,0 +1,45 @@
+Given an array of integers arr and an integer d. In one step you can jump from index i to index:
+
+i + x where: i + x < arr.length and 0 < x <= d.
+i - x where: i - x >= 0 and 0 < x <= d.
+In addition, you can only jump from index i to index j if arr[i] > arr[j] and arr[i] > arr[k] for all indices k between i and j (More formally min(i, j) < k < max(i, j)).
+
+You can choose any index of the array and start jumping. Return the maximum number of indices you can visit.
+
+Notice that you can not jump outside of the array at any time.
+
+
+Example 1:
+Input: arr = [6,4,14,6,8,13,9,7,10,6,12], d = 2
+Output: 4
+Explanation: You can start at index 10. You can jump 10 --> 8 --> 6 --> 7 as shown.
+Note that if you start at index 6 you can only jump to index 7. You cannot jump to index 5 because 13 > 9. You cannot jump to index 4 because index 5 is between index 4 and 6 and 13 > 9.
+Similarly You cannot jump from index 3 to index 2 or index 1.
+
+
+
+Example 2:
+
+Input: arr = [3,3,3,3,3], d = 3
+Output: 1
+Explanation: You can start at any index. You always cannot jump to any index.
+
+
+
+
+Example 3:
+
+Input: arr = [7,6,5,4,3,2,1], d = 1
+Output: 7
+Explanation: Start at index 0. You can visit all the indicies. 
+
+
+
+
+
+
+Constraints:
+
+1 <= arr.length <= 1000
+1 <= arr[i] <= 10^5
+1 <= d <= arr.length