[Leet.2391] Streak Day 94 🔥

2391. Minimum Amount of Time to Collect Garbage

---

문제 설명

garbage = ["G","P","GP","GG"], travel = [2,4,3]

다음과 같이 각도시의 garbage배열이 주어진다. 종류는 "G","P","M"만 존재
travel은 각 도시 i에서 i+1로 이동하는 비용이다.
트럭이 각각 G P M 3종류가 있고, 한트럭이 움직일때는 다른트럭이 움직일 수 없을 때 (트럭 3대 전부 0에서 출발) 최소 비용값 구하라

---

문제 풀이

1. 계산을 해보다보니, 결국에는 만약 G가 맨마지막에 하나만 있어도 트럭은 끝까지가서 가져와야한다.
2. 이말인 즉슨 결국 가장 뒤에있는 인덱스값 (3종류)까지 도달하기 위한 비용을 계산하고
3. 추가로 이제 쓰레기를 줍는비용, 그냥 모든 쓰레기의 개수를 더하면 끝이다 !

결국 어떻게 맨 마지막 친구를 구할 것인가...

stride활용해서 그냥 뒤에서부터 구해주면 된다. 총 3번의 반복문(각 종류별)

어떻게 garbage[i]에 원하는게 있는지 알 수 있는가? contains 활용 !

 if garbage[i].contains(category) {
                    return travelSum[i]
                }

최종 제출 코드

class Solution {
    func garbageCollection(_ garbage: [String], _ travel: [Int]) -> Int {
        var travelSum = [0]
        var answer = 0
        for idx in 0 ..< travel.count {
            travelSum.append(travelSum[idx] + travel[idx])
        }
        for item in garbage {
            answer += (item.count)
        }

        let trucks = ["G", "P", "M"]
        for truck in trucks {
            answer += findIdx(truck)
        }

        func findIdx(_ category: String) -> Int {
            for i in stride(from: travelSum.count - 1, to: -1, by: -1) { // 뒤에서부터 찾기
                if garbage[i].contains(category) {
                    return travelSum[i]
                }
            }
            return 0
        }
        return answer
    }
}

---

타인의 코드

class Solution {
    struct Info {
        var m: Int = 0
        var p: Int = 0
        var g: Int = 0

        var total: Int {
            return m + p + g
        }
    }
    func garbageInfo(_ garbage: String) -> Info {
        var info = Info()
        for g in garbage {
            switch g {
                case "P":
                info.p += 1
                case "G":
                info.g += 1
                case "M":
                info.m += 1
                default:
                break
            }
        }
        return info
    }
    func garbageCollection(_ garbage: [String], _ travel: [Int]) -> Int {
        var mTime = 0
        var gTime = 0
        var pTime = 0
        
        var currentTravel = 0
        var collectionTime = 0

        for (g, t) in zip(garbage, [0] + travel) {
            let info = garbageInfo(g)
            currentTravel += t
            collectionTime += info.total
            if info.m > 0 {
                mTime = currentTravel
            }
            if info.p > 0 {
                pTime = currentTravel
            }
            if info.g > 0 {
                gTime = currentTravel
            }
        }
        return mTime + pTime + gTime + collectionTime
    }
}

전반적인 코드는 유사하지만, 특히 zip을 활용한 방식이 효율적이라고 느껴졌다.
나는 끝에서부터 처리하는 방식을 사용했지만, 문제에 따라 적용이 어려울 수 있을텐데, 이 풀이는 좀 더 정석인느낌? 앞에서부터 순차적으로 따라가면서 값을 갱신시켜주는 것이라서 그렇다.