Untitled

import java.io.*;

public class Main {
    public static int noOfDivaOneRoles = 0;
    public static int noOfDivaTwoRoles = 0;

    public static int d1Index = 0;
    public static int d2Index = 0;

    public static void main(String args[]) throws FileNotFoundException {

        // InputStream is = new FileInputStream("testinput.txt");
        Kattio io = new Kattio(System.in, System.out);
        // Kattio io = new Kattio(is, System.out);
        int actorsUsed = 0; // Antal skådespelare som fått roller

        int n = io.getInt(); // Antal roller i problemet.
        int s = io.getInt(); // Antal scener i problemet.
        int k = io.getInt(); // Antal skådespelare i problemet.

        int rolesActors[][] = new int[n][k + 1];
        int scenesRoles[][] = new int[s][n + 1];
        int divaOneRoles[] = new int[n];
        int divaTwoRoles[] = new int[n];

        int usedActors[] = new int[n];
        int sol[][] = new int[n][n + 2]; // Lösningsarray.

        // Fyll 2d array med alla roller och vilka skådisar som kan spela respektive
        // roll.
        int available = 0;
        for (int i = 0; i < n; i++) {
            available = io.getInt();
            rolesActors[i][0] = available;
            // System.out.print("roleActors[" + i + "][0]: " + rolesActors[i][0] + " ");
            for (int j = 1; j <= available; j++) {
                rolesActors[i][j] = io.getInt();
                // System.out.print("roleActors[" + i + "][" + j + "]: " + rolesActors[i][j] + "
                // ");
                if (rolesActors[i][j] == 1) {
                    divaOneRoles[noOfDivaOneRoles] = i + 1;
                    noOfDivaOneRoles++;
                } else if (rolesActors[i][j] == 2) {
                    divaTwoRoles[noOfDivaTwoRoles] = i + 1;
                    noOfDivaTwoRoles++;
                }
            }
        }
        // Fyll 2d array med alla scener och vilka roller som är i respektive scen.
        for (int i = 0; i < s; i++) {
            available = io.getInt();
            scenesRoles[i][0] = available;
            for (int j = 1; j <= available; j++) {
                scenesRoles[i][j] = io.getInt();
            }
        }

        int d1d2[] = new int[2];

        d1d2 = getDivas(divaOneRoles, divaTwoRoles);

        while (checkDivaScenes(d1d2, scenesRoles)) {
            d1d2 = getDivas(divaOneRoles, divaTwoRoles);
        }
        sol = insertActor(d1d2[0] - 1, 1, 0, sol);
        sol = insertActor(d1d2[1] - 1, 2, 1, sol);
        usedActors[0] = 1;
        usedActors[1] = 2;
        actorsUsed += 2;
        int roleIndex = 2;
        int superActor = k + 1;
        boolean found = false;
        for (int i = 0; i < n; i++) {
            if (d1d2[0] == i + 1 || d1d2[1] == i + 1) {
                continue;
            }
            for (int j = 1; j < rolesActors[i].length; j++) {
                if (!checkTaken(rolesActors[i][j], usedActors)) {
                    usedActors[roleIndex] = rolesActors[i][j];
                    actorsUsed++;
                    found = true;
                    sol = insertActor(i, rolesActors[i][j], roleIndex, sol);
                    break;
                }
            }
            if (!found) {
                usedActors[roleIndex] = superActor;
                sol = insertActor(i, superActor, roleIndex, sol);
                superActor++;
                actorsUsed++;
            }
            roleIndex++;
            found = false;
        }
        // för debugging purposes
        System.out.println(actorsUsed);
        printSol(sol);
        // System.out.println("Diva 1: " + "Roll " + d1d2[0]);
        // System.out.println("Diva 2: " + "Roll " + d1d2[1]);

        io.close();

    }

    private static void printSol(int[][] sol) {
        for (int i = 0; i < sol.length; i++) {
            for (int j = 0; j < sol[i].length; j++) {
                if (sol[i][j] == 0) {
                    break;
                }
                System.out.print(sol[i][j] + " ");
            }
            System.out.println("");
        }
    }

    private static int[][] insertActor(int role, int actor, int roleIndex, int[][] sol) {
        sol[roleIndex][0] = actor;
        sol[roleIndex][1] = 1;
        sol[roleIndex][2] = role + 1;
        return sol;
    }

    private static boolean checkTaken(int actor, int[] usedActors) {
        for (int i = 0; i < usedActors.length; i++) {
            if (usedActors[i] == actor) {
                return true;
            }
        }
        return false;
    }

    private static boolean checkDivaScenes(int[] d1d2, int[][] sr) {
        boolean dOneInScene = false;
        boolean dTwoInScene = false;
        for (int i = 0; i < sr.length; i++) {
            for (int j = 1; j <= sr[i][0]; j++) {
                if (sr[i][j] == d1d2[0]) {
                    dOneInScene = true;
                } else if (sr[i][j] == d1d2[1]) {
                    dTwoInScene = true;
                }
                if (dOneInScene == true && dTwoInScene == true) {
                    return true;
                }
            }
            dOneInScene = dTwoInScene = false;
        }
        return false;
    }

    private static int[] getDivas(int[] d1r, int[] d2r) {
        int[] d1d2 = new int[2];
        for (int i = d1Index; i < noOfDivaOneRoles; i++) {
            for (int j = d2Index; j < noOfDivaTwoRoles; j++) {
                if (d1r[i] != d2r[j]) {
                    d1d2[0] = d1r[i];
                    d1d2[1] = d2r[j];
                    d2Index++;
                    return d1d2;
                }
                d2Index++;
            }
            d1Index++;
        }
        return d1d2;

    }
}