粉刷房子 III

/*
 * This solution uses Java Streams to solve the problem of painting houses to form a specific number of blocks with minimum cost.
 * We leverage the same dynamic programming approach but implement it in a more functional style with Streams.
 */
import java.util.*;
import java.util.stream.*;

public class Solution {
    public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
        int MAX_COST = 1000001;
        int[][][] dp = new int[m][target + 1][n + 1];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j <= target; j++) {
                Arrays.fill(dp[i][j], MAX_COST);
            }
        }
        IntStream.range(1, n + 1).forEach(k -> {
            if (houses[0] == 0) {
                dp[0][1][k] = cost[0][k - 1];
            } else if (houses[0] == k) {
                dp[0][1][k] = 0;
            }
        });
        IntStream.range(1, m).forEach(i -> {
            IntStream.range(1, target + 1).forEach(j -> {
                IntStream.range(1, n + 1).forEach(k -> {
                    if (houses[i] != 0 && houses[i] != k) {
                        return;
                    }
                    int currentCost = houses[i] == 0 ? cost[i][k - 1] : 0;
                    IntStream.range(1, n + 1).forEach(kPrev -> {
                        if (k == kPrev) {
                            dp[i][j][k] = Math.min(dp[i][j][k], dp[i - 1][j][kPrev] + currentCost);
                        } else {
                            dp[i][j][k] = Math.min(dp[i][j][k], dp[i - 1][j - 1][kPrev] + currentCost);
                        }
                    });
                });
            });
        });
        return IntStream.range(1, n + 1)
                         .map(k -> dp[m - 1][target][k])
                         .min()
                         .orElse(MAX_COST) == MAX_COST ? -1 : IntStream.range(1, n + 1).map(k -> dp[m - 1][target][k]).min().orElse(MAX_COST);
    }
}