/*
 * _|_|_|_|_|  _|_|_|_|    _|_|_|  _|_|_|_|_|  _|_|_|      _|_|   
 *       _|    _|        _|                _|        _|  _|    _| 
 *     _|      _|_|_|      _|_|          _|      _|_|        _|   
 *   _|        _|              _|      _|            _|    _|     
 * _|_|_|_|_|  _|        _|_|_|      _|        _|_|_|    _|_|_|_| 
 */

#include <bits/stdc++.h>

constexpr int INF = 1E7;

namespace Solution {
  int Solve(int K, const std::vector<int> &arr) {
    for (auto v: arr) { std::cerr << v << ' '; }
    std::cerr << '\n';

    int N = (int) arr.size(), ans = 0;
    std::vector dp(K + 1, std::vector(N, -INF));
    std::vector pre(K + 1, std::vector(N, -INF));
    std::vector suf(K + 1, std::vector(N, -INF));
    std::vector smx(K + 1, std::vector(N, -INF));

    dp[0][0] = 0;
    std::stack<int> sta;
    sta.emplace(0);

    for (int i = 1; i < N; i++) {
      for (int j = 1; j <= K; j++) {
        smx[j][i] = dp[j - 1][i - 1] + 1;
        pre[j][i] = dp[j - 1][i - 1] + 1;
        suf[j][i] = dp[j - 1][i - 1] + 1;
      }

      while (!sta.empty() && arr[i] > arr[sta.top()]) {
        int p = sta.top();
        for (int j = 1; j <= K; j++) {
          smx[j][i] = std::max(smx[j][i], smx[j][p]);
          pre[j][i] = std::max(pre[j][i], pre[j][p] + 1);
        }
        sta.pop();
      }

      int p = sta.top();
      for (int j = 1; j <= K; j++) {
        suf[j][i] = std::max(suf[j][i], suf[j][p] + 1);
        pre[j][i] = std::max(pre[j][i], pre[j][p]);
      }
      sta.emplace(i);

      for (int j = 1; j <= K; j++) {
        dp[j][i] = std::max({smx[j][i], suf[j][i], pre[j][i]});
      }
    }

    for (int i = 1; i <= N; i++) { ans = std::max(ans, dp[K][i]); }
    return ans;
  }
}// namespace Solution

int main() {
#ifdef LOCAL
  freopen("task.in", "r", stdin);
  freopen("task.out", "w", stdout);
  freopen("task.err", "w", stderr);
#endif
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);

  int N, K, pos = -1;
  std::cin >> N >> K;
  std::vector<int> arr(N), tmp(N);

  for (int i = 0; i < N; i++) {
    std::cin >> arr[i];
    if (arr[i] == N) { pos = i; }
  }

  for (int i = 0; i < N; i++) { tmp[i] = arr[(i + pos) % N]; }

  int ans = Solution::Solve(K, tmp);
  std::reverse(tmp.begin() + 1, tmp.end());
  ans = std::max(ans, Solution::Solve(K, tmp));
  std::cout << ans + 1 << '\n';

  return 0;
}