气球谜题

import java.util.Arrays;
import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        String s = in.next();
        int[] costs = new int[n];
        for (int i = 0; i < n; i++) {
            costs[i] = in.nextInt();
        }
        // 0 :全红、形如000
        // 1 :全黄、形如111
        // 2 :全蓝、形如222
        // 3 :黄红、形如10
        // 4 :蓝黄、形如21
        // 5 :红蓝、形如02
        // 6 :蓝红、形如20
        // 7 :红黄、形如01
        // 8 :黄蓝、形如12
        // 9 :黄蓝红、形如120
        // 10 :红蓝黄、形如021
        // 11 :黄红蓝、形如102
        // 12 :蓝黄红、形如210
        // 13 :蓝红黄、形如201
        // 14 :红黄蓝、形如012
        int[] t = new int[3]; //t[0]、t[1]、t[2]分别表示更改为红黄蓝颜色需要花费的时间
        long[] dp = new long[15];  //表示更改为对应的颜色类型需要花费的最少时间
        for (int i = 0; i < s.length(); i++) {
            t[0] = t[1] = t[2] = costs[i];
            t[s.charAt(i) - '0'] = 0; //改为当前颜色的花费为0
            dp[14] = Math.min(dp[14], dp[7]) + t[2];  //红黄蓝只能由红黄蓝本身以及红黄变过来
            dp[13] = Math.min(dp[13], dp[6]) + t[1];
            dp[12] = Math.min(dp[12], dp[4]) + t[0];
            dp[11] = Math.min(dp[11], dp[3]) + t[2];
            dp[10] = Math.min(dp[10], dp[5]) + t[1];
            dp[9] = Math.min(dp[9], dp[8]) + t[0];
            dp[8] = Math.min(dp[8], dp[1]) + t[2];
            dp[7] = Math.min(dp[7], dp[0]) + t[1];
            dp[6] = Math.min(dp[6], dp[2]) + t[0];
            dp[5] = Math.min(dp[5], dp[0]) + t[2];
            dp[4] = Math.min(dp[4], dp[2]) + t[1];
            dp[3] = Math.min(dp[3], dp[1]) + t[0];
            dp[2] += t[2];
            dp[1] += t[1];
            dp[0] += t[0];
        }

        long minV =  Long.MAX_VALUE;
        for (int i = 0; i < 15; i++) {
            minV = Math.min(minV, dp[i]);
        }
        System.out.println(minV);
    }
}

#时间对比中相对论
import sys

n = int(sys.stdin.readline())  # 任务数量
colors = sys.stdin.readline().strip()  # 每个任务的颜色
times = list(map(int, sys.stdin.readline().split()))  # 每个任务的处理时间
total = sum(times)  # 总处理时间
permutations = [
    ('0', '1', '2'), ('0', '2', '1'),
    ('1', '0', '2'), ('1', '2', '0'),
    ('2', '0', '1'), ('2', '1', '0'),
]  #permutations：排列；序列
# 所有可能的颜色排列（处理器处理颜色的顺序）
min_cost = float('inf') 

for perm in permutations:
    a, b, c = perm   
    dp0 = 0  # 处理器A的初始负载
    dp1 = -float('inf') # 处理器B的初始负载（尚未开始处理）
    dp2 = -float('inf') # 处理器C的初始负载（尚未开始处理）
    for i in range(n):
        current_color = colors[i] #每个任务的颜色
        t = times[i]        
        if current_color == a:
            new_dp0 = dp0 + t
            new_dp1 = dp1
            new_dp2 = dp2
        elif current_color == b:
            new_dp0 = dp0
            new_dp1 = max(dp1 + (t if dp1 != -float('inf') else 0), dp0 + t)
            new_dp2 = dp2
        else:
            new_dp0 = dp0
            new_dp1 = dp1
            new_dp2 = max(dp2 + (t if dp2 != -float('inf') else 0), dp1 + t)
        dp0, dp1, dp2 = new_dp0, new_dp1, new_dp2
     # 计算当前排列下的最大负载
    current_max = max(dp0, dp1 if dp1 != -float('inf') else 0, dp2 if dp2 != -float('inf') else 0)
    current_cost = total - current_max  # 目标是最小化这个值
    if current_cost < min_cost:
        min_cost = current_cost
print(min_cost)