6번 https://tech.kakao.com/2019/10/02/kakao-blind-recruitment-2020-round1/

kakao2020six.java

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Solution {
	private List<Integer> clkwiseidxing(int n, int[] weak, int start) {
		// clockwise
    	// 넘어가면 바퀴 수에 따라 더해준다.
    	List<Integer> wps = new ArrayList<>();
    	for(int count=0; count<weak.length; count++) {
    		int point = circular(weak.length, start+count);
    		int div = (start+count) / weak.length;
    		if(div > 0) {
    			wps.add(weak[point] + div * n);
    		} else if(div == 0) {
    			wps.add(weak[point]);
    		}
    	}
    	return wps;
	}
	
	private List<Integer> cclkwiseidxing(int start, int[] weak) {
    	// counter-clockwise
		List<Integer> wpcs = new ArrayList();
		for(int count=0; count<weak.length; count++) {
			int point = circular(weak.length, start-count);
			wpcs.add(weak[point]);
		}
		System.out.println(wpcs);
		return wpcs;
	}
	
	private int circular(int n, int i) {
		int modi = i % n;
		if(modi < 0) {
			modi += n;
			return modi;
		} else {
			return modi;
		}
	}
	
	
	private List<Integer> intervalList(List<Integer> weak) {
		var result = new ArrayList<Integer>();
		
		for(int i=0; i<weak.size()-1; i++) {
			int interval = weak.get(i+1) - weak.get(i);
			result.add(interval);
		}
		
		return result;
	};
	
	private int[] tocclkwise(int n, int[] weak) {
		int[] result = new int[weak.length];
		for(int i=0; i<weak.length; i++) {
			result[i] = n - weak[i];
		}
		Arrays.sort(result);
		return result;
	}
	
    public int solution(int n, int[] weak, int[] dist) {
        // 최소 인원을 투입하려면 반드시 이동거리가 긴 녀석들만을 써야한다.
        var descdist = Arrays.stream(dist)
        		.boxed().sorted((a,b)->b-a)
        		.collect(Collectors.toList());
//        System.out.println(descdist);
        
        List<List<Integer>> startpoints = new ArrayList<>();
        // 결국 원형을 어떻게 돌 것인가에 대한 모든 방법을 찾아내야한다.
        // 각 지점에서 출발하는 모든 경우를 본다.
        for(int start=0; start<weak.length; start++) {
            // 각 시작지점마다 직선으로 펼친다.
        	startpoints.add(clkwiseidxing(n, weak, start));
            // 반시계 방향을 +로 생각한 뒤 오름차순 정렬해서 시계방향처럼 똑같이한다.
        	startpoints.add(clkwiseidxing(n, tocclkwise(n, weak), start));
        }
        
        // 모든 경우의 수는 각 취약지점 간의 interval의 순서있는 조합이다.
        startpoints.stream().forEach(System.out::println);
        var intervals = startpoints.stream().map(new Solution()::intervalList).collect(Collectors.toList());
        intervals.stream().forEach(System.out::println);
        
        int answer = 0;
        answer = startpoints.stream()
                // 최소 몇명이 있어야 현재의 간격 조합에서 다 수리가능한가?
        		.mapToInt(e->countminmem(e,descdist))
        		.min().getAsInt();
        System.out.println(answer);
        if(answer == Integer.MAX_VALUE) return -1;
        else return answer;
    }
    
    int countminmem(List<Integer> points, List<Integer> descdist){
    	
    	int fix = 0;
    	int member = 0;
    	int move = 0;
    	while(fix < points.size() && member < descdist.size()) {
    		if(move == 0)
    			move = points.get(fix) + descdist.get(member);
    		if(move < points.get(fix)) {
    			member += 1;
    			move = 0;
    		} else {
    			fix += 1;
    			if(fix == points.size()) member += 1;
    		}
    	}
//    	System.out.println(fix + " " + member);
    	if(fix < points.size()) return Integer.MAX_VALUE;
    	else return member;
    }

    public static void main(String[] args) {
        new Solution().solution(12, new int[]{1,5,6,10}, new int[]{1,2,3,4});
        new Solution().solution(12, new int[]{1,3,4,9,10}, new int[]{3,5,7});
        // 질문 목록에서 찾은 예시들
    	new Solution().solution(200, new int[] {0,10,50,80,120,160}, new int[] {1, 10, 5, 40, 30});
    	new Solution().solution(30, new int[]{0,3,11,21}, new int[]{10,4});
    	new Solution().solution(12, new int[]{0,10}, new int[]{1,2});
    }
}

왜 14번만 막힐까? 순열이 반드시 필요한가?