Java Memory Management & Collections

List<List<String>> groupAnagrams(String[] strs) {
    Map<String,List<String>> map = new HashMap<>();
    for (String s : strs) {
        char[] ch = s.toCharArray(); Arrays.sort(ch);
        map.computeIfAbsent(new String(ch), k -> new ArrayList<>()).add(s);
    }
    return new ArrayList<>(map.values());
}
// "eat"→sort→"aet", "tea"→sort→"aet" → same group!

int[] topKFrequent(int[] nums, int k) {
    Map<Integer,Integer> freq = new HashMap<>();
    for (int n:nums) freq.merge(n,1,Integer::sum);
    PriorityQueue<int[]> pq = new PriorityQueue<>((a,b)->a[1]-b[1]);
    for (var e:freq.entrySet()) {
        pq.offer(new int[]{e.getKey(),e.getValue()});
        if(pq.size()>k) pq.poll();
    }
    int[] res=new int[k];
    for(int i=k-1;i>=0;i--) res[i]=pq.poll()[0];
    return res;
}

class LRUCache extends LinkedHashMap<Integer,Integer> {
    final int cap;
    LRUCache(int c) { super(c,0.75f,true); cap=c; } // true=accessOrder
    public int get(int k) { return super.getOrDefault(k,-1); }
    public void put(int k,int v) { super.put(k,v); }
    @Override protected boolean removeEldestEntry(Map.Entry e) { return size()>cap; }
}

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> seen = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int need = target - nums[i];
        if (seen.containsKey(need))
            return new int[] { seen.get(need), i };
        seen.put(nums[i], i);
    }
    return new int[] {};
}
// [2,7,11,15] t=9:
// i=0: need=7, not in map → put {2:0}
// i=1: need=2, found at 0 → return [0,1] ✓

public boolean isValid(String s) {
    Deque<Character> stack = new ArrayDeque<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') stack.push(c);
        else {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if (c == ')' && top != '(') return false;
            if (c == ']' && top != '[') return false;
            if (c == '}' && top != '{') return false;
        }
    }
    return stack.isEmpty();
}

class MinStack {
    Deque<Integer> stack = new ArrayDeque<>();
    Deque<Integer> minStack = new ArrayDeque<>();

    public void push(int val) {
        stack.push(val);
        int curMin = minStack.isEmpty() ? val : Math.min(val, minStack.peek());
        minStack.push(curMin);
    }
    public void pop()    { stack.pop(); minStack.pop(); }
    public int  top()    { return stack.peek(); }
    public int  getMin(){ return minStack.peek(); }
}
// push(5): stack=[5], min=[5]
// push(3): stack=[3,5], min=[3,5]
// push(7): stack=[7,3,5], min=[3,3,5]
// getMin()=3 ✓  pop()→stack=[3,5],min=[3,5] → getMin()=3 ✓

public int longestConsecutive(int[] nums) {
    Set<Integer> set = new HashSet<>();
    for (int n : nums) set.add(n);
    int best = 0;
    for (int n : set) {
        if (!set.contains(n - 1)) { // start of a sequence
            int cur = n, len = 1;
            while (set.contains(++cur)) len++;
            best = Math.max(best, len);
        }
    }
    return best;
}
// [100,4,200,1,3,2]: set has all values
// n=1: 0 not in set → start! count 1,2,3,4 → len=4 → best=4 ✓