@@ -13,5 +13,5 @@ leetcode.ipr
 leetcode.iws
 out/
 problems/src.iml
-.idea/*
+.idea
 .gradle/

@@ -266,6 +266,17 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Toss Strange Coins](problems/src/dynamic_programming/TossStrangeCoins.java) (Medium)
 - [Knight Dialer](problems/src/dynamic_programming/KnightDialer.java) (Medium)
 - ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Palindrome Removal](problems/src/dynamic_programming/PalindromeRemoval.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Restore The Array](problems/src/dynamic_programming/RestoreTheArray.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Cherry Pickup II](problems/src/dynamic_programming/CherryPickupII.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Constrained Subsequence Sum](problems/src/dynamic_programming/ConstrainedSubsequenceSum.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Largest Multiple of Three](problems/src/dynamic_programming/LargestMultipleOfThree.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Largest Multiple of Three](problems/src/dynamic_programming/MaximumProfitInJobScheduling.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Number of Music Playlists](problems/src/dynamic_programming/NumberOfMusicPlaylists.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Paint House III](problems/src/dynamic_programming/PaintHouseIII.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Shortest Path Visiting All Nodes](problems/src/dynamic_programming/ShortestPathVisitingAllNodes.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Smallest Sufficient Team](problems/src/dynamic_programming/SmallestSufficientTeam.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Stone Game IV](problems/src/dynamic_programming/StoneGameIV.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Tallest Billboard](problems/src/dynamic_programming/TallestBillboard.java) (Hard)
 
 
 #### [Greedy](problems/src/greedy)
@@ -287,6 +298,7 @@ My accepted leetcode solutions to some of the common interview problems.
 - [Broken Calculator](problems/src/greedy/BrokenCalculator.java) (Medium)
 - [Two City Scheduling](problems/src/greedy/TwoCityScheduling.java) (Easy)
 - ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Minimum Time to Build Blocks](problems/src/greedy/MinimumTimeToBuildBlocks.java) (Hard)
+- ![#f03c15](https://placehold.it/15/f03c15/000000?text=+) [Reducing Dishes](problems/src/greedy/ReducingDishes.java) (Hard)
 
 #### [Hashing](problems/src/hashing)
 

@@ -0,0 +1,89 @@
+package dynamic_programming;
+
+import java.util.Arrays;
+
+/**
+* Created by gouthamvidyapradhan on 28/07/2020 Given a rows x cols matrix grid representing a field
+* of cherries. Each cell in grid represents the number of cherries that you can collect.
+*
+* <p>You have two robots that can collect cherries for you, Robot #1 is located at the top-left
+* corner (0,0) , and Robot #2 is located at the top-right corner (0, cols-1) of the grid.
+*
+* <p>Return the maximum number of cherries collection using both robots by following the rules
+* below:
+*
+* <p>From a cell (i,j), robots can move to cell (i+1, j-1) , (i+1, j) or (i+1, j+1). When any robot
+* is passing through a cell, It picks it up all cherries, and the cell becomes an empty cell (0).
+* When both robots stay on the same cell, only one of them takes the cherries. Both robots cannot
+* move outside of the grid at any moment. Both robots should reach the bottom row in the grid.
+*
+* <p>Example 1:
+*
+* <p>Input: grid = [[3,1,1],[2,5,1],[1,5,5],[2,1,1]] Output: 24 Explanation: Path of robot #1 and
+* #2 are described in color green and blue respectively. Cherries taken by Robot #1, (3 + 2 + 5 +
+* 2) = 12. Cherries taken by Robot #2, (1 + 5 + 5 + 1) = 12. Total of cherries: 12 + 12 = 24.
+* Example 2:
+*
+* <p>Input: grid =
+* [[1,0,0,0,0,0,1],[2,0,0,0,0,3,0],[2,0,9,0,0,0,0],[0,3,0,5,4,0,0],[1,0,2,3,0,0,6]] Output: 28
+* Explanation: Path of robot #1 and #2 are described in color green and blue respectively. Cherries
+* taken by Robot #1, (1 + 9 + 5 + 2) = 17. Cherries taken by Robot #2, (1 + 3 + 4 + 3) = 11. Total
+* of cherries: 17 + 11 = 28. Example 3:
+*
+* <p>Input: grid = [[1,0,0,3],[0,0,0,3],[0,0,3,3],[9,0,3,3]] Output: 22 Example 4:
+*
+* <p>Input: grid = [[1,1],[1,1]] Output: 4
+*
+* <p>Constraints:
+*
+* <p>rows == grid.length cols == grid[i].length 2 <= rows, cols <= 70 0 <= grid[i][j] <= 100
+*/
+public class CherryPickupII {
+private final int[] R = {1, 1, 1};
+private final int[] C = {0, -1, 1};
+
+public static void main(String[] args) {
+int[][] A = {
+{1, 0, 0, 3},
+{2, 0, 0, 0, 0, 3, 0},
+{2, 0, 9, 0, 0, 0, 0},
+{0, 3, 0, 5, 4, 0, 0},
+{1, 0, 2, 3, 0, 0, 6}
+};
+System.out.println(new CherryPickupII().cherryPickup(A));
+}
+
+int[][][] DP;
+
+public int cherryPickup(int[][] grid) {
+DP = new int[grid.length][grid[0].length][grid[0].length];
+for (int i = 0; i < grid.length; i++) {
+for (int j = 0; j < grid[0].length; j++) {
+Arrays.fill(DP[i][j], -1);
+}
+}
+return dp(0, 0, grid[0].length - 1, grid);
+}
+
+private int dp(int r, int c1, int c2, int[][] grid) {
+if (DP[r][c1][c2] != -1) return DP[r][c1][c2];
+else {
+int count = (c1 == c2) ? grid[r][c1] : (grid[r][c1] + grid[r][c2]);
+int max = count;
+for (int i = 0; i < 3; i++) {
+int newR = r + R[i];
+int newC1 = c1 + C[i];
+if (newR >= 0 && newR < grid.length && newC1 >= 0 && newC1 < grid[0].length) {
+for (int j = 0; j < 3; j++) {
+int newC2 = c2 + C[j];
+if (newC2 >= 0 && newC2 < grid[0].length) {
+max = Math.max(max, count + dp(newR, newC1, newC2, grid));
+}
+}
+}
+}
+DP[r][c1][c2] = max;
+return max;
+}
+}
+}

