Count Double Increasing Series in A Range in Java

Two integers P and Q, are given to us. The task is to find the total count of a series whose current element is double or more than double than the last occurred element of the series such that any element of the series can not exceed P. It can be equal to P.

Example 1:

Input

int P = 9, int Q = 3

Output: 14

Explanation: There are total 14 series whose size is 3, and the current element is twice or more than twice than the last occurred element of the series such that each element of the series is less than or equal to 9. All those series are: {1, 2, 4}, {1, 2, 5}, {1, 2, 6}, {1, 2, 7}, {1, 2, 8}, {1, 2, 9}, {1, 3, 6}, {1, 3, 7}, {1, 3, 8}, {1, 3, 9}, {1, 4, 8}, {1, 4, 9}, {2, 4, 8}, {2, 4, 9}

Example 2:

Input

int P = 12, int Q = 4

Output: 10

Explanation: There are total 10 series whose size is 4, and the current element is twice or more than twice than the last occurred element of the series such that each element of the series is less than or equal to 12. All those series are: {1, 2, 4, 8}, {1, 2, 4, 9}, {1, 2, 4, 10}, {1, 2, 4, 11}, {1, 2, 4, 12}, {1, 2, 5, 10}, {1, 2, 5, 11}, {1, 2, 5, 12}, {1, 2, 6, 12}, {1, 3, 6, 12}

Example 3:

Input

int P = 15, int Q = 7

Output: 0

Explanation: There is no series that will be of size 7 whose current element is twice or more than twice the previous element such that each element will be less than or equal to 15. Hence, the output is 0.

Naïve Approach:

In the naïve approach, we will use recursion in a top-down manner to find the solution.

FileName: DoubleIncSeq.java

public class DoubleIncSeq 
{
    public int getTotalSeqCount(int p, int q)
    {
    // handling the base case 
    // which is if either the value of p
    // or q (sequence size) is zero, then it is 
    // not possible to generate the sequence
    // hence, the answer is 0
    if(p == 0 || q == 0)
    {
        return 0;
    }
    
    // handling another base case where the value of
    // q (sequence size) is equal to 1, then in that case
    // every number 1 to p is a sequence in itself. Therefore,
    // the answer is p.
    if(q == 1)
    {
        return p;
    }

    // recursively finding the solution where the current element is twice 
    // or more than twice the previous element
    return (getTotalSeqCount(p - 1, q) + getTotalSeqCount(p / 2, q - 1));
            
    }
    
    // main method
    public static void main(String argvs[]) 
    {
    // creating an object of the class DoubleIncSeq
    DoubleIncSeq obj = new DoubleIncSeq();
    
    // input 1
    int p = 9;
    int q = 3;
    
    // invoking the method getTotalSeqCount()
    // and storing the answer
    int ans = obj.getTotalSeqCount(p, q);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }
    
    System.out.println();
    
    // input 2
    p = 12;
    q = 4;
    
    // invoking the method getTotalSeqCount()
    // and storing the answer
    ans = obj.getTotalSeqCount(p, q);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }
    
    System.out.println();
    
    // input 3
    p = 15;
    q = 7;
   
    // invoking the method getTotalSeqCount()
    // and storing the answer
    ans = obj.getTotalSeqCount(p, q);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }
    
    }
}

Output:

There are total 14 series whose elements are <= 9 and are of size: 3

There are total 10 series whose elements are <= 12 and are of size: 4

There is no series whose elements are <= 15 and is of size: 7

Complexity Analysis: One recursive call is giving birth to two more recursive calls. Hence, the time complexity of the program is exponential.

Because of the exponential time complexity, the above program is not suitable for larger inputs. Hence, it is required to do some optimization in order to reduce the time complexity.

Approach: Recursion with Memoization

There are many subproblems in the above program that are solved again and again. Therefore, it is required to avoid the repetition of the subproblems with the help of a two-dimensional array that stores the answer to the computed subproblems. The illustration of the same is mentioned in the following program.

FileName: DoubleIncSeq1.java

public class DoubleIncSeq1 
{
    // a method that assigns -1 to 
    // each element of the 2-D array 
    public void initialize(int dp[][])
    {
        int r = dp.length;
        int c = dp[0].length;
        
        for(int i = 0; i < r; i++)
        {
            for(int j = 0; j < c; j++)
            {
                dp[i][j] = -1;
            }
        }
    }
    
    
    public int getTotalSeqCount(int p, int q, int dp[][])
    {
    // handling the base case 
    // which is if either the value of p
    // or q (sequence size) is zero, then it is 
    // not possible to generate the sequence
    // hence, the answer is 0
    if(p == 0 || q == 0)
    {
        return 0;
    }
    
    // handling another base case where the value of
    // q (sequence size) is equal to 1, then in that case
    // every number 1 to p is a sequence in itself. Therefore,
    // the answer is p.
    if(q == 1)
    {
        return p;
    }
    
    // the value of dp[p][q] is already computed
    // hence no need to compute it again. We can simply
    // return the value of dp[p][q]
    if(dp[p][q] != -1)
    {
        return dp[p][q];
    }

    // recursively finding the solution where the current element is twice 
    // or more than twice the previous element
    dp[p][q] = (getTotalSeqCount(p - 1, q, dp) + getTotalSeqCount(p / 2, q - 1, dp));
    return (getTotalSeqCount(p - 1, q, dp) + getTotalSeqCount(p / 2, q - 1, dp));
            
    }
    
