3-giljihun

[giljihun]

🔗 문제 링크

백준 - IOIOI

저는 김소혜 원픽이었습니다

✔️ 소요된 시간

1h

✨ 수도 코드

틀린 접근

일단 먼저 틀린 접근 먼저 말씀드리겠습니다.
위에 사진 보면 보이시겠지만, 시간 초과 야무지게 했습니다 !
근데 뭐. 구현은 일단 박고 보는거 아니겠으예(이거 맞습니꺼 데미안)

1. 입력으로 주어지는 "패턴"을 먼저 만든다.
   예를들어 N = 2, pattern = "IOIOI".

2. 문자열 인덱스 시작점, 끝점을 1씩 증가시키며 끝까지 돈다.
   (끝점이 초과되지 않을때까지)

// MARK: - Input
guard let N = Int(readLine() ?? "") else { exit(0) }
guard let M = Int(readLine() ?? "") else { exit(0) }
guard let S = readLine() else { exit(0) }

// MARK: - M 인덱스를 +1 하면서 체킹
let patternLength = 2 * N + 1
var result = 0

// 패턴 생성
var pattern = "I"
for _ in 0..<N {
    pattern += "OI"
}

for i in 0...(M - patternLength) {
    let start = S.index(S.startIndex, offsetBy: i)
    let end = S.index(start, offsetBy: patternLength)
    let window = String(S[start..<end])

    if window == pattern {
        result += 1
    }
}

하지만 이 방식은 !

이유는 두가지로 확인이 됩니다.

1. 문자열 슬라이싱은 매우 느리다.

Swift에서 서브스트링을 추출할 때는 복잡한 계산이 들어간다고 합니다.

2. 문자열을 전부 순회하며 비교

S의 길이 M은 문제 조건상 최대 1,000,000이죠?
이걸 길이 2N + 1 짜리 문자열과 계속 비교합니다.
시간복잡도? => O(M x N)

결론적으로 패턴 슬라이싱 + 브루트포스로 시간 붐붐 !

---

위 에러를 통해 찾아야할 방법은?
당장 막 떠오르진 않잖아요. 그렇지만 확실한 것은 있다.

"최대 M번만 비교하도록 만들어야한다."

= "한 번의 스캔만 하도록 로직을 바꿔야한다."

---

정답을 가져다준 접근

1. N의 숫자에 따라 패턴은 정해진다.
   N: 1-> "IOI",
   N: 2 -> "IOIOI",
   N: 3 -> "IOIOIOI".

결국, "IOI"가 반복된다는 것.

그러니까, N이 2면.
IOI 다음에 마지막 I에 이어서 OI가 오면 우리가 원하는 패턴이라는 것!

2. IOI를 찾았다면, 시작 인덱스에 +2로 점프하자. 그리고 다시 IOI를 찾아!

여기서 핵심은 IOI를 찾을 때마다, count를 올려주는 것이다.
만약 count가 입력값 N과 동일해지면 이건 우리가 찾은 패턴!

3. 코드로 다시 확인해보자.

while i < M - 1 {
    // IOI가 등장? -> 카운트를 1개 올림
    if chars[i - 1] == "I", chars[i] == "O", chars[i + 1] == "I" {
        count += 1
        // 카운트가 만약 N이 되었다? 우리가 찾는 패턴이 등장한 것.
        if count == N {
            result += 1
            // 근데 바로 다음에 중복적으로 패턴이 나올 수도 있으니, 1을 줄이기.
            count -= 1
        }
        i += 2
    }
    // 다음으로 이동했더니 IOI가 안나옴? -> 0으로 초기화.
    // 그리고 다음 인덱스부터 다시 비교시작.
    else {
        count = 0
        i += 1
    }
}

📚 새롭게 알게된 내용

1. 문자열 탐색 최적화의 중요성

• Swift에서 String을 슬라이싱하는 연산 (String[start..<end] 이런거)은 내부적으로 새로운 문자열을 생성한다고 한다. 그래서 매우 느림.
• 이 방식을 심지어 반복문에서 사용?! -> 개느림, 앵간하면 코테에서 시간초과 각오.

2. 캐릭터 배열로 변환해서 인덱스 접근하기

// MARK: - Input
guard let N = Int(readLine() ?? "") else { exit(0) }
guard let M = Int(readLine() ?? "") else { exit(0) }
guard let S = readLine() else { exit(0) }

let chars = Array(S)
var result = 0
var count = 0

