docs(algorithms, greedy): gas stations

Author: BrianLusina

algorithms/dynamic_programming/buy_sell_stock/README.md

@@ -126,5 +126,3 @@ Output: 6
 - Arrays
 - Dynamic Programming
 - Greedy
-
-

algorithms/dynamic_programming/buy_sell_stock/__init__.py

@@ -5,18 +5,23 @@
 def max_profit(prices: List[int]) -> int:
     """
     Find the maximum profit that can be made from buying and selling a stock once
+
+    Time complexity is O(n) as we iterate through each price to get the maximum profit
+    Space complexity is O(1) as no extra space is used
+    Args:
+        prices(list): list of prices
+    Returns:
+        int: maximum profit that can be made
     """
     if prices is None or len(prices) < 2:
         return 0
 
     start_price = prices[0]
     current_max_profit = 0
 
-    for price in prices:
-        if price < start_price:
-            start_price = price
-        elif price - start_price > current_max_profit:
-            current_max_profit = price - start_price
+    for price in prices[1:]:
+        start_price = min(start_price, price)
+        current_max_profit = max(current_max_profit, price - start_price)
 
     return current_max_profit
 
@@ -28,13 +33,14 @@ def max_profit_two_pointers(prices: List[int]) -> int:
     Space: O(1), no extra memory is used
     Time: O(n), where n is the size of the input list & we iterate through the list only once
     """
-    if prices is None or len(prices) < 2:
+    number_of_prices = len(prices)
+    if prices is None or number_of_prices < 2:
         return 0
 
     left, right = 0, 1
     current_max_profit = 0
 
-    while right < len(prices):
+    while right < number_of_prices:
         low = prices[left]
         high = prices[right]
 

algorithms/dynamic_programming/buy_sell_stock/test_max_profit.py

@@ -1,6 +1,9 @@
 import unittest
 
-from . import max_profit, max_profit_two_pointers
+from algorithms.dynamic_programming.buy_sell_stock import (
+    max_profit,
+    max_profit_two_pointers,
+)
 
 
 class MaxProfitTestCases(unittest.TestCase):

algorithms/greedy/gas_stations/README.md

@@ -42,3 +42,54 @@ Therefore, you can't travel around the circuit once no matter where you start.
 
 - Array
 - Greedy
+
+## Solution
+
+If there is more gas along the route than the cost of the route, then there is guaranteed to be a solution to the problem.
+So the first step is to check if the sum of the gas is greater than or equal to the sum of the cost. If it is not, then
+we return -1.
+
+Next, we iterate through the gas station to find the starting index of our circuit using a greedy approach: whenever we
+don't have enough gas to reach the next station, we move our starting gas station to the next station and reset our gas
+tank.
+
+We start at the first station, and fill our tank with gas[0] = 5 units of gas. From there, it takes cost[0] = 1 units of
+gas to travel to the next station, so we arrive at station 2 (index 1) with 4 units of gas.
+
+![Solution 1](./images/solutions/gas_stations_solution_1.png)
+![Solution 2](./images/solutions/gas_stations_solution_2.png)
+![Solution 3](./images/solutions/gas_stations_solution_3.png)
+
+At station 2, we fill our tank with gas[1] = 2 units of gas, for a total of 6 units of gas. It takes cost[1] = 5 units
+of gas to travel to the next station, so we arrive at station 3 with 1 unit of gas
+
+![Solution 4](./images/solutions/gas_stations_solution_4.png)
+![Solution 5](./images/solutions/gas_stations_solution_5.png)
+
+Now at station 3, we fill our tank with gas[2] = 0 units of gas, for a total of 1 unit of gas. It takes cost[2] = 5 units
+of gas to travel to the next station, which we don't have.
+
+This is where our greedy approach comes in. We reset our starting station to the next station i + 1 and reset our gas
+tank to 0. We can do this because all other start indexes between 0 and 2 will also run into the same problem of not
+having enough gas to reach the next station, so we can rule them out.
+
+![Solution 6](./images/solutions/gas_stations_solution_6.png)
+![Solution 7](./images/solutions/gas_stations_solution_7.png)
+
+If we follow this approach of resetting the start index and gas tank whenever we don't have enough gas to reach the next
+station, then when we finish iterating, the last start index will be the solution to the problem.
+
+![Solution 8](./images/solutions/gas_stations_solution_8.png)
+![Solution 9](./images/solutions/gas_stations_solution_9.png)
+![Solution 10](./images/solutions/gas_stations_solution_10.png)
+![Solution 11](./images/solutions/gas_stations_solution_11.png)
+
+### Complexity Analysis
+
+#### Time Complexity
+
+O(n) where n is the number of gas stations. We only iterate through the gas stations once.
+
+#### Space Complexity
+
+O(1) We only use constant extra space for variables.

algorithms/greedy/gas_stations/__init__.py

@@ -22,10 +22,14 @@ def can_complete_circuit(gas: List[int], cost: List[int]) -> int:
 
     gas_tank, start_index = 0, 0
 
-    for i in range(len(gas)):
-        gas_tank += gas[i] - cost[i]
+    for gas_station in range(len(gas)):
+        # can reach next station:
+        # update remaining fuel
+        gas_tank += gas[gas_station] - cost[gas_station]
 
         if gas_tank < 0:
-            start_index = i + 1
+            # can't reach next station:
+            # try starting from next station
+            start_index = gas_station + 1
             gas_tank = 0
     return start_index