Hello LeetCode!

/*
 * Problem Statement:
 * Given a list of words, determine the minimum cost to collect all the letters in the string "helloleetcode" from these words.
 * The cost of taking a letter from a word is calculated as the product of the number of letters to its left and right in the word.
 * If it's not possible to collect all the letters, return -1.
 */

import java.util.*;
import java.util.stream.Collectors;

public class Solution {
    public int minCostToCollectLetters(String[] words) {
        String target = "helloleetcode";
        Map<Character, Integer> targetCount = target.chars()
            .mapToObj(c -> (char)c)
            .collect(Collectors.toMap(c -> c, c -> 1, Integer::sum));

        Map<Character, List<Integer>> costs = new HashMap<>();
        Arrays.stream(words).forEach(word -> {
            for (int i = 0; i < word.length(); i++) {
                char c = word.charAt(i);
                if (targetCount.containsKey(c)) {
                    int cost = i * (word.length() - i - 1);
                    costs.computeIfAbsent(c, k -> new ArrayList<>()).add(cost);
                }
            }
        });

        int totalCost = 0;
        for (Map.Entry<Character, Integer> entry : targetCount.entrySet()) {
            char c = entry.getKey();
            int required = entry.getValue();
            if (costs.containsKey(c)) {
                List<Integer> availableCosts = costs.get(c);
                if (availableCosts.size() < required) return -1;
                Collections.sort(availableCosts);
                totalCost += availableCosts.subList(0, required).stream().mapToInt(Integer::intValue).sum();
            } else {
                return -1;
            }
        }

        return totalCost;
    }
}