蓝桥杯-数学知识和简单动态规划专题2（包含历年蓝桥杯真题和详细注释）

脆皮小刺猬

已于 2023-07-16 15:04:10 修改

阅读量159

点赞数 2

分类专栏：备战蓝桥杯算法学习历程刷题日记文章标签：蓝桥杯动态规划算法

于 2023-03-27 10:50:53 首次发布

本文链接：https://blog.csdn.net/m0_62609939/article/details/129789453

版权

刷题日记同时被 3 个专栏收录

95 篇文章 1 订阅

订阅专栏

算法学习历程

81 篇文章 1 订阅

订阅专栏

备战蓝桥杯

64 篇文章 1 订阅

订阅专栏

摘花生

最长上升子序列

地宫取宝(第五届蓝桥杯省赛C++A/B/C组,第五届蓝桥杯省赛JAVAB/C组)

波动数列(第五届蓝桥杯省赛C++A组,第五届蓝桥杯省赛JAVAA组)

摘花生

Hello Kitty想摘点花生送给她喜欢的米老鼠。

她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。

地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。

Hello Kitty只能向东或向南走，不能向西或向北走。

问Hello Kitty最多能够摘到多少颗花生。

输入格式

第一行是一个整数T，代表一共有多少组数据。

接下来是T组数据。

每组数据的第一行是两个整数，分别代表花生苗的行数R和列数 C。

每组数据的接下来R行数据，从北向南依次描述每行花生苗的情况。每行数据有C个整数，按从西向东的顺序描述了该行每株花生苗上的花生数目M。

输出格式

对每组输入数据，输出一行，内容为Hello Kitty能摘到得最多的花生颗数。

数据范围

1≤T≤1001≤T≤100,
1≤R,C≤1001≤R,C≤100,
0≤M≤10000≤M≤1000

输入样例：

输出样例：

8
16

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 105;
int dp[N][N];//定义地图
int n;
int main()
{
    cin>>n;
    while (n -- ){
        memset(dp,0,sizeof dp);
        int r,c;
        cin>>r>>c;
        for(int i=1;i<=r;i++)
            for(int j=1;j<=c;j++)
                cin>>dp[i][j];//对输入进行处理
        
        for(int i=1;i<=r;i++)
        {
            for(int j=1;j<=c;j++)
            {
                dp[i][j]=max(dp[i-1][j]+dp[i][j],dp[i][j-1]+dp[i][j]);
    //因为只能从上往下和从左往右，所以dp[i][j]就从dp[i-1][j]和dp[i][j-1]取较大值加d[i][j]
            }
        }
        cout<<dp[r][c]<<endl;
        
    }
    return 0;
}

最长上升子序列

给定一个长度为 NN 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 NN。

第二行包含 NN 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

数据范围

1≤N≤10001≤N≤1000，
−109≤数列中的数≤109−109≤数列中的数≤109

输入样例：

7
3 1 2 1 8 5 6

输出样例：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int a[N],dp[N];//dp[i]表示以a[i]字符结尾的的最长上升子序列
int n;
int main()
{
    
    cin>>n;
    for(int i=0;i<n;i++)cin>>a[i];
    for(int i=0;i<n;i++)dp[i]=1;//每一个下标子序列都至少为1 代表他自己
    for(int i=1;i<n;i++)
    {
        //枚举i之前所有的情况 寻找比a[i]小的a[j] 
        for(int j=0;j<i;j++)
        {
            if(a[i]>a[j])dp[i]=max(dp[i],dp[j]+1);
            //即dp[i]=max(dp[i],dp[j]+1) 取较大值
        }
    }
    int ans=0;
    //枚举以每个字符结尾的最长上升子序列的长度 就是整个字符串最长上升子序列的长度
    for(int i=0;i<n;i++)ans=max(dp[i],ans);
    cout<<ans<<endl;
    return 0;
    
}

地宫取宝(第五届蓝桥杯省赛C++A/B/C组,第五届蓝桥杯省赛JAVAB/C组)

X 国王有一个地宫宝库，是 n×mn×m 个格子的矩阵，每个格子放一件宝贝，每个宝贝贴着价值标签。

地宫的入口在左上角，出口在右下角。

小明被带到地宫的入口，国王要求他只能向右或向下行走。

走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

当小明走到出口时，如果他手中的宝贝恰好是 kk 件，则这些宝贝就可以送给小明。

请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这 kk 件宝贝。

输入格式

第一行 33 个整数，n,m,kn,m,k，含义见题目描述。

接下来 nn 行，每行有 mm 个整数 CiCi 用来描述宝库矩阵每个格子的宝贝价值。

输出格式

输出一个整数，表示正好取 kk 个宝贝的行动方案数。

该数字可能很大，输出它对 10000000071000000007 取模的结果。

数据范围

1≤n,m≤501≤n,m≤50,
1≤k≤121≤k≤12,
0≤Ci≤120≤Ci≤12

输入样例1：

2 2 2
1 2
2 1

输出样例1：

输入样例2：

2 3 2
1 2 3
2 1 5

输出样例2：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 55;
//dp[i][j][k][c]表示从起点走到i,j 已经取了k件物品并且最后一件物品价格是c
int dp[N][N][13][14];
int w[N][N];
int mod=1e9+7;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
            {
            //数组默认为0  物品价格最小为0 因此将其+1变为1 才可以满足格子价值比手上价值还大
                cin>>w[i][j];w[i][j]++;
            }
    
    dp[1][1][1][w[1][1]]=1;//走到第一个格子 取一件物品 最后一件价格为w[1][1]
    dp[1][1][0][0]=1;//走到第一个格子 取0件物品 最后一件价格为0
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            if(i==1&&j==1)continue;
            for(int u=0;u<=12;u++)//枚举所有的数量
            {
                //枚举最后一个物品价值所有的大小情况
                for(int v=0;v<=13;v++){
                    int& val=dp[i][j][u][v];
                    //(i,j)的方案数等于(i,j-1)+(i-1,j)的方案数 不取w(i,j)的情况
                    val=(val+dp[i][j-1][u][v])%mod;
                    val=(val+dp[i-1][j][u][v])%mod;
                    //如果要取第i件物品 v必须为w[i][j] 表示最后一个商品价值
                    if(v==w[i][j]){
                        for(int c=0;c<v;c++)
                        {
                            //(i,j)的方案数等于(i,j-1)+(i-1,j)的方案数 取w(i,j)的情况
                            val=(val+dp[i][j-1][u-1][c])%mod;
                            val=(val+dp[i-1][j][u-1][c])%mod;
                        }
                    }
                    
                }
            }
        }
        
    int ans=0;
    //枚举所有取k件物品 最后一件物品价值为0-13的所有情况
    for(int i=0;i<=13;i++)ans=(ans+dp[n][m][k][i])%mod;
    cout<<ans<<endl;
    return 0;
}

波动数列(第五届蓝桥杯省赛C++A组,第五届蓝桥杯省赛JAVAA组)

观察这个数列：

1 3 0 2 -1 1 -2 …

这个数列中后一项总是比前一项增加2或者减少3，且每一项都为整数。

栋栋对这种数列很好奇，他想知道长度为 nn 和为 ss 而且后一项总是比前一项增加 aa 或者减少 bb 的整数数列可能有多少种呢？

输入格式

共一行，包含四个整数 n,s,a,bn,s,a,b，含义如前面所述。

输出格式

共一行，包含一个整数，表示满足条件的方案数。

由于这个数很大，请输出方案数除以 100000007100000007 的余数。

数据范围

1≤n≤10001≤n≤1000,
−109≤s≤109−109≤s≤109,
1≤a,b≤1061≤a,b≤106

输入样例：

4 10 2 3

输出样例：

样例解释

两个满足条件的数列分别是2 4 1 3和7 4 1 -2。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1010;
int f[N][N];
const int mod=100000007 ;
//求a%b的正余数
int get_mod(int a,int b)
{
    return (a%b+b)%b;
}
int main()
{
    int n,s,a,b;
    cin>>n>>s>>a>>b;
    f[0][0]=1;
    //f[i][j]表示前i项 当前总和除以n的余数为j的方案数
    for(int i=1;i<n;i++)
        for(int j=0;j<n;j++)
            f[i][j]=(f[i-1][get_mod(j-a*i,n)]+f[i-1][get_mod(j+b*i,n)])%mod;
    cout<<f[n-1][get_mod(s,n)]<<endl;
    return 0;
}