저는 문자열을 캐릭터 배열로 변환해서 사용했는데요.
이런 문자열 문제를 새로운 방향성을 찾기 좋았던 것 같습니다.
(사실 이게 되게 key였던 것 같아요.)

3. 문자열 탐색 문제에서의 시간복잡도

• 시간 조건을 너무 자세하게 살펴보기 보다는, 내가 짜는 알고리즘이 최대한 문자열을 한 번만 순회할 수 있도록 설계한다면 대부분 다 통과가능한 것 같습니다.

사실 말이 쉽지..지만요..

후기

카톡인가 어딘가에서 "문자열 탐색" 푸셨다고 들어서..
생각해보니 슬라이싱이 파이썬하고는 확실히 달랐던 것 같고해서
다시 슬라이싱에 대해 공부겸 풀어봤는데.

걍 확실히 Swift에서 문자열 슬라이싱은 쓰레기가 맞는걸로..
(아니면 반박좀 해주세요 제발. 저도 아니라고 하고싶어요.)

[bishoe01]

입력받는 부분 잘 활용했습니다.. 👍

[bishoe01]

이 부분만 살짝다르네요! 저는 Array에 담아줬는데, 이렇게하면 나중에 filter,map,reduce쓰면서 처리해주느라 시간,메모리 다 좀 손해보는 느낌이었거든요..
길선생님이 푸신게 더 직관적이고 메모리에도 효율적인 것 같습니다..!

[giljihun]

감사합니다 ㅋㅋ
음 Array에 담아서 처리하는 방식이 가독성은 더 좋을 수도 있을 것 같아요

지금 구조가 패턴을 수집 -> 후처리하는 구조인데,
중간 로직이 복잡하다면 사실 제가 작성한 코드로는 흐름을 분리하고 테스팅하기엔 어려울 수도 있을 것 같습니다. 메모리 손해에 대한 내용은 정확한 캐치를 하신 것 같네요!! 굿입니다

[giljihun]

아래 코드도 확인해보니 후처리를 클로저로 한 번에 조지시는(?) 부분이 야무지네요..

[bishoe01]

import Foundation
func IOIOI(_ time: Int, _ length: Int, _ s: String) {
    let arr = Array(s)
    var cnt = 0
    var cntArr = [Int]()
    var cursor = 0
    while cursor < length - 2 {
//        print(cursor)
        if arr[cursor] == "I", arr[cursor + 1] == "O", arr[cursor + 2] == "I" {
            cnt += 1
            cursor += 2
        } else {
            cntArr.append(cnt)
            cnt = 0
            cursor += 1
        }
    }
    cntArr.append(cnt) // 남은애
//    print(cntArr.filter { item in
//        item >= time
//    }.reduce(0, +))  이 부분 틀려서 수정했음, 연속된거에 매몰돼서, 그게 아니라 연속된거에서 - 반복수 + 1 해줘야 진짜 원하는 개수가 나옴 딱맞춰서 될 수는 없으니까

    print(cntArr.filter { $0 >= time }.map { $0 - time + 1 }.reduce(0, +))
}

처음에는 String.Index써서 계속 slicing해주면서 찾아주려했는데, (약간 슬라이딩윈도우)
진짜 엄청나게 번거롭고 머리가 전혀 안돌아가서 리셋하고 Array로 만들어준다음에 배열[숫자]로 접근하면서 처리를 해줬습니다..!

위에 리뷰에서 말씀드린 차이점이라하면
1, var cntArr = [Int]()를 선언해주고
2, else 에 걸리면 (연속이 안되면) cntArr에 담아줍니다.
3. 마지막에 print(cntArr.filter { $0 >= time }.map { $0 - time + 1 }.reduce(0, +)) 로 처리!

주석에 써있는 것처럼 왜 map이 생겼냐하면.. 이게 겹칠 수가 있다보니, 만약 IOIOIOI 문자열에 숫자는 2라면, 이게 3번 반복된다고해서 답이 3이 나오겠지만 , 그게 아니라 3번반복 - 2(필요조건) + 1 로 답이 2가 나와야하기때문에 수정이 필요했습니다 !

[MuchanKim]

저 백준 부분 점수있는 거 처음알았어요 ㅋㅋㅋ 길이 실패했던 코드랑 비슷한 로직으로 했었습니다. 완탐은 역시 터지는군요.

슬라이딩 윈도우 알고리즘에 대해 처음 알았는데 특정 패턴이 포함된 부분 문자열 찾기에 용이할 것 같군요. DP랑 마찬가지로 코드를 보고 머리속에서 돌려봤을 땐 '아 이렇게 되는 거구나'하지만, 실제로 짜보라고 하면 막막해지는 것 같네요. ^^

