// Original C++ solution (slower):
#include<cstdio>

#include<cstring>

#include<vector>

#include<queue>

#include<stack>

#include<algorithm>

#include<cmath>

#include<climits>

#include<string>

#include<set>

#include<numeric>

#include<map>

#include<iostream>

using namespace std;

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

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

#define irep(i,n) for(int i = ((int)(n)-1);i>=0;i--)

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

typedef long long ll;

typedef pair<ll, ll> mp;

ll mod = 1e9+7;

ll inf = 1e18;

//LLONG_MIN



//WA



struct segmentTree{

	static const int MAX_SIZE = 1 << 17;

	long long segMin[2 * MAX_SIZE - 1]={}, segAdd[2 * MAX_SIZE - 1]={};

	int n;

	segmentTree(){}

	segmentTree(int sz, long long* v){

		n=sz;

		rep(i,n)add(i,i+1,v[i]);

	}



	//区間[a, b)に値xを加算する.

	void add(int a, int b, int x, int k = 0, int l = 0, int r = MAX_SIZE)

	{

		if (r <= a || b <= l) return; //もし交差しない区間であれば終える.

		

		if (a <= l && r <= b){ //もし今みている区間[l, r)が[a, b)に完全に内包されていれば

			segAdd[k] += x;  //区間[l, r)にkを加算する.

			return;

		}

		

		add(a, b, x, k * 2 + 1, l, (l + r) / 2); //子の区間に(必要があれば)xを加算する.

		add(a, b, x, k * 2 + 2, (l + r) / 2, r); //〃



		//親の区間の最小値は, 子の区間の最小値 + 自分に一様に加算されている値 である.一様に加算される値は更新しなくて良い.

		segMin[k] = min(segMin[k * 2 + 1] + segAdd[k * 2 + 1], segMin[k * 2 + 2] + segAdd[k * 2 + 2]);

	}



	long long getMin(int a, int b, int k = 0, int l = 0, int r = MAX_SIZE)

	{

		if (r <= a || b <= l) return (LLONG_MAX);

		

		if (a <= l && r <= b) return (segMin[k] + segAdd[k]); //完全に内包されていれば,その区間の最小値を返す.

		

		long long left = getMin(a, b, k * 2 + 1, l, (l + r) / 2); //子の区間の最小値を求める.

		long long right = getMin(a, b, k * 2 + 2, (l + r) / 2, r); //子の区間の最小値を求める

		

		return (min(left, right) + segAdd[k]); //親の区間の最小値は, 子の区間の最小値 + 自分に一様に加算されている値 である (大切なので2回書きました!!)

	}

};





int main(void){

	ll N,x,A[100010],ans=inf;

	cin>>N>>x;

	rep(i,N){

		cin>>A[i];

	}

	segmentTree f(N,A);

	rep(i,N){//魔法の回数

		ll sum=x*i;

		rep(j,N){//スライムjを手に入れるのにかかる最小コスト

			if(j>=i){

				sum+=f.getMin(j-i,j+1);

			}else{

				sum+=min(f.getMin(0,j+1),f.getMin(N-(i-j),N));

			}

		}

		// cout<<sum<<endl;

		ans=min(ans,sum);

	}

	// cout<<f.getMin(1,3)<<endl;

	cout<<ans<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<cstring>

#include<vector>

#include<queue>

#include<algorithm>

#include<cmath>

#include<climits>

#include<string>

#include<set>

#include<numeric>

#include<map>

#include<iostream>

using namespace std;

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

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

#define irep(i,n) for(int i = ((int)(n)-1);i>=0;i--)

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

typedef long long ll;

typedef pair<ll, ll> mp;



/*



*/



template<typename T_n>

struct segment_tree{

	typedef struct node_{

		T_n value;

		int left,right; //[left,right)

		struct node_ *left_child,*right_child;

	}* node;

	node parent_node = new node_;

	T_n default_value=1e18;//範囲外の場合の評価値

	T_n eval(T_n a, T_n b){//segment_treeの評価関数

		return min(a,b);

	}

	T_n back_propagation(T_n before, T_n after){//伝播する値を計算

		return min(before,after);

	}

	segment_tree(int left,int right){//どんな範囲でも作れる

		make_segtree_(parent_node,left,right);

	};

	void make_segtree_(node p,int left,int right){

		p->left=left;

		p->right=right;

		p->value=default_value;

		if(left+1!=right){

			node q=new node_, r=new node_;

			p->left_child=q;

			p->right_child=r;

			make_segtree_(q,left,(left+right)/2);

			make_segtree_(r,(left+right)/2,right);

		}else{//要素数が1個

			p->left_child=NULL;

			p->right_child=NULL;

		}

	}

	T_n query(int left,int right){//[left,right)

		return query_(parent_node,left,right);

	}

	T_n query_(node p,int left,int right){

		if(p->right<=left || right<=p->left)return default_value;

		if(left<=p->left && p->right<=right)return p->value;

		return eval( query_(p->left_child,left,right), query_(p->right_child,left,right) );

	}

	void change(int pos,T_n value){

		change_(parent_node,pos,value);

	}

	T_n change_(node p,int pos,T_n value){

		//上に差分を伝播

		T_n diff;

		if(p->left<=pos && pos<p->right){//入っているなら

			if(p->left==pos && pos+1==p->right){//justなら

				diff = back_propagation(p->value,value);

			}else{

				diff = eval(change_(p->left_child,pos,value), change_(p->right_child,pos,value));

			}

			p->value = eval(p->value,diff);

		}else{

			diff=default_value;

		}

		return diff;//差分が上に伝播する

	}

};



int main(void){

	ll n,x,a[2010],ok=0,ng=1e9+7,ans=1e18;

	segment_tree<ll> f(0,2010);

	cin>>n>>x;

	rep(i,n){

		cin>>a[i];

		f.change(i,a[i]);

	}

	reg(k,0,n){//魔法を使う回数

		ll sum=0;

		rep(i,n){

			if(i-k>=0){

				sum+=f.query(i-k,i+1);

			}else{

				sum+=min(f.query(0,i+1),f.query(n-(k-i),n+1));

			}

		}

		ans=min(ans,x*k+sum);

	}

	cout<<ans<<endl;

	return 0;

}

// Fastest known solution for this problem: