31-xxubin04

[xxubin04]

🔗 문제 링크

134: Gas Station

✔️ 소요된 시간

1시간 + α

✨ 수도 코드

1. 문제 이해

주어지는 주유소를 전부 순회할 수 있는 시작 주유소 번호를 반환하는 문제이다.
주유소 번호 = 인덱스 번호라는 것을 주의하자.

Ex1에서의 gas = [1, 2, 3, 4, 5], cost = [3, 4, 5, 1, 2]이다.
(gas[i] = 각 주유소에서 얻는 가스양, cost[i] = 각 주유소로 가기 위해 쓰는 가스양)

3번 주유소(인덱스 = 3)에서 시작해보자.
탱크에 가스를 저장한다고 치기 위해 변수 tank를 만들자. 그리고 탱크는 처음에 비어있기에 tank = 0으로 지정해준다.

• gas = 4, cost = 1, index = 3
  • 3번 주유소 -> tank += 4 (4) -> 4번 주유소로 가기 -> tank -= 1 (3)
• gas = 5, cost = 2, index = 4
  • 4번 주유소 -> tank += 5 (8) -> 0번 주유소로 가기 -> tank -= 2 (6)
• gas = 1, cost = 3, index = 0
  • 0번 주유소 -> tank += 1 (7) -> 1번 주유소로 가기 -> tank -= 3 (4)
• gas = 2, cost = 4, index = 1
  • 1번 주유소 -> tank += 2 (6) -> 2번 주유소로 가기 -> tank -= 4 (2)
• gas = 3, cost = 5, index = 2
  • 2번 주유소 -> tank += 3 (5) -> 3번 주유소로 가기 -> tank -= 5 (0)

가스의 양은 항상 0보다 크거나 같아야 한다. 음수가 된다면 다음 주유소로 이동할 수 없기 때문에 모든 주유소를 순회해서 시작했던 주유소로 돌아올 수 없다.

2. 시간초과😊

다음은 40개의 테스트 케이스 중에서 33개까지만 통과한 코드들이다.

시간초과1

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        original_gas, original_cost = gas, cost
        start = []
        # idx = [r for r in range(len(gas))]
        cnt = -1
        for g, c in zip(gas, cost):
            cnt += 1
            if g-c >= 0: start.append(cnt)
        for j in start:
            tank = 0
            cnt = 0
            gas = original_gas[cnt:] + original_gas[:cnt]
            cost = original_cost[cnt:] + original_cost[:cnt]
            for g, c in zip(gas, cost):
                tank = tank + g - c
                cnt += 1
                if tank < 0: break
            if tank >= 0: 
                return cnt
        return -1

시간초과2

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        original_gas, original_cost = gas, cost
        start = []
        idx = [r for r in range(len(gas))]
        for i, g, c in zip(idx, gas, cost):
            if g-c >= 0: 
                tank = 0
                gas = original_gas[i:] + original_gas[:i]
                cost = original_cost[i:] + original_cost[:i]
                cal = []
                for g, c in zip(gas, cost):
                    cal.append(g-c)
                ans = 0
                check = True
                for a in range(len(cal)):
                    ans += cal[a]
                    if ans < 0: check = False
                if check == True: return i
        return -1

시간초과3

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        original_gas, original_cost = gas, cost
        start = []
        cnt = -1
        for g, c in zip(gas, cost):
            cnt += 1
            if g-c >= 0: 
                tank = 0
                gas = original_gas[cnt:] + original_gas[:cnt]
                cost = original_cost[cnt:] + original_cost[:cnt]
                cal = []
                for g, c in zip(gas, cost):
                    cal.append(g-c)
                ans = 0
                check = True
                for a in range(len(cal)):
                    ans += cal[a]
                    if ans < 0: check = False
                if check == True: return cnt
        return -1

3. 코드 분석

