Algorithms Q&A - Recent questions and answers in Dynamic Programming

Answered: Minimizing Weight of a Linear Partition

Sat, 16 Dec 2023 18:39:46 +0000

To minimize the weight of the linear k-partition of the given array A[1:n], you can use dynamic programming. Define a 2D array DP where DP[i][j] represents the minimum weight of the linear j-partition for the subarray A[1:i]. The recurrence relation can be expressed as follows:

DP[i][j] = min{1 < x < i} { DP[x][j-1] + sum(A[x+1:i]) }]

Here, sum(A[x+1:i]) represents the sum of elements in the subarray A[x+1:i].

The base case is DP[i][1] = sum(A[1:i]) since the minimum weight of a linear 1-partition is the sum of the entire array.

The final answer will be in DP[n][k], as it represents the minimum weight of the linear k-partition for the entire array A.

DP[i][j] = min(DP[i][j], DP[x][j - 1] + prefix_sums[i] - prefix_sums[x])

return DP[n][k]

code:

def linear_k_partition(A, k):

n = len(A)

prefix_sums = [0] * (n + 1)

for i in range(1, n + 1):

prefix_sums[i] = prefix_sums[i - 1] + A[i - 1]

DP = [[float('inf')] * (k + 1) for _ in range(n + 1)]

for i in range(1, n + 1):

DP[i][1] = prefix_sums[i]

for j in range(2, k + 1):

for i in range(1, n + 1):

for x in range(i):

DP[i][j] = min(DP[i][j], DP[x][j - 1] + prefix_sums[i] - prefix_sums[x])

return DP[n][k]

A = [4, 8, 7, 6, 5, 1, 2, 3]

k = 3

result = linear_k_partition(A, k)

print(result)

Answered: DNA sequences

Sat, 16 Dec 2023 17:55:42 +0000

Notation: LCS(i,j) represents the length of maximum common subsequence of the respective strings A(0...i), B(0....j)

Optimality: To get the Longest Common Subsequence (LCS) at position (i)(j)

when the final characters of two strings, A and B, do not match (A(i) is not equal to B(i)), take the maximum of two values: LCS(i)(j) = MAX(LCS(i-1)(j), LCS(i)(j-1)).

if A(i) equal to B(i) then LCS(i)(j) = 1+ LCS(i-1)(j-1)

This illustrates the notion that the LCS is affected by the LCS values derived by removing the final character from each string when the last characters are not identical.

