## Algorithm

Problem Name: 983. Minimum Cost For Tickets

You have planned some train traveling one year in advance. The days of the year in which you will travel are given as an integer array `days`. Each day is an integer from `1` to `365`.

Train tickets are sold in three different ways:

• a 1-day pass is sold for `costs[0]` dollars,
• a 7-day pass is sold for `costs[1]` dollars, and
• a 30-day pass is sold for `costs[2]` dollars.

The passes allow that many days of consecutive travel.

• For example, if we get a 7-day pass on day `2`, then we can travel for `7` days: `2`, `3`, `4`, `5`, `6`, `7`, and `8`.

Return the minimum number of dollars you need to travel every day in the given list of days.

Example 1:

```Input: days = [1,4,6,7,8,20], costs = [2,7,15]
Output: 11
Explanation: For example, here is one way to buy passes that lets you travel your travel plan:
On day 1, you bought a 1-day pass for costs[0] = \$2, which covered day 1.
On day 3, you bought a 7-day pass for costs[1] = \$7, which covered days 3, 4, ..., 9.
On day 20, you bought a 1-day pass for costs[0] = \$2, which covered day 20.
In total, you spent \$11 and covered all the days of your travel.
```

Example 2:

```Input: days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]
Output: 17
Explanation: For example, here is one way to buy passes that lets you travel your travel plan:
On day 1, you bought a 30-day pass for costs[2] = \$15 which covered days 1, 2, ..., 30.
On day 31, you bought a 1-day pass for costs[0] = \$2 which covered day 31.
In total, you spent \$17 and covered all the days of your travel.
```

Constraints:

• `1 <= days.length <= 365`
• `1 <= days[i] <= 365`
• `days` is in strictly increasing order.
• `costs.length == 3`
• `1 <= costs[i] <= 1000`

## Code Examples

### #1 Code Example with Javascript Programming

```Code - Javascript Programming```

``````
const mincostTickets = function(days, costs) {
const last7 = [], last30 = []
let res = 0
for(let d of days) {
while(last7.length && last7[0][0] + 7 <= d) last7.shift()
while(last30.length && last30[0][0] + 30 <= d) last30.shift()
last7.push([d, res + costs[1]])
last30.push([d, res + costs[2]])
res = Math.min(res + costs[0], last7[0][1], last30[0][1])
}
return res
};
``````
Copy The Code &

Input

cmd
days = [1,4,6,7,8,20], costs = [2,7,15]

Output

cmd
11

### #2 Code Example with Python Programming

```Code - Python Programming```

``````
class Solution:
def mincostTickets(self, days: List[int], costs: List[int]) -> int:
day, days, last = [0] * 366, set(days), days[-1]
for i in range(1, last + 1):
if i not in days:
day[i] = day[i - 1]
else:
day[i] = min(day[i - 1] + costs[0], day[i - 7 if i>= 7 else 0] + costs[1], day[i - 30 if i >= 30 else 0] + costs[2])
return day[last]
``````
Copy The Code &

Input

cmd
days = [1,4,6,7,8,20], costs = [2,7,15]

Output

cmd
11

### #3 Code Example with C# Programming

```Code - C# Programming```

``````
using System;

namespace LeetCode
{
public class _0983_MinimumCostForTickets
{
public int MincostTickets(int[] days, int[] costs)
{
var memo = new int?[days.Length];
return DP(0, days, costs, memo, new int[] { 1, 7, 30 });
}

private int DP(int index, int[] days, int[] costs, int?[] memo, int[] duration)
{
if (index >= days.Length) return 0;
if (memo[index].HasValue) return memo[index].Value;

var result = int.MaxValue;
var index2 = index;
for (int type = 0; type  <  3; type++)
{
while (index2 < days.Length && days[index2] < days[index] + duration[type])
index2++;

result = Math.Min(result, DP(index2, days, costs, memo, duration) + costs[type]);
}

memo[index] = result;
return result;
}
}
}
``````
Copy The Code &

Input

cmd
days = [1,2,3,4,5,6,7,8,9,10,30,31], costs = [2,7,15]

Output

cmd
17