E. Maximum Questions dp

本文深入探讨了使用C++实现动态规划算法解决特定问题的方法。通过实例代码,详细介绍了如何利用动态规划来优化字符串处理任务,特别是针对含有'a'、'b'和'?'字符的字符串,以最小成本最大化特定条件下的目标值。文章覆盖了状态转移方程的设定、DP表的初始化及更新策略,为读者提供了全面的算法理解和实践指导。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <queue>

using namespace std;

int n,m;
char ch[100005];

int dp[100005][2];
int ct[100005][5][2];

int main() {
    while(~scanf("%d",&n))
    {
        memset(dp,0,sizeof(dp));
        memset(ct,0,sizeof(ct));

        scanf("%s",ch);
        scanf("%d",&m);

        for(int i=1;i<=n;i++)
        {
            int id=i%2;
            char tp=ch[i-1];
            for(int j=0;j<3;j++)
            {
                for(int k=0;k<2;k++)
                {
                    ct[i][j][k]=ct[i-1][j][k];
                }
            }
            if(tp=='a')
                ct[i][0][id]++;
            else if(tp=='b')
                ct[i][1][id]++;
            else if(tp=='?')
                ct[i][2][id]++;
        }

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

            int val=0,cost=0;
            int sta=i-m+1;
            int ae=ct[i][0][0]-ct[i-m][0][0];
            int ao=ct[i][0][1]-ct[i-m][0][1];
            int be=ct[i][1][0]-ct[i-m][1][0];
            int bo=ct[i][1][1]-ct[i-m][1][1];

            if(sta%2==1)
            {
                if(ae==0 && bo==0)
                {
                    val=dp[i-m][0]+1;
                    cost=dp[i-m][1]+(m-ao-be);
                    if((val>dp[i][0]) || (val==dp[i][0] && cost < dp[i][1]))
                    {
                        dp[i][0]=val;dp[i][1]=cost;
                    }
                }
            }
            else
            {
                if(ao==0 && be==0)
                {
                    val=dp[i-m][0]+1;
                    cost=dp[i-m][1]+(m-ae-bo);
                    if((val>dp[i][0]) || (val==dp[i][0] && cost < dp[i][1]))
                    {
                        dp[i][0]=val;dp[i][1]=cost;
                    }
                }
            }

        }
        printf("%d\n",dp[n][1]);
    }
    return 0;
}

 

### Python NumPy `maximum` 函数的用法 NumPy 的 `numpy.maximum` 是一个用于逐元素比较两个数组并返回较大值的函数[^2]。以下是其基本语法: ```python numpy.maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) ``` #### 参数说明 - **x1**, **x2**: 输入数组或标量。这两个参数可以是相同形状的数组,或者可以通过广播机制扩展到兼容的形状。 - **out**: 可选参数,指定输出存储的位置。 - **where**: 布尔掩码数组,决定哪些位置执行操作。 #### 返回值 返回一个新的数组,其中每个元素都是对应于输入数组中的最大值。如果其中一个输入是一个标量,则将其与其他数组的每个元素进行比较。 #### 示例代码 以下是一些使用 `numpy.maximum` 的例子: ```python import numpy as np # 使用标量和数组 a = 3 b = np.array([1, 5, a]) result = np.maximum(a, b) print(result) # 输出: array([3, 5, 3]) # 使用两个数组 c = np.array([2, 4, 6]) d = np.array([1, 8, 3]) result_array = np.maximum(c, d) print(result_array) # 输出: array([2, 8, 6]) ``` 在第一个示例中,标量 `3` 被用来与数组 `[1, 5, 3]` 进行逐元素的最大值计算[^2]。 第二个示例展示了如何通过两个数组之间的逐元素比较得到结果。 #### 广播特性 当两个输入数组具有不同的形状时,只要它们能够被广播成相同的形状,`numpy.maximum` 就能正常工作。 ```python e = np.ones((3, 1)) f = np.arange(3) g = np.maximum(e, f[:, None]) # 利用广播机制 print(g) # 输出: # [[1. 1. 1.] # [1. 1. 1.] # [2. 2. 2.]] ``` 在这里,`arange(3)` 和 `ones((3, 1))` 经过广播后形成 `(3, 3)` 形状的结果矩阵[^2]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值