# Appreciation

/*
 * Problem :: 2631 / 줄세우기
 *
 * Kind :: Dynamic Programming
 *
 * Insight
 * - 3 7 5 2 6 1 4 는
 *   + 3 7 4 5 2 6 1 (4번 아이를 7번 아이의 뒤로)
 *     3 4 5 2 6 1 7 (7번 아이를 맨 뒤로)
 *     1 3 4 5 2 6 7 (1번 아이를 맨 앞으로)
 *     1 2 3 4 5 6 7 (2번 아이를 1번 아이의 뒤로)
 *     로도 정렬할 수 있지만
 *   + 1 3 7 5 2 6 4 (1번 아이를 맨 앞으로)
 *     1 2 3 7 5 6 4 (2번 아이를 1번 아이의 뒤로)
 *     1 2 3 4 7 5 6 (4번 아이를 3번 아이의 뒤로)
 *     1 2 3 4 5 6 7 (7번 아이를 6번 아이의 뒤로)
 *     로도 정렬할 수 있다
 *     # 위의 방법은 순서나 바꾸는 위치는 다를지 몰라도
 *       모두 1, 2, 4, 7번 아이의 순서를 바꾸어 주고있다
 *       -> 3 7 5 2 6 1 4 에서
 *          3 5 6 은 증가하는 순서대로 이미 정렬되어있다고 생각하면
 *          1 2 4 7 은 그렇지 않기 때문이다
 *
 * - 물론 3 7 5 2 6 1 4 에서
 *   1 4 를 증가하는 순서대로 이미 정렬되어있다고 생각하면
 *   2 3 5 6 7 은 그렇지 않기 때문에 이 아이들의 위치를 바꾸어 주어야 한다
 *   + 문제에서는 가장 적은 수의 아이를 옮기는 것이므로
 *     가장 긴 증가하는 부분 수열의 길이를 찾아야 한다
 *     # 그 길이를 전체 아이의 수에서 뺀 것이 바로 답이다
 *
 * Point
 * - dp[N-1] 에 증가하는 가장 긴 부분수열의 값이 들어있지 않을 수도 있다
 *   + 2 3 4 5 1 의 경우
 *     dp[0] = 1
 *     dp[1] = 2
 *     dp[2] = 3
 *     dp[3] = 4
 *     dp[4] = 1
 *     이므로, 결국 dp 중 가장 큰 값을 찾아야 한다
 */

# Code

//
//  BOJ
//  ver.C++
//
//  Created by GGlifer
//
//  Open Source

#include <iostream>
#include <algorithm>

using namespace std;

#define endl '\n'

// Set up : Global Variables
/* None */

// Set up : Functions Declaration
/* None */


int main()
{
    // Set up : I/O
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    // Set up : Input
    int N; cin >> N;
    int A[N];
    for (int i=0; i<N; i++)
        cin >> A[i];

    // Process
    int dp[N]; /* dp[i] = 0 부터 시작하는 i 번째 숫자로 끝나는 수열 중
                *         증가하는 가장 긴 부분수열의 길이 */
    fill_n(dp, N, 1); /* 초기화 */
    for (int i=2; i<=N; i++) {
        for (int j=1; j<i; j++) {
            /* i 번째 숫자가 j 번째 숫자보다 크다면 */
            if (A[i] > A[j]) {
                /* dp[i] 는 dp[j]+1 이 가능, 이 중 가장 큰 값을 찾음 */
                dp[i] = max(dp[i], dp[j]+1);
            }
        }
    }

    // Control : Output
    cout << N - *max_element(dp, dp+N) << endl;
}

// Helper Functions
/* None */