@@ -0,0 +1,52 @@
+package dynamic_programming;
+
+import java.util.*;
+
+/** Created by gouthamvidyapradhan on 14/05/2020 */
+public class ConstrainedSubsequenceSum {
+
+public static void main(String[] args) {
+int[] A = {10, -2, -10, -5, 20};
+System.out.println(new ConstrainedSubsequenceSum().constrainedSubsetSum(A, 2));
+}
+
+class Node {
+int v, i;
+
+public int getV() {
+return v;
+}
+
+public int getI() {
+return i;
+}
+
+Node(int v, int i) {
+this.v = v;
+this.i = i;
+}
+}
+
+public int constrainedSubsetSum(int[] nums, int k) {
+Queue<Node> pQ =
+new PriorityQueue<>(Comparator.comparing(Node::getV).thenComparing(Node::getI).reversed());
+int max = Integer.MIN_VALUE;
+for (int i = 0; i < nums.length; i++) {
+int value = nums[i];
+while (!pQ.isEmpty() && (i - pQ.peek().i > k)) {
+pQ.poll();
+}
+if (pQ.isEmpty()) {
+pQ.offer(new Node(value, i));
+} else {
+if (pQ.peek().v + value > value) {
+pQ.offer(new Node(pQ.peek().v + value, i));
+} else {
+pQ.offer(new Node(value, i));
+}
+}
+max = Math.max(max, pQ.peek().v);
+}
+return max;
+}
+}

@@ -0,0 +1,80 @@
+package dynamic_programming;
+
+import java.util.Arrays;
+
+/**
+* Created by gouthamvidyapradhan on 29/05/2020 Given an integer array of digits, return the largest
+* multiple of three that can be formed by concatenating some of the given digits in any order.
+*
+* <p>Since the answer may not fit in an integer data type, return the answer as a string.
+*
+* <p>If there is no answer return an empty string.
+*
+* <p>Example 1:
+*
+* <p>Input: digits = [8,1,9] Output: "981" Example 2:
+*
+* <p>Input: digits = [8,6,7,1,0] Output: "8760" Example 3:
+*
+* <p>Input: digits = [1] Output: "" Example 4:
+*
+* <p>Input: digits = [0,0,0,0,0,0] Output: "0"
+*
+* <p>Constraints:
+*
+* <p>1 <= digits.length <= 10^4 0 <= digits[i] <= 9 The returning answer must not contain
+* unnecessary leading zeros.
+*/
+public class LargestMultipleOfThree {
+public static void main(String[] args) {
+int[] A = {8, 4, 1, 7};
+System.out.println(new LargestMultipleOfThree().largestMultipleOfThree(A));
+}
+
+int[][][] DP;
+
+public String largestMultipleOfThree(int[] digits) {
+Arrays.sort(digits);
+for (int i = 0, j = digits.length - 1; i < j; i++, j--) {
+int t = digits[i];
+digits[i] = digits[j];
+digits[j] = t;
+}
+DP = new int[digits.length][3][2];
+for (int i = 0; i < digits.length; i++) {
+for (int j = 0; j < 3; j++) {
+Arrays.fill(DP[i][j], -2);
+}
+}
+dp(0, 0, digits);
+StringBuilder sb = new StringBuilder();
+int r = 0;
+for (int i = 0; i < digits.length; i++) {
+if (DP[i][r][1] >= DP[i][r][0]) {
+if (sb.length() != 1 || sb.charAt(0) != '0') {
+sb.append(digits[i]);
+}
+r = (Integer.parseInt(String.valueOf(r + "" + digits[i])) % 3);
+}
+}
+return sb.toString();
+}
+
+private int dp(int i, int r, int[] A) {
+if (i == A.length) {
+return r == 0 ? 0 : -1;
+} else if (DP[i][r][0] != -2) {
+return Math.max(DP[i][r][0], DP[i][r][1]);
+} else {
+int d = A[i];
+int newR = (Integer.parseInt(String.valueOf(r + "" + d)) % 3);
+int result = dp(i + 1, newR, A);
+if (result >= 0) {
+result = result + 1;
+}
+DP[i][r][1] = result;
+DP[i][r][0] = dp(i + 1, r, A);
+return Math.max(DP[i][r][0], DP[i][r][1]);
+}
+}
+}