// Slower C++ solution:
#include <vector>

#include <iostream>

#include <cmath>

#include <map>

#include <unordered_map>

#include <algorithm>

#include <fstream>

#include <unistd.h>

#include <string.h>

#include <string>

#include <numeric>

#include <queue>

#include <deque>

#include <sstream>

#include <iomanip>

#include <set>

#include <stack>

#include <cassert>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<int> vi;

typedef vector<ll> vl;

typedef vector<vl> vvl;

typedef vector<vvl> vvvl;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<bool> vb;

typedef vector<vector<bool>> vvb;

typedef vector<vvb> vvvb;

typedef vector<vvvb> vvvvb;

typedef vector<string> vs;

typedef vector<vs> vvs;

typedef vector<vvs> vvvs;

typedef vector<char> vc;

typedef vector<vector<char>> vvc;

typedef vector<double> vd;

typedef vector<vd> vvd;

typedef vector<vvd> vvvd;

typedef pair<ll, ll> PL;

typedef vector<PL> vpl;

typedef vector<vector<PL>> vvpl;

const int INF = 1001001001;

const ll LINF = 1e17;

const double pi = 3.1415926535897932;

const string endstr = "\n";

#define FOR(i, a, b) for(ll i = (a); i < b; i++)

#define RFOR(i, a, b) for(ll i = (a); i > b; i--)

#define rep(i, n) for(ll i = 0; i < n; i++)

#define rrep(i, n) for(ll i = n-1; i > -1; i--)

#define FORMAP(it, m) for(auto it = m.begin(); it != m.end(); it++)

#define ff first

#define ss second

#define pb push_back

#define epb emplace_back

#define ALL(X) (X).begin(),(X).end()



template <typename T>

T gcd(T a, T b) {

    return (a == 0) ? b : gcd(b%a, a);

}

template <typename T>

T lcm(T a, T b) {

    return a / gcd(a, b) * b;

}



bool p_comp_fs(const PL p1, const PL p2){ return p1.first < p2.first;};

bool p_comp_fg(const PL p1, const PL p2){ return p1.first > p2.first;};

bool p_comp_ss(const PL p1, const PL p2){ return p1.second < p2.second;};

bool p_comp_sg(const PL p1, const PL p2){ return p1.second > p2.second;};

template <typename T>

vector<T> uniquen(vector<T> vec){

    sort(ALL(vec));

    vec.erase(unique(vec.begin(), vec.end()), vec.end());

    return vec;

}



inline ll popcnt(ll x){return __builtin_popcountll((unsigned long long)x);};

template<class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }

template<class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }

//friend bool operator<(const stc& lhs, const stc& rhs){

//    return std::tie(lhs.l, lhs.r) < std::tie(rhs.l, rhs.r);

//}



template<typename Monoid>

struct SegmentTree {

    using F = function<Monoid(Monoid, Monoid) >;

    

    ll sz;

    vector<Monoid> seg;

    

    const F f;

    const Monoid M1;

    

    SegmentTree(ll n, const F f, const Monoid &M1) : f(f), M1(M1) {

        sz = 1;

        while(sz < n) sz <<= 1;

        seg.assign(2 * sz, M1);

    }

    

    void set(ll k, const Monoid &x) {

        seg[k + sz] = x;

    }

    

    void build() {

        for(ll k = sz - 1; k > 0; k--) {

            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);

        }

    }

    

    void update(ll k, const Monoid &x) {

        k += sz;

        seg[k] = x;

        while(k >>= 1) {

            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);

        }

    }

    

    Monoid query(ll a, ll b) {

        Monoid L = M1, R = M1;

        for(a += sz, b += sz; a < b; a >>= 1, b >>= 1) {

            if(a & 1) L = f(L, seg[a++]);

            if(b & 1) R = f(seg[--b], R);

        }

        return f(L, R);

    }

    

    Monoid operator[](const ll &k) const {

        return seg[k + sz];

    }

};



// Usage:

// SegmentTree<ll> seg(L+1, [](ll a, ll b) { return min(a, b); }, LINF);





ll N, X;

vl A;

SegmentTree<ll> seg(2*2100, [](ll a, ll b){return min(a,b);}, LINF);



ll cost(ll K){

    ll res = K*X;

    vl mns(N, LINF);



    FOR(i, N, 2*N){

        ll mn = seg.query(i-K, i+1);

        mns[i%N] = mn;

    }

    rep(i, N) res += mns[i];

    return res;

}







int main(){

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);

    cin >> N >> X;

    A = vl(N); rep(i, N) cin >> A[i];

    

    rep(i, 2*N){

        seg.update(i, A[i%N]);

    }

    ll ans = LINF;

    rep(k, N) chmin(ans, cost(k));

    cout << ans << endstr;

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1264442454918344x):
#include <vector>

#include <iostream>

#include <cmath>

#include <map>

#include <unordered_map>

