蓝桥杯——最大的算式——DP

本文探讨了蓝桥杯竞赛中解决最大算式问题的动态规划(DP)方法。通过定义dp[i][j]表示前i个数中包含j个乘号的组合,其中dp[i][0]存储前i个数的和。递推公式dp[i][j] = max(dp[i][j], dp[l-1][j-1] * (ans[i] - ans[l-1]))用于更新状态,通过遍历所有位置l,将前l个数字中j-1个乘号的最大值与第l到i个数字的和相乘,再与当前j个乘号的值比较,取最大值。这种方法巧妙地解决了问题。" 108224840,10012345,使用BERT进行智能文本生成:DistillBERT解析,"['人工智能', '自然语言处理', '预训练模型', 'Python']


问题描述
  题目很简单,给出N个数字,不改变它们的相对位置,在中间加入K个乘号和N-K-1个加号,(括号随便加)使最终结果尽量大。因为乘号和加号一共就是N-1个了,所以恰好每两个相邻数字之间都有一个符号。例如:
  N=5,K=2,5个数字分别为1、2、3、4、5,可以加成:
  1*2*(3+4+5)=24
  1*(2+3)*(4+5)=45
  (1*2+3)*(4+5)=45
  ……
输入格式
  输入文件共有二行,第一行为两个有空格隔开的整数,表示N和K,其中(2<=N<=15, 0<=K<=N-1)。第二行为 N个用空格隔开的数字(每个数字在0到9之间)。
输出格式
  输出文件仅一行包含一个整数,表示要求的最大的结果
样例输入
5 2
1 2 3 4 5
样例输出
120
样例说明
  (1+2+3)*4*5=120

dp[i][j]  所代表的是前i个数里面有j个乘号。。

然后dp[i][0] 中放入的则是前i个数字的和。

递推式dp[i][j] = max(dp[i][j], dp[l-1][j-1] * (ans[i] - ans[l-1]));

怎么解释呢,就是说在前i个数中,遍历所有的位置l,所以说应该把前l个数字中拥有的j-1个乘号的最大值乘以从第l个数到第i个数字的和,

然后和当前位置的j个乘号的数值比较,取最大的就好了。

挺巧妙的...


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <map>
#include <set>
#include <sstream>
#include <queue>
#include <stack>
#define INF 0x3f3f3f3f
#define mem(a,b) memset(a,b,sizeof(a));
#define For(a,b) for(int i = a;i<b;i++)
#define ll long long
#define MAX_N 100010

using namespace std;
int x[20];
ll dp[20][20];
int ans[20];
int main()
{

    int n,m;
    scanf("%d %d",&n,&m);
    mem(ans,0);
    mem(dp,0);

    for(int i = 1; i<=n; i++)
    {
        cin>>x[i];
        ans[i] = ans[i-1] + x[i];
    }
    for(int i = 1; i<=n; i++)
    {
        dp[i][0] = ans[i];
    }

    for(int i = 2; i<=n; i++)
    {
        int num = min(i-1,m);
        for(int j = 1; j<=num; j++)
        {
            for(int l = 2; l<=n; l++)
            {
                dp[i][j] = max(dp[i][j],dp[l-1][j-1] * (ans[i]-ans[l-1]));
            }
        }
    }
    printf("%lld\n",dp[n][m]);
    return 0;
}











### 关于蓝桥杯 Python 中跳跃类题目及其解法 #### 题目背景与分析 蓝桥杯竞赛中的跳跃类题目通常涉及数组操作、动态规划 (Dynamic Programming, DP) 或贪心算法。这类问题的核心在于如何合理设计状态以及优化计算过程[^2]。 对于跳跃类问题,常见的场景包括: - **单向跳跃**:给定一系列位置和每一步可跳的最大步数,判断能否到达终点。 - **多方向跳跃**:允许向前或向后跳跃一定距离,求最小跳跃次数或其他目标函数值。 以下是针对此类问题的一个通用解决方案框架: --- #### 动态规划解决跳跃问题的思路 动态规划是一种常用的策略来处理跳跃类问题。其核心思想是定义一个 `dp` 数组,其中每个元素表示达到该位置所需的最少跳跃次数或某种最优条件下的代价。 假设我们有一个长度为 `n` 的数组 `arr` 表示各个位置的状态,则可以按照如下方式构建动态规划方程: ```python def min_jumps(arr): n = len(arr) dp = [float('inf')] * n # 初始化 dp 数组为无穷大 dp[0] = 0 # 初始位置不需要跳跃 for i in range(1, n): # 遍历每一个位置 for j in range(i): # 尝试从前一个位置跳到当前位置 if j + arr[j] >= i and dp[j] != float('inf'): # 如果可以从 j 跳到 i dp[i] = min(dp[i], dp[j] + 1) # 更新当前最少跳跃次数 return dp[-1] if dp[-1] != float('inf') else -1 # 返回最后一个位置的结果 ``` 上述代码实现了基于动态规划的最小跳跃次数问题解答方法。 --- #### 使用贪心算法优化跳跃问题 除了动态规划外,某些特定条件下还可以采用更高效的贪心算法解决问题。例如,在“跳跃游戏”中只需要验证是否存在一种路径能够抵达终点即可,而无需关心具体的跳跃次数。 下面是一个典型的贪心算法实现例子: ```python def can_jump_greedy(arr): max_reach = 0 # 当前能到达的最远索引 for i, jump in enumerate(arr): if i > max_reach: # 若当前位置无法被覆盖则返回 False return False max_reach = max(max_reach, i + jump) # 更新最大可达范围 return True # 如果循环结束说明可以到达最后一位 ``` 此段代码利用了局部最优原则——即每次尽可能扩展所能触及的距离,从而保证整体效率最高。 --- #### 总结 无论是通过动态规划还是贪心算法解决跳跃类问题,都需要仔细考虑边界情况并选择合适的数据结构存储中间结果。此外,实际编程过程中还应注意时间复杂度控制以应对大规模数据集带来的挑战。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值