35-H0ngJu

[H0ngJu]

🔗 문제 링크

전깃줄

✔️ 소요된 시간

측정불가

✨ 수도 코드

금요일에 시작해서,, 틈날 때마다 계속 고민을 했는데요

접근 방법이 1도 떠오르지 않았습니다.
구현도 아닌 것 같고,, 무슨 알고리즘을 써야하는지 가닥이 안보이더라고요.

일단 문제에서 주어진 예시로 보면,

서로 연결된 A와 B가 다음 전깃줄의 A B보다 작으면 겹치지 않기 때문에 해당 방식으로 없애야 할 최소 전깃줄을 셀 수 있지 않을까? 했습니다.

(전깃줄 연결 정보들은 sort했다고 가정하겠습니다)

하지만 아래의 케이스에서 예외가 발생합니다.

정보들을 내림차순으로 정렬하고, 하나씩 꺼낸다는 가정이면,
5 - 1이 먼저 선택이 되었고, 남아있을 경우는 A < 5 and B < 1입니다.
해당 로직의 결과는 없애야할 최소 전깃줄이 4가 됩니다.

실제로는 1인데 말이죠..
정렬을 오름차순을 한다해도 위 예시에서 1-5가 연결된 상태라면 역시 오류가 발생합니다.

그렇게,, 계속 계속 고민했는데,,,
아무리 생각해도

무엇을 먼저 체크하냐에 따라 그에 대한 영향이 뒷 줄에도 갈 수 밖에 없는데,,
그리디하게 접근해야하는 문제인가?? 하면서 머리가 터졌습니다..

먼가 아 될듯말듯 될듯말듯 될듯말듯

결국 오늘 아침되서야 레퍼런스 확인했네요

결론 부터 말하면 DP입니다........................
LIS 개념이 들어가요

각 전깃줄을 택하고
해당 전깃줄이 마지막 전깃 줄이라고 생각하고 겹치지 않게 만들 수 있는 케이스를 dp에 저장합니다.
-> 이때 조건은 앞 전깃줄의 B < 현재 전깃줄 B입니다.

가장 긴 증가하는 부분 순열
응용 문제 인 것 같네요.

DP로 풀어야하는 건 줄은 진짜 생각도 못했네요 🤯

import sys

def input() : return sys.stdin.readline().rstrip()

N = int(input())
info = [list(map(int, input().split())) for _ in range(N)]

info.sort()

LIS = [1] * N

for i in range(1, N):
    for j in range(i):
        if info[j][1] < info[i][1]:
            LIS[i] = max(LIS[i], LIS[j] + 1)

print(N-max(LIS))

📚 새롭게 알게된 내용

[tgyuuAn]

와 잠깐,,, 이 문제 예전에 풀었었는데 지금 다시 보니까 뇌정지와서

LIS인거도 확인하고 풀라고해쓷네 안풀리는데,,,

[tgyuuAn]

import java.util.*;
import kotlin.math.*;

fun main() {
    val linesCount = readln().toInt()
    val lines = mutableListOf<Pair<Int, Int>>()
    
    repeat(linesCount) {
        val (x,y) = readln().split(" ")
        .map{ it.toInt() }
        
        lines.add(x to y)
    }
    
    val sortedLines = lines.sortedBy({it.first}).map{ it.second }
    
    val dp = IntArray(linesCount) { 1 }

    for(idx in 1 until lines.size){
        val now = sortedLines[idx]
        
        for(prevIdx in 0 until idx){
            val prevValue = sortedLines[prevIdx]
            
            if(prevValue < now){
                dp[idx] = max(dp[idx], dp[prevIdx]+1)
            }
        }
    }
    
    println(linesCount - dp.max())
}

와 분명 예전에 풀었던 문젠데 다시 보니까 긴가민가 해서...

LIS인거도 알고있었는데,,, 안풀리더라고요....

덕분에 리마인드 잘했습니다.... 땡베감~~~~~~~~

import java.util.*;

fun main() {
    val linesCount = readln().toInt()
    val lines = mutableListOf<Pair<Int, Int>>()
    
    repeat(linesCount) {
        val (x,y) = readln().split(" ")
        .map{ it.toInt() }
        lines.add(x to y)
    }
    
    val sortedLines = lines.sortedBy({it.first}).map{ it.second }
    val lis = mutableListOf(sortedLines[0])
    for(idx in 1 until lines.size){
        val now = sortedLines[idx]
        
        if(lis.last() < now) {
            lis.add(now)
            continue
        }
        
        var left = -1
        var right = lis.size
        while (left+1<right) {
            val mid = (left+right)/2
            
            if(check(lis, mid, now)){
                left = mid
            } else {
                right = mid
            }
        }

        lis[left+1] = now
    }

    println(linesCount - lis.size)
}

fun check(lis:List<Int>, mid:Int, elem:Int): Boolean {
    if(lis[mid] < elem){
        return true
    }
    
    return false
}

위에껀 DP안쓰구 이분탐색으로 써서 시간을 더 줄인 LIS!!!