#include <algorithm>

#include <fstream>

#include <unistd.h>

#include <string.h>

#include <string>

#include <numeric>

#include <queue>

#include <deque>

#include <sstream>

#include <iomanip>

#include <set>

#include <stack>

#include <cassert>

#include <functional>

using namespace std;

typedef long long ll;

typedef vector<int> vi;

typedef vector<ll> vl;

typedef vector<vl> vvl;

typedef vector<vvl> vvvl;

typedef vector<vi> vvi;

typedef vector<vvi> vvvi;

typedef vector<bool> vb;

typedef vector<vector<bool>> vvb;

typedef vector<vvb> vvvb;

typedef vector<vvvb> vvvvb;

typedef vector<string> vs;

typedef vector<vs> vvs;

typedef vector<vvs> vvvs;

typedef vector<char> vc;

typedef vector<vector<char>> vvc;

typedef vector<double> vd;

typedef vector<vd> vvd;

typedef vector<vvd> vvvd;

typedef pair<ll, ll> PL;

typedef vector<PL> vpl;

typedef vector<vector<PL>> vvpl;

const int INF = 1001001001;

const ll LINF = 1e17;

const double pi = 3.1415926535897932;

const string endstr = "\n";

#define FOR(i, a, b) for(ll i = (a); i < b; i++)

#define RFOR(i, a, b) for(ll i = (a); i > b; i--)

#define rep(i, n) for(ll i = 0; i < n; i++)

#define rrep(i, n) for(ll i = n-1; i > -1; i--)

#define FORMAP(it, m) for(auto it = m.begin(); it != m.end(); it++)

#define ff first

#define ss second

#define pb push_back

#define epb emplace_back

#define ALL(X) (X).begin(),(X).end()



template <typename T>

T gcd(T a, T b) {

    return (a == 0) ? b : gcd(b%a, a);

}

template <typename T>

T lcm(T a, T b) {

    return a / gcd(a, b) * b;

}



bool p_comp_fs(const PL p1, const PL p2){ return p1.first < p2.first;};

bool p_comp_fg(const PL p1, const PL p2){ return p1.first > p2.first;};

bool p_comp_ss(const PL p1, const PL p2){ return p1.second < p2.second;};

bool p_comp_sg(const PL p1, const PL p2){ return p1.second > p2.second;};

template <typename T>

vector<T> uniquen(vector<T> vec){

    sort(ALL(vec));

    vec.erase(unique(vec.begin(), vec.end()), vec.end());

    return vec;

}



inline ll popcnt(ll x){return __builtin_popcountll((unsigned long long)x);};

template<class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }

template<class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }

//friend bool operator<(const stc& lhs, const stc& rhs){

//    return std::tie(lhs.l, lhs.r) < std::tie(rhs.l, rhs.r);

//}



template<typename Monoid>

struct SegmentTree {

    using F = function<Monoid(Monoid, Monoid) >;

    

    ll sz;

    vector<Monoid> seg;

    

    const F f;

    const Monoid M1;

    

    SegmentTree(ll n, const F f, const Monoid &M1) : f(f), M1(M1) {

        sz = 1;

        while(sz < n) sz <<= 1;

        seg.assign(2 * sz, M1);

    }

    

    void set(ll k, const Monoid &x) {

        seg[k + sz] = x;

    }

    

    void build() {

        for(ll k = sz - 1; k > 0; k--) {

            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);

        }

    }

    

    void update(ll k, const Monoid &x) {

        k += sz;

        seg[k] = x;

        while(k >>= 1) {

            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);

        }

    }

    

    Monoid query(ll a, ll b) {

        Monoid L = M1, R = M1;

        for(a += sz, b += sz; a < b; a >>= 1, b >>= 1) {

            if(a & 1) L = f(L, seg[a++]);

            if(b & 1) R = f(seg[--b], R);

        }

        return f(L, R);

    }

    

    Monoid operator[](const ll &k) const {

        return seg[k + sz];

    }

};



// Usage:

// SegmentTree<ll> seg(L+1, [](ll a, ll b) { return min(a, b); }, LINF);





ll N, X;

vl A;

vvl dp;



ll cost(ll K){

    ll res = K*X;

    vl mns(N, LINF);



    rep(i, N){

        res += dp[i][K];

    }

    return res;

}







int main(){

    ios_base::sync_with_stdio(false);

    cin.tie(nullptr);

    cin >> N >> X;

    A = vl(N); rep(i, N) cin >> A[i];

    dp = vvl(N, vl(N, LINF));

    

    rep(i, N) dp[i][0] = A[i];

    

    FOR(k, 1, N) rep(i, N){

        dp[i][k] = min(dp[i][k-1], A[(i-k+N)%N]);

    }

    

    ll ans = LINF;

    rep(k, N) chmin(ans, cost(k));

    cout << ans << endstr;

    return 0;

}