HashMap & HashSet — Deep Dive

int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> seen = new HashMap<>(); // value → index
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (seen.containsKey(complement))
            return new int[]{seen.get(complement), i};
        seen.put(nums[i], i); // add AFTER checking
    }
    return new int[]{};
}

// Dry run: nums=[2,7,11,15], target=9
// i=0: complement=7, seen={} → miss → seen={2:0}
// i=1: complement=2, seen={2:0} → HIT → return [0,1] ✓

int romanToInt(String s) {
    Map<Character, Integer> val = Map.of(
        'I', 1, 'V', 5, 'X', 10, 'L', 50,
        'C', 100, 'D', 500, 'M', 1000);
    int result = 0, prev = 0;
    for (int i = s.length() - 1; i >= 0; i--) {
        int curr = val.get(s.charAt(i));
        result += (curr < prev) ? -curr : curr;
        prev = curr;
    }
    return result;
}

// Dry run: "MCMXCIV" (right to left)
// i=6: V=5,  prev=0 → 5>=0 → add 5.  result=5,  prev=5
// i=5: I=1,  prev=5 → 1< 5 → sub 1.  result=4,  prev=1
// i=4: C=100,prev=1 → 100>=1→ add 100.result=104,prev=100
// i=3: X=10, prev=100→ 10<100→sub 10.result=94, prev=10
// i=2: M=1000...→ result=1994 ✓

List<List<String>> groupAnagrams(String[] strs) {
    Map<String, List<String>> map = new HashMap<>();
    for (String s : strs) {
        char[] c = s.toCharArray();
        Arrays.sort(c);
        String key = new String(c);          // canonical form
        map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
    }
    return new ArrayList<>(map.values());
}

// Dry run: ["eat","tea","tan"]
// "eat" → sort → "aet" → map={"aet":["eat"]}
// "tea" → sort → "aet" → map={"aet":["eat","tea"]}
// "tan" → sort → "ant" → map={"aet":[...], "ant":["tan"]}
// Return [[eat,tea],[tan]] ✓

int[] topKFrequent(int[] nums, int k) {
    // Step 1: frequency map
    Map<Integer, Integer> freq = new HashMap<>();
    for (int x : nums) freq.merge(x, 1, Integer::sum);

    // Step 2: min-heap of size k (keeps top-k frequent)
    PriorityQueue<Integer> pq =
        new PriorityQueue<>((a, b) -> freq.get(a) - freq.get(b));
    for (int key : freq.keySet()) {
        pq.offer(key);
        if (pq.size() > k) pq.poll(); // evict least frequent
    }

    // Step 3: extract answers
    int[] res = new int[k];
    for (int i = k - 1; i >= 0; i--) res[i] = pq.poll();
    return res;
}

// nums=[1,1,1,2,2,3], k=2
// freq={1:3, 2:2, 3:1}
// heap after all: [2(freq2), 1(freq3)] → [1,2] ✓

int subarraySum(int[] nums, int k) {
    Map<Integer, Integer> prefixCount = new HashMap<>();
    prefixCount.put(0, 1);  // empty prefix sum seen once
    int sum = 0, count = 0;
    for (int x : nums) {
        sum += x;
        count += prefixCount.getOrDefault(sum - k, 0);
        prefixCount.merge(sum, 1, Integer::sum);
    }
    return count;
}

// Dry run: nums=[1,1,1], k=2
// Start: map={0:1}, sum=0, count=0
// x=1: sum=1, need sum-k=1-2=-1 → map has 0 → count=0 → map={0:1,1:1}
// x=1: sum=2, need 2-2=0 → map has 1 → count=1  → map={0:1,1:1,2:1}
// x=1: sum=3, need 3-2=1 → map has 1 → count=2  → map={...,3:1}
// Return 2 ✓

int longestConsecutive(int[] nums) {
    Set<Integer> set = new HashSet<>();
    for (int x : nums) set.add(x);

    int longest = 0;
    for (int x : set) {
        if (!set.contains(x - 1)) {   // x is a sequence start
            int len = 1;
            while (set.contains(x + len)) len++;
            longest = Math.max(longest, len);
        }
    }
    return longest;
}

// [100,4,200,1,3,2] → set={100,4,200,1,3,2}
// x=100: set has 99? No → start. 101? No → len=1
// x=4:   set has 3? Yes → NOT a start → skip
// x=1:   set has 0? No → start. 2?Yes,3?Yes,4?Yes,5?No → len=4
// longest = 4 ✓

class LRUCache extends LinkedHashMap<Integer, Integer> {
    private int capacity;

    LRUCache(int capacity) {
        // true = access-order (most recently used first)
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        super.put(key, value);
    }

    // Called automatically by LinkedHashMap after each put
    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> e) {
        return size() > capacity; // evict when over capacity
    }
}