Add unique paths (fixes #2873) (#2943)

Co-authored-by: Andrii Siriak <siryaka@gmail.com>

src/main/java/com/thealgorithms/dynamicprogramming/UniquePaths.java

@@ -0,0 +1,67 @@
+/** Author : Siddhant Swarup Mallick
+ * Github : https://github.com/siddhant2002
+ */
+
+
+/**
+ * A robot is located at the top-left corner of a m x n grid (marked 'Start' in the diagram below).
+ * The robot can only move either down or right at any point in time.
+ * The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+ * How many possible unique paths are there?
+ */
+
+/** Program description - To find the number of unique paths possible */
+
+package com.thealgorithms.dynamicprogramming;
+
+import java.util.*;
+
+public class UniquePaths {
+    public static boolean uniquePaths(int m , int n , int ans) {
+        int []dp = new int[n];
+        Arrays.fill(dp,1);
+        for (int i=1; i<m; i++)
+        {
+            for (int j=1; j<n; j++)
+            {
+                dp[j] += dp[j-1];
+
+            }
+        }
+        return dp[n-1]==ans;
+        // return true if predicted answer matches with expected answer
+    }
+    // The above method runs in O(n) time
+    public static boolean uniquePaths2(int m , int n , int ans) {
+        int dp[][] = new int[m][n];
+        for (int i=0; i<m; i++)
+        {
+            dp[i][0] = 1;
+        }
+        for (int j=0; j<n; j++)
+        {
+            dp[0][j] = 1;
+        }
+        for (int i=1; i<m; i++)
+        {
+            for (int j=1; j<n; j++)
+            {
+                dp[i][j]=dp[i-1][j]+dp[i][j-1];
+            }
+        }
+        return dp[m-1][n-1]==ans;
+        // return true if predicted answer matches with expected answer
+    }
+    // The above mthod takes O(m*n) time
+}
+/**
+     * OUTPUT :
+     * Input - m = 3, n = 7
+     * Output: it returns either true if expected answer matches with the predicted answer else it returns false
+     * 1st approach Time Complexity : O(n)
+     * Auxiliary Space Complexity : O(n)
+     * Input - m = 3, n = 7
+     * Output: it returns either true if expected answer matches with the predicted answer else it returns false
+     * 2nd approach Time Complexity : O(m*n)
+     * Auxiliary Space Complexity : O(m*n)
+     */