import std.stdio, std.conv, std.string;
import std.array, std.range, std.algorithm, std.container;
import std.math, std.random, std.bigint, std.datetime, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }

int DEBUG_LEVEL = 0;
void print()(){ writeln(""); }
void print(T, A ...)(T t, lazy A a){ write(t), print(a); }
void print(int level, T, A ...)(T t, lazy A a){ if(level <= DEBUG_LEVEL) print(t, a); }

void main(string[] args){
	if(args.length > 1 && args[1] == "-debug"){
		if(args.length > 2 && args[2].isNumeric) DEBUG_LEVEL = args[2].to!int;
		else DEBUG_LEVEL = 1;
	}
	
	int n = read.to!int;
	long a = read.to!long;
	long b = read.to!long;
	
	int[] ps;
	foreach(i; 0 .. n) ps ~= read.to!int - 1;
	print!1("ps:", ps);
	
	// us[p]: pより左にある、pより大きい最小の数
	int[] us = new int[](n);
	foreach(i; 0 .. n){
		int u = n * 2;
		foreach(j; 0 .. i) if(ps[j] > ps[i] && ps[j] < u) u = ps[j];
		us[ps[i]] = u;
	}
	print!1("us:", us);
	
	// vs[p]: pより右にある、pより小さい最大の数
	int[] vs = new int[](n);
	foreach(j; 0 .. n){
		int v = -1;
		foreach(i; j + 1 .. n) if(ps[i] < ps[j] && ps[i] > v) v = ps[i];
		vs[ps[j]] = v;
	}
	print!1("vs:", vs);
	
	// xs[k]: 0 .. k を左に、k + 1 .. n を右に寄せる最小のコスト
	long[] xs = new long[](n);
	foreach(k; 0 .. n){
		long x;
		foreach(i; 0 .. k) x += (us[i] >= k + 1? 0: b);
		foreach(j; k + 1 .. n) x += (vs[j] < k? 0 : a);
		xs[k] = x;
	}
	print!1("xs:", xs);
	
	// xs[k]のうちで最小のものを探す
	long ans = a * n + b * n;
	foreach(k; 0 .. n) if(xs[k] < ans) ans = xs[k];
	
	ans.writeln;
	
}

/*

ローテーションと言っているのは要素を取って別の場所に挿入する操作
同じ要素に対して2回行うことは無駄なので、高々1回しか行わない

左へ移動して左からソートしていくか、右へ移動して右からソートしていくか？
最終形としては、
・ある項は固定されている
・それより左は、左へ移動してソートした要素たち
・それより右は、右へ移動してソートした要素たち
という状態になるはず

ただし、元からソートされていて移動しなくてすむ要素というのがある
「自分は、いくつまでが右へソートされたら左へソートしなくてすむのか」
「自分は、いくつまでが左へソートされたら右へソートしなくてすむのか」
をあらかじめ考えておく

たとえばこの入力例5では
> 9 40 50
> 5 3 4 7 6 1 2 9 8

3は、
　もし5が右へ移動することになったなら自分は左へは移動する必要がない
　もし1と2が左へ移動することになったなら自分は右へは移動する必要がない
7は、
　どんな場合にも左へ移動する必要がない
　もし1と2と6が左へ移動することになったなら自分は右へは移動する必要がない

これは
　自分より左にある、自分より大きい最小の数
　自分より右にある、自分より小きい最大の数

を調べるということ
（N=5000なのでこれを求めるのは二重ループで良い）

その上で
　「0 .. kを左へ、k + 1 .. nを右へソートする場合のコスト」を求める
　（最終的に求めるものは　min(k) x[k]　）

iより左にある、iより大きい最小の数 u[i]
jより右にある、jより小きい最大の数 v[j]
0 .. kを左へ、k + 1 .. nを右へソートする場合のコスト x[k]

x[k] = sum(i; 0 .. k) (u[i] >= k + 1? 0: A) + sum(j; k + 1 .. n) (v[j] < k? 0: B)

*/
