1class Solution {
2    /**
3     * Computes the minimum cost based on grouping character costs.
4     *
5     * Strategy:
6     * 1. Accumulate the total cost of all characters.
7     * 2. Group the costs by their corresponding character, summing each group.
8     * 3. The answer is the total cost minus the largest single group's sum,
9     *    which is equivalent to taking the minimum of (total - groupSum)
10     *    across all groups.
11     *
12     * @param s    the input string of characters
13     * @param cost the cost associated with each character at the same index
14     * @return the minimum cost after removing the most "valuable" group
15     */
16    public long minCost(String s, int[] cost) {
17        // Total cost of every character in the string.
18        long totalCost = 0;
19
20        // Maps each distinct character to the summed cost of its occurrences.
21        Map<Character, Long> costByChar = new HashMap<>(26);
22
23        // Build the total cost and per-character grouped costs in one pass.
24        for (int i = 0; i < cost.length; ++i) {
25            totalCost += cost[i];
26            costByChar.merge(s.charAt(i), (long) cost[i], Long::sum);
27        }
28
29        // Initialize the answer with the full total as the upper bound.
30        long minResult = totalCost;
31
32        // For each character group, consider removing that group's entire cost
33        // and keep track of the smallest remaining total.
34        for (long groupCost : costByChar.values()) {
35            minResult = Math.min(minResult, totalCost - groupCost);
36        }
37
38        return minResult;
39    }
40}
41

1class Solution {
2public:
3    long long minCost(string s, vector<int>& cost) {
4        // Accumulate the total cost of all characters.
5        long long totalCost = 0;
6
7        // Map each distinct character to the sum of its costs.
8        unordered_map<char, long long> costByChar;
9
10        // Build the total cost and the per-character cost sums.
11        for (int i = 0; i < static_cast<int>(cost.size()); ++i) {
12            totalCost += cost[i];
13            costByChar[s[i]] += cost[i];
14        }
15
16        // Start with the assumption of removing everything (upper bound).
17        long long answer = totalCost;
18
19        // For each character group, consider keeping that group entirely
20        // and removing the rest, then take the minimum remaining cost.
21        for (const auto& [character, groupCost] : costByChar) {
22            answer = min(answer, totalCost - groupCost);
23        }
24
25        return answer;
26    }
27};
28```
29
30**A note on correctness:** This approach keeps only the *single* character group with the maximum total cost. This is correct **only** when the string consists of characters that are all the same (or when the intended problem is "keep one group"). 
31
32For the classic LeetCode problem **1578 (Minimum Cost to Make at Least One String Repeating / removing characters to avoid equal adjacent letters)**, the standard solution differs — it processes consecutive equal-character runs and keeps the most expensive character in each run:
33
34```cpp
35class Solution {
36public:
37    long long minCost(string s, vector<int>& cost) {
38        long long totalRemoved = 0;  // Accumulated cost of removed characters.
39        int i = 0;
40        int n = static_cast<int>(s.size());
41
42        while (i < n) {
43            char currentChar = s[i];
44            long long groupSum = 0;   // Sum of costs in the current run.
45            int groupMax = 0;         // Maximum single cost in the current run.
46
47            // Expand over the run of identical adjacent characters.
48            while (i < n && s[i] == currentChar) {
49                groupSum += cost[i];
50                groupMax = max(groupMax, cost[i]);
51                ++i;
52            }
53
54            // Keep the most expensive char, remove the rest of the run.
55            totalRemoved += groupSum - groupMax;
56        }
57
58        return totalRemoved;
59    }
60};
61

1/**
2 * Minimum Time to Make Rope Colorful.
3 * Removes balloons so that no two adjacent balloons share the same color,
4 * minimizing the total removal time.
5 *
6 * @param s    The colors of the balloons, one character per balloon.
7 * @param cost The time needed to remove each corresponding balloon.
8 * @returns    The minimum total time to remove balloons.
9 */
10function minCost(s: string, cost: number[]): number {
11    const n: number = s.length;
12    let answer: number = 0;
13    let index: number = 0;
14
15    // Scan through the string, processing each run of identical adjacent colors.
16    while (index < n) {
17        const color: string = s[index];
18        let groupSum: number = 0; // Total cost of all balloons in the current run.
19        let groupMax: number = 0; // Largest single cost in the current run.
20
21        // Extend the run while the color stays the same.
22        while (index < n && s[index] === color) {
23            groupSum += cost[index];
24            groupMax = Math.max(groupMax, cost[index]);
25            index++;
26        }
27
28        // Keep the most expensive balloon in the run; remove the rest.
29        answer += groupSum - groupMax;
30    }
31
32    return answer;
33}
34