길 코드보면 항상 깔끔한 것 같아요. 한번 정제를 하고 PR올리시나요? 아니면 이게 야생의 코드인가요?

(슬라이딩 윈도우로는 안풀어봤습니다.)

50점짜리 코드

import Foundation

let N = Int(readLine()!)!
let M = Int(readLine()!)!
let S = Array(readLine()!)

var pattern = Array("IOI" + String(repeating: "OI", count: N-1))
let patternCount = pattern.count

var count = 0

for i in 0...M-patternCount {
    var isMatch = true
    
    for j in 0..<patternCount {
        if S[i+j] != pattern[j] {
            isMatch = false
            break
        }
    }
    
    if isMatch {
        count += 1
    }
}

print(count)

[MuchanKim]

string으로 받고 배열로 바꿔주는 과정에서 변수를 또 쓰신 이유가 있을까요?

[MuchanKim]

별거 아니지만 이 부분 저는 특이하게 느껴졌어요! 보통 일반적인 조건문에는 &&쓰지 않나요? Swift에서 지향하는 컨벤션인지??
물론 결과는 같지만 '콤마'와 '&&'를 쓰는 기준이 있으신가요?

if chars[i - 1] == "I" && chars[i] == "O" && chars[i + 1] == "I"

[giljihun]

아이고.. 무 아닙니다 칭찬 너무 감사합니다!

1. 한번 정제를 하고 PR올리시나요? 아니면 이게 야생의 코드인가요?

정제하진 않고 백준에서 바로 긁어서 주석만 수정하거나? 그런 것 같습니다. 그런데 애초에 풀 때 엄청 시간을 재고 풀질 않아서 그런 것 같아요! ㅋㅋ 추가적으로는 이 문제는 브루트포스로 실패할때는 되게 더럽거든요! 그냥 100점 받은 풀이가 애초에 코드층이 얇아서 그렇게 보이는 것 같슴다!

2. string으로 받고 배열로 바꿔주는 과정에서 변수를 또 쓰신 이유가 있을까요?

이 질문이 제가 2가지 의도로 해석이 되가지고, 약간 잘 이해가 안되었는데요!!,,

if 1)

let chars = Array(readLine()!)

이런식으로 왜 한 번에 받지 않았는지 여쭤보시는걸까요??

이렇게 작성한 이유는, 사실 큰 이유는 없고 가독성이 더 좋은 방식을 택한 것 같습니다.

if 2)

아니면, 문자열을 입력받고서

let chars = Array(S)

를 통해 Character 배열로 바꾼 이유에 대해 여쭤보시는걸까요??

이건 문자열 인덱싱이 불편했기 때문입니다. chars[i]처럼 인덱스로 각 문자를 다루고 싶어서 배열화했습니다!

3. 콤마'와 '&&'를 쓰는 기준이 있으신가요?

오 이거 되게 좋은 관찰이네요.

결론적으로,
저만의 스타일이 있다기 보다는 '콤마'와 '&' 둘다 같은 문법이다보니,
조건에 맞춰서 자연스러운게 관성적으로 나가는 것 같아요.

근데 이렇게 말씀해주시고 보니,
개인적으로는 &&보단 콤마가 간결해서 가독성이 더 좋은 것 같습니다.

[giljihun]

2.

if 1) 에 추가적으로
제가 guard let 구문으로 시작해가지구 두 줄로 써야했네요!

guard let S = Array(readLine()) else { exit(0) } => ❌

readLine() -> String?이기에
Array(readLine())로 쓸 수가 없네요! (옵셔널 타입을 바로 캐릭터 배열로 바꾸려하기 때문)

[YooGyeongMo]

쓸데없이 문자열 알고리즘 썼다가 머리통 박살난 저입니다.

• 저의 최애는 전소미와 김도연이었습니다 ... 호호

[YooGyeongMo]

음 .... 몇번 나오는지 반복되는게 IOI이니 이것만 반복적으로 그리디하게 체크해주면 되는것이었군요...

처음에 슬라이딩 윈도우 + 브루트 포스로 풀었을때 시간초과로 뻥 ! 하고 터져서 학부때 배운게 생각나서 얕은 지식으로 KMP를 검색하여 구현하여 만들어보았는데.... 이해하는 시간이 엄청 오래 걸렸습니다...

