Dynamic Programming (I)

1. Dynamic Programming

　　Generally speaking, Dynamic Programming (DP) is an algorithmic paradigm where we solve an optimization problem with optimal structure in a bottom-up way to avoid overlapping sub-problems. According to CLRS, a problem exhibits optimal structure if you need to find the solution to its sub-problems before accomplishing the whole optimization problem. In this sense, every problem that can be solved by DP is based on a DAG structure, where each node is a sub-problem and a sub-problem can be solved only if its preceding sub-problems have been solved.

　　We refuse to solve the DP problems in a recursive way in that we will be faced with a lot of overlapping sub-problems, which render such solution awfully inefficient. Usually, we choose to sacrifice space in order to save time when we exploit the optimal structure of an optimization problem. Moreover, there are some space compression techniques to minimize the cost of a solution. 

2. Knapsack Problems

　　About the description of Knapsack Problems, please refer to wikipedia.

　　(1)  Here is my solution to Knapsack with repetition:

    public static int solve(int num, int vol)   {
        // Here we use DP to solve Unbounded Knapsack Problem
        // Precondition: cost[] and value[] are the weights and values
        //            of the num objects respectively
        // Postcondition: the maximum value that a knapsack with 
        //            capacity vol can contain is returned
        int[] dp = new int[vol+1];
        for (int i=0;i<=vol;i++){
            // Solve the problem in a bottom-up way, so that
            //        for all j<=i dp[j] will be the max value that a knapsack
            //        of capacity v can contain
            for (int j=0;j<=num;j++){
                if (cost[j]<=i && dp[i-cost[j]]+value[j]>dp[i]) {
                    dp[i] = dp[i-cost[j]]+value[j];
                }
            }
        }
        return dp[vol];
    }

　　(2)  This is my solution to Knapsack without repetition:

    public static int solve(int num,int vol)  {
        // Here we use DP to solve 0 - 1 Knapsack Problem
        // Precondition: cost[] and value[] are the weights and values
        //            of the num objects respectively
        // Postcondition: the maximum value that a knapsack with 
        //            capacity vol can contain is returned
        int [][] dp = new int[vol+1][num+1];
        //     dp[i][j] will be the max value that a knapsack of capacity i
        //            can contain by choosing objects from 0 to j-1
        // Basic Cases:    dp[i][j] = 0, for all (i==0||j==0)
        for (int j=1;j<=num;j++) {
            for (int i=1;i<=vol;i++) {
                dp[i][j] = dp[i][j-1];
                if (cost[j-1]<=i && dp[i-cost[j-1]][j-1]+value[j-1]>dp[i][j]) {
                    dp[i][j] = dp[i-cost[j-1]][j-1]+value[j-1];
                }
            }
        }
        return dp[vol][num];
    }

3. Maximum Sum of Consecutive Subsequence

　　Many dynamic programming problems relies on a recursive structure like sequences, such as the classical Longest Common Subsequence introduced in CLRS. In this section, I wish to offer my solution to POJ 2479, a problem that requires to calculate the maximum sum among all the consecutive sub-sequences of a given integer sequence.

import java.util.*;

public class Main {
    public static Scanner in;
    public static int num;
    public static int [][] dp;
    
    public static long maxSum()  {
        for (int i=1;i<num;i++) {
            // Invariant: for j<=i, dp[j][0] will be the max
            //        sum of all the sub-sequences ending at j
            if (dp[i-1][0]>0) {
                dp[i][0]+=dp[i-1][0];
            }
        }
        for (int i=1;i<num;i++) {
            // Invariant: for j<=i, dp[j][0] will be the max
            //        sum of all the sub-sequences whose ending
            //        index is no larger than j
            if (dp[i-1][0]>dp[i][0]) {
                dp[i][0] = dp[i-1][0];
            }
        }
        for (int i=num-2;i>=0;i--) {
            // Invariant: for j>=i, dp[j][0] will be the max
            //        sum of all the sub-sequences starting at j
            if (dp[i+1][1]>0) {
                dp[i][1]+=dp[i+1][1];
            }
        }
        for (int i=num-2;i>=0;i--) {
            // Invariant: for j>=i, dp[j][0] will be the max
            //        sum of all the sub-sequences whose starting
            //        index is no less than j
            if (dp[i+1][1]>dp[i][1]) {
                dp[i][1] = dp[i+1][1];
            }
        }
        int val = dp[0][0]+dp[num-1][1];
        for (int i=1;i<num;i++) {
            if (dp[i-1][0]+dp[i][1]>val) {
                val = dp[i-1][0]+dp[i][1];
            }
        }
        return val;
    }
    public static void main(String[] args) {
        in = new Scanner(System.in);
        dp = new int [50000][2];
        int t = in.nextInt();
        String line; StringTokenizer str;
        for (int i=0;i<t;i++) {
            num = in.nextInt();
            in.nextLine();        // skip the newline symbol
            line = in.nextLine();     // nextInt() is too time-consuming
            str = new StringTokenizer(line);
            for (int j=0;j<num;j++) {
                dp[j][0] = dp[j][1] = Integer.parseInt(str.nextToken());
            }
            System.out.println(maxSum());
        }
        in.close();
    }
}

References:

　　1. Cormen, T. H. et al. Introduction to Algorithms[M].北京：机械工业出版社，2006-09
　　2. Dasgupta, Sanjoy, Christos Papadimitriou, and Umesh Vazirani. Algorithms[M].北京：机械工业出版社，2009-01-01