zoukankan      html  css  js  c++  java
  • DP的初级问题——01包、最长公共子序列、完全背包、01包value、多重部分和、最长上升子序列、划分数问题、多重集组合数

      当初学者最开始学习 dp 的时候往往接触的是一大堆的 背包 dp 问题, 那么我们在这里就不妨讨论一下常见的几种背包的 dp 问题;

       初级的时候背包 dp 就完全相当于BFS DFS 进行搜索之后的记忆化查找。

      背包问题 一 、   0 ~ 1 背包问题

        实现一、  return max ( rec ( i + 1, j ) , rec ( i + 1, j - cost[ i ]) + value[ i ]);      //对第 i  件物品的选或者不选

        记忆化、      这个是由于实现一产生的dp数组 : dp[ i ] [ j ] : 首先注意这个 i 表示的是第 i 件物品, j 表示的是剩余的价值, 那么这个整体的 dp 表示的就是 i 件物品到 最后一个物品 n - 1 他能够产生的最大价值;

            同样我们利用那个递归关系,我们可以知道

          dp[ i ] [ j ] = max ( dp[ i + 1] [ j ] ,  dp[ i + 1] [ j - w[ i ] ] + value [ i ]) ; 

     1 #include <iostream>
     2 #include <cstdio>
     3 #include <cstdlib>
     4 #include <cstring>
     5 #include <cmath>
     6 #include <cctype>
     7 #include <algorithm>
     8 #include <vector>
     9 #include <queue>
    10 #include <list>
    11 #include <map>
    12 #include <stack>
    13 #include <set>
    14 #include <string>
    15 
    16 using namespace std;
    17 const int MAX_N = 1010;
    18 const int MAX_W = 1010;
    19 int dp[MAX_N][MAX_W];
    20 int N, W;
    21 int w[MAX_N], value[MAX_N];
    22 int main()
    23 {
    24     cin>>N>>W;
    25     for(int i = 0; i < N; i++)  cin>>w[i]>>value[i];
    26     dp[N][0] = 0;
    27     fill(dp[N], dp[N] + W, 0);
    28     for(int i = N - 1; i >= 0; i--){
    29         for(int j = 0; j <= W; j++){
    30             if(j < w[i])
    31                 dp[i][j] = dp[i+1][j];
    32             else
    33                 dp[i][j] = max(dp[i+1][j], dp[i+1][j-w[i]] + value[i]);
    34         }
    35     }
    36     return 0;
    37 }
    View Code

      如果你觉着这样逆着推导有点不舒服的话, 我们可以简单的对dp 数组换一下定义, 我们从原来的 dp [i] [j]  使用由 i 到最后; 同样dp[ i + 1 ] [ j ]我们可以设定为 从 0 到 i 这  i + 1 个物品, 但是你需要注意了;

      

     1 #include <iostream>
     2 #include <cstdio>
     3 #include <cstdlib>
     4 #include <cstring>
     5 #include <cmath>
     6 #include <cctype>
     7 #include <algorithm>
     8 #include <vector>
     9 #include <queue>
    10 #include <list>
    11 #include <map>
    12 #include <stack>
    13 #include <set>
    14 #include <string>
    15 
    16 using namespace std;
    17 const int MAX_N = 1010;
    18 const int MAX_W = 1010;
    19 int dp[MAX_N][MAX_W];
    20 int N, W;
    21 int w[MAX_N], value[MAX_N];
    22 int main()
    23 {
    24     cin>>N>>W;
    25     for(int i = 0; i < N; i++)  cin>>w[i]>>value[i];
    26     fill(dp[0], dp[0] + W, 0);
    27     for(int i = 0; i < N; i++){
    28         for(int j = 0; j <= W; j++){
    29             if(j < w[i])
    30                 dp[i+1][j] = dp[i][j];
    31             else
    32                 dp[i+1][j] = max(dp[i][j], dp[i][j-w[i]] + value[i]);
    33         }
    34     }
    35    printf("THE RESULT : %d
    ", dp[N][W]);
    36     return 0;
    37 }
    View Code

       最长公共子序列问题:

      那么我们完全可以把看看成追赶问题, 而且联想 dp 背包问题的 i + 1而不是 i 的巧妙设定, 这样防止了数组下标的越界!

        dp[ i + 1] [ j + 1] : 这个指的是 s0[ i ] 与 s0[ j ]   到这两个字符串的这两个元素的时候, 他目前的最长公共子序列长度的问题, i 是表示长度为 i ; j 表示长度为 j ; 分别表示了两个子序列的长度。

      那我们利用追赶问题的方法进行寻找上下级别的关系:

      dp[ i + 1] [ j + 1] = dp[ i ] [ j ] + 1; 这个是当且仅当 s0[ i ] = s1[ j ] ;

      当不满足这个等式的时候

      dp [ i + 1] [ j + 1] = max ( dp[ i + 1] [ j ],  dp[ i ] [ j +1])   //这个就是因为最后两个不相等, 不可能同时使用, 所以说我们删去一个 , 还可以减小问题的规模!

      

     1 #include <iostream>
     2 #include <cstring>
     3 #include <bits/stdc++.h>
     4 #include <algorithm>
     5 #include <cstdio>
     6 #include <cstdlib>
     7 #include <string>
     8 #include <cctype>
     9 #include <cmath>
    10 using namespace std;
    11 const int MAX_S = 1010;
    12 char s0[MAX_S], s1[MAX_S];
    13 int len1, len0;
    14 int dp[MAX_S][MAX_S];
    15 int main()
    16 {
    17     cin>>s0>>s1;
    18     len0 = strlen(s0);
    19     len1 = strlen(s1);
    20     fill(dp[0], dp[0] + MAX_S, 0);
    21     for(int i = 0; i < len0; i++){
    22         for(int j = 0; j < len1; j++){
    23             if(s0[i] == s1[j]){
    24                 dp[i+1][j+1] = dp[i][j] + 1;
    25             }
    26             else{
    27                 dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
    28             }
    29         }
    30     }
    31     printf("THE ANSWER IS THAT : %d
    ", dp[len0][len1]);
    32     return 0;
    33 }
    34 
    35 /*
    36 abcd
    37 becd
    38 
    39 
    40 */
    41  
    View Code

    终于到了兄弟们最喜欢的完全背包问题了 :

        那么对于这个类似于 0 1背包, 但是数量无限的情况下, 我们如何进行递归呢?

        最简单的、 最容易想的就是仿照我们的0 1 背包进行求解

        他是由第 i 个物品买还是不买,转换成了买多少个!!

        为了保持正向进行, 我们的 dp [ i + 1] [ j ]  表示的是在处理第 i 件产品, 结果是 0 - i 种物品合理选择后的最大价值量 ! 

      因此我们有 dp[ i + 1] [ j ] =  max(dp [ i ] [ j - k * w[ i ] ] + k * value[ i ] ) 注意这个是要保证下标索引是 大于零 的, 而且我们的 k 是自然数 ;

      但是不得不说这样的算法复杂度太高, 那么我们怎么进一步化简??  

      dp[ i + 1] [ j ] = max(dp [ i ] [ j ], dp[ i + 1] [ j - w[ i ]] + value[ i ]);

      注意了, 调用这个式子的时候一定要注意, 这个下标索引大于零, 而且初始化

       dp[ i + 1] [ j ] =  max(dp [ i ] [ j - k * w[ i ] ] + k * value[ i ] )  k >= 0;

            = max(dp[ i ] [ j ] , dp [ i ] [ j - k * w[ i ] ] + k * value[ i ] )  k >= 1;

            = max(dp[ i ] [ j ] , dp [ i ] [ j  - w[ i ] - k * w[ i ] ] + k * value[ i ]  + value[ i ])  k >= 0;

            = max(dp[ i ] [ j ] , dp [ i  + 1 ] [ j  - w[ i ] ]  + value[ i ]);  

      那么这样的证明就是好起来了。

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #include <string>
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <stack>
    #include <cctype>
    #include <algorithm>
    #include <cmath>
    #include <queue>
    
    using namespace std;
    const int MAX = 105;
    int dp[MAX][MAX];
    int w[MAX], v[MAX];
    int W, N;
    
    //这个是对完全背包问题的解决
    //分为了两种解法
    int main()
    {
        int N;  cin>>N>>W;
        for(int i = 0; i < N; i++){
            scanf("%d%d", w + i, v + i);
        }
        memset(dp, 0, sizeof(dp));  //小小的初始化一手
        //不节省空间的写法
        for(int i = 0; i < N; i++){
            for(int j = 0; j <= W; j++){
                if(j-w[i] >= 0)
                    dp[i+1][j] = max(dp[i][j], dp[i+1][j-w[i]]+v[i]);
                else
                    dp[i+1][j] = dp[i][j];
            }
        }
        printf("THE FIRST RESULT IS %d
    ", dp[N][W]);
    
        //节省空间的写法
        memset(dp, 0, sizeof(dp));  //再次进行初始化
        for(int i = 0; i < N; i++){
            for(int j = 0; j <= W; j++){
                if(j-w[i] >= 0)
                    dp[0][j] = max(dp[0][j], dp[0][j-w[i]]+v[i]);
                else
                    dp[0][j] = dp[0][j];
            }
        }
        printf("THE SECOND RESULT IS %d
    ", dp[0][W]);
    
        return 0;
    }
    /*
    3 7
    3 4
    4 5
    2 3
    
    
    THE RESULT SHOULD BE 10
    
    */
    View Code

     0-1 背包问题二

         注意初始化时候的灵魂加一

         这个是适用于NV 复杂度, 还有一个普通的 NW 复杂度, 在下面的代码之中都有着提及

    #include <iostream>
    #include <cstdio>
    #include <cstdlib>
    #include <cstring>
    #include <string>
    #include <vector>
    #include <list>
    #include <map>
    #include <set>
    #include <stack>
    #include <cctype>
    #include <algorithm>
    #include <cmath>
    #include <queue>
    
    using namespace std;
    const int MAX = 105;
    const int MAX_V = 100;
    const int INF = 1e6;
    int dp[MAX+1][MAX+1];
    int w[MAX], v[MAX];
    int W, N;
    
    
    int main()
    {
        int N;  cin>>N>>W;
        for(int i = 0; i < N; i++){
            scanf("%d%d", w + i, v + i);
        }
        memset(dp, 0, sizeof(dp));  //小小的初始化一手
        //0 1 背包的多种解法, 直接暴力 NW, 后者是进一步优化后的节省空间的一维数组的直接求解,又或者是NV
    
        //FIRST 直接暴力 dp NW      dp[i+1][j] 前 i 个物品的重量不超过 J 的最大价值
        for(int i = 0; i < N; i++){
            for(int j = 0; j <= W; j++){
                if(j >= w[i])
                    dp[i+1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]); //买或者不买
                else
                    dp[i+1][j] = dp[i][j];
            }
        }
        printf("FIRST RESULT IS %d
    ", dp[N][W]);
    
        //SECOND 多次利用了同一个一维数组, 复杂度没有变,但是在所占存储大大优化
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < N; i++){
            for(int j = W; j >=0 ; j--){
                if(j >= w[i])
                    dp[0][j] = max(dp[0][j], dp[0][j - w[i]] + v[i]); //买或者不买
                else
                    dp[0][j] = dp[0][j];
            }
        }
        printf("SECOND RESULT IS %d
    ", dp[0][W]);
    
    
    
        //THIRD O(NV)这个是需要看你的数据要求然后进行选择
        // dp[i+1][j] 表示的是, 对前 I 个物品进行选择,, 然后当前 J 价值的最小重量
        for(int i = 0; i < N; i++)  fill(dp[i], dp[i] + MAX_V + 1, INF), dp[i][0] = 0; //进行小小的初始化
        for(int i = 0; i < N; i++){
            for(int j = 0; j <= MAX_V; j++){
                if(j - v[i] >= 0)
                    dp[i+1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]); //当前获取价值所需要的最小重量
                else    dp[i+1][j] = dp[i][j];
            }
        }
        int res = 0;
        for(int i = 0; i <= MAX_V; i++){
            if(dp[N][i] <= W){
                res = i;    //我们需要找的是重量要求条件之内的最大价值
            }
        }
        printf("THE THIRD RESULT : %d
    ", res);
    
    
        //FOURTH O(NV)这个是需要看你的数据要求然后进行选择
        // dp[i+1][j] 表示的是, 对前 I 个物品进行选择,, 然后当前 J 价值的最小重量
        //这个是教科书上面最简短的代码
        fill(dp[0], dp[0] + MAX_V + 1, INF);  dp[0][0] = 0;
        for(int i = 0; i < N; i++){
            for(int j = 0; j <= MAX_V; j++){
                if(j - v[i] >= 0)
                    dp[i+1][j] = min(dp[i][j], dp[i][j - v[i]] + w[i]); //当前获取价值所需要的最小重量
                else    dp[i+1][j] = dp[i][j];
            }
        }
        res = 0;
        for(int i = 0; i <= MAX_V; i++){
            if(dp[N][i] <= W){
                res = i;    //我们需要找的是重量要求条件之内的最大价值
            }
        }
        printf("THE FOURTH RESULT : %d
    ", res);
        return 0;
    }
    /*
    4 5
    2 3
    1 2
    3 4
    2 2
    
    
    THE RESULT SHOULD BE 7
    
    */
    View Code

    多重部分和问题

    最长上升子序列问题    

     最简单的第一种算法, 就是把它抽象为追赶问题, 而且

      dp [ j ] = max ( dp [ j ] , dp [ i ] + 1 );    i < j 而且 a [ i ] < a [ j ];      有些问题, 我们需要的是最长下降子序列的问题 

      代码

     1 /*
     2     将本题目抽象出来居然是 最长上升子序列问题
     3 */
     4 #include <iostream>
     5 #include <cstdio>
     6 #include <cstdlib>
     7 #include <cstring>
     8 #include <cmath>
     9 #include <cctype>
    10 #include <algorithm>
    11 #include <vector>
    12 #include <queue>
    13 #include <list>
    14 #include <map>
    15 #include <stack>
    16 #include <set>
    17 #include <string>
    18 
    19 using namespace std;
    20 const int MAX_N = 4e4+10;
    21 int a[MAX_N];
    22 int dp[MAX_N];
    23 
    24 int main()
    25 {
    26     int T;  cin>>T;
    27     while(T--){
    28         int n;  cin>>n;
    29         for(int i = 0; i < n; i++){
    30             scanf("%d", &a[i]);
    31         }
    32         memset(dp, 0, sizeof(dp));
    33         int res = 0;
    34         dp[0] = 1;
    35         for(int i = 1; i < n; i++){
    36             dp[i] = 1;
    37             for(int j = 0; j < i; j++){
    38                 if(a[i] > a[j]){
    39                     dp[i] = max(dp[i], dp[j] + 1);
    40                     res = max(res, dp[i]);
    41                 }
    42             }
    43         }
    44         printf("THE RESULT :
    ");
    45         printf("%d
    ", res);
    46     }
    47     return 0;
    48 }
    View Code

      下一个dp [i] 就更牛逼了, 甚至可以使用二分查找; 真的是好用!!

      (注意下标存取的是长度, 然后dp [ i ] 存储是传说当中的当前长度的最小尾部元素)

      lower_bound : ai >= k  的最小指针

      upper_bound : ai >k  的最小指针 

     1 /*
     2     将本题目抽象出来居然是 最长上升子序列问题
     3 */
     4 #include <iostream>
     5 #include <cstdio>
     6 #include <cstdlib>
     7 #include <cstring>
     8 #include <cmath>
     9 #include <cctype>
    10 #include <algorithm>
    11 #include <vector>
    12 #include <queue>
    13 #include <list>
    14 #include <map>
    15 #include <stack>
    16 #include <set>
    17 #include <string>
    18 
    19 using namespace std;
    20 const int MAX_N = 4e4+10;
    21 const int INF = 1e5;
    22 int a[MAX_N];
    23 int dp[MAX_N];
    24 //然后里面的dp换了含义, dp[i] 代表的是长度为 i 的最小尾部,
    25 //那么我们就可以依靠这个进行不断地更新
    26 
    27 int main(void){
    28     int T;  cin>>T;
    29     while(T--){
    30         int n;  cin>>n;
    31         for(int i = 0; i < n; i++){
    32             scanf("%d", &a[i]);
    33         }
    34         fill(dp, dp + n, INF);
    35         for(int i = 0; i < n; i++){
    36             *lower_bound(dp, dp + n, a[i]) = a[i];
    37         }
    38      //   printf("THE RESULT IS :
    ");
    39         printf("%d
    ", lower_bound(dp, dp + n, INF) - dp);
    40     }
    41     return 0;
    42 }
    View Code
  • 相关阅读:
    【Autofac】- 创建的类的生命周期
    SQL Server 性能调优 之执行计划(Execution Plan)调优
    SQL Server 监测语句
    机器学习进阶-案例实战-图像全景拼接-图像全景拼接(RANSCA) 1.sift.detectAndComputer(获得sift图像关键点) 2.cv2.findHomography(计算单应性矩阵H) 3.cv2.warpPerspective(获得单应性变化后的图像) 4.cv2.line(对关键点位置进行连线画图)
    机器学习进阶-案例实战-图像全景拼接-书籍SIFT特征点连接 1.cv2.drawMatches(对两个图像的关键点进行连线操作)
    机器学习进阶-图像特征sift-SIFT特征点 1.cv2.xfeatures2d.SIFT_create(实例化sift) 2. sift.detect(找出关键点) 3.cv2.drawKeypoints(画出关键点) 4.sift.compute(根据关键点计算sift向量)
    机器学习进阶-图像特征harris-角点检测 1.cv2.cornerHarris(进行角点检测)
    机器学习进阶-项目实战-信用卡数字识别 1.cv2.findContour(找出轮廓) 2.cv2.boudingRect(轮廓外接矩阵位置) 3.cv2.threshold(图片二值化操作) 4.cv2.MORPH_TOPHAT(礼帽运算突出线条) 5.cv2.MORPH_CLOSE(闭运算图片内部膨胀) 6. cv2.resize(改变图像大小) 7.cv2.putText(在图片上放上文本)
    机器学习进阶-直方图与傅里叶变换-傅里叶变换(高低通滤波) 1.cv2.dft(进行傅里叶变化) 2.np.fft.fftshift(将低频移动到图像的中心) 3.cv2.magnitude(计算矩阵的加和平方根) 4.np.fft.ifftshift(将低频和高频移动到原来位置) 5.cv2.idft(傅里叶逆变换)
    机器学习进阶-直方图与傅里叶变化-直方图均衡化 1.cv2.equalizeHist(进行直方图均衡化) 2. cv2.createCLAHA(用于生成自适应均衡化图像)
  • 原文地址:https://www.cnblogs.com/lucky-light/p/11504534.html
Copyright © 2011-2022 走看看