import java.io.*;
import java.util.*;

/**
 * LIS - DFS
 */
public class Main {
    static int N;
    static int[] arr;
    static LinkedList<Integer> answer = new LinkedList<>(); // 마지막 원소를 O(1)로 확인하기 위해 LinkedList로 할당

    public static void main(String[] args) throws IOException {
        setting(); // 입력 세팅

        LinkedList<Integer> sequence = new LinkedList<>(); // 부분 수열을 담기 위한 연결 리스트 생성

        dfs(0, sequence); // 모든 경우의 수를 찾기 위해 DFS 수행

        // 결과 출력
        StringBuilder sb = new StringBuilder();
        sb.append(answer.size()).append("\n");

        for (Integer elem : answer) {
            sb.append(elem).append(" ");
        }

        System.out.println(sb);
    }

    private static void dfs(int index, LinkedList<Integer> seq) {
        if (index >= N) { // 모든 인덱스를 순회했다면
            if (answer.size() < seq.size()) { // 현재 정답 후보보다 더 큰 부분수열을 찾았다면
                answer = new LinkedList<>(seq); // 깊은 복사로 새로운 정답 후보로 교체
            }
            return;
        }

        // 만약 수열이 비어있거나 가장 마지막 원소보다 큰 값이 arr[index]라면
        if (seq.isEmpty() || arr[index] > seq.getLast()) {
            seq.add(arr[index]); // 수열에 추가하고
            dfs(index + 1, seq); // 다음 index에 dfs 적용
            seq.removeLast(); // 수열에서 다시 빼기
        }

        dfs(index + 1, seq); // 현재 원소 건너뛰기
    }

    private static void setting() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
    }
}

import java.io.*;
import java.util.*;

/**
 * LIS - DP로 풀기
 */
public class Main {
    static int N;
    static int[] arr;

    public static void main(String[] args) throws IOException {
        setting(); // 입력 세팅

        List<Integer> sequence = solve();

        // 결과 출력
        StringBuilder sb = new StringBuilder();
        sb.append(sequence.size()).append("\n");

        for (Integer elem : sequence) {
            sb.append(elem).append(" ");
        }

        System.out.println(sb);
    }

    private static List<Integer> solve() {
        int[] dp = new int[N]; // 더 큰 길이를 저장하기 위한 dp 배열
        int[] prev = new int[N]; // LIS에 속하는 원소를 추적하기 위한 prev 배열
        Arrays.fill(dp, 1); // 초기 길이 1로 초기화
        Arrays.fill(prev, -1); // 이전 인덱스가 없음을 확인하기 위해 -1로 초기화

        int maxLength = 0; // 가장 긴 배열의 길이 저장
        int maxIdx = -1; // 가장 긴 배열의 마지막 인덱스 저장. 추후 원소들을 추적할 때 사용

        // 0 ~ N - 1까지의 원소를 범위를 넓혀가며 순회하는데
        for (int i = 0; i < N; i++) {
            // i 이전의 원소들 중에서
            for (int j = 0; j < i; j++) {
                // j 원소보다 i원소가 크고, j 원소를 마지막으로 하는 수열의 길이에 i 원소를 추가하는 방법이 더 길면
                if (arr[j] < arr[i] && dp[j] + 1 > dp[i]) {
                    dp[i] = dp[j] + 1; // arr[i]를 마지막 원소로 하는 LIS의 길이 업데이트
                    prev[i] = j; // 배열을 추적하기 위해 직전 원소의 인덱스를 저장
                }
            }
            // i까지의 길이가 가장 길면
            if (dp[i] > maxLength) {
                maxLength = dp[i];
                maxIdx = i; // 마지막 인덱스를 maxIdx로 업데이트
            }
        }

        // 배열을 추적해 복원하기 위한 과정
        List<Integer> seq = new ArrayList<>();

        // maxIdx가 -1 즉 다음 인덱스가 없을 때까지 iterating
        while (maxIdx != -1) {
            seq.add(arr[maxIdx]); // 리스트에 추가
            maxIdx = prev[maxIdx];
        }

        Collections.reverse(seq); // 리스트에 역순으로 저장되어 있음
        return seq;
    }

