import java.util.*;
import java.util.Map.Entry;

class Solution {
    
    static Map<String,Integer> map;
    
    public List<String> solution(String[] orders, int[] course) {
        List<String> ans= new ArrayList<>(); 
        
        for(int i=0; i<orders.length; i++){
            char[] temp = orders[i].toCharArray();
            Arrays.sort(temp);
            orders[i] = String.valueOf(temp);
        }  
        for(int i=0; i<course.length; i++){
            map = new HashMap<>();
            int max = Integer.MIN_VALUE;
            
            for(int j=0; j<orders.length; j++){
                StringBuilder sb= new StringBuilder();
                if(orders[j].length()>=course[i]){
                    comb(orders[j],sb,0,0,course[i]);
                }
            }
            
            for(Entry<String,Integer> entry : map.entrySet()){
                max = Math.max(max, entry.getValue());
            }
            for(Entry<String,Integer> entry: map.entrySet()){
                if(entry.getValue() == max && max>=2){
                    ans.add(entry.getKey());
                }
            }
        }
        Collections.sort(ans);
        return ans;
        
    }
    public static void comb(String str, StringBuilder sb, int idx,int depth,int n){
        if(depth == n){
            map.put(sb.toString(),map.getOrDefault(sb.toString(),0)+1);
            return;
        }
        for(int i=idx; i<str.length(); i++){
            sb.append(str.charAt(i));
            comb(str,sb,i+1,depth+1,n);
            sb.delete(depth,depth+1);
        }
    }
}

1. Map.Entry.getValue()[getKey()]로 키,값 독립적으로 조회하기

2. String 정렬 방법:
   String -> String.toCharArray() -> Arrays.sort(배열) -> String.valueOf(charArr)

   두번째

import java.util.*;
import java.util.Map.Entry;

/*
 조합의 경우 순서에 상관없으므로 순서를 정렬해서 조합을 구하는 편이 편하다.
*/

class Solution {
    Map<String,Integer> map;
    
    public List<String> solution(String[] orders, int[] course) {
        List<String> ans = new ArrayList<>();
        
        //orders배열 정렬
        for(int i=0; i<orders.length; i++){
            //사전식으로 정렬해야 하므로 
            char[] tmp = orders[i].toCharArray();
            Arrays.sort(tmp);
            orders[i] = String.valueOf(tmp);
        }
        // course 순회하며 가능한 order로 부터 메뉴 추출(조합)
        for (int i=0; i<course.length; i++){
            map = new HashMap<>();
            int menuLen = course[i];
            
            for(int j=0; j<orders.length; j++){
                if(orders[j].length()>=menuLen){
                    StringBuilder sb = new StringBuilder();
                    comb(sb,orders[j],0,0,menuLen);
                }
            }
            int max = Integer.MIN_VALUE;
            for(Entry<String,Integer> entry: map.entrySet()){
                max = Math.max(entry.getValue(),max);
            }
            for(Entry<String,Integer> entry: map.entrySet()){
                if(entry.getValue() == max && max>=2){
                    ans.add(entry.getKey());
                }
            }
        }
        Collections.sort(ans);
        
        return ans;
    }
    
    public void comb(StringBuilder sb, String nowOrder,int idx,int curLen, int targetLen){
        if(curLen == targetLen){
            String newKey = sb.toString();
            map.put(newKey, map.getOrDefault(newKey,0)+1);
            return;
        }
        if(idx >= nowOrder.length()) return;
        
        for(int i=idx; i<nowOrder.length(); i++){
            sb.append(nowOrder.charAt(i));
            // idx와 i 착각해서 1시간 날림
            comb(sb,nowOrder,i+1,curLen+1,targetLen); 
            sb.delete(curLen,curLen+1);
        }
    }
}