https://programmers.co.kr/learn/courses/30/lessons/43162

문제 접근

1. 내가 못 풀었다.
2. 연결 되어 있지 않으면 answer 카운트
3. 재귀를 통해 2차원 배열의 한 요소(배열)에 들어가, 모든 경우를 다 탐색한 다음,
4. 방문 정보를 visit에 기록한다.
5. 연결 점이 없을 경우, main의 for문에 들어오게 되며, 그때마다 answer를 하나씩 + 한다. (네트워크가 분리 되어있어서 개별의 개수를 가진다, 라는 표기)

소스 코드

func solution(_ n:Int, _ computers:[[Int]]) -> Int {
    var answer = 0
    var copycomputers = computers
    var visited = Array<Bool>(repeating: false, count: n)

    for i in 0..<n {
        if !visited[i] {
            answer += 1
            dfs(point: i, visited: &visited, computers: &copycomputers, n: n)
        }
    }

    return answer
}
func dfs(point: Int, visited: inout [Bool], computers: inout [[Int]], n: Int) {
    visited[point] = true
    for i in 0..<n {
        if !visited[i] && computers[point][i] == 1 {
            dfs(point: i, visited: &visited, computers: &computers, n: n)
        }
    }
}

https://leetcode.com/problems/binary-search/

문제 접근

1. 일단 순차적으로 다 탐색 걸리면 브레이크! 반환! -> 성능이 안 조음.
2. Binary Search의 개념 검색, 반으로 쪼개고 또 반으로 쪼개고 또 반으로 쪼개고,
3. 반복문을 사용하는 방법 -> 성능이 그게 그건데?
4. 재귀를 사용하는 방법 -> 성능이 더 안 조은데..?

소스 코드

1. 단순 탐색

   func search(_ nums: [Int], _ target: Int) -> Int {
    var result = -1
    for i in 0..<nums.count {
        if nums[i] == target {
            result = i
        }
    }
    return result
   }

