算法2022 · 动态规划

影月丶暮风

已于 2022-09-24 15:44:35 修改

阅读量634

点赞数

分类专栏： Algorithm Design 2022 文章标签：动态规划蓝桥杯算法 c++

于 2022-03-17 20:31:39 首次发布

本文链接：https://blog.csdn.net/qq_21893163/article/details/123559906

版权

Algorithm Design 2022 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

最初的篇章感谢！bilibili：正月点灯笼 BV18x411V7fm

【暴力】-->【递归】-->【带着备忘录の递归】-->【迭代 / 动态规划】

求解max+路径追踪

【局部最优】-->【总体最优】

依托（递归式）寻找（顺推）的方法

分治：子问题之间是独立的，备忘录没有意义

动态规划：子问题之间有重复部分，借用备忘录减少计算次数

工作の选择问题（背包）

（无法处理多个【前置任务 · 结束时间】一致的情况，因为pre只能存一个前置地址）

//动态规划·原初之篇章
//哔哩哔哩：正月点灯笼  BV18x411V7fm
// 8个工作，分别挣钱51846324
//分别占用时间段【1：1 4】【2：3 5】【3：0 6】【4：4 7】【5：3 8】【6：5 9】【7：6 10】【8：8 11】
//怎么选择工作，赚钱最多？
//背包·动态规划

#include <iostream>
#include <stdio.h>
using namespace std;
int n, num = 0, a[998][2];
int value[998], pre[998], opt[998] = {};
bool work[998];

void init(bool *b)
{
    int x;
    for (x = 0; x < 998; x++)
        b[x] = false;
}
void find(int *pre, bool *work, int n)
{
    if (n <= 0)
        return;
    if (work[n])
    {
        num++;
        find(pre, work, pre[n]);
        printf("%d、", n); //选择了第n好工作
    }
    else
    {
        find(pre, work, n - 1);
    }
}

int main()
{
    int x, y, z;
    printf("【工作选择问题】输入工总数：");
    scanf("%d", &n);
    printf("输入各项工作的【启动时间】【结束实践】【工资】");
    for (x = 1; x <= n; x++)
        scanf("%d%d%d", &a[x][0], &a[x][1], &value[x]);
    //【开始时间0】【结束时间1】
    //【prev(5)】：选择第五项工作时，前面可以完成的事件中，最接近事件5的事件序号
    init(work);
    for (x = 1; x <= n; x++) //【后置任务】
    {
        int max, maxk; //【前置任务·最迟结束时间】
        bool have = false;
        for (y = 1; y <= n; y++)    //【前置任务】
        {                           //如果前置任务，多个任务的结束时间相同呢（T9  2 4 14）暂时不考虑
            max = 0;                //【前置任务·最大结束时间】maxk【最大结束任务编号】
            if (a[y][1] <= a[x][0]) //【y前置任务结束时间】  比【后方任务启动时间早】
            {
                have = true;       //存在的
                if (max < a[y][1]) //更靠后的时间点
                {
                    maxk = y;
                    max = a[y][1];
                    // printf("更新啦 %d %d\n", x, y);
                }
            }
        }
        if (have) //存在
            pre[x] = maxk;
        else
            pre[x] = 0;
    }

    printf("\nPreview：");
    for (x = 1; x <= n; x++)
        printf("%d ", pre[x]);

    for (x = 1; x <= n; x++)
    {
        int a, b;
        a = opt[pre[x]] + value[x]; //选择这个工作+之前的收益
        b = opt[x - 1];             //不选这个工作，拿之前收益即可
        if (a > b)
        {
            opt[x] = a;
            work[x] = true;
        }
        else
            opt[x] = b;
    }

    printf("\nOption：");
    for (x = 1; x <= n; x++)
        printf("%d ", opt[x]);

    printf("\n选择了");
    find(pre, work, n);
    printf("共%d件工作", num);
    return 0;
}

/*
8
1 4 5
3 5 1
0 6 8
4 7 4
3 8 6
5 9 3
6 10 2
8 11 4

*/

T9情况未加入，可部署14 9 6 多种价值（等待改进中）

