3-alstjr7437

[alstjr7437]

🔗 문제 링크

먹을 것인가 먹힐 것인가

✔️ 소요된 시간

15분

✨ 수도 코드

시간복잡도로 허덕일 줄 알고 문제를 골랐는데 일단 제출하고 보자라고 제출했는데 맞아버렸어요;;

투포인터, 정렬 문제였습니다!!

정렬!

우선 배열들을 sort, sorted로 정렬을 합니다!

투포인터로 값 찾기!

• 앞쪽에 x는 더 작은게 없었던 내용입니다.
• 3은 1보다 큽니다.
  • 결과 값 + 1
  • point = 1
• 7은 이전 내용인 3보다 크므로 point를 더하고 시작합니다.
  • 비교할 배열에 3보다 크니 결과 값 + 1, point = 2
• 8은 앞에 7보다 크니 point인 2를 더하고 시작
  • 6보다 크니 결과 값 + 1

결론

위와 같은 방식으로 진행하게 되면
원래 모든 배열을 비교해야했지만

앞전에 사용했던 비교연산을 통해서 불필요한 연산(이미 더작은건 비교할 필요 ❌)을 제거해줬습니다!

📚 새롭게 알게된 내용

Swift에서 Sort와 Sorted

Sort
배열의 자리들을 변경해서 원본의 값들을 변경하기 때문에 Mutable해야함

Sorted
정렬된 배열을 리턴해서 복제된 정렬 값을 가져옴

둘다 O(n logn)

원본 배열 보존이 필요한 경우 ➡️ Sorted()
필요 없는 경우 ➡️ 메모리 사용량을 두배로 늘리기 떄문에 ➡️ Sort()

그래서 확인해보니 막 생각보다 메모리 사용률에 드라마틱한 변화는 없었음..

(위가 sort, 아래가 sorted)

[bishoe01]

와 엄청 깔끔하네요.. 👍 저는 좀 고군분투하다보니까 같은 로직인데도 좀 난잡한 감이 있네요..
배워갑니닷

[YooGyeongMo]

핀쌤 커서 쓰셔서 그런지 변수명을 커서로 하셨군요.
aItem 혹은 bIdx 같은 변수명이나 인덱스 명들이 저는 가끔 가독성이 낮다고 판단될 때가 있는데 핀쌤과 킨더쌤 혹은 여러분들은 어떠신가요 ?

[alstjr7437]

맞아요 한번씩 햇갈려서 다른 좋은 변수명 찾으면서 고민하다가 결국 익숙한 곳으로 돌아오게 되더라구요 ㅠ..

[bishoe01]

import Foundation

func 먹을것먹힐것(_ arrayA: [Int], _ arrayB: [Int]) -> Int {
    var answer = 0
    var cursor = 0
    var tmpAnswer = 0
    for aItem in arrayA {
        for bIdx in cursor ..< arrayB.count {
            let target = arrayB[bIdx]
            if aItem > target { // A가 더 클 때 ! 카운팅 해줘야됨 !
                tmpAnswer += 1
                cursor += 1
            }
            else { // 이제 명맥이 끊긴 것
                break
            }
        }
        answer += tmpAnswer
    }

    return answer
}

tmpAnswer에다가 값을 저장해두고, answer에 추가하는식으로 해줬는데,
킨더선생님이 쓰신 코드에서는 point랑 같은 역할일 겁니다 ..!

문제보고 직관적으로 풀어도 되겠지~했다가 시간초과떠서 한 번 생각하게 해준 문제같습니다.!

[MuchanKim]

일단 완탐으로 들이박았다가 바로 시간초과 떠서 이분탐색으로 풀었습니다. 투포인터는 활용을 해본적이 없어서 이참에 투포인터로 풀어보든 해야겠어요!

B배열만 소팅해주고 순회할 때 target보다 작은 가장 큰 원소의 위치(인덱스)를 찾는 방향으로 구현했어요! 그리고 리턴할 때는 +1을 해줘서 타겟보다 작은 원소의 개수를 구해줬어요! 이런 방식으로 A의 각 원소에 대응하는 B에서 작은 값들을 구했답니다..ㅎㅎ