    // main method
    public static void main(String argvs[]) 
    {
    // creating an object of the class DoubleIncSeq1
    DoubleIncSeq1 obj = new DoubleIncSeq1();
    
    // input 1
    int p = 9;
    int q = 3;
    
    
    // creating a 2-D array temp for memoization
    int temp[][] = new int[p + 1][q + 1];
    
    // invoking the method initialize that
    // assign -1 to each element of the 2-D
    // array temp
    obj.initialize(temp);
    
    // invoking the method getTotalSeqCount()
    // and storing the answer
    int ans = obj.getTotalSeqCount(p, q, temp);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }
    
    System.out.println();
    
    // input 2
    p = 12;
    q = 4;
    
    // creating a 2-D array temp1 for memoization
    int temp1[][] = new int[p + 1][q + 1];
    
    // invoking the method initialize that
    // assign -1 to each element of the 2-D
    // array temp
    obj.initialize(temp1);
    
    // invoking the method getTotalSeqCount()
    // and storing the answer
    ans = obj.getTotalSeqCount(p, q, temp1);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }
    
    System.out.println();
    
    // input 3
    p = 15;
    q = 7;
    
    // creating a 2-D array temp2 for memoization
    int temp2[][] = new int[p + 1][q + 1];

    // invoking the method initialize that
    // assign -1 to each element of the 2-D
    // array temp
    obj.initialize(temp2);
    
    // invoking the method getTotalSeqCount()
    // and storing the answer
    ans = obj.getTotalSeqCount(p, q, temp2);
    
    if(ans > 0)
    {
    System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
    }
    else
    {
    System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
    }    
    }
}

Output:

There are total 14 series whose elements are <= 9 and are of size: 3

There are total 10 series whose elements are <= 12 and are of size: 4

There is no series whose elements are <= 15 and is of size: 7

Complexity Analysis: Because of the memoization, the time complexity of the program is O(p x q). Also, the program is using an auxiliary array for storing the answer of the subproblem, making the space complexity of the program O(p x q), where p is the maximum value an element can have in the required series and q is the total count of the series found.

As it is a known fact that the iterative approach is always better than the recursive approach, we will try to write the above program using loops.

FileName: DoubleIncSeq2.java

public class DoubleIncSeq2 
{

public int getTotalSeqCount(int p, int q)
{

// creating a 2-D array temp for memoization
int dp[][] = new int[p + 1][q + 1];

for (int m = 0; m < p + 1; m++)
{
for (int n = 0; n < q + 1; n++)
{
// handling the base case 
// which is if either the value of m
// or n (the sequence size) is zero, then it is 
// not possible to generate the sequence
// hence, the answer is 0
if (m == 0 || n == 0)
{
dp[m][n] = 0;
}

// a sequence can never exist if its length
// is greater than the maximum value
// cannot exist
else if (m < n)
{
dp[m][n] = 0;
}

// handling another base case where the value of
// n (sequence size) is equal to 1, then in that case
// every number 1 to m is a sequence in itself. Therefore,
// the answer is m.

else if (m == 1)
{
dp[m][n] = m;
}

// else do the calculation
else
{
dp[m][n] = dp[m - 1][n] + dp[m / 2][n - 1];
}
}
}
return dp[p][q];    



}

// main method
public static void main(String argvs[]) 
{
// creating an object of the class DoubleIncSeq2
DoubleIncSeq2 obj = new DoubleIncSeq2();

// input 1
int p = 9;
int q = 3;

// invoking the method getTotalSeqCount()
// and storing the answer
int ans = obj.getTotalSeqCount(p, q);

if(ans > 0)
{
System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
}
else
{
System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
}

System.out.println();

// input 2
p = 12;
q = 4;

// invoking the method getTotalSeqCount()
// and storing the answer
ans = obj.getTotalSeqCount(p, q);

if(ans > 0)
{
System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
}
else
{
System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
}

System.out.println();

// input 3
p = 15;
q = 7;

// invoking the method getTotalSeqCount()
// and storing the answer
ans = obj.getTotalSeqCount(p, q);

if(ans > 0)
{
System.out.println("There are total " + ans + " series whose elements are <= " + p + " and are of size: " + q);
}
else
{
System.out.println("There is no series whose elements are <= " + p + " and is of size: " + q);    
}



}
}

Output:

There are total 14 series whose elements are <= 9 and are of size: 3

There are total 10 series whose elements are <= 12 and are of size: 4

There is no series whose elements are <= 15 and is of size: 7

Complexity Analysis: The time, as well as space complexity of the program is the same as the previous program.

Next TopicLongest Consecutive Subsequence in Java

← prev next →