Add files via upload

Author: dipta-dhar

Algorithms/dpAlgorithms/CoinChange.cpp

@@ -0,0 +1,30 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int coins[] = {1, 5, 10, 25, 50};
+int dp[7500][5];
+
+int coinChange(int amount, int index) {
+    if (amount == 0)                return 1;
+    if (dp[amount][index] != -1)    return dp[amount][index];
+
+    int ways = 0;
+    for (int i=index; i<5; ++i) {
+        if (amount >= coins[i])
+            ways += coinChange(amount - coins[i], i);
+    }
+
+    return dp[amount][index] = ways;
+}
+
+int main() {
+    //freopen("in.txt", "r", stdin);
+    //freopen("out.txt", "w", stdout);
+
+    int amount;
+    memset(dp, -1, sizeof dp);
+    while (scanf("%d", &amount) == 1) {
+        printf("%d\n",coinChange(amount, 0));
+    }
+    return 0;
+}

Algorithms/dpAlgorithms/CoinChange.java

@@ -0,0 +1,27 @@
+package dpAlgorithms;
+
+import java.util.Arrays;
+
+public class CoinChange {
+	public static int countWays(int s[], int m, int n) {
+		int[] arr = new int[n+1];
+		
+		Arrays.fill(arr, 0);
+		arr[0] = 1;
+		for(int i=0; i<m; i++) {
+			for(int j=s[i]; j<=n; j++) {
+				arr[j] += arr[j-s[i]];
+			}
+		}
+		
+		return arr[n];
+	}
+	
+	public static void main(String[] args) {
+		int arr[] = {1, 2, 3};
+		int m = arr.length;
+		int n = 4;
+		
+		System.out.println(countWays(arr, m, n));
+	}
+}

Algorithms/dpAlgorithms/CoinChange.py

@@ -0,0 +1,18 @@
+def count(S, m, n ):
+
+	if (n == 0):
+		return 1
+
+	if (n < 0):
+		return 0;
+
+	if (m <=0 and n >= 1):
+		return 0
+
+	return count( S, m - 1, n ) + count( S, m, n-S[m-1] );
+
+arr = [1, 2, 3]
+m = len(arr)
+print(count(arr, m, 4))
+
+

Algorithms/dpAlgorithms/LCS.cpp

@@ -0,0 +1,73 @@
+#include<stdio.h>
+#include<string.h>
+
+int max(int a, int b);
+void findLCS(char *X, char *Y, int XLen, int YLen);
+
+int max(int a, int b) {
+	return (a > b)? a : b;
+}
+
+void findLCS(char *X, char *Y, int XLen, int YLen) {
+	int L[XLen + 1][YLen + 1];
+	int r, c, i;
+
+    /// Find LCS
+	for(r=0; r<=XLen; r++) {
+		for(c=0; c<=YLen; c++) {
+			if(r==0 || c==0)            L[r][c] = 0;
+            else if(X[r-1] == Y[c-1])   L[r][c] = L[r-1][c-1] + 1;
+            else                        L[r][c] = max(L[r-1][c],  L[r][c-1]);
+		}
+	}
+
+	/// Print LCS
+	r = XLen;
+	c = YLen;
+	i = L[r][c];
+
+	char LCS[i+1];
+
+	/*
+	 * setting the NULL character at the end of LCS character array.
+	 * as we know in C programming language, NULL character is used
+	 * to denote the end of a string
+	 */
+	LCS[i] = '\0';
+
+	while(r>0 && c>0) {
+
+		if(X[r-1] == Y[c-1]) {
+
+			LCS[i-1] = X[r-1];
+
+			i--;
+			r--;
+			c--;
+
+		}
+		else if(L[r-1][c] > L[r][c-1])
+            r--;
+        else
+            c--;
+	}
+
+	/// print result
+	printf("Length of the LCS: %d\n", L[XLen][YLen]);
+	printf("LCS: %s\n", LCS);
+}
+
+int main()
+{
+	//the two sequences
+	char X[] = "ABCF";
+	char Y[] = "ACF";
+
+	//length of the sequences
+	int XLen = strlen(X);
+	int YLen = strlen(Y);
+
+	findLCS(X, Y, XLen, YLen);
+
+	return 0;
+}

Algorithms/dpAlgorithms/LCS.cs

@@ -0,0 +1,33 @@
+using System;
+ 
+namespace LCS
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            string word1 = "thisisatest";
+            string word2 = "testing123testing";
+ 
+            Console.WriteLine(lcsBack(word1, word2));
+            Console.ReadKey();
+        }
+ 
+        public static string lcsBack(string a, string b)
+        {
+            string aSub = a.Substring(0, (a.Length - 1 < 0) ? 0 : a.Length - 1);
+            string bSub = b.Substring(0, (b.Length - 1 < 0) ? 0 : b.Length - 1);
+ 
+            if (a.Length == 0 || b.Length == 0)            
+                return "";
+            else if (a[a.Length - 1] == b[b.Length - 1])
+                return lcsBack(aSub, bSub) + a[a.Length - 1];
+            else
+            {
+                string x = lcsBack(a, bSub);
+                string y = lcsBack(aSub, b);
+                return (x.Length > y.Length) ? x : y;
+            }
+        }
+    }
+}

Algorithms/dpAlgorithms/LCS.java

@@ -0,0 +1,35 @@
+package dpAlgorithms;
+
+public class LCS {
+	
+	public static int getLongestCommonSubsequence(String a, String b){
+		int m = a.length();
+		int n = b.length();
+		int[][] dp = new int[m+1][n+1];
+	 
+		for(int i=0; i<=m; i++){
+			for(int j=0; j<=n; j++){
+				if(i==0 || j==0){
+					dp[i][j]=0;
+				}else if(a.charAt(i-1)==b.charAt(j-1)){
+					dp[i][j] = 1 + dp[i-1][j-1];
+				}else{
+					dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
+				}
+			}
+		}
+	 
+		return dp[m][n];
+	}
+	
+	public static void main(String[] args) {
+		String a = "abcdef";
+		String b = "acf";
+		
+		int lcs_length = getLongestCommonSubsequence(a, b);
+		
+		System.out.println("1st string: "+ a + "\n2nd string: " + b);
+		System.out.println("LCS length is: " + lcs_length);
+	}
+
+}

Algorithms/dpAlgorithms/LCS.py

@@ -0,0 +1,23 @@
+def lcs(a, b):
+    lengths = [[0 for j in range(len(b)+1)] for i in range(len(a)+1)]
+    # row 0 and column 0 are initialized to 0 already
+    for i, x in enumerate(a):
+        for j, y in enumerate(b):
+            if x == y:
+                lengths[i+1][j+1] = lengths[i][j] + 1
+            else:
+                lengths[i+1][j+1] = max(lengths[i+1][j], lengths[i][j+1])
+    # read the substring out from the matrix
+    result = ""
+    x, y = len(a), len(b)
+    while x != 0 and y != 0:
+        if lengths[x][y] == lengths[x-1][y]:
+            x -= 1
+        elif lengths[x][y] == lengths[x][y-1]:
+            y -= 1
+        else:
+            assert a[x-1] == b[y-1]
+            result = a[x-1] + result
+            x -= 1
+            y -= 1
+    return result

Algorithms/dpAlgorithms/LIS.cpp

@@ -0,0 +1,57 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void printoutput(int *arr, int *out, int curi);
+
+int main()
+{
+    int arr[] = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
+    int *res;
+    int *out;
+
+    int len = sizeof(arr)/sizeof(arr[0]);
+    int max = len > 0 ? 1 : 0;
+    int n = 1;
+    int maxi = 0;
+    int i,j;
+
+    res = (int*)malloc(sizeof(int) * len);
+    out = (int*)malloc(sizeof(int) * len);
+    for (i=0; i < len; i++) {
+        res[i] = 1;
+        out[i] = -1;
+    }
+
+    for (i = 1; i < len; i++) {
+        n = res[i];
+        for (j = 0; j < i; j++) {
+            if ((arr[i] > arr[j]) && (res[j] >= n)) {
+                n = res[j] + 1;
+                out[i] = j;
+            }
+        }
+        res[i] = n;
+        if (n > max) {
+            maxi = i;
+            max = n;
+        }
+    }
+
+    printf("The LIS length is: %d\n", max);
+    printf("LIS value is:\n");
+    if (len != 0)
+        printoutput(arr, out, maxi);
+    printf("\n");
+
+    return 0;
+}
+
+void printoutput(int *arr, int *out, int curi) {
+    if (curi < 0)
+        return;
+
+    if (out[curi] != -1) {
+        printoutput(arr, out, out[curi]);
+    }
+    printf("%d ", arr[curi]);
+}

Algorithms/dpAlgorithms/LIS.java

@@ -0,0 +1,50 @@
+package dpAlgorithms;
+
+import java.util.Arrays;
+
+public class LIS {
+	
+	public static int recursiveLIS(int arr[], int i, int n, int prev) {
+		/*
+			Complexity: O(2^n)
+		*/
+		if (i == n)
+			return 0;
+		
+		int excl = recursiveLIS(arr, i+1, n, prev);
+		
+		int incl = 0;
+		if (arr[i] > prev) {
+			incl = 1 + recursiveLIS(arr, i+1, n, arr[i]);
+		}
+		
+		return Integer.max(incl, excl);
+	}
+	
+	public static int dpLIS(int arr[]) {
+		/*
+			Complexity: O(n log n)
+		*/
+		int[] L = new int[arr.length];
+		
+		L[0] = 1;
+		for(int i=1; i<arr.length; i++) {
+			for(int j=0; j<i; j++) {
+				if (arr[j]<arr[i] && L[j]>L[i]) {
+					L[i] = L[j];
+				}
+			}
+			L[i]++;
+		}
+		
+		return Arrays.stream(L).max().getAsInt();
+	}
+	
+	public static void main(String[] args) {
+		int[] arr = {0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15};
+		
+		///int len = recursiveLIS(arr, 0, arr.length, Integer.MIN_VALUE);
+		int lis_len = dpLIS(arr);
+		System.out.println("Length os LIS is: " + lis_len);
+	}
+}

Algorithms/dpAlgorithms/LPsubsequence.cpp

@@ -0,0 +1,37 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int lps(char *);
+
+int main()
+{
+    char str[] = "abcdeRTONUedcba";
+    int lps_len = lps(str);
+    printf ("Length of Longest palindromic subsequence is: %d\n", lps_len);
+
+    return 0;
+}
+
+int lps(char *str) {
+   int n = strlen(str);
+   int i, j, cl;
+   int L[n][n];
+
+
+   // Strings of length 1 are palindrome of length 1
+   for(i = 0; i < n; i++)
+      L[i][i] = 1;
+
+    for(cl=2; cl<=n; cl++) {
+        for(i=0; i<n-cl+1; i++) {
+            j = i+cl-1;
+
+            if (str[i] == str[j] && cl == 2)    L[i][j] = 2;
+            else if (str[i] == str[j])          L[i][j] = L[i+1][j-1] + 2;
+            else                                L[i][j] = max(L[i][j-1], L[i+1][j]);
+        }
+    }
+
+    return L[0][n-1];
+}
+