矩阵连乘感谢bilibili·笨手笨脚oO 教学视频的启发！

#include <iostream>
#include <stdio.h>
using namespace std;
#define max 0xfffffff
#define N 2745
int n, p[N + 1], dp[N + 1][N + 1], way[N + 1][N + 1];

void test()
{
    int x, y;
    for (x = 1; x <= n; x++)
    {
        for (y = 1; y <= n; y++)
        {
            if (dp[x][y] == max)
                printf("T\t");
            else
                printf("%d\t", dp[x][y]);
        }
        printf("\n\n\n");
    }
    printf("\n\n\n");
    for (x = 1; x <= n; x++)
    {
        for (y = 1; y <= n; y++)
        {
            printf("%d\t", way[x][y]);
        }
        printf("\n\n\n");
    }
}
void init()
{
    printf("输入【矩阵个数】：");
    scanf("%d", &n);
    int x, y;
    for (x = 0; x <= n; x++) //《初始化》
    {
        for (y = 0; y <= n; y++)
        {
            way[x][y] = 0;
            dp[x][y] = max;
        }
    }
    printf("输入【行列情况】："); //共【n+1】个数字
    for (x = 0; x <= n; x++)
    {
        scanf("%d", &p[x]);
        dp[x][x] = 0; //自己不能乘以自己
    }
}
void Find_Answer()
{
    int x, y, z, t, min, temp;
    for (x = 2; x <= n; x++) //【分区大小】从2到n
    {
        for (y = 1; y <= n; y++) //【分区块·起始点】··结束点位置或出现溢出情况
        {
            z = x + y - 1; //例如n=5  x=3  y=2 起始点2分3点即234 结束点4=3+2-1
            // z【分区块·末端点 】
            if (z > n) //末端点·溢出
                break;
            for (t = y; t < z; t++) //【寻找·切入位置】【切入起始点后方】y-z之间，寻找t后切入
            {
                min = dp[y][z]; //【T1前端】【T2后端】【T1后 或 T2前（此处T1后） 】看位置t
                temp = dp[y][t] + dp[t + 1][z] + p[y - 1] * p[z] * p[t];
                if (min > temp)
                {
                    min = dp[y][z] = temp;
                    way[y][z] = t;
                }
            }
        }
    }
    printf("最小乘积次数：%d\n", dp[1][n]);
}
void Find_Way(int x, int y)
{
    if (x == y)
        return;
    int k = way[x][y];
    Find_Way(x, k);
    Find_Way(k + 1, y);
    printf("A[%d,%d] * A[%d,%d]\n", x, k, k + 1, y);
}

int main()
{
    init();
    Find_Answer();
    test();
    Find_Way(1, n);
    return 0;
}
/*
6
2 7 5 4 2 3 8

5
30 35 15 5 10 20

*/

【学习记录】矩阵连乘-动态规划-计算机算法_哔哩哔哩_bilibili
第一次写少了+1，出现异常

初始化：给予dp除【主对角线】外所有区域为max，way区全给到0

从【局部最小】推算到【全局最小】

《关于矩阵所需乘积次数》2*4 4*8总次数2*4*8

dp[x][y]：x到y矩阵，所需最小的乘积次数，默认为MAX

寻找切入后方矩阵，例如【37 74 42】三矩阵（可选切入点2个 1 2）

假如从1切入，总次数：3*7*2 （后面矩阵先乘，为7*2的矩阵；前面不变3*7）

第一层循环：迭代！从2到n（几个矩阵相乘·从局部到总体）

第二层循环：火力覆盖·起始点

给到终止点坐标，溢出则跳出

第三层循环：寻找切入点（最多n-1）

如果切入后乘积次数少

之前的局部最优（已经乘出俩矩阵了）【y，t】【t+1，z】+本次乘积需要次数

min更替，[y][z]之间以k作为分隔（路径记录）

路径输出的时候，先递归到最底层，再一步步扩大表示括号

.

最长公共子序列

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
char a[500], b[500], dp[500][500] = {}, way[500][500];

