1. First point to note is that we need to ride all the buses in order and we can't skip any. That means we need to ride buses in order like 1,2, 3, …, n. We can't ride 3 first and then 1.
2. We want to start as late as possible
3. ith bus can be rode on xi ,2xi,3xi,etc
4. We can take ride different buses on same day, but in order only

Of course, we will take the last bus on the last day in the journey. So first task is to find what's the last possible day to take the last bus? Answer is multiple of xn which is less than d and closest to d.

The value can be computed as d-(d%xn), let it call boundn

Now for the previous bus x(n-1) the last possible date to ride is boundn so for this bus the value can be computed as bound_n-(boundn%x(n-1)), let it call bound(n-1)

So, this is a loop and in similar fashion we can continue up to bus 1 and find out what's the last possible day for bus 1 which is our answer.

Below is the pseudocode for the above algorithm:

1. Initialize bound =d

2. for(int i=n-1;i>=0;i--)
       bound = min(bound,bound-(bound%arr[i]));
   end for  
   

Dry run:

For the first example
Initially bound =d=10
------------------------------
i=2
Bound=min(10,10-10%arr[2])=min(10,10-0)=10
------------------------------

i=1
Bound=min(10,10-10%arr[1])=min(10,10-7)=7
------------------------------

i=0
Bound=min(7,7-7%arr[0])=min(7,7-1)=6
------------------------------

Final result is 6

C++ implementation:

#include <bits/stdc++.h>
using namespace std;

#define endl "\n"
#define lli long long int

lli arr[1000];

lli min(lli a, lli b)
{
    return a < b ? a : b;
}

int main()
{
    ios_base::sync_with_stdio(0);
    
    cin.tie(0);
    cout.tie(0);
    
    int test_case;
    
    cin >> test_case;
    
    for (int tc = 1; tc <= test_case; tc++) {
        lli n, d;
        cin >> n >> d;

        for (int i = 0; i < n; i++) {
            cin >> arr[i];
        }
        lli bound = d;
        for (int i = n - 1; i >= 0; i--) {
            bound = min(bound, bound - (bound % arr[i]));
        }
        cout << "Case #" << tc << ": " << bound << endl;
    }

    return 0;
}

Output:

3
3 10
3 7 2
4 100
11 10 5 50
1 1
1
Case #1: 6
Case #2: 99
Case #3: 1