Neste exercício devemos receber vários inputs diferentes.
O exercício é bem complexo de ser compreendido (precisei de ajuda pra entender o enunciado) e vou tentar explicar da melhor forma possível. Para isso, vou dividir o exercício em duas partes:

=========

Parte I

• Recebemos um int n. Este int delimita a quantidade de Arrays que teremos na lista.
• Recebemos um int d. Este int delimita a quantidade de elementos dentro do array.

Exemplo (n = 2 | d = 3, 4):

2
3 11 22 33
4 54 12 3 12

Logo, todos os primeiros números estão, na verdade, ordenando a quantidade de listas ou a quantidade de elementos da lista.

Para resolver essa primeira parte do problema segui o seguinte passo a passo:

• Fiz o Scanner
• Peguei o int n a partir desse Scanner
• Criei um ArrayList[] nArray = new ArrayList[n] (n significa que o número de arrays obedecerá o input n
• Fiz um for que pega, através do scanner.nextInt() cada novo Array através de d.
• Dentro do for, fiz outro for declarando um int j que fará a substituição de cada posição [i] dos arrays.

Ficou mais ou menos assim:

        Scanner scanner = new Scanner(new File("input.txt"));
        int n = scanner.nextInt();
        int d;

        ArrayList[] nArray = new ArrayList[n]; // n é a quantidade de arrays

            for (int i = 0; i < n; i++) {
                d = scanner.nextInt();
                nArray[i] = new ArrayList();
                for (int j = 0; j < d; j++){
                    nArray[i].add(scanner.nextInt());
            }
        }

Perceba que o primeiro for percorre o tamanho de n enquanto que o segundo for percorre o tamanho de d. Isso significa que só fazemos o segundo array depois que passamos por todos os elementos dele e assim até que o número de arrays seja menor < do que n

=========

Parte II

Agora vem a segunda parte do problema. Aqui recebemos outro int chamado q e é ele que delimita a quantidade de linhas (chamadas) que vamos ter.
Aqui, escolhemos dois números, x e y. x especifica o número da linha e y especifica o número da coluna. Isso quer dizer que vamos "pegar" um elemento de cada array que declaramos anteriormente através de x e y.
A ilustração do problema pode ser mais clara:

Aqui a ilustração que fiz para entender melhor os ints n, d e q.

Para resolver a segunda parte, fiz o seguinte passo a passo:

• Declarei o int q = scanner.nextInt()
• Declarei também x e y, sem inicializá-los. > É importante declará-los fora do for que vamos fazer, porque usaremos mesmo quando a iteração acabar.
• O for consiste em iterar a letra h até que o tamanho seja menor < do que q e escanear x e y. Assim:

            int q = scanner.nextInt();
            int x;
            int y;

            for (int h = 0; h < q; h++){
                x = scanner.nextInt();
                y = scanner.nextInt();

Por fim, para que o console devolva a mensagem ERROR! caso x e y não convirjam, é necessário fazer um try / catch. Nesse caso, como os Arrays começam na posição 0 (e não levamos isso em consideração para declarar as posições em x e y), precisamos especificar no try que a posição que queremos é, na verdade, x - 1 e y - 1.
No catch declaramos que a Exception e gera um System.out.println("ERROR!");.

O código final fica assim:

public class Solution {
    public static void main(String[] args) throws Exception {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int d;

        ArrayList[] nArray = new ArrayList[n];

            for (int i = 0; i < n; i++) {
                d = scanner.nextInt();
                nArray[i] = new ArrayList();
                for (int j = 0; j < d; j++){
                    nArray[i].add(scanner.nextInt());
            }
        }
            int q = scanner.nextInt();
            int x;
            int y;

            for (int h = 0; h < q; h++){
                x = scanner.nextInt();
                y = scanner.nextInt();
                try{
                    System.out.println(nArray[x-1].get(y-1));
                } catch(Exception e){
                    System.out.println("ERROR!");
                }
            }

        scanner.close();
    }
}

=========

Referências

ArrayList : Oracle

============

Essa publicação faz parte de uma série de exercícios resolvidos em Java no HackerRank. Acesse a série completa:

• HackerRank #6 | Scanner e End-of-file
• HackerRank #7 | Int to String / String to Int
• HackerRank #8 | Date and Time
• HackerRank #9 | Static Initializer Block
• HackerRank #10 | Currency Formatter
• HackerRank #11 | DataTypes
• HackerRank #12 | Strings Introduction
• HackerRank #13 | Substring Comparisons
• HackerRank #14 | Abstract Class
• HackerRank #18 | BigInteger
• HackerRank #19 | Loops II
• HackerRank #20 | String Reverse
• HackerRank #23 | Instanceof keyword
• HackerRank #26 | Generics
• HackerRank #27 | 1D Array
• HackerRank #28 | Anagrams
• HackerRank #33 | Arraylist
• HackerRank #34 | Exception Handling Try / Catch
• HackerRank #36 | Exception Handling
• HackerRank #37 | List
• HackerRank #38 | SubArray
• HackerRank #39 | HashSet
• HackerRank #40 | Java Dequeue