void work()
{
    printf("启动输入：");
    scanf("%s%s", &a, &b);
    for (int x = 1; x <= strlen(a); x++)
    {
        for (int y = 1; y <= strlen(b); y++)
        {
            if (a[x - 1] == b[y - 1])
            {
                dp[x][y] = dp[x - 1][y - 1] + 1;
                way[x][y] = 1;
            }
            else if (dp[x - 1][y] > dp[x][y - 1])
            {
                dp[x][y] = dp[x - 1][y];
                way[x][y] = 2;
            }
            else
            {
                dp[x][y] = dp[x][y - 1];
                way[x][y] = 3;
            }
        }
    }
}
void Find_road(int x, int y)
{
    if (x == 0 || y == 0)
        return;
    if (way[x][y] == 1)
    {
        Find_road(x - 1, y - 1);
        printf("%c ", a[x - 1]);
    }
    else if (way[x][y] == 2)
        Find_road(x - 1, y);
    else
        Find_road(x, y - 1);
}
void show()
{
    for (int x = 1; x <= strlen(a); x++)
    {
        for (int y = 1; y <= strlen(b); y++)
        {
            printf("%d\t", dp[x][y]);
        }
        printf("\n\n\n");
    }

    printf("\n");

    for (int x = 1; x <= strlen(a); x++)
    {
        for (int y = 1; y <= strlen(b); y++)
        {
            printf("%d\t", way[x][y]);
        }
        printf("\n\n\n");
    }
    printf("子串情况：");
    Find_road(strlen(a), strlen(b));
}

int main()
{
    work();
    show();

    return 0;
}

/*
1528936
568937

*/

为什么是用这种矩阵迭代方式呢，正在研究中

最长字段和·动态规划

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int main()
{
    int n, a[666];
    printf("输入总数：");
    scanf("%d", &n);
    for (int x = 1; x <= n; x++)
        scanf("%d", &a[x]);
    int b[666] = {}, max = 0, k, q; //【sum】是局部的求和，小于0时候被丢弃
    int dp[666] = {};
    for (int x = 1; x <= n; x++)
    {
        if (dp[x - 1] > 0)            //【简化】dp[x-1]+a[x]>a[x]
            dp[x] = dp[x - 1] + a[x]; //【延续·最大序列和】
        else                          //【更迭·更好的启发点】
        {
            dp[x] = a[x];
            q = x; //起发点
        }          //否则，丢弃sum，更新为当前值

        if (dp[x] > max)
        {
            max = dp[x];
            k = x; //用于存放最大值所处位置
        }
    }
    printf("最大值：%d，起发点%d，终点%d", max, q, k);
    return 0;
}

/*
10
-2 -1 3 5 10 -2 -1 2 5 -2
*/

思想论：局部最优到总体最优

顺推，选定【起发点】往后求和

如果：求和数值<0，这个启发点被丢弃，更新启发点

如果：求和数值>0，继续往后走，加上当前数值

（做出正贡献/负贡献）阶段中或有起起落落，但是总体是要往前走的

【其实根本上是比较递推公式P59，>0是简化的写法】

在某个阶段中，左侧一定往上走，右侧或往下走，如果下跌太厉害，这个阶段认为作废

为什么要从当前点开始，而不从之前废弃阶段的某个点开始呢？

因为从某个点开始（取中点），会更多的包含下跌部分而非前面的上升部分

这个对子段数字扩大是不良影响，（而且失去了之前上升部分的作用

前废弃阶段部分取值下跌的更厉害）；所以要整体废除重新做人（有点KMP的感觉）

在此基础上，寻找阶段的max数值

最大子矩阵·暴力+动态规划

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
int main()
{ //最大子段和，动态规划
    int n, a[666];
    printf("输入总数：");
    scanf("%d", &n);
    for (int x = 1; x <= n; x++)
        scanf("%d", &a[x]);
    int b[666] = {}, max = 0, k, q; //【sum】是局部的求和，小于0时候被丢弃
    int dp[666] = {};
    for (int x = 1; x <= n; x++)
    {
        if (dp[x - 1] > 0)            //【简化】dp[x-1]+a[x]>a[x]
            dp[x] = dp[x - 1] + a[x]; //【延续·最大序列和】
        else                          //【更迭·更好的启发点】
        {
            dp[x] = a[x];
            q = x; //起发点
        }          //否则，丢弃sum，更新为当前值

        if (dp[x] > max)
        {
            max = dp[x];
            k = x; //用于存放最大值所处位置
        }
    }
    printf("最大值：%d，起发点%d，终点%d", max, q, k);
    return 0;
}