    private static void setting() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
    }
}

import java.io.*;
import java.util.*;

/**
 * LIS - DP + 이분탐색으로 풀기
 */
public class Main {
    static int N;
    static int[] arr;

    public static void main(String[] args) throws IOException {
        setting(); // 입력 세팅

        List<Integer> sequence = solve();

        // 결과 출력
        StringBuilder sb = new StringBuilder();
        sb.append(sequence.size()).append("\n");

        for (Integer elem : sequence) {
            sb.append(elem).append(" ");
        }

        System.out.println(sb);
    }

    private static List<Integer> solve() {
        List<Integer> LIS = new ArrayList<>(); // LIS 배열 초기화

        // 원소들을 순회하면서
        for (int num : arr) {
            int idx = Collections.binarySearch(LIS, num); // 배열 안에 원소가 들어갈 위치를 찾기 위해 이분탐색
            if (idx < 0) idx = -(idx + 1); // lower_bound 위치 찾기

            if (idx == LIS.size()) LIS.add(num); // idx가 배열의 인덱스보다 더 큰 인덱스를 가리키면 배열에 추가
            else LIS.set(idx, num); // 아니면 배열 안에 해당 요소를 업데이트
        }

        return LIS;
    }

    private static void setting() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
    }
}

import java.io.*;
import java.util.*;

/**
 * LIS - DP + 이분탐색으로 풀기2
 */
public class Main {
    static int N;
    static int[] arr;

    public static void main(String[] args) throws IOException {
        setting(); // 입력 세팅

        List<Integer> sequence = solve();

        // 결과 출력
        StringBuilder sb = new StringBuilder();
        sb.append(sequence.size()).append("\n");

        for (Integer elem : sequence) {
            sb.append(elem).append(" ");
        }

        System.out.println(sb);
    }

    private static List<Integer> solve() {
        List<Integer> LIS = new ArrayList<>(); // LIS 리스트 초기화
        int[] prev = new int[N]; // LIS에 속하는 원소를 추적하기 위한 prev 배열
        List<Integer> indexList = new ArrayList<>(); // LIS 리스트에 속한 원소의 실제 arr에서의 인덱스 저장
        Arrays.fill(prev, -1); // 이전 인덱스가 없음을 확인하기 위해 -1로 초기화

        // 원소들을 순회하면서
        for (int i = 0; i < N; i++) {
            int idx = Collections.binarySearch(LIS, arr[i]); // 배열 안에 원소가 들어갈 위치를 찾기 위해 이분탐색
            if (idx < 0) idx = -(idx + 1); // lower_bound 위치 찾기

            if (idx == LIS.size()) { // idx가 배열의 인덱스보다 더 큰 인덱스를 가리키면 어느 값보다도 큰 값이란 뜻
                LIS.add(arr[i]); // 배열에 추가
                indexList.add(i); // indexList에도 동일한 위치에 i도 저장
            }
            else { // 아니면
                LIS.set(idx, arr[i]); // 배열 안에 해당 원소를 업데이트
                indexList.set(idx, i); // indexList에도 동일한 위치에 i로 업데이트
            }
            // LIS 리스트에 첫번째로 추가된 값을 제외하고
            if (idx > 0) prev[i] = indexList.get(idx - 1); // LIS배열에 idx - 1에 저장되어 있는 인덱스 저장 
        }

        // LIS 원소 역추적
        List<Integer> lisSequence = new ArrayList<>();
        int lastIdx = indexList.get(indexList.size() - 1); // LIS에 저장된 마지막 인덱스 가져오기
        while (lastIdx != -1) { // 가장 처음으로 돌아갈 때까지
            lisSequence.add(arr[lastIdx]);
            lastIdx = prev[lastIdx]; // 이전 인덱스로 업데이트
        }
        Collections.reverse(lisSequence); // 마지막부터 거꾸로 삽입했으므로 다시 바꾸기

        return lisSequence;
    }

    private static void setting() throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }
    }
}