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 <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int inf = (1 << 30) - 1;

const int N = 4e4 + 5;

int a[N];

const int K = 105;

struct Tree {
	Tree *ls, *rs;
	int minn, lazy;
	
	Tree() {
		minn = 0, lazy = 0;
	}
	
	void update(int k) {
		minn += k;
		lazy += k;
	}
	
	void merge(Tree t1, Tree t2) {
		minn = min(t1.minn, t2.minn);
	}
} seg[(N * K) << 1];
int tot;

void build(Tree *t, int l, int r) {
	if (l == r) {
		return;
	}
	int mid = (l + r) >> 1;
	t->ls = &seg[++tot];
	t->rs = &seg[++tot];
	build(t->ls, l, mid);
	build(t->rs, mid + 1, r);
}

void pushdown(Tree *t) {
	t->ls->update(t->lazy);
	t->rs->update(t->lazy);
	t->lazy = 0;
}

void change(Tree *t, int l, int r, int x, int y, int k) {
//	printf("c %d %d %d %d %d\n", l, r, x, y, k);
	if (x <= l && r <= y) {
		t->update(k);
		return;
	}
	int mid = (l + r) >> 1;
	pushdown(t);
	if (x <= mid) {
		change(t->ls, l, mid, x, y, k);
	}
	if (mid < y) {
		change(t->rs, mid + 1, r, x, y, k);
	}
	t->merge(*t->ls, *t->rs);
}

Tree query(Tree *t, int l, int r, int x, int y) {
//	printf("q %d %d %d %d\n", l, r, x, y);
	if (x <= l && r <= y) {
		return *t;
	}
	int mid = (l + r) >> 1;
	pushdown(t);
	Tree ans;
	ans.minn = inf;
	if (x <= mid) {
		ans.merge(ans, query(t->ls, l, mid, x, y));
	}
	if (mid < y) {
		ans.merge(query(t->rs, mid + 1, r, x, y), ans);
	}
//	printf("a %d %d %d %d %d\n", l, r, x, y, ans.minn);
	return ans;
}

int dp[N][K];

int last[N];

int main() {
	int n, k;
	scanf("%d%d", &n, &k);
	for (int i = 1; i <= n; ++i) {
		scanf("%d", &a[i]);
	}
	tot = k;
	memset(dp, 0x3f, sizeof dp);
	for (int j = 1; j <= k; ++j) {
		build(&seg[j], 1, n);
//		dp[0]
	}
	dp[0][0] = 0;
//	printf("i");
	for (int i = 1; i <= n; ++i) {
//		printf("%d ", last[a[i]]);
//		printf("%d\n", i);
		for (int j = 1; j <= min(i, k); ++j) {
//			printf("C %d %d %d %d\n", j, i, i, dp[i - 1][j - 1]);
//			printf("%d ", j);
			change(&seg[j], 1, n, i, i, dp[i - 1][j - 1]);
//	printf("p");
			if (last[a[i]]) {
//				printf("C %d %d %d %d\n", j, 1, last[a[i]], i - last[a[i]]);
				change(&seg[j], 1, n, 1, last[a[i]], i - last[a[i]]);
			}
//			printf("Q %d %d %d\n", j, 1, i);
//	printf("t");
			dp[i][j] = query(&seg[j], 1, n, 1, i).minn;
//			printf("%d ", dp[i][j]);
		}
//		printf("\n");
		last[a[i]] = i;
	}
	int minn = inf;
	for (int j = 1; j <= k; ++j) {
		minn = min(minn, dp[n][j]);
	}
	printf("%d", minn);
//	printf("\n%d", dp[0][1]);
}