Ukg || customer experience intern ✓

import java.util.*;

public class RasikhBox {
    static void gravity(char[][] g) {
        int r = g.length, c = g[0].length;
        for (int col = 0; col < c; col++) {
            int cnt = 0;
            for (int row = 0; row < r; row++)
                if (g[row][col] == '*') cnt++;
            for (int row = 0; row < r - cnt; row++) g[row][col] = '.';
            for (int row = r - cnt; row < r; row++) g[row][col] = '*';
        }
    }

    static char[][] rightR(char[][] g) {
        int r = g.length, c = g[0].length;
        char[][] res = new char[c][r];
        for (int i = 0; i < c; i++)
            for (int j = 0; j < r; j++)
                res[i][j] = g[r - 1 - j][i];
        return res;
    }

    static char[][] leftR(char[][] g) {
        int r = g.length, c = g[0].length;
        char[][] res = new char[c][r];
        for (int i = 0; i < c; i++)
            for (int j = 0; j < r; j++)
                res[i][j] = g[j][c - 1 - i];
        return res;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(), n = sc.nextInt();
        char[][] box = new char[m][n];
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                box[i][j] = sc.next().charAt(0);
        int k = sc.nextInt();
        String[] ops = new String[k];
        for (int i = 0; i < k; i++) ops[i] = sc.next();
        gravity(box);
        for (String op : ops) {
            if (op.equals("right")) box = rightR(box);
            else box = leftR(box);
            gravity(box);
        }
        int R = box.length, C = box[0].length;
        for (int i = 0; i < R; i++) {
            for (int j = 0; j < C; j++) {
                System.out.print(box[i][j]);
                if (j + 1 < C) System.out.print(" ");
            }
            if (i + 1 < R) System.out.println();
        }
        sc.close();
    }
}

import bisect

def lis_length(v):
    d = []
    for x in v:
        pos = bisect.bisect_left(d, x)
        if pos == len(d):
            d.append(x)
        else:
            d[pos] = x
    return len(d)

def main():
    n = int(input().strip())
    s = input().strip().split()
    s = [c[0] for c in s]
    fixed_parts = list(map(int, input().strip().split()))
    fixed_pos = [p - 1 for p in fixed_parts]

    orders = [
        ['A', 'B', 'C'], ['A', 'C', 'B'],
        ['B', 'A', 'C'], ['B', 'C', 'A'],
        ['C', 'A', 'B'], ['C', 'B', 'A']
    ]

    cntA, cntB, cntC = s.count('A'), s.count('B'), s.count('C')
    best = float('inf')
    found = False

    for ord_ in orders:
        size0 = cntA if ord_[0] == 'A' else cntB if ord_[0] == 'B' else cntC
        size1 = cntA if ord_[1] == 'A' else cntB if ord_[1] == 'B' else cntC
        s0, s1, s2 = 0, size0, size0 + size1

        T = [None] * n
        for i in range(s0, s1): T[i] = ord_[0]
        for i in range(s1, s2): T[i] = ord_[1]
        for i in range(s2, n): T[i] = ord_[2]

        ok = True
        for p in fixed_pos:
            if p < 0 or p >= n or s[p] != T[p]:
                ok = False
                break
        if not ok:
            continue

        slots = {'A': [], 'B': [], 'C': []}
        for i, c in enumerate(T):
            slots[c].append(i)

        ia = ib = ic = 0
        mapped = []

        for c in s:
            if c == 'A':
                if ia >= len(slots['A']): ok = False; break
                mapped.append(slots['A'][ia]); ia += 1
            elif c == 'B':
                if ib >= len(slots['B']): ok = False; break
                mapped.append(slots['B'][ib]); ib += 1
            elif c == 'C':
                if ic >= len(slots['C']): ok = False; break
                mapped.append(slots['C'][ic]); ic += 1
        if not ok:
            continue

        keep = lis_length(mapped)
        shifts = n - keep
        best = min(best, shifts)
        found = True

    if not found:
        print("Impossible", end="")
    else:
        print(best, end="")

main()