/*
10
-2 -1 3 5 10 -2 -1 2 5 -2
*/

9_最大子矩阵_动态规划3_哔哩哔哩_bilibili

//最大子矩阵·动态规划
#include <iostream>
#include <stdio.h>
using namespace std;
int m, n, a[50][50];
int dp1[50][50] = {};
int xy[4] = {}, maxx = (1 << 31); //起始点·终止点坐标；最大值
void test()
{
    printf("\n\n【DP1·辅助数组情况】\n");
    for (int x = 1; x <= m; x++)
    {
        for (int y = 1; y <= n; y++)
            printf("%d\t", dp1[x][y]);
        printf("\n\n\n");
    }
}
void init()
{
    printf("输入参数：");
    scanf("%d%df", &m, &n);
    for (int x = 1; x <= m; x++)
        for (int y = 1; y <= n; y++)
            scanf("%d", &a[x][y]);
    //辅助矩阵生成
    for (int x = 1; x <= m; x++)
    {
        for (int y = 1; y <= n; y++)
        {
            dp1[x][y] += dp1[x - 1][y] + a[x][y]; //上一行加来
        }
    }
    // test();
}
void work()
{
    for (int x = 1; x <= m; x++) //【起始行】
    {
        for (int y = x; y <= m; y++) //【终末行】
        {
            int t[n + 1]; //每列情况
            for (int z = 1; z <= n; z++)
                t[z] = dp1[y][z] - dp1[x - 1][z];
            //【局部转化·为一维状态】
            //下面就和一维处理一样了
            int dp[n + 1] = {}, yy;
            for (int z = 1; z <= n; z++)
            {
                if (dp[z - 1] > 0)            //简化判断式P59
                    dp[z] = dp[z - 1] + t[z]; //【延续】
                else
                {
                    yy = z;
                    dp[z] = t[z]; //【更迭·启动点】
                }
                if (dp[z] > maxx)
                {
                    maxx = dp[z];
                    xy[0] = x;  //行·起始
                    xy[1] = yy; //列·起始
                    xy[2] = y;  //行·终末
                    xy[3] = z;  //列·终末
                }
            }
        }
    }
}
void ans()
{
    printf("最大矩阵和：%d  <%d %d>--<%d %d>\n", maxx, xy[0], xy[1], xy[2], xy[3]);
}

int main()
{
    init();
    work();
    ans();
    return 0;
}

/*
5 8
1   6  -4  9    7   2 2 -1
4 -75   9 16    1   4 1  4
9   1   6  6    8   6 1  3
6   1   4  5    1   5 6  8
7   9   9  1  -72   4 3  1

109 <1 3>--<4 8>
*/

关于动态规划的思想：

dp1[x]：【x及以上行】の求和

dp1[x]-dp1[y]：[y+1]到[x]的行，对应列求和

【前两个for】：部署《起始行》、《终末行》

【第三个for】：部署当前【双行划分下 · 列总和情况】t[x]

之后就是一维状态的处理；需要特别注意的是

【终末点】：位置好找，就是max

在【起点更迭】的时候，y可能是局部更迭，所以采用yy进行保存

01背包问题·递归

//【01背包】【完全背包】【部分背包】Day69
//启封の章节：BV1aN411d7Yi?p=19  暴力递归出奇迹
#include <iostream>
#include <stdio.h>
using namespace std;
int n, c, w[2745], p[2745];
void init()
{
    printf("输入【商品数】【背包载重】：");
    scanf("%d%d", &n, &c);
    printf("输入【重量】【价值】：\n");
    for (int x = 1; x <= n; x++)
        scanf("%d%d", &w[x], &p[x]);
}
int work(int x, int c)
{
    if (c < w[x] || x < 1) //【容量不足】【递归结束】
        return 0;
    int a = work(x - 1, c);
    int b = work(x - 1, c - w[x]) + p[x];
    return a > b ? a : b;
}

