"Algorithms that programmers must master" Dynamic Programming "Part 2"

"Algorithms that programmers must master" Dynamic Programming "Part 2"

In the daily work of programmers, mastering various algorithms is essential. Dynamic programming is a commonly used algorithm and is widely used in solving optimization problems. This article mainly introduces the medium difficulty content of dynamic programming, including two-dimensional DP and digital DP.

2DDP

Two-dimensional dynamic programming (DP) refers to using a two-dimensional array to represent the state, where the first dimension represents which element is selected, and the second dimension represents the currently selected state. This method is particularly useful when solving problems where the state that needs to be transferred is relatively complex.

Example 1: Matrix path counting

Problem description: Given an $n\times In\; the\; matrix\; m$ , how many ways are there in total from the upper left corner to the lower right corner? Each time you can only go right or down.

Idea analysis: define state $d{p}_{i,j}$means from $(1,1)$ Go to$(i,j)$ , then the state transition equation can be defined as:$d{p}_{i,j}=d{p}_{i-1,j}+d{p}_{i,j-1}$, where $d{p}_{i-1,j}$Indicates walking from the above position to $(i,j)$，$d{p}_{i,j-1}$Indicates walking from the left position to $(i,j)$ , adding the number of solutions in the two situations can be obtained from$(1,1)$ Go to$(i,j)$ number of options. In particular, when$i=1$ or$j=When\; 1$ , there is only one path, so$d{p}_{1,j}=d{p}_{i,1}=1$。

Finally, return $d{p}_{n,m}$It is the number of options from the upper left corner to the lower right corner.

int[][] dp = new int[n][m];
for (int i = 0; i < n; i++) {
    
    
    dp[i][0] = 1;
}
for (int i = 0; i < m; i++) {
    
    
    dp[0][i] = 1;
}
for (int i = 1; i < n; i++) {
    
    
    for (int j = 1; j < m; j++) {
    
    
        dp[i][j] = dp[i-1][j] + dp[i][j-1];
    }
}
return dp[n-1][m-1];

Digital DP

Digital DP refers to an algorithm that uses each digit of a number as a state to solve number-related problems. The idea of ​​​​digital DP is to take the numbers apart, process them bit by bit according to the number of digits, solve the number of solutions for each digit, and finally combine them to get the final result.

Example 2: The sum of the numbers is kknumber of$k\; numbers$

Problem description: Given two positive integers $a$ and$b$ , find that$a\le x\le b$ , andxxThe sum of all the numbers in$x$ is equal to kkThe number of natural numbers of$k\; .$

Idea analysis: We can use digital DP to solve this problem. Like the previous example, we define the state $d{p}_{i,j,k}$Indicates that the current processing reaches the $i$ digit, the sum of the numbers is$The\; number\; of\; options\; for\; j$ . Then the state transition equation can be defined as:$d{p}_{i,j,k}=\sum _{d=0}^{9}d{p}_{i-1,j-d,k-1}$, where $d$ represents the number currently processed, which is the$i$ -digit number. Then$d{p}_{i-1,j-d,k-d}$It means the previous $i-The\; sum\; of\; 1$ -digit numbers is$j-d$ , the number of digits is$k-$The number of solutions is$1$$The\; situations\; of\; d$ are accumulated together to get$d{p}_{i,j,k}$value. In particular, when $i=0$ and$j=k=When\; 0$ , this can be regarded as a legal solution, that is,$d{p}_{0,0,0}=1$。

Next, we optimize the state of digital DP, because for a number $n$ , the sum of its digits is at most$9$ , so$d{p}_{i,j,k}=0$ when$j>9k$ , that is, the current processing reaches the$i$ digit, the sum of numbers is greater than9 k 9kYou can skip it directly at$9k$$.$In addition, in order to facilitate calculation, we can convert the upper limit into a string, such as$b=1234$ is converted into$s="1234"$ , then consider bit by bit, if$s_i<d$ , then the current number cannot be$d$ , the next bit needs to continue to be considered, if$s_i=d$ , then the current number can be taken as$d$ , the next bit also needs to be considered, if$s_i>d$ , then the next digit can be filled with any number without further consideration.

When implementing, we need to use a $The\; sum$ variable is used to record the sum of the various digits of the current number, and the number of solutions in all states is added to obtain the final result.

public int count(int n, int k) {
    
    
    int[][][] dp = new int[11][91][91];
    dp[0][0][0] = 1;
    for (int i = 1; i <= 10; i++) {
    
    
        for (int j = 0; j <= 81; j++) {
    
    
            for (int l = 0; l <= 81; l++) {
    
    
                for (int d = 0; d <= 9; d++) {
    
    
                    if (j >= d && l >= d) {
    
    
                        dp[i][j][l] += dp[i - 1][j - d][l - d];
                    }
                }
            }
        }
    }
    int ans = 0;
    String s = String.valueOf(n);
    int[] num = new int[s.length() + 1];
    for (int i = 0; i < s.length(); i++) {
    
    
        num[i + 1] = s.charAt(i) - '0';
    }
    for (int i = 1; i < num.length; i++) {
    
    
        for (int j = 0; j < num[i]; j++) {
    
    
            if (j <= k - ans - (num.length - i) * 9) {
    
    
                ans += dp[num.length - i][k - ans - j][(num.length - i) * 9 + j];
            }
        }
        if (num[i] > k - ans - (num.length - i) * 9) {
    
    
            break;
        }
        sum += num[i];
    }
    if (sum == k) {
    
    
        ans++;
    }
    return ans;
}

Conclusion

This article mainly introduces the medium difficulty content of dynamic programming, including two-dimensional DP and digital DP, and attaches two example questions as a template reference. Through practical application and practice, I believe readers can have a deeper understanding of the ideas and applications of dynamic programming.