小红的数组切割

n,k=list(map(int,input().strip().split()))
a=list(map(int,input().strip().split()))
s=input().strip()
dp=[[-float("inf")]*(1+k) for _ in range(1+n)]
dp[0][0]=0
weight=[0]*n
for i in range(n):
    if s[i]=='0':
        weight[i]=-1
    else:
        weight[i]=1


presum=[0]*(n+1)
opsum=[0]*(n+1)
ans=-float("inf")
for i in range(1,n+1):
    presum[i]=presum[i-1]+weight[i-1]*a[i-1]
for i in range(1,n+1):
    opsum[i]=opsum[i-1]+weight[i-1]

for i in range(1,n+1):
    for j in range(1,min(i,k)+1):
        for t in range(0,i):

            dp[i][j]=max(dp[i][j],dp[t][j-1]+(opsum[i]-opsum[t])*j+presum[i]-presum[t])
for j in range(1,min(n,k)+1):
    ans=max(ans,dp[-1][j])

print(ans)

function maxArrayValue(n, k, a, s) {
    // 计算 op 数组
    let op = new Array(n);
    let fixedSum = 0;
    for (let i = 0; i < n; i++) {
        op[i] = s[i] === '1' ? 1 : -1;
        fixedSum += op[i] * a[i];
    }

    // 前缀和 opSum[t] = op[0] + ... + op[t-1]，方便求区间和
    let opSum = new Array(n + 1).fill(0);
    for (let i = 1; i <= n; i++) {
        opSum[i] = opSum[i - 1] + op[i - 1];
    }

    // dp[i][j]：前 i 个元素切成 j 块的最大 sum(op * block_id)
    const INF = -1e18;
    let dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(INF));
    dp[0][0] = 0;

    for (let i = 1; i <= n; i++) {
        for (let j = 1; j <= Math.min(k, i); j++) {
            for (let m = 0; m < i; m++) {
                // [m, i) 是第 j 块
                if (dp[m][j - 1] === INF) continue;
                let blockOpSum = opSum[i] - opSum[m];
                dp[i][j] = Math.max(dp[i][j], dp[m][j - 1] + j * blockOpSum);
            }
        }
    }

    // 求最大可能的附加部分
    let maxExtra = INF;
    for (let j = 1; j <= k; j++) {
        maxExtra = Math.max(maxExtra, dp[n][j]);
    }

    return maxExtra + fixedSum;
}

// 测试样例
let n = 5, k = 3;
let a = [3, -2, 4, 1, 5];
let s = "10110";  // op: 1, -1, 1, 1, -1
console.log(maxArrayValue(n, k, a, s)); // 根据情况计算