30-wnsmir

[wnsmir]

🔗 문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/181188

✔️ 소요된 시간

1h

✨ 수도 코드

처음에 이문제를보고 잠시 조합을 떠올렸습니다.
각 조합별로 다 시도해보고, 그중 가장 작은 원소의 수를 답으로 return하려했지만 1부터 50만의 조합은 너무도 크더군요,,

바로 접고 전에 오흠스 알고리즘수업떄 비슷한유형을 들은 기억이 나 그리디를 두번쨰로 떠올렸습니다.

구간이 [1, 3] 이렇게 있다면 처음엔 첫번쨰원소를 기준으로 잡으려했는데 가만히 생각해보니 최대중첩을 위해선 앞에서부터 시작한다고 했을댸 해당구간의 가장 뒤를 기준으로 잡아야 최대한 많은구간을 겹칠 수 있었습니다.

즉 구간을 빠트리지 않기 위해 구간의 끝을 기준으로 먼저 정렬을 해주고,
첫구간부터 끝지점을 기준으로 미사일읠 요격해줍니다.

요격할떄 해당구간의 다른미사일도 제거해주고, 남은 구간이 없을떄까지 반복해줍니다.

그리디를 푼지 오래돼서 이걸 그대로 구현해버렸습니다..

def solution(targets):
    count = 0
    # 뒤의 원소로 정렬
    sorted_targets = sorted(targets, key = lambda x:x[1])
    
    # 첫번쨰 구간부터 끝나는지점을 기준으로 미사일 요격
    for target in sorted_targets:
        # 모두 요격하면 종료
        if len(targets) == 0:
            break
        if target not in targets:
            continue
            
        end = target[1]
        n = len(targets)
        selected = []
        
        flag = False
        for i in range(n):
            # 시작은 end보다 작고 끝은 크거나 같은 구간이라면 삭제
            if end > targets[i][0] and targets[i][1] >= end:
                selected.append(i)
                flag = True
        
        for i in reversed(selected):
            del targets[i]
        
        if flag == True:
            count += 1

    return count

삭제가 들어가는순간 시간초과가 나더라구요
사실 이문제는 굳이 구현을 해줄 필요가 없었습니다

def solution(targets):
    # 끝나는 지점 기준 오름차순 정렬
    targets.sort(key=lambda x: x[1])

    count = 0
    last_shot = -1
    for start, end in targets:
        if start >= last_shot:
            count += 1
            last_shot = end
            
    return count

그냥 미사일 발사지점을 정해두고 다음구간의 시작점이 마지막 발사지점보다 크거나 같으면, 그 구간의 마지막지점을 다시 발사지점으로 업데이트해줍니다. 같거나 큰 이유는, 같을떄도 경계값은 요격이 안되기 때문입니다.

[kokeunho]

저는 금방 풀이법이 떠오르지 않아서
준용님의 풀이를 보고 풀었습니다.

그리디 문제를 잘 안풀어서 그런지, 접근 방식이 잘 떠오르지 않았네요.
그래서 코드는 짧았어도 얻어가는게 있었다고 생각합니다.

좋은 문제 감사합니다. 수고하셨습니다~

import java.util.*;

class Solution {
    public int solution(int[][] targets) {
        Arrays.sort(targets, (a, b) -> Integer.compare(a[1], b[1]));
        
        int count = 0;
        int missleX = -1;
        
        for (int[] target : targets) {
            int start = target[0];
            int end = target[1];
            
            if (missleX < start) {
                count++;
                missleX = end - 1;
            }
        }
        return count;
    }
}

[kangrae-jo]

그리디스러운 문제이군요! 18분 걸렸습니다ㅎㅎ
알고리즘 초반에 이런 문제를 몇번 다뤄봐서인지, 이렇게 s ~ e 가 있으면
s와 e중 어느것을 기준으로 정렬을 할 지 고민을 해보는 편인 것 같아요.
(또는 스위핑 알고리즘도 살짝 고려하긴 합니다.)

처음에 든 생각은 s기준 정렬이었는데 구현을 조금씩 하다보니까 안되겠더라구요.
그래서 e기준 정렬로 바꾸고 로직을 실행시키니 정답이었습니다.

오랜만에 명쾌하게 답을 찾은 문제를 만나서 기분이 좋네요.

코드는 같습니다.

#include <algorithm>
#include <vector>

using namespace std;

bool compareTo(const vector<int>& a, const vector<int>& b) {
    return a[1] < b[1];
}

int solution(vector<vector<int>> targets) {
    sort(targets.begin(), targets.end(), compareTo);

    int answer = 0;
    int curE = -1;
    for (int i = 0; i < targets.size(); i++) {
        int s = targets[i][0];
        int e = targets[i][1];
        
        if (s >= curE) {
            answer++;
            curE = e;
        }
    }
    
    return answer;
}

[9kyo-hwang]

전 그리디가 참 어렵네요... 약간 요런 길이/막대 관련된 건 끝점 기준으로 정렬하면 반은 먹고 들어간건데 전 그 다음이 계속 안떠오르네요 허...

요격이 개구간 (s, e)에 대해 이뤄져서 포격 좌표 x가 해당 구간의 시작점 s보다 작거나 같으면 구간 끝점으로 점프 시키면서 개수를 늘린다... 짜고 보면 참 간단한 것을...

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int solution(vector<vector<int>> targets) {
    sort(targets.begin(), targets.end(), [](vector<int>& lhs, vector<int>& rhs) {
        return lhs[1] < rhs[1];
    });
    
    int answer = 0;
    int x = 0;
    
    for(auto& t : targets) {
        if(x <= t[0]) {
            ++answer;
            x = t[1];
        }
    }
    
    return answer;
}

[g0rnn]

20분 고민하다가 답이 안나와서 풀이를 봤습니다. 저도 그리디를 생각하지 않은건 아닌데 어떻게 매번 최적의 해를 찾을 수 있을지 고민하다가 떠오르지 않았네요.

그리디는 정렬과 밀접하게 관련이 있는 것 같아요. 정렬을 하는 방법은 다를 수 있지만 최적의 해를 찾는 기준은 정렬 방식에 따라 바뀌는 듯 하구요.

전 다른 분들과는 다르게 시작점을 기준으로 정렬해보았습니다.

구간에 대한 굵은 선(약간 히스토그램? 막대그래프 같은)을 그리고 이 선을 굵게 유지시키면 됩니다. 만약 굵은 선에 다음 시작 지점이 포함되지 않는다면 새로운 굵은 선을 그렸다고 치는거죠.

import java.util.*;

class Solution {
    public int solution(int[][] targets) {     
        Arrays.sort(targets, (a, b) -> a[0] - b[0]);
        int preStart = targets[0][0];
        int preEnd = targets[0][1];
        int answer = 1; // 멘 처음 target을 요격하는 미사일
        
        
        // 굵은 선을 그린다고 하고, 이 선을 최대한 굵게 유지시키면 됨
        // 선이 굵게 유지되어야 더 많은 미사일을 포함시킬 수 있으니까
        for (int i = 1; i < targets.length; i++) {
            int curStart = targets[i][0];
            int curEnd = targets[i][1];
            
            if (preStart <= curStart && curStart < preEnd) {
                preStart = Math.max(preStart, curStart);
                preEnd = Math.min(preEnd, curEnd);
            } else {
                answer++;
                preStart = curStart;
                preEnd = curEnd;
            }
        }
        
        return answer;
    }
}