import Foundation

func binarySearch(_ arr: [Int], _ target: Int) -> Int {
    var left = 0
    var right = arr.count - 1
    var res = -1
    
    while left <= right {
        let mid = (left + right) / 2
        
        if arr[mid] < target {
            res = mid
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    
    return res + 1
}

let cycle = Int(readLine()!)!

for _ in 0..<cycle {
    _ = readLine()!.split(separator: " ").map { Int($0)! }
    let A = readLine()!.split(separator: " ").map { Int($0)! }
    let B = readLine()!.split(separator: " ").map { Int($0)! }.sorted()
    
    var res = 0
    for a in A {
        res += binarySearch(B, a)
    }
    print(res)
}

완탐으로 하면 시간 초과나는 이유~~

N,M은 최대 20000 크기를 가질 수 있음요.
즉, O(N*M)이 가지는 최악의 연산 횟수는 20000x20000 =400,000,000(4억)번이 됩니다..

컴푸타가 1초에 1억~10억회 연산을 한다고 하더군요. 그렇다면 0.4초 ~ 4초까지 걸리게 됩니다.
이 문제에서 제한 시간은 1초이니 시간 초과가 날 수 밖에 없었군요. 감사합니다.

혹시 이 부분 제가 오해하고 있는게 있다면 답글 부탁드립니다!!

[MuchanKim]

???? 이렇게 간결하게 풀 수도 있군요... 투포인터를 활용해본 적이 없어서 이분탐색으로 했는데 잘 배워갑니다!

[YooGyeongMo]

챗 쉨한테 저도 무꺼 보고 정리해달라했는데 항상 입력값 보고 완탐을 할지 안할지 딱 알려줬음해서 참고자료 첨부해봅니다 하지만 췟쉑이라서 검증이 안된것이니 저희끼리 시행착오를 겪어가며 좀 더 업데이트해보는것도 좋아보입니다.

[alstjr7437]

2만이 보이면 완탐이 뭔가 안된다는 압박이 느껴져서 했는데 잘 된 것 같네요 감사합니다!

[sep037]

시간 초과 22입입니다 . . 저도 그냥 때려 박은 코드랑 킨더 힌트 얻고 투포인터로 풀어왔어요 !

//
//  main.swift
//  7795
//
//  Created by Seungeun Park on 5/5/25.
//

import Foundation


let N = Int(readLine()!)! // 테스트 케이스 수

for _ in 0 ..< N {
    let counts = readLine()!.split(separator: " ").map { Int($0)! }
    let countA = counts[0]
    let countB = counts[1]
    
    let Aarray = readLine()!.split(separator: " ").map { Int($0)! }
    let Barray = readLine()!.split(separator: " ").map { Int($0)! }

    print(comparison(A: Aarray, B: Barray))
}

//func comparison(A: [Int], B: [Int]) -> Int {
//    var count = 0
//    for a in A {
//        for b in B {
//            if a > b {
//                count += 1
//            }
//        }
//    }
//    return count
//}
// 시간 초과 ㅋㅋ

func comparison(A: [Int], B: [Int]) -> Int {
    let sortedA = A.sorted()
    let sortedB = B.sorted() // 일단 정렬
    var count = 0
    
    var j = 0

    for a in sortedA {
        while j < sortedB.count && sortedB[j] < a {
            j += 1
        }
        count += j
    }
    return count
}

[YooGyeongMo]

안냐세요 킨더 저는 이진탐색으로 풀었담돠

[YooGyeongMo]

코드가 되게 깔끔하네요 ,, 포인터가 두개로 되면 A만큼 B만큼 각각 시간 복잡도 가지니 O(N+M)만큼 가지는게 맞을까요 ???

알아보니 sorted는 N(LogN) 이네요!!

결국 완탐에서 발전해서 투포인터로 풀면 되는 문제였군요 ! 저는 이진 탐색으로 풀었습니다 !!

import Foundation

let T = Int(readLine()!)!

for _ in 0..<T {
    let nm = readLine()!.split(separator: " ").map {Int($0)!}
    let N = nm[0], M = nm[1]
    
    let A = readLine()!.split(separator:" ").map { Int($0)!}
    let B = readLine()!.split(separator:" ").map { Int($0)!}.sorted()
    
    var count = 0
    for found in A {
        count += check(B, found)
    }
    print(count)
}
// 8 1 7 3 1
// 1 3 6
// 0  < 3
// mid = 1
// arr[1] = 3 < 4
// left = 2
// 2 < 3
// mid = 2
// arr[2] 6 < 4
// right = 2
// left == 2 , right == 2
// left -> 2
func check(_ arr: [Int], _ target: Int) -> Int {
    var left = 0
    var right = arr.count
    
    while left < right {
        let mid = (left + right) / 2
        if arr[mid] < target {
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

직접 비교하니 더 좋군요 ! 투 포인터도 연습해야겠어요 !

[alstjr7437]

오호 이진 탐색은 생각 못했었는데 이진 탐색으로 하는 방법도 있네요 좋네요!

[YooGyeongMo]

@alstjr7437 고수의 향기 킨더 .... 그의 코드는 클린코드였다... 캬 ~

[giljihun]

투포인터 문제 완전 오랜만이라 좋았습니다!!!
다른 분들 코드도 보니까 바이너리서치로 풀 수도 있겠네요

/* MARK: - SOLUTION
 
 A는 B를 먹어.
 A는 B를 자기보다 크기가 작아야 먹어.
 
 A = {8, 1, 7, 3, 1}
 B = {3, 6, 1} 이면,
 
 8 - 3, 8 - 6, 8 - 1
 7 - 3, 7 - 6, 7 - 1
 3 - 1
 => 7가지
 
 이렇게 몇가지인지 구하시오~
 
 
 조건 : 1 ≤ N, M ≤ 20,000)
 -> 최악 4억번 검사;;
 
 일단.. 다 정렬시키고, 투포인터하자

 */
import Foundation

guard let T = Int(readLine() ?? "") else { exit(0) }

var result: [Int] = []

// 테스트 케이스 입력 받기
(0..<T).forEach { caseNumber in
    guard let AandB = readLine()?.split(separator: " "),
          let N = Int(AandB[0]),
          let M = Int(AandB[1]) else { exit(0) }
    
    guard let lineA = readLine() else { exit(0) }
    let A = lineA.split(separator: " ").compactMap { Int($0) }
    guard A.count == N else { exit(0) }
    
    guard let lineB = readLine() else { exit(0) }
    let B = lineB.split(separator: " ").compactMap { Int($0) }
    guard B.count == M else { exit(0) }
    
    result.append(eatPairs(A, B))
}

// 먹는쌍 구하기
func eatPairs(_ A: [Int], _ B: [Int]) -> Int {
    let sortedA = A.sorted()
    let sortedB = B.sorted()
    var count = 0
    var bIndex = 0

    for a in sortedA {
        while bIndex < sortedB.count && sortedB[bIndex] < a {
            bIndex += 1
        }
        count += bIndex
    }

    return count
}

// 출력
(0..<T).forEach { caseNumber in
    print(result[caseNumber])
}

[giljihun]

안녕하세요 제 입력부도 평가해주세요~

import Foundation

guard let T = Int(readLine() ?? "") else { exit(0) }

var result: [Int] = []

// 테스트 케이스 입력 받기
(0..<T).forEach { caseNumber in
    guard let AandB = readLine()?.split(separator: " "),
          let N = Int(AandB[0]),
          let M = Int(AandB[1]) else { exit(0) }
    
    guard let lineA = readLine() else { exit(0) }
    let A = lineA.split(separator: " ").compactMap { Int($0) }
    guard A.count == N else { exit(0) }
    
    guard let lineB = readLine() else { exit(0) }
    let B = lineB.split(separator: " ").compactMap { Int($0) }
    guard B.count == M else { exit(0) }
    
    result.append(eatPairs(A, B))
}

[YooGyeongMo]

@giljihun 길!!!!! 캬 ...... AandB 카멜투탑봉오리케이슨가예 직이네예 !

compactmap 활용까지 ... 와우 !! 와 근데 투포인터 생각은 해도 바로 구현이 쉽지 않은데 멋집니다