사실, 계속 고치다가 시간초과 이슈가 해결되지 않아서 34개 테스트 케이스만 통과한 코드를 올리게 되었다...
다시 풀어보고 모든 테스트 케이스를 통과한다면 다시 올려야겠다..😂

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        if sum(gas) < sum(cost):
            return -1
        for i in range(len(gas)):
            tank = 0
            for g, c in zip(gas[i:]+gas[:i], cost[i:]+cost[:i]):
                tank = tank + g -c
                if tank < 0: break
            if tank >= 0: return i
        return -1

위의 계산과정 사진과 풀이를 참고해보면, 다음과 같다.

tank = (4-1) + (5-2) + (1-3) + (2-4) + (3-5) 

그리고 우리는 1. 가스 충전(+)과 2. 가스 사용(-)를 거친 상태의 가스 상태가 음수이면 안된다. 즉, 괄호로 묶는 부분이 한 주유소에서 거치는 과정(n주유소에서 가스얻고, 다음 주유소 가기위해 가스사용)이므로 이 괄호의 계산이 음수가 되면, 다음 주유소로 가는 과정에서 가스 부족으로 갈 수 없게 되는 경우이다.

위의 tank 식은 sum(gas) - sum(cost)과 같다. ((4+5+1+2+3) - (1+2+3+4+5))
그러므로, sum(gas) < sum(cost) == tank < 0이므로 이 경우에는 -1을 반환해준다.

for문으로 모든 주유소를 순회가능한 경우가 나올때까지 확인해준다.
계산 과정에서 tank가 음수가 되는 경우가 생긴다면, 즉시 break하고 다음 주유소를 시작점으로 잡은 경우를 확인해준다.
만약, 모든 주유소를 확인하고 tank >= 0이라면 인덱스이면서 주유소의 번호인 i를 반환한다.

4. 전체 코드

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        if sum(gas) < sum(cost):
            return -1
        for i in range(len(gas)):
            tank = 0
            for g, c in zip(gas[i:]+gas[:i], cost[i:]+cost[:i]):
                tank = tank + g -c
                if tank < 0: break
            if tank >= 0: return i
        return -1

📚 새롭게 알게된 내용

다 해결하고 PR 올렸어야 하는데 12시가 넘어서 올립니다😭
시간초과... 힘드네요🥲 풀이를 제대로 썼을지 모르겠네요..
문제 풀때마다 항상 많이 부족한 것을 느끼고 갑니다..

[9kyo-hwang]

1. 최초 코드

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
        for i, (g, c) in enumerate(zip(gas, cost)):
            if g < c:  # 현재 지점에서 출발할 수 없는 경우
                continue

            tank = 0
            for _ in range(len(gas)):  # 지금 지점에서 출발해봄
                tank += gas[i] - cost[i]
                if tank < 0:  # 비용이 더 크면 더 못가므로 stop
                    break
                i = (i + 1) % len(gas)  # 인덱스 조정(0부터 시작이 아니기 때문)
            
            if tank >= 0:  # 끝까지 돌았는데도 잔여 연료가 있다면 완주 성공
                return i

        return -1  # 모든 경우에 대해 return i를 진입하지 못했다면 불가능한 케이스

나름 합리적인 코드라 생각됐지만...

오 ㅋㅋ 빠꾸없는 반례에 걸려버렸습니다. $O(n^2)$이 되면서 냅다 시간 터져버렸더라구요.

2. 개선된 코드

어떤 A 지점에서 B 지점으로 간다고 할 때, 중간에 얼마나 연료가 넘치게 충전했든 마지막 하나에서 연료 다 깎아먹어서 못가게 되면 A와 B 사이(A 포함)에 존재하는 모든 지점 은 출발할 수 있는 지점이 아니게 됩니다.
그렇다면, 굳이 못가는 사이 지점을 탐색할 필요 없이 바로 건너뛰면 되겠죠?

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
        if sum(gas) < sum(cost):
            return -1
        
        start = 0
        while start < len(gas):
            tank = 0
            for i in range(len(gas)):
                i = (i + start) % len(gas)
                tank += (gas[i] - cost[i])
                if tank < 0:
                    start = i + 1
                    break
            
            if tank >= 0:
                return start

        return -1

