Problem: You are given an array a of n integers. Define the cost of some array t as follows:

$$$cost(t) = ∑_{x ∈ set(t) } last(x) - first(x),$$$ 

where set(t) is the set of all values in t without repetitions, first(x), and last(x) are the indices of the first and last occurrence of x in t, respectively. In other words, we compute the distance between the first and last occurrences for each distinct element and sum them up.

You need to split the array a into k consecutive segments such that each element of a belongs to exactly one segment and the sum of the cost of individual segments is minimum.

Input

The first line contains two integers n, k (1 ≤ n ≤ 35 000, 1 ≤ k ≤ min(n,100)).

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ n).

Output

Output the minimum sum of the cost of individual segments.

Examples

Input


7 2
1 6 6 4 6 6 6


Output


3


Input


7 4
5 5 5 5 2 3 3


Output


1

Note

In the first example, we can divide the array into [1,6,6,4] and [6,6,6]. Cost of [1,6,6,4] will be (1-1) + (3 - 2) + (4-4) = 1 and cost of [6,6,6] will be 3-1 = 2. Total cost would be 1 + 2 = 3.

In the second example, divide the array into [5,5],[5],[5,2,3] and [3]. Total Cost would be 1 + 0 + 0 + 0 = 1.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#define endl '\n'

typedef long long ll;

const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3f;

const int MAX = 3.5e4 + 10;

struct Seg {
	ll seg[4*MAX], lazy[4*MAX];
	int n, *v;
	Seg () {}
	ll build(int p, int l, int r) {
		lazy[p] = 0;
		if (l == r) return seg[p] = v[l];
		int m = (l+r)/2;
		return seg[p] = min(build(2*p, l, m), build(2*p+1, m+1, r));
	}
	void build(int n2, int* v2) {
		n = n2, v = v2;
		build(1, 0, n-1);
	}
	void prop(int p, int l, int r) {
		seg[p] += lazy[p];
		if (l != r) lazy[2*p] += lazy[p], lazy[2*p+1] += lazy[p];
		lazy[p] = 0;
	}
	ll query(int a, int b, int p, int l, int r) {
		prop(p, l, r);
		if (a <= l and r <= b) return seg[p];
		if (b < l or r < a) return INF;
		int m = (l+r)/2;
		return min(query(a, b, 2*p, l, m), query(a, b, 2*p+1, m+1, r));
	}
	ll update(int a, int b, int x, int p, int l, int r) {
		prop(p, l, r);
		if (a <= l and r <= b) {
			lazy[p] += x;
			prop(p, l, r);
			return seg[p];
		}
		if (b < l or r < a) return seg[p];
		int m = (l+r)/2;
		return seg[p] = min(update(a, b, x, 2*p, l, m),
			update(a, b, x, 2*p+1, m+1, r));
	}
};

Seg S[105];
int dp[105][MAX];


int main(){ _
	int n, k; cin >> n >> k;
	
	vector<int> v(n), nxt(n), last(n, -1), first(n, -1);
	for (auto &i : v) cin >> i, i--;
	
	for (int i=n-1; i+1; i--) {
		if (last[v[i]] != -1) nxt[i] = last[v[i]];
		else nxt[i] = i;
		//if (fist[v[i]] == -1) first[v[i]] = i;
		last[v[i]] = i;
	//	cout << i << " " << nxt[i] << endl;
	}
	
	for (int i=0; i<k; i++) S[i].build(n+1, dp[i]);
	for (int i = n-1; i+1; i--) {
		dp[1][i] = dp[1][i+1] + (nxt[i]-i);
		S[1].update(i, i, dp[1][i], 1, 0, n);
	}
	//for (int i=0; i<n; i++) cout << S[1].query(i, i, 1, 0, n-1) << " ";
	//cout << endl;
	
	for (int i=n-2; i+1; i--) {
		//cout << i << " nxt " << nxt[i] << endl;
		for (int j = 2; j<=k; j++) {
			S[j-1].update(nxt[i]+1, n, nxt[i]-i, 1, 0, n);
			dp[j][i] = S[j-1].query(i+1, n, 1, 0, n);
			S[j].update(i, i, dp[j][i], 1, 0, n);
		//	cout << dp[j][i] << " ";
		}
		//cout << endl;
	}
	
	//for (int i=0; i<n; i++) cout << S[1].query(i, i, 1, 0, n-1) << " ";
	//cout << endl;
	cout << dp[k][0] << endl;

	
	exit(0);
}