Longest Repeating Subsequence

Find length of the longest repeating subsequence such that the two subsequences don’t have same string character at same position, i.e., any k’th character in the two subsequences shouldn’t have the same index in the original string.

This problem can be solved using the Longest Common Subsequence problem. LRS(str, str) where str is the input string with the restriction that when both the characters are same, they shouldn’t be on the same index in the two strings.

package amazon.dp;

public classLongestRptSubseq {

     private static int getLRS(String string) {

          

           char[] charArray = string.toCharArray();

           int len = charArray.length;

          

           int[][] dp = new int[len+1][len+1];

          

           for(int i=1;i<=len;i++) {

               

                for (int j=1;j<=len;j++) {

                     // If characters match and indexes are not same

                     if (charArray[i-1] == charArray[j-1] && i!=j) {

                           dp[i][j] =  1 + dp[i-1][j-1];

                          

                     } else {

                           // If characters do not match

                           dp[i][j] = Math.max(dp[i][j-1], dp[i-1][j]);

                     }

                }

           }

          

           return dp[len-1][len-1];

     }

     public static voidmain(String[] args) {

           String string = "amazonazom";

           int len = getLRS(string);

           System.out.println("Longest Repeating Subsequence "+len);

     }

}

Count number of ways to cover a distance

Count total number of ways to cover the distance with 1, 2 and 3 steps.

Recursion solution time complexity is exponential i.e. O(3n).

Since same sub problems are solved again, this problem has overlapping sub problems property. So min square sum problem has both properties of a dynamic programming problem.

public class MaxStepsCount {

     /** Dynamic Programming. */

     private static int getMaxWaysDP(int distance) {

           int[] count = new int[distance+1];

           count[0] = 1;

           count[1] = 1;

           count[2] = 2;

           /** Memorize the Sub-problem in bottom up manner*/

           for (int i=3; i<=distance; i++) {

                count[i] = count[i-1] + count[i-2] + count[i-3];               

           }

           return count[distance];

     }

     /** Recursion Approach. */

     private static int getMaxWaysRecur(intdistance) {

           if(distance<0) {

                return 0;

           } else if(distance==0) {

                return 1;

           }

           return getMaxWaysRecur(distance-1)+getMaxWaysRecur(distance-2)

                     +getMaxWaysRecur(distance-3);

     }

     public static void main(String[] args) {

           // Steps pf 1, 2 and 3.

           int distance = 10;

           /** Recursion Approach. */

           int ways = getMaxWaysRecur(distance);

           System.out.println(ways);

           /** Dynamic Programming. */

           ways = getMaxWaysDP(distance);

           System.out.println(ways);

     }

}

Find a Pair Whose Sum is Closest to Zero in Array

This problem is also called minimum absolute sum pair.

You are given an array of integers, containing both +ve and -ve numbers. You need to find the two elements such that their sum is closest to zero.

importjava.util.Arrays;

/**

 * Class to find the pair whose sum closer to zero.

 * @authorrajesh.kumar

 */

public classSumClosestToZero {

     public static voidmain(String[] args) {

           int[] array = {10,12,14,16,-8,10,18,19,7,-6};

           getPairWithCloserToZeroSum(array);

     }

     /**

      * Method to print the pair.

      * @param array

      */

     private static voidgetPairWithCloserToZeroSum(int[] array) {

           Arrays.sort(array);

           int length = array.length;

          

           if(length==0 || length==1) {

                System.out.println("No pair exists !!");

           }

          

           int i = 0;

           int j = length -1;

           int minSum = array[i] + array[j];

           int minL = i; int minR= j;

           while (i  <  j) {

                int sum = array[i] + array[j] ;

                /* If sum of the elements at index i and j equals 0 */

                if (Math.abs(minSum)>Math.abs(sum)) {

                     minSum = sum;

                     minL = i;

                     minR = j;

                } else if(sum<0) {

                     i++;

                 } else {

                     j--;

                }

           }

           System.out.println("Pair is"

               +array[minL]+","+array[minR]+")");

     }

}