시간과 공간이 제일 좋은게 젤 위에가 길 코드입니다 ㅋㅋㅋ
반복이 보장된 곳에서는 그리디하게 풀면되는 문제입니다... ㅋㅋㅋ...

아래는 KMP 알고리즘으로 접미사, 접두사로 어디까지 반복되는지 pi 배열을 담아서 int형으로 계산한 후 KMP를 통해 양쪽 끝에서 부터 브루트 포스처럼 일일이 다 체크하는것이아니라 양쪽에서 좁혀오면서 일치하다가 하나가 틀린 패턴이 나오면 그만큼 띄어넘고 그 뒤에 부터 체크하는 엄청 효율적인 문자열 알고리즘입니다.

KMP 블로그
https://velog.io/@hwan2da/%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-KMP-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98
KMP 영상
https://www.youtube.com/watch?v=yWWbLrV4PZ8

import Foundation

// N = 'O' 의 개수 N+1 = 'I'의 개수
// PN의 길이는 2N+1 -> I만 붙이고 뒤에 OI만 붙이면 ?
// 슬라이딩 윈도우와 KMP 사용하면 될듯함 ?
// 최소 N은 1이상임

// 1. 패턴 만들기: "IOI"가 N번 반복된 PN
func makePattern(n: Int) -> String {
    var pattern = "I"
    for _ in 0..<n {
        pattern += "OI"
    }
    return pattern
}

// 2. 접두사 배열 (pi 배열) 생성
func makePi(_ pattern: String) -> [Int] {
    let p = Array(pattern)
    var pi = Array(repeating: 0, count: p.count)
    var j = 0
    
    for i in 1..<p.count {
        while j > 0 && p[i] != p[j] {
            j = pi[j - 1]
        }
        if p[i] == p[j] {
            j += 1
            pi[i] = j
        }
    }
    return pi
}


// 3. KMP 매칭
func kmp(_ text: String, _ pattern: String) -> Int {
    let t = Array(text)
    let p = Array(pattern)
    let pi = makePi(pattern)
    
    var j = 0
    var count = 0
    
    for i in 0..<t.count {
        while j > 0 && t[i] != p[j] {
            j = pi[j - 1]
        }
        if t[i] == p[j] {
            if j == p.count - 1 {
                count += 1
                j = pi[j]
            } else {
                j += 1
            }
        }
    }
    return count
}

// 4. 메인 실행
let N = Int(readLine()!)!
let _ = Int(readLine()!)!        // S의 길이는 안 써도 됨
let S = readLine()!

let pattern = makePattern(n: N)
let result = kmp(S, pattern)
print(result)

[sep037]

저는 도저히 풀 방법이 생각 안 나서 데미안 코드랑 길 코드 이해하면서 제가 다시 짜봤어요 !
그냥 단순한 계산 ? 문제로 만났으면 편안햇을 문제인데 코드로 치려니 진절머리가 나던데요 .

//
//  main.swift
//  5525
//
//  Created by Seungeun Park on 5/7/25.
//

import Foundation

let N = Int(readLine()!)!
let _ = Int(readLine()!)! // 문자열 길이는 필요 없음
let S = Array(readLine()!) // 문자열을 배열로 바꿔 인덱싱하기 쉽게

var i = 0
var match = 0
var count = 0

while i < S.count - 2 {
    if S[i] == "I" && S[i+1] == "O" && S[i+2] == "I" {
        match += 1
        if match == N {
            count += 1
            match -= 1 // 중첩 가능한 패턴 고려
        }
        i += 2 // IOI 다음은 'I'부터 다시 검사
    } else {
        match = 0
        i += 1
    }
}

print(count)

[alstjr7437]

다른분들이 이미 리뷰를 너무 잘해놔주셔서 더 할말이 없네요!!...

저는 아래와 같이 풀었습니다!

let n = Int(readLine()!)!
let m = Int(readLine()!)!

let s = readLine()!.map{$0}

var result = 0
var cur = 0
var count = 0

while cur < m-2{
    if String(s[cur...cur + 2]) == "IOI"{
        count += 1
        cur += 2
        if count == n{
            result += 1
            count -= 1
        }
    } else {
        count = 0
        cur += 1
    }
}

print(result)

[alstjr7437]

index처럼 변수명을 사용해도 괜찮았을 것 같은데 i로 사용하신 이유는 간결성 때문일까요?

[giljihun]

맞슴다 조건이 단순하긴해도 길어서 이때는 간결성이 더 중요하다고 판단했슴다!