2. 반복문을 사용하는 이진 탐색

   func search(_ nums: [Int], _ target: Int) -> Int {
    var numscopy = nums
    numscopy.sort(by: <)
   
    var low = 0
    var high = numscopy.count - 1
    var mid = 0
   
    while (low <= high) {
        mid = (low + high) / 2
        if numscopy[mid] == target {
            return mid
        }
        else if numscopy[mid] > target {
            high = mid - 1
        }
        else {
            low = mid + 1
        }
    }
    return -1

3. 재귀함수를 통한 이진 탐색

   func search(_ nums: [Int], _ target: Int) -> Int {
    let numscopy = nums.sorted(by: <)
   
    return binarySerach(nums: numscopy, target: target, low: 0, high: numscopy.count - 1)
   }
   

func binarySerach(nums: [Int], target: Int, low: Int, high: Int) -> Int { if low > high { return -1 }

let mid = (low + high) / 2

if nums[mid] == target {
    return mid
}
else if (nums[mid] > target) {
    return binarySerach(nums: nums, target: target, low: low, high: mid - 1)
}
else {
    return binarySerach(nums: nums, target: target, low: mid + 1 , high: high)
}

} ```

https://leetcode.com/problems/rotate-array/

문제 접근

1. k번 만큼 뒤에서 빼서 제일 앞에 삽입

소스코드

for _ in 0..<k {
    let temp = nums.removeLast()
    nums.insert(temp, at: 0)
}

https://leetcode.com/problems/find-the-winner-of-the-circular-game/

문제 접근

1. 배열로 만들어서
2. 배열의 인덱스 k만큼 +1 하다가
3. 도중에 배열의 count를 넘으면, 0으로 초기화
4. [1,2,3,6] 여기서 6을 지운 경우, 0으로 초기화

소스 코드

func findTheWinner(_ n: Int, _ k: Int) -> Int {
    var arr: [Int] = []
    var index: Int = 0
    for i in 0..<n {
        arr.append(i+1)
    }
    while (arr.count != 1) {
        for _ in 0..<k - 1 {
            if index >= arr.count - 1 {
                index = 0
                continue
            }
            index += 1
        }
        arr.remove(at: index)
        if index > arr.count - 1 {
            index = 0
        }
    }
    return arr[0]
}

https://leetcode.com/problems/rabbits-in-forest/

문제 접근

1. 처음엔 자기는 제외하고 몇 마리 있는지 알려주기 때문에
2. 대답 유형 key, 대답 횟수 value 이런식으로 만들어서 dictionary에 저장한 다음,
3. key - (value - 1) 이렇게 일반식 만들어서 풀었는 데,
4. 예외 처리해야할게 너무 많더라.
5. 예외는 0이 등장하는 경우, key - (value - 1)이 음수가 되는 경우 (1이라고 대답하는 토끼가 2마리 이상인 경우)
6. 예외처리 일반식을 못 짜서 풀이 참고함.

소스 코드

1. 처음에 작성한 코드

   class Solution {
    func numRabbits(_ answers: [Int]) -> Int {
        var result = 0
        var collected: [Int:Int] = [:]
        for ans in answers {
            collected[ans, default: 0] += 1
        }
        collected.forEach { k, val in
            if k < 1 {
   
            }
            else {
                result += k - (val - 1)
            }
        }
        result += answers.count
        return result
    }
   }

2. 참고한 코드

   class Solution {
    func numRabbits(_ answers: [Int]) -> Int {
        var ans = 0
        var collected: [Int:Int] = [:]
   
        for count in answers {
            if collected[count] == nil {
                collected[count] = 0
                ans += count + 1
            }
            else {
                collected[count]! += 1
            }
   
            if collected[count] == count {
                collected.removeValue(forKey: count)
            }
        }
   
        return ans
    }
   }

처음에 작성한 코드는 대답하면 대답하는 대로 다 딕셔너리의 벨류를 추가하고 예외의 가능성을 두지 않았는 데, 대답하면 결과에만 반영하고 값은 0으로 초기화 한다.

if collected[count] == nil {
    collected[count] = 0
    ans += count + 1
}

else {
    collected[count]! += 1
}

이후 등장하면 count up해서 논리의 오류 (1,1,1로 대답했는데 셋다 같은 색상일 순 없으니까)가 발생하면 아래의 구문으로 대답을 초기화 해서 새로운 색상에 접근하는 듯 했다.

if collected[count] == count {
    collected.removeValue(forKey: count)
}

접근이 어려운 게 아니라 바로 위의 코드를 생각하는 것이 너무 어려웠다.

https://leetcode.com/problems/height-checker/

문제 접근

1. 오름차순으로 정렬하고
2. 정렬하지 않은 원본하고 비교해서 다를 때마다 count up!
3. 반환!

소스 코드

func heightChecker(_ heights: [Int]) -> Int {
    let target = heights.sorted(by: <)
    var cnt: Int = 0
    for i in 0..<heights.count {
        if heights[i] != target[i] {
            cnt += 1
        }
    }
    return cnt
}

https://www.acmicpc.net/problem/15649

문제 접근

1. https://velog.io/@sett_park/%EB%AA%A8%EB%93%A0-%EC%88%9C%EC%97%B4 -> 여기서 백트래킹을 위해 풀었던 사전 지식을 이용했다.
2. 처음에 repeating 값을 줄 때 n으로 주고 싶었는데, n으로 주니까 index 오버가 났다.
3. 그래서 그냥 최댓값 주고 풀었다.

소스코드

import Foundation

let input = readLine()!
let myinput: [Int] = input.components(separatedBy: " ").map(){Int($0)!}
let n = myinput[0]
let m = myinput[1]
var visited: [Bool] = [Bool](repeating: false, count: 8)
var result: [String] = [String](repeating: " ", count: 8)

func solution(_ depth: Int) {
    if depth == m {
        var temp: [String] = []
        for i in 0..<depth {
            temp.append(result[i])
        }
        print(temp.joined(separator: " "))
        return
    }

    for i in 0..<n {
        if visited[i] {
            continue
        }
        visited[i] = true
        result[depth] = "\(i+1)"
        solution(depth + 1)
        visited[i] = false
    }
}

solution(0)

최대를 8로 주고 푸니까 출력이 내 눈에는 1 2 3 4 이렇게 보이는데 컴퓨터는 1 2 3 4 (빈값) (빈값) (빈값) (빈값) 이렇게 보이나부다 자꾸 출력 형식 잘못되었다고 ㅋㅋ.. 그래서 출력용 배열 그때, 그때 만들어주고 결과 출력함. 잘 됨.

백트래킹 한번 더 공부해야할듯..?

https://www.acmicpc.net/problem/10974

문제 접근

1. 백트래킹의 기본 이해를 예제 코드를 본 문제인데
2. 재귀로 계속 접근하다가 조건을 걸어주는 듯..? (유망성 판단)
3. 여기선 Array<Visited>와 Array<result>를 맵핑시켜서 문제를 해결 했다.
4. visited가 여부로 유망성을 판단하는 건가..?

소스 코드

let input = Int(readLine()!)!
var result: [String] = [String](repeating: " ", count: input)
var visited: [Bool] = [Bool](repeating: false, count: input)

func solution(_ depth: Int) {
    if depth == input {
        print(result.joined(separator: " "))
        return
    }

    for i in 0..<input {
        if visited[i] {
            continue
        }
        visited[i] = true
        result[depth] = "\(i+1)"
        solution(depth + 1)
        visited[i] = false
    }
}

solution(0)

https://leetcode.com/problems/container-with-most-water/

문제 접근

1. 물을 많이 채우라고 하시네요.
2. 가장 큰 수를 찾아서 그걸 기준으로 해볼까..? 하다가 작아도 가로가 길면? 이라는 예외가 생각나서 패스
3. 그럼 그냥 하나하나 다 따져봐야겠네..?
4. 이중 포문으로 해볼까..?? 시간초과남 ㅋ

func maxArea(_ height: [Int]) -> Int {
    var result = 0
    for i in 0..<height.count {
        for j in (i+1)..<height.count {
            let subject = min(height[i], height[j])
            let tempResult = subject * abs(i-j)
            if result < tempResult {
                result = tempResult
            }
        }
    }
    return result
}

5. 같은 방법인데 2중 포문만 날려서 해보기로 함. (index 때문에 2중 포문 썼는 데 index 외부에서 주고 while문으로 처리하기)

6. 근데 어차피 같은 방법인데 아래 같이 쓰다가 막힘.

   var result = 0
        var index1 = 0
        let index2 = height.count - 1
        while index1 < index2 {
            let subject = min(height[index1], height[index2])
            let width = abs(index1 - index2)
            let water = subject * width
            result = max(result, water)
            index1 += 1
        }
        return result

7. 다른 사람 거 참고 했는데 아래와 같이 조건을 넣어줌

   if height[index1] < height[index2] {
    index1 += 1
   }
   else {
    index2 -= 1
   }

8. 최대한 큰 숫자 끼리만 해보려고 이러한 식을 넣은게 아닐까 추측해 봄 정확히는 모르겠네..요..?

소스 코드

        var result = 0
        var index1 = 0
        var index2 = height.count - 1
        while index1 < index2 {
            let subject = min(height[index1], height[index2])
            let width = abs(index1 - index2)
            let water = subject * width
            result = max(result, water)
            if height[index1] < height[index2] {
                index1 += 1
            }
            else {
                index2 -= 1
            }
        }
        return result

https://leetcode.com/problems/validate-stack-sequences/

문제 접근

1. pushed를 뽑다가 poped의 첫번째 숫자하고 pushed의 방금 뽑은 숫자하고 같아야만 뽑을 수 있나..? 어쨌든 앞에서 부터 뽑아서 Queue를 적용하는 건 맞는데, 구체적인 이해가 안됐음.
2. pushed 뽑은걸 어디다 저장해놓고 저장해놓은 마지막 숫자가 poped의 첫번째 숫자와 동일하면 poped을 하기로 함.
3. 이런식으로 해서 둘다 비워지면 되는 거 아닌가..?

소스 코드

    func validateStackSequences(_ pushed: [Int], _ popped: [Int]) -> Bool {
        var result: [Int] = []
        var mypoped = popped
        for item in pushed {
            result.append(item)

            while !result.isEmpty && result.last == mypoped.first {
                result.removeLast()
                mypoped.removeFirst()
            }
        }
        return result.count == 0 ? true : false
    }

https://leetcode.com/problems/top-k-frequent-elements/

문제 접근

1. 문제가 너무 읽기 힘들어서.. output만 보고
2. 같은 수면 넣지말고 크면 넣고를 반복해서,
3. k길이의 배열을 만든 다음 반환 해라. 인줄,
4. 그게 아니라 가장 많이 등장한 놈들을 뽑으라는 k만큼 뽑으란 거 였음 (읽을걸..)
5. 어느 정도 등장했는 지 표시하면 좋겠다. 하다가,
6. 해쉬로 하면 쉽겠네 해서 풀음.
7. key를 배열에 있는 값으로 value를 등장한 수 만큼!
8. 중간에 dictionary 문법을 몇개 몰라서 좀 해맨거 말고는 어렵지 않았다.

소스 코드

var myValue: [Int:Int] = [:]
var result: [Int] = []
for num in nums {
    myValue[num, default: 0] += 1
}
let a = myValue.sorted { key1, key2 in
    key1.value > key2.value
}
for i in 0..<k {
    result.append(a[i].key)
}
return result

https://leetcode.com/problems/minimize-maximum-pair-sum-in-array/

문제 접근

1. 문제 이해 못함.
2. ㅋ 응애
3. 문제의 output 과정을 보고 대충 가우스덧셈으로 구해야 하는 구나 했음.
4. 근데 왜 그리디에요.. pair up을 할때 가장 격차가 적은 수 끼리 묶어 줘서 그런가..?

소스코드

func minPairSum(_ nums: [Int]) -> Int {
    var result = 0
    var mynums = nums
    var resultNums: [Int] = []
    mynums.sort(by: <)
    for i in 0..<mynums.count / 2 {
        resultNums.append(mynums[i] + mynums[mynums.count - i - 1])
    }
    print(resultNums)
    for i in 0..<resultNums.count {
        result = max(result, resultNums[i])
    }
    return result
}

https://leetcode.com/problems/find-k-pairs-with-smallest-sums/submissions/

문제 접근

1. 일단 [u,v] 형태로 만들고 내부 u+v해서 대소 비교한 다음,
2. 정렬함 작은 순서대로,
3. k 만큼 넣음
4. 시간 초과 남 ㅋ
5. https://leetcode.com/submissions/detail/535145859/testcase/ 테스트 케이스 너무 살벌한 데.. 시간초과 해결할 방법 모르겠다.

소스 코드

func kSmallestPairs(_ nums1: [Int], _ nums2: [Int], _ k: Int) -> [[Int]] {
    var result: [[Int]] = []
    var myarr: [[Int]] = []

    for i in 0..<nums1.count {
        for j in 0..<nums2.count {
            let tempArr = [nums1[i], nums2[j]]
            myarr.append(tempArr)
        }
    }
    myarr.sort { a, b in
        sum(arr: a) < sum(arr: b)
    }
    for i in 0..<k {
        if i > myarr.count {
            break
        }
        result.append(myarr[i])
    }
    return result
}

func sum(arr : [Int]) -> Int{
    var result = 0
    for i in 0..<arr.count {
        result += arr[i]
    }
    return result
}

https://leetcode.com/problems/keys-and-rooms/

문제 접근

1. 이게 왜 dfs, bfs야..
2. 그냥 배열있는거 다 들어가보면 되는 거 아닌가?
3. 일단 다 들어가 봄. 들어갈 때마다 FLAG 세워서 표시할까 하다가...
4. flag 세울 때 별로 좋은 방법이 안 떠오르는 거임.. 들어간 방을 순차적으로 정렬해서 1,2,3,4가 다 있는지 따지거나 뭐 그런거 밖에 안 떠올라서,
5. 보니까 방의 개수 비교하는 굉장한 방법이 있더라.

소스 코드

func canVisitAllRooms(_ rooms: [[Int]]) -> Bool {
        var findedRooms: [Int] = []
        findRoom(rooms: rooms, roomNumber: 0, findedRooms: &findedRooms)
        return findedRooms.count == rooms.count
    }

    func findRoom(rooms: [[Int]], roomNumber: Int, findedRooms: inout [Int]) {
        findedRooms.append(roomNumber)
        for i in 0..<rooms[roomNumber].count {
            if !findedRooms.contains(rooms[roomNumber][i]) {
                findRoom(rooms: rooms, roomNumber: rooms[roomNumber][i], findedRooms: &findedRooms)
            }
        }
    }

https://programmers.co.kr/learn/courses/30/lessons/42883?language=swift

문제 접근

1. 처음에 문제가 이해가 안감, 더 큰 수가 있는데?
2. 정렬하지 말란 소리였음. 예를 들어서 1234, 2면 34인데 43이 왜 안되지 한참 고민함.
3. 어떻게 큰 수를 뽑을까. 현재 들어온 거보다 나중에 들어온 값이 크면 현재꺼 날리고 나중꺼 갱신하고 이렇게 푸는 거 같은데 구체적인 예시를 못 들겠는 거임.
4. 여러 자료 참고했는데 이거 다 싶은 게 없었음. C++이나 파이썬에 내공이 부족해서 그런 듯
5. 그러다가 기가막힌 논리를 찾았는 데 그리디에 가장 적합한 거 같았음.

다시 접근

1. result.isEmpty면 일단 넣어
2. result.last가 내가 넣으려는 수보다 작아? 그럼 날려. 그리고 한번 버린거 표시해(k를 줄여)
3. 1, 2를 반복하다가 내가 넣으려는 수가 더 작아? 그럼 넣어 또 1, 2를 반복해.
4. 이렇게하면 나중일은 생각안하고 그냥 내가 마지막 놈 보다 작아? 커? 이거만 따져서 가장 그리디에 적합한 것 같았다.
5. 그리고 append할때 k를 줄이지 않기 때문에 마지막에 자릿수 날리는 작업도 필요한 듯 하다. 아래의 소스 코드

while (mycount > 0) {
        result.removeLast()
        mycount -= 1
    }

소스코드

func solution(_ number: String, _ k: Int) -> String {
    let numarr = Array(number)
    var mycount = k
    var result: [Character] = []
    for i in 0..<numarr.count {
        while (!result.isEmpty && result.last! < numarr[i] && mycount > 0) {
            result.removeLast()
            mycount -= 1
        }
        result.append(numarr[i])
    }

    while (mycount > 0) {
        result.removeLast()
        mycount -= 1
    }

    return String(result)
}

https://leetcode.com/problems/reveal-cards-in-increasing-order/

문제 접근

1. 첨에는 오름차순?으로 정렬 후 반으로 쪼개서 하나씩 빼서 넣으려고 함.
2. 근데 아무리 봐도 아닌 거임. Output이 [2,13,3,11,5,17,7] 이게 아닌 [2,11,3,13,5,17,7] 이거라면 모를까...
3. 근데 Example 1을 보니까 다 만들고 나서 첫 번째 인덱스 값 빼고 그 다음 값 제일 뒤로 보내고, 이걸 반복함
4. 그래서 제일 뒤로 보내고 인덱스값 넣고를 하면 되지 않을까!? 했는 데, 제일 처음에 17이 들어오는 거임?
5. 그래서 내림차순?으로 정렬하고 Example에서 설명하는 로직 그대로 써서 해결함.

소스코드

func deckRevealedIncreasing(_ deck: [Int]) -> [Int] {
    var copydeck = deck
    copydeck.sort(by: >)
    var result: [Int] = []
    for _ in 0..<copydeck.count {
        if result.count == 0 {
            result.append(copydeck.removeFirst())
        }
        else {
            let last = result.removeLast()
            result.insert(last, at: 0)
            result.insert(copydeck.removeFirst(), at: 0)
        }
    }
    return result
}

https://leetcode.com/problems/queens-that-can-attack-the-king/

문제 접근

1. 처음엔 아래와 같이 지성있는 탐색을 하고 싶었으나,
2. 그런거 모르겠고 그냥 상하좌우,대각선 8방향 탐색해서 풀었음.
3. 솔직히 틀릴 줄 알았는 데, 한방에 맞았음..
4. 알고리즘이라 하기도 창피하다... 그냥 2차원 배열 열심히 탐색함 ㅎㅎ..

소스코드

class Solution {
    func queensAttacktheKing(_ queens: [[Int]], _ king: [Int]) -> [[Int]] {
        var temp: [[Int]] = []
        var flag: [Int] = [0,0,0,0,0,0,0,0]
        for j in 1..<9 {
            for i in 0..<queens.count {
                if king[0] + j == queens[i][0] && king[1] == queens[i][1] {
                    if flag[0] == 0 {
                        temp.append(queens[i])
                        flag[0] = 1
                    }
                }
                if king[0] - j == queens[i][0] && king[1] == queens[i][1] {
                    if flag[1] == 0 {
                        temp.append(queens[i])
                        flag[1] = 1
                    }
                }
                if king[1] + j == queens[i][1] && king[0] == queens[i][0] {
                    if flag[2] == 0 {
                        temp.append(queens[i])
                        flag[2] = 1
                    }
                }
                if king[1] - j == queens[i][1] && king[0] == queens[i][0] {
                    if flag[3] == 0 {
                        temp.append(queens[i])
                        flag[3] = 1
                    }
                }
            }
        }

        for j in 1..<9 {
            for i in 0..<queens.count {
                if king[0] + j == queens[i][0] && king[1] + j == queens[i][1] {
                    if flag[4] == 0 {
                        temp.append(queens[i])
                        flag[4] = 1
                    }
                }
                if king[0] - j == queens[i][0] && king[1] + j == queens[i][1] {
                    if flag[5] == 0 {
                        temp.append(queens[i])
                        flag[5] = 1
                    }
                }
                if king[0] + j == queens[i][0] && king[1] - j == queens[i][1] {
                    if flag[6] == 0 {
                        temp.append(queens[i])
                        flag[6] = 1
                    }
                }
                if king[0] - j == queens[i][0] && king[1] - j == queens[i][1] {
                    if flag[7] == 0 {
                        temp.append(queens[i])
                        flag[7] = 1
                    }
                }
            }
        }
        return temp
    }
}

https://leetcode.com/problems/group-anagrams/

문제 접근

1. 문제가 이해가 잘 안감
2. 출력문을 보고 감을 잡았는데 ["eat","tea","tan","ate","nat","bat"] 이 배열 중에 abt를 가지는 문자는 bat밖에 없고 같은 원리로 ant를 가지는 문자는 nat, tan 이렇게 분류 하는 거 같았다.
3. 그래서 배열의 한 요소 마다 정렬함수를 이용해서 정렬하고 그 것을 키 값으로 사용해서 Dictionary에 추가함. tea와 ate는 정렬에 의해서 똑같이 aet로 분류될 거 같았다.

소스코드

func groupAnagrams(_ strs: [String]) -> [[String]] {
        var temp = [String: [String]]()
        for i in 0..<strs.count {
            let mytemp = String(strs[i].sorted())
            temp[mytemp, default: []] += [strs[i]]
        }
        return Array(temp.values)
    }

오늘 첨 알았는데 if~else문을 쓰지 않고 default: []로 초기화 할 수 있더라.

https://programmers.co.kr/learn/courses/30/lessons/42842

문제 접근

1. 가운데 있는 노랑을 어떻게 표현할까.. 갈색을 1 노랑을 0으로 해서
2. 갈색이 8 노랑이 1인 경우 [1,1,1,1,0,1,1,1,1]
3. 뭐 이런식으로 접근했는데 가운데 쯔음 있네... 이 정도 외에는 별다른 소득이 없었다. 근데 이것도 24, 24 적용하니까 좀 아닌 거 같고...
4. 약수로 구해서 만약 12면 1,2,3,4,6,12 이런식으로 해서 뭘 해봐야 하나 하다가 결론을 도출할 때 약수의 가운데 부분을 뽑아서 큰 수로 정렬하면 얼추 맞더라.
5. 그래서 가운데, 가운데 + 1 인덱스 값 (홀수일 경우 가운데 값 두번) 가져와서 풀어 봄.
6. 테스트 케이스 3개 틀림. 다 틀릴 줄 알았는 데 놀람.
7. 다시 살펴보니까 외곽의 브라운의 개수는 배치에 따라 달라지고 가로 세로 길이의 곱으로 알 수 있다고 생각해서
8. 배치한 약수를 가우스의 덧셈 방식으로 두개 뽑아서 브라운 타일의 개수와 비교하였다.
9. (2 X 가로) + (2 X 세로) - 4 = 브라운 타일이 만족하면 값을 반환하였다. (여기서 -4를 해주는 이유는 대각선 모서리 끝의 타일이 겹쳐서 한번 더 계산되기 때문)

소스 코드

func solution(_ brown:Int, _ yellow:Int) -> [Int] {
    let total = brown + yellow
    var i = 1
    var tiles: [Int] = []
    var result: [Int] = []
    while i <= total {
        if total % i == 0 {
            tiles.append(i)
        }
        i += 1
    }
    for i in 0...tiles.count {
        let index = (tiles.count - 1) - i
        if (tiles[index] * 2) + (tiles[i] * 2) - 4 == brown {
            result.append(tiles[index])
            result.append(tiles[i])
            return result
        }
    }
    return result
}

https://leetcode.com/problems/sum-root-to-leaf-numbers/

문제 접근

1. DFS 여서 인접 행렬로 만들고 하나의 큐와 하나의 스택으로 풀어야 겠다
2. input = [1,2,3,4,5]이 이렇게 생겨서 주어진 배열을 인접 행렬로 만드는 작업이 필요한가 의문이 들었음.
3. 2가 아니고 그냥 Tree를 만들어서 주더라. 재귀로 풀기로 생각함.
4. DFS 재귀 호출하는 방식만 따지면 됐는데,
5. 트리를 탐색할 때 아래의 트리에서 1,2,3 그리고 4 이렇게 탐색하면 되는데 1,2,3 한번 1,2,4 한번 이렇게 탐색하려고 하니까 문제가 잘 안풀렸다. 그냥 1,2,3 탐색한 후 4도 탐색해서 합에 반영해주면 되는 문제였는데

결론. 5와 같은 방식으로 해결

소스 코드

func sumNumbers(_ root: TreeNode?) -> Int {

    return sumDFS(node: root, curNum: 0)
}

func sumDFS(node: TreeNode?, curNum: Int) -> Int {
    let curNum = 10 * curNum + node!.val

    if node?.left == nil, node?.right == nil {
        return curNum
    }

    var sum = 0

    if node?.left != nil {
        sum += sumDFS(node: node?.left, curNum: curNum)
    }

    if node?.right != nil {
        sum += sumDFS(node: node?.right, curNum: curNum)
    }

    return sum
}