통과 따이~

3. 순회 한 번으로 끝내는 코드...?

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
        if sum(gas) < sum(cost):
            return -1

        start, tank = 0, 0
        for i, (g, c) in enumerate(zip(gas, cost)):
            tank += (g - c)

            if tank < 0:
                tank = 0
                start = i + 1

        return start

gas 총 공급량이 cost 총 소모량보다 많다면, 반드시 한 바퀴를 돌 수 있는 지점이 있다는 뜻이 됩니다.
그거를 딱 한 번만 순회해서 해결하는 코드인데... 저도 꼼꼼하게 따져보지 않아서 명확하게 설명이 잘 안되네요... 한 번 알아보실래요? 😈

[xxubin04]

순회 한번으로도 풀 수 있었군요!!
생각해보니 굳이 gas[j:] + gas[:j] 이런식으로 다시 n부터 n-1까지 한 바퀴를 확인해 줄 필요가 없네요.

for i in range(len(gas)):
# index(주유소 번호) : 0 1 2 3 ... m ... n

위와 같다면 만약 m ( 0 < m < n)(start = m)에서 한 바퀴 순회가 가능하다고 쳤을 때, 인덱스 0부터 m-1주유소에서 tank < 0이 아니었다는 것이므로 for문 순회가 끝나고 나서 마지막으로 정해진 start를 반환하면 되는거였네요!

갑자기 '시작하는 주유소에 따라 각 주유소를 거치는 과정에서 tank 값이 달라질 수도 있지 않나?'라는 의문이 생겼는데 이것도 문제 없더라구요.

1. 0 ~ m-1에서의 주유소에서 시작했을 때는 tank < 0인 순간이 단 한번이라도 생긴다는 것
2. 어디서부터 시작하던지 시작 주유소의 바로 앞 tank가 음수지만, for문 순회하는 동안 정해진 start는 for문이 끝날때까지 tank < 0인 순간이 단 한번도 없는 것
3. 주유소를 한 바퀴 무조건 순회 가능하며 유일함(하나의 시작점에서만 가능)

이므로 문제가 되지 않는 것을 알았습니다.

신기하네요... 감사합니다!👍

[Dolchae]

아이고 시간초과...😂😂 엄청 많이 다시 도전해보셨네요..👍👍 수고많으십니다🔥😊

[gjsk132]

처음에 풀었을 때는 리스트로 결과를 다 저장하니 코드가 복잡해지고 시간이 오래걸리는 문제가 생겨서 다른 방법으로 바꿔줬습니다!

gas와 cost의 값의 차를 나열했을 때, 볼 수 있는 2가지 규칙을 사용했습니다.

1. 같은 부호가 연속으로 있으면 겹칠 수 있다.
2. 다른 부호가 이어져있다면
   a. 두 개의 합이 양수인 경우 맨 앞에 그대로 두고
   b. 두 개의 합이 음수라면 해당 위치보다 뒤에서 시작해야해서 따로 빼뒀다가 마지막 값의 결과와 비교해주면 됩니다.
   ( -에서 + 넘어가냐 +에서 - 넘어가냐에 따라 기억해야하는 시작 지점이 달라진다. )

이런 특징을 사용한다면, 모든 지점을 리스트로 기억하거나, 여러 번 반복을 해주지 않아도 됩니다.

코드

class Solution:
    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:

        pos = 0
        total = 0
        minus = 0

        for i in range(len(gas)):
            if (tmp := gas[i] - cost[i]) == 0:
                continue

            elif total * tmp >= 0:
                total += tmp

                if tmp < 0:
                    pos = i + 1

                continue

            if (n := tmp + total) < 0:
                minus += n
                total = 0
                pos = i if tmp > 0 else i + 1
            else:
                total = n

        return pos if total + minus >= 0 else -1

뭔가 코드가 복잡한데 더 짧게 줄이려다가 한참 붙잡고 있었네요...

그래도 나름 성공적으로 정리됐습니다! :)