int main()
{
    init();
    printf("max=%d", work(n, c));
    return 0;
}

/*
n物品，每个物品重w，价值v；背包总载重为c；要求价值最大，怎么选？
载重13，5个商品，先重量后价格；ans=28（123）
5 13
4 9
5 10
4 9
3 2
10 24
*/

01背包问题·带备忘录の递归

//【01背包】·带备忘录的递归（改造）
#include <iostream>
#include <stdio.h>
using namespace std;
int n, c, w[2745], p[2745], dp[2745][2745] = {};
// dp[n][c]：在c容量下，商品n号之前所有取值可能中，最大的价值
//先查表，表里有就用，没有就算；总是保存表格
void init()
{
    printf("输入【商品数】【背包载重】：");
    scanf("%d%d", &n, &c);
    printf("输入【重量】【价值】：\n");
    for (int x = 1; x <= n; x++)
        scanf("%d%d", &w[x], &p[x]);
}
int work(int x, int c)
{
    if (c < w[x] || x < 1) //【容量不足】【递归结束】
        return 0;
    if (dp[x][c] != 0)
        return dp[x][c];
    int a = work(x - 1, c);
    int b = work(x - 1, c - w[x]) + p[x];
    dp[x][c] = a > b ? a : b;
    return a > b ? a : b;
}

int main()
{
    init();
    printf("max=%d", work(n, c));
    return 0;
}

/*
n物品，每个物品重w，价值v；背包总载重为c；要求价值最大，怎么选？
载重13，5个商品，先重量后价格；ans=28（123）
5 13
4 9
5 10
4 9
3 2
10 24
*/

01背包·动态规划（处置dp数组）+路径追踪

//【01背包问题】动态规划   dp顺推
#include <iostream>
#include <stdio.h>
using namespace std;
int n, c, w[2745], p[2745], dp[2745][2745] = {};
bool way[2745][2745];
void init()
{
    printf("输入【商品数】【背包载重】：");
    scanf("%d%d", &n, &c);
    printf("输入【重量】【价值】：\n");
    for (int x = 1; x <= n; x++)
        scanf("%d%d", &w[x], &p[x]);
    for (int x = 1; x <= 2745; x++)
        dp[0][x] = dp[x][0] = 0;
    for (int x = 1; x <= 2745; x++)
        for (int y = 1; y <= 2745; y++)
            way[x][y] = false;
}
void test()
{

    for (int x = 1; x <= n; x++)
    {
        for (int y = 1; y <= c; y++)
            printf("%d\t", dp[x][y]);
        printf("\n\n\n");
    }
}
void way_back(int n, int c) //当前是【商品几】，剩余容量
{
    // printf("苏晓辉666\n");
    if (n == 0) //没得选
        return;
    if (way[n][c]) //有选择这个商品
    {
        way_back(n - 1, c - w[n]);
        printf("<%d号；重量%d；价值%d>  \n", n, w[n], p[n]);
    }
    else
        way_back(n - 1, c);
}
void ans()
{
    printf("max=%d\n", dp[n][c]);
    printf("选择的商品：\n");
    way_back(n, c);
}
void work()
{
    // dp[i,c]=max dp[i-1][c]   dp[i-1,c-Wx]+Px
    for (int x = 1; x <= n; x++) //【dp顺推】商品1-->n
    {
        for (int y = 1; y <= c; y++) //【dp顺推】容量1-->c
        {
            int a = dp[x - 1][y];                               //不选择
            int b = w[x] <= y ? dp[x - 1][y - w[x]] + p[x] : 0; //放得下就塞进去
            dp[x][y] = a > b ? a : b;
            way[x][y] = a > b ? false : true; //【路径追踪】 有选择就是true
        }
    }
}
int main()
{
    init();
    work();
    test();
    ans();
    system("pause");
    return 0;
}

/*
n物品，每个物品重w，价值v；背包总载重为c；要求价值最大，怎么选？
载重13，5个商品，先重量后价格；ans=28（123）
5 13
4 9
5 10
4 9
3 2
10 24
*/