#include <bits/stdc++.h>
using namespace std;
int N, K;
int a[35005], last[35005], pre[35005];
int dp[55][35005], st[4 * 35005], lazy[4 * 35005];
void build(int k, int si, int ss, int se) {
  if (ss == se) {
    st[si] = dp[k][ss];
    return;
  }
  int mid = (ss + se) / 2;
  build(k, 2 * si + 1, ss, mid);
  build(k, 2 * si + 2, mid + 1, se);
}
void lazyprop(int si, int len) {
  if (!lazy[si]) return;
  st[si] += lazy[si];
  if (len > 1) {
    lazy[2 * si + 1] += lazy[si];
    lazy[2 * si + 2] += lazy[si];
  }
  lazy[si] = 0;
  return;
}
void update(int si, int ss, int se, int l, int r) {
  lazyprop(si, se - ss + 1);
  if (ss > se || ss > r || se < l) return;
  if (ss >= l && se <= r) {
    lazy[si]++;
    lazyprop(si, se - ss + 1);
    return;
  }
  int mid = (ss + se) / 2;
  update(2 * si + 1, ss, mid, l, r);
  update(2 * si + 2, mid + 1, se, l, r);
  st[si] = max(st[2 * si + 1], st[2 * si + 2]);
  return;
}
int query(int si, int ss, int se, int r) {
  lazyprop(si, se - ss + 1);
  if (ss > se || ss > r) return 0;
  if (se <= r) return st[si];
  int mid = (ss + se) / 2;
  return max(query(2 * si + 1, ss, mid, r), query(2 * si + 2, mid + 1, se, r));
}
void solve(int k) {
  memset(st, 0, sizeof(st));
  memset(lazy, 0, sizeof(lazy));
  build(k - 1, 0, 0, N - 1);
  dp[k][0] = 1;
  for (int i = 1; i < N; i++) {
    if (pre[i] == -1)
      update(0, 0, N - 1, 0, i - 1);
    else
      update(0, 0, N - 1, pre[i], i - 1);
    dp[k][i] = max(dp[k - 1][i], query(0, 0, N - 1, i - 1));
  }
}
int main() {
  cin >> N >> K;
  int i;
  memset(last, -1, sizeof(last));
  for (i = 0; i < N; i++) {
    cin >> a[i];
    pre[i] = last[a[i]];
    last[a[i]] = i;
  }
  set<int> s;
  for (i = 0; i < N; i++) {
    s.insert(a[i]);
    dp[1][i] = s.size();
  }
  for (i = 2; i <= K; i++) solve(i);
  cout << dp[K][N - 1] << endl;
  return 0;
}