Recurrence Relation: if A(i)!=B(i) then LCS(i, j) =max( LCS(i-1,j) ,(i, j-1)

if A(i)=B(j) then LCS(i, j) = 1 + LCS(i-1,j-1)

Algorithm:

def find_lcs(A, B):

dp = [[0] * (len(B) + 1) for _ in range(len(A) + 1)]

for i in range(1, len(A) + 1):

for j in range(1, len(B) + 1):

dp[i][j] = dp[i-1][j-1] + 1 if A[i-1] == B[j-1] else max(dp[i-1][j], dp[i][j-1])

lcs = ''.join([s1[i-1] for i, j in zip(range(len(A), 0, -1), range(len(B), 0, -1)) if dp[i][j] != dp[i-1][j] and dp[i][j] != dp[i][j-1]])

return lcs

s1 = "ACTGACT"

s2 = "CAAGCATA"

result = find_lcs(s1, s2)

print(result)

As we are storing the results of sub-problem in the array of size n1*n2 so the time and space complexity of this problem is O(n1*n2)

Answered: “Teleportation” across astro-haunted galaxies

Wed, 13 Dec 2023 20:43:14 +0000

We observe that the problem is similar to all pairs shortest path problem, but in addition to that, we have the constraint that we can go through at most m astro-haunted galaxies. We model this constraint also in our notation.

Notation Let D(i,j,k) denote the cost of the shortest path from i to j using at most k astro-haunted galaxies.

Recursive Formulation Recursive formulation on D(i,j,k) can be written on the variable k and by deciding on the last astro-haunted galaxy on the path from i to j . D(i,j,k) = min { D(i,j,k-1), min (1≤z≤n | A[z]=1 ) {D(i,z,k-1) + D(z,j,0)} } We observe that A[z] = 1 constraint specifies that the galaxy z is astro haunted.

Further, by taking the minimum with D(i,j,k-1) we satisfy the constraint of at most k astro-haunted galaxies, while still avoiding pitfall of leaving this value undefined in case there is no astro haunted galaxy.

Base Case D(i,j,0) can be solved simply by using All Pairs Shortest Path and by eliminating all astro-haunted galaxies.

Algorithm The algorithm can easily be written in terms of for loops for each of the indices in the notation of D(i,j,k) . As is often observed, the index of the main recursive formulation usually forms the outermost loop.

// Step 1: Base Case

Calculate D[i][j][0] as All Pairs Shortest path by ignoring the astro haunted galaxies.

// Step 2: Inductive Step

for k = 1 to m

for i = 1 to n

for j = 1 to n

Calculate D[i][j][k] = min {D([i][j][k-1], D[i][z][k-1] + D[z][j][0] for all z such that A[z] = 1}

Time Complexity

Time Complexity of base case: O(n^3 ) from the all pairs shortest path problem. Each calculation of D(i,j,k) takes O(n) time. Further, there are kn^2 entries in the dynamic programming table. Therefore, the total time Complexity of recursive portion: O(k n^3) Therefore, the total time complexity is O(k n^3 ).

Answered: Barbie's Array of Diamonds

Wed, 13 Dec 2023 05:26:01 +0000

Notation: We shall call the list diamonds[i], where i ranges from 0 to n, be the list of all of Barbie's diamonds. We also have corresponding tuple (shiny_i, weight_i) values for each i-th diamond in diamonds[i]. Let D(i) be the maximum number of diamonds in line for the i-th diamond.

Optimal Substructure: The maximum number of diamonds in line for the i-th diamond depends on the maximum number of diamonds in line for a smaller index diamond.

Recurrence Relation: D(i) = 1 + max(D(j)) for j < i where shiny_j < shiny_i and weight_j < weight_i; or D(i) = 1 if no such j exists.

Algorithm:

```
def barbie(diamonds):
n = len(diamonds)

# Initialize D(i) array, which is the DP table. Initially, each diamond forms a line with itself, therefore = 1. When D is filled, we look for max(D) as the solution for max number of diamonds in a line.
D = [1] * n

# Sort diamonds by shiny value
diamonds = sorted(diamonds, key=lambda x: x[0]) # According to wiki, Timsort worst case is O(n log n)

# Fill DP table. Start at index 1.
for i in range(1, n):
for j in range(i):
shiny_j, shiny_i = diamonds[j][0], diamonds[i][0]
weight_j, weight_i = diamonds[j][1], diamonds[j][1]
if (shiny_j < shiny_i) and (weight_j < weight_i):
D[i] = max(D[i], D[j] + 1) # Is the current line greater regardless or is there a valid diamond to add to the line?

# Return max number of diamonds in a line found.
return max(D)

diamonds = [(5, 10), (6, 12), (4, 8), (7, 15), (3, 5)]
barbie(diamonds) # Answer is 5 diamonds in a line. If you sort the diamonds list by shiny value, the LIS according to weight is 5.
```

Time complexity: solution runs in O(n^2 * log n)

Answered: Maximize value of coins from k stacks, of n coins each

Tue, 12 Dec 2023 22:59:40 +0000

Notation: Let MCV(V, i, j) denote the maximum coin value that we can obtain given the list of coins V[i..j] . Further, let S(V,i,j) denote the sum of the values of all the coins in V[i..j] .
Recursive Formulation: We observe that once the first player pockets the first or the last coin, the opponent realizes the maximum value from the remaining list. Therefore, the value realized by the first player is the sum of the list minus the value realized by the opponent. Therefore, we can write MCV(V,i,j) as:
MCV(V,i,j)= ma x {S(V,i,j) – MCV(V – v i ), S(V,i,j) MCV(V – v j )}
This can further be written as: MCV(V,i,j)=S(V,i,j) – mi n {MCV(V – v i ), MCV(V – v j ) }
The base case of the recurrence can be set as MCV(φ) = 0 , or equivalently that the value that can be realized by a single element list is the value of that element.
Algorithm: This algorithm works like many other algorithms that need to “grow” the range of the array. Specifically, the iterations can work as follows:
Notation: Let MCV(V, i, j) denote the maximum coin value that we can obtain given the list of coins V[i..j] . Further, let S(V,i,j) denote the sum of the values of all the coins in V[i..j] .
Recursive Formulation: We observe that once the first player pockets the first or the last coin, the opponent realizes the maximum value from the remaining list. Therefore, the value realized by the first player is the sum of the list minus the value realized by the opponent. Therefore, we can write MCV(V,i,j) as:
MCV(V,i,j)= ma x {S(V,i,j) – MCV(V – v i ), S(V,i,j) MCV(V – v j )}
This can further be written as: MCV(V,i,j)=S(V,i,j) – mi n {MCV(V – v i ), MCV(V – v j ) }
The base case of the recurrence can be set as MCV(φ) = 0 , or equivalently that the value that can be realized by a single element list is the value of that element.
Algorithm: This algorithm works like many other algorithms that need to “grow” the range of the array. Specifically, the iterations can work as follows:
double[][] S = new double[n][n];

double[][] MCV = new double[n][n];

// Initialize S[i,i] = V[i]

// Initialize MCV[i,i] = V[i]

for i=0 to n-2

for j=i+1 to n-1

S[i,j]=S[i,j-1]+V[j]

for k=1 to n-1

for i=0 to n-2

MCV[i,i+k] = S[i,i+k] - min{MCV[i+1,i+k], MCV[i,i+k-1]}

Answered: Selecting lowest cost hotel rooms, with no adjacent rooms selected

Sun, 10 Dec 2023 22:28:21 +0000

Notation: Suppose S(i,j) is the smallest cost of selecting j hotel rooms from 1..i hotel rooms
The principle of optimality holds i.e., it has optimal sub-structure
Base Case S(1,1) = c[1]
We need to find S(n,k).
Recursive Formulation: S(i,j) = min { S(i-1,j), S(i-2,j-1) + c[i] }

Algorithm:

for i = 1 to n

for j = 1 to k

S(i,j) = min { S(i-1,j), S(i-2,j-1) + c[i] }

Time Complexity= O(nk)

Answered: "SpicyBitter" Sequence of Sauces

Thu, 02 Jul 2020 10:34:50 +0000

Let us tackle it by sorting the list of sauces by the characteristics of Spiciness and Bitterness and apply the Longest increasing sub-sequence problem. We can consider a sauce to be greater when BOTH spiciness and bitterness is strictly greater than another sauce.

The LISA algorithm is as follows:

Let A[1...n] represents the sauce options and let B(i) represents the size of the longest strictly increasing subsequence that ends at position i.

That sequence must include A[i], thus, each B(i) is, at least, 1. We can conclude, we can

write the recurrence as:

B(1)=1
B(i) = max {B(j)}+1, such that j < i and A[j] < A[i]

We observe that to calculate each L(i), we need O(n) time, to examine the A[j] values against A[i], for all j < i.
Thus, we can calculate all B(i) values in O(n^2) time, then find the largest one in O(n) time. Therefore, overall complexity is O(n^2). Even though, we can try to make it better by finding the largest value by updating B (i) in the recurrence.

Answered: Love (Skip) thy neighbor

Tue, 23 Jun 2020 21:15:55 +0000

Using S(j) represent the maximum sum of the points that can be achieved by first j numbers

S(j) can be defined recursively as follows:

s(j)=max{s(j-1),s(j-2)+pv[j]}

The two arguments in the max function correspond to the cases where we select (j – 1)-th element and then j-th element, or we select j-th element and (j – 1)-th element. As if S(j) is optimal, then the sub-solutions S(j-1) and S(j-2) must be optimal as well.

the persudo code is

S[1] = a[1]

S[2] = max{pv[1], pv[2]}

for j = 3 to n

S[j] = max {S[j-1], S[j-2]+pv[j]

The time complexity is O(n).

Answered: Gold is a precious metal

Wed, 08 May 2019 16:43:10 +0000

Notation: let f[i][v] means the max value for the total i choice along with the total v length.

Recursion: f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

Algorithm:

int main()
{
    //int m = 120;
    //int n = 5;
    //vector<int> w = { 0, 40, 50, 70, 40, 20 };
    //vector<int> v = { 0, 10, 25, 40, 20, 10 };

    int m, n;    
    while (cin >> m >> n)
    {
        vector<int> w(n + 1, 0);
        vector<int> v(n + 1, 0);
        for (int i = 1; i <= n; i++)
        {
            int tmp;
            cin >> tmp;
            w[i] = tmp;
        }
        for (int i = 1; i <= n; i++)
        {
            int tmp;
            cin >> tmp;
            v[i] = tmp;
        }
        vector< vector<int> > vec(n + 1, vector<int>(m + 1, 0));
        for (int i = 1; i <= n; i++)
        {
            for (int j = 1; j <= m; j++)
            {
                if (w[i] > j)
                    vec[i][j] = vec[i - 1][j];
                else
                {
                    int tmp1 = v[i] + vec[i - 1][j - w[i]];
                    int tmp2 = vec[i - 1][j];
                    vec[i][j] = tmp1 > tmp2 ? tmp1 : tmp2;
                }
            }
        }
        double val = vec[n][m] * 0.1;
        cout << val << endl;
    }

    system("pause");
}

Answered: If you are happy and you know it, jump up high!

Thu, 02 May 2019 06:10:51 +0000

A simple retreat, you only have three actions to reach the final state

Answered: Around the block party planning

Thu, 02 May 2019 05:55:52 +0000

You must traverse, so it is impossible to be better than O(n)

Answered: Maximum Value Contiguous Subregion

Thu, 02 May 2019 04:55:43 +0000

First judge what kind of rectangle I want to get. If the negative numbers are the majority, the rectangle is very small. On the contrary, this rectangle is very large. Choose from the sum of the rectangle. The worst case is the negative number is not the majority but very small or otherwise. But divide into two situations will quicker in most case.

If it is a large rectangle, I will shrink from the outside to the inside, as long as the sum of the reduced circles is negative, continue to shrink. If it is positive, check the negative number in the circle and the size of the circle. If it is still regular, Otherwise continue until the confirmation is correct, going back to the best known result.

If it is a small rectangle, it expands from the largest positive number, and each positive number expands to the best result when the total is negative, until the traversal of all positive possibilities.

Answered: Cost Minimizing Ice Cream Shop

Thu, 02 May 2019 02:49:47 +0000

In fact, it is far more complicated than your model. The shipped goods are not necessarily consumed in one day. The consumption of the same volume of ice cream is not linear.

Answered: Make change using smallest number of coins of given denominations

Thu, 12 Jul 2018 03:38:15 +0000

Would this be a greedy approach? You are taking the optimum number of higher value coins in each iteration

Notation:

M = value to make change for

C = the number of coins used

V = coin denominations, V[i] gives the value for i-th coin

for i = k to 1

while M >= V[i]

C += 1

M -= V[i]

Answered: 1-D k-means clustering

Wed, 09 May 2018 02:41:33 +0000

Sorry, I just found that I can not prove the optimility of this solution. Maybe It is not an optimal solution.

Answered: Canoeing on the cheap

Thu, 08 Mar 2018 19:32:33 +0000

I guess this is a example of All Pair Shartest Path Dynamic Programming algorithm where we have to return the Shortest Path from 1 to N

Answered: Calculate g(1000) given the following definition of g function..

Sun, 22 Oct 2017 00:28:23 +0000

This problem is very similar to the fib by using dynamic programming.

The solution is using tabulation.

memo=[1]*1001
memo[0]=0
def g(n):
    if n<=0:
        return memo[0]
    elif n<=10:
        return memo[n]
    for i in range(11,n+1):
        memo[i]=memo[i-1]+3*memo[i-3]+7*memo[i-10]
    return memo[n]

print(g(1000))

Answered: Maximum Value But Limited Neighbors

Tue, 18 Jul 2017 21:02:06 +0000

Notation

MVBLN(i,m): Maximum value sum that can be achieved from the array A[1..i], using adjacent 1s at most m times.

Recurrence Relation

MVBLN(i,m) = max{MVBLN(i-1,m), MVBLN(i-1,m-1) + A[i], MVBLN(i-2,m) + A[i]}

Base Case: MVBLN(i,0) can be solved separately, using a separate problem, that we can call maximum value no neighbors. MVNN(i) = max{MVNN(i-1), MVNN(i-2) + A[i]}. MVNN(0) = 0. MVNN(1) = a[1]. MVNN(2) = max{a[1], a[2]}.

Optimality

MVBLN(i,m) is either an extension of MVBLN(i-1,m-1) that includes A[i], or extends MVBLN(i-2,m) that includes A[i], or something that uses MVBLN(i-1,m) and just ignores A[i].

Answered: Magical eggs and tiny floors

Mon, 19 Jun 2017 18:26:49 +0000

We can use dynamic programming to solve this problem.

Notation: M[i][j]: The minimized number of throws when we have i eggs and j floors to test. We also have the base case: M[n][1]=1, M[1][n]=n.( Note: If we just have 1 floor, we only have to throw one time; If we have 1 egg and n floor to try, we can start at the first floor and we may have n throws in the worst case.)

Optimality: We can throw the egg from k floor at first. If the egg is broken, we will test the remaining (j-k) floors in the worst case; if the egg is not broken, we will test the remaining (k-1) floors in the worst case.

Recurrence relation: M[i][j] = min{max{M[i-1][k-1],M[i][j-k]} + 1} ( Note: We use the max at here because we need to consider the worst case of them. )

Algorithm:

for i = 1 to m
         for j = 1 to n
                for k = 1 to n
                    M[i][j] = min{max{M[i-1][k-1],M[i][j-k]} + 1}