// Slower C++ solution:
#include "bits/stdc++.h"

using namespace std;

#ifndef LOCAL

#define endl '\n'

#endif



#define fr(i, a, b) for(int i = a; i <= b; i++)

#define rf(i, a, b) for(int i = a; i >= b; i--)

#define pf push_front

#define pb push_back

#define eb emplace_back

#define fi first

#define se second

#define all(x) x.begin(), x.end()

#define rall(x) x.rbegin(), x.rend()

#define sz(x) (int)x.size()

#define lb lower_bound

#define ub upper_bound



typedef long long ll;

typedef long double f80;

typedef pair<int,int> pii;

typedef pair<ll,ll> pll;



int pct(int x) { return __builtin_popcount(x); }

int pct(ll x) { return __builtin_popcountll(x); }

int bt(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))

int bt(ll x) { return 63 - __builtin_clzll(x); } // floor(log2(x))

int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }

ll cdiv(ll a, ll b) { return a / b + !(a < 0 || a % b == 0); }

int nxt_C(int x) { int c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }

ll nxt_C(ll x) { ll c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }



vector<int> get_bits(int mask) {

	vector<int> bb;

	while(mask) { int b = bt(mask); bb.pb(b); mask ^= (1 << b); }

	reverse(all(bb));

	return bb;

}



int get_mask(vector<int> v) {

	int mask = 0;

	for(int x : v) { mask ^= (1 << x); }

	return mask;

}



template<typename T>

void uniq(vector<T> &v) { sort(all(v)); v.resize(unique(all(v)) - v.begin()); }



mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());



ll rand(ll l, ll r){

	uniform_int_distribution<ll> uid(l, r);

	return uid(rng);

}



void sc() {}



template <typename Head, typename... Tail>

void sc(Head &H, Tail &... T) { cin >> H; sc(T...); }



#ifdef LOCAL

#define debug(...) cerr << "[L:" << __LINE__ << "][" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

#else

#define debug(...) 42

#endif



// #ifndef LOCAL

// string to_string(__int128 x) {

// 	string s = "";

// 	bool neg = 0;

// 	if(x < 0) { s += "-"; neg = 1; x = -x; }

// 	if(!x) s += '0';

// 	while(x) {

// 		int rem = x % 10;

// 		s += to_string(rem);

// 		x /= 10;

// 	}

// 	reverse(s.begin() + neg, s.end());

// 	return s;

// }

// #endif



const int mod = 1e9 + 7; // 998244353;



int pwr(int a,ll b) {

	int ans = 1;

	while(b) {

		if(b & 1) ans = (ans * 1LL * a) % mod;

		a = (a * 1LL * a) % mod;

		b >>= 1;

	}

	return ans;

}



/*

	Lookout for overflows!!

	Check array sizes!!

	Clear before test cases!!

	Use the correct modulo!!

	Check for corner cases!!

	Are you forgetting something?!

	Read problem statement carefully!!!

*/



const int N = 4005;

ll a[N];



void solve() {

	int n;

    ll x;

    sc(n, x);

    fr(i, 1, n) {

        sc(a[i]);

        a[i + n] = a[i];

    }

    ll ans = 1e18;

    for(int k = 0; k <= n - 1; k++) {

        ll cost = k * x;

        int len = k + 1;

        deque<pii> d;

        fr(i, 1, 2 * n) {

            while(!d.empty() && d.back().fi >= a[i]) d.pop_back();

            d.push_back({a[i], i});

            while(!d.empty() && d.front().se <= i - len) d.pop_front();

            if(i > n)

                cost += d.front().fi;

        }

        ans = min(ans, cost);

    }

    cout << ans;

}



int main() {

	ios :: sync_with_stdio(0);

	cin.tie(0);

	cout.tie(0);

	int t = 1;

	// cin >> t;

	for(int tt = 1; tt <= t; tt++) {

		solve();

	}

	return 0;

}

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



typedef long long LL;



const int MAXN = 4005;



template<typename _T>

void read( _T &x )

{

	x = 0;char s = getchar();int f = 1;

	while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}

	while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}

	x *= f;

}



template<typename _T>

void write( _T x )

{

	if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }

	if( 9 < x ){ write( x / 10 ); }

	putchar( x % 10 + '0' );

}



template<typename _T>

_T MIN( const _T a, const _T b )

{

	return a < b ? a : b;

}



int q[MAXN];

int a[MAXN];

int N, x;



LL calc( const int l )

{

	LL ret = 1ll * l * x;

	int h = 1, t = 0, r = 1;

	for( int i = 1 ; i <= N ; i ++ )

	{

		while( h <= t && q[h] < i ) h ++;

		for( ; r <= i + l ; r ++ )

		{

			while( h <= t && a[q[t]] >= a[r] )

				t --;

			q[++ t] = r;

		}

		ret += a[q[h]];

	}

	return ret;

}



int main()

{

	read( N ), read( x );

	for( int i = 1 ; i <= N ; i ++ ) read( a[i] ), a[i + N] = a[i];

	LL ans = 1e18;

	for( int i = 0 ; i < N ; i ++ )

		ans = MIN( ans, calc( i ) );

	write( ans ), putchar( '\n' );

	return 0;

}