Java：如何暴力遍历HashMap<Integer, Boolean>的所有布尔值组合

Got it, let's solve this problem. You need to generate every possible boolean combination for a HashMap with keys from 1 to N, modifying the HashMap directly instead of converting to an array. Here's a straightforward approach that mimics binary counting (since each boolean is a bit, and we're going through all 2^N possible values):

Step-by-Step Explanation #

The core idea is to treat each key's boolean value as a bit in a binary number. We start with all false (like 0000 for N=4), then increment this "binary number" by flipping values from the highest key down to the lowest—just like how you carry over digits when adding 1 to a binary number.

Java Code Example #

import java.util.HashMap;

public class HashMapBooleanGenerator {
    public static void main(String[] args) {
        int N = 4; // Replace with your desired N value
        HashMap<Integer, Boolean> boolMap = new HashMap<>();
        
        // Initialize all keys to false (matching your starting state)
        for (int key = 1; key <= N; key++) {
            boolMap.put(key, false);
        }
        
        int totalCombos = (int) Math.pow(2, N);
        for (int i = 0; i < totalCombos; i++) {
            // --------------------------
            // Insert your custom logic here: use the current HashMap state for calculations
            System.out.println("Combination " + (i + 1) + ": " + boolMap);
            // --------------------------
            
            // Generate next combination by flipping values (simulate binary increment)
            int currentKey = N;
            while (currentKey >= 1) {
                boolean currentVal = boolMap.get(currentKey);
                boolMap.put(currentKey, !currentVal);
                
                // If we flipped from false to true, no more carryover needed—exit loop
                if (boolMap.get(currentKey)) {
                    break;
                }
                // Otherwise, carry over to the previous smaller key
                currentKey--;
            }
        }
    }
}

How It Works #

1. Initialization: We first populate the HashMap with keys 1 to N, all set to false—exactly your required starting state.
2. Loop Through Combinations: We run exactly 2^N iterations (since that's the total number of unique boolean combinations possible).
3. Process Current State: In each iteration, you can add your custom code to use the HashMap's current values (e.g., run calculations using the keys and their boolean states).
4. Generate Next Combination: Starting from the largest key (N), we flip its value. If it turns to true, we're done with this increment. If it turns to false (meaning it was true before), we move to the next smaller key and repeat—this mimics the carryover behavior in binary addition.

Time Complexity #

While each individual increment might take up to N steps in the worst case (e.g., flipping all true values to false), the average number of flips per combination is 2, leading to an overall time complexity of O(2^N)—which meets your requirement perfectly.

内容的提问来源于stack exchange，提问作者CheeseBites