Taulukko

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 *
 * @author DevBonBon
 */
public class Datatahti_taulukko {

    public static class SetFinder implements Runnable {

        private final int[] ints;
        private final int startIndex;
        private final int endIndex;
        private final int maxDifferent;
        //
        private final AtomicInteger result;
        private final AtomicBoolean done;

        public SetFinder(int[] ints, int startIndex, int endIndex, int maxDifferent) {
            this.ints = ints;
            this.startIndex = startIndex;
            this.endIndex = endIndex;
            this.maxDifferent = maxDifferent;

            this.result = new AtomicInteger(0);
            this.done = new AtomicBoolean(false);
        }

        public int getResult() {
            return this.result.get();
        }

        public boolean isDone() {
            return this.done.get();
        }

        @Override
        public void run() {
            //This still needs some tweaking, but it's 3AM, so no
            for (int i = startIndex; i < endIndex; i++) {
                for (int j = i; j < ints.length; j++) {
                    if (!tooManyDifferent(Arrays.copyOfRange(ints, i, j + 1), maxDifferent)) {
                        this.result.incrementAndGet();
                    } else {
                        break;
                    }
                }
            }

            this.done.lazySet(true);
        }

        public static final boolean tooManyDifferent(int[] ints, int maxDifferent) {
            Set<Integer> set = new HashSet<>();
            for (int i : ints) {
                set.add(i);
                if (set.size() > maxDifferent) {
                    return true;
                }
            }
            return false;
        }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //I read that split is actually "slow" (only hundreds of milliseconds slower, when iterating
        //hundreds of thousands of times) so lets try something different
        //First inputline
        String fl = input.nextLine();
        //Get the size of the table and max different ints in any subset
        int size = Integer.parseInt(fl.substring(0, fl.indexOf(" ", 1)));
        int maxDifferent = Integer.parseInt(fl.substring(fl.indexOf(" ", 1) + 1, fl.length()));
        //NOTE: Came up with something better
        String tableString = input.nextLine();

        //Convert tableString into an int array
        int pow[] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
        int[] tableInts = new int[size];
        int length = tableString.length();
        int index = length - 1;
        int spot = tableInts.length - 1;
        int number = 0;
        //Iterates through all characters from the back and adds them together
        while (index >= 0) {
            char c = tableString.charAt(index);
            if (c != ' ') {
                switch (c) {
                    case '0':
                        break;
                    default:
                        number += (c - '0') * pow[length - index - 1];
                        break;
                }
            } else {
                tableInts[spot] = number;
                number = 0;
                //Get ready for next iteration
                length = index;
                spot--;
            }
            index--;
        }
        //Also get the last number
        tableInts[spot] = number;

        //So let's be greedy, who needs efficiency anyway...
        //I've got some ideas, but I'm currious to see how this goes
        //NOTE: it's pretty stupid that this actually works
        long result = 0;
        //The amount of threads we want to create, with a pinch of magic numbers
        int threads;
        if (size <= 50) {
            threads = 1;
        } else {
            threads = 6;
        }

        SetFinder finders[] = new SetFinder[threads];
        boolean findersDone[] = new boolean[threads];
        //Create and start the threads
//        finders[0] = new SetFinder(tableInts, 0, (size / threads), maxDifferent);
//        finders[1] = new SetFinder(tableInts, (size / threads), 2 * (size / threads), maxDifferent);
//        finders[2] = new SetFinder(tableInts, 2 * (size / threads), 3 * (size / threads), maxDifferent);
//        finders[3] = new SetFinder(tableInts, 3 * (size / threads), size, maxDifferent);

        for (int i = 0; i < threads; i++) {
            finders[i] = new SetFinder(tableInts, i * (size / threads), (i + 1) * (size / threads), maxDifferent);
            finders[i].run();

            findersDone[i] = false;
        }
        //Check all threads and get their results
        int allDone = 0;
        while (allDone < threads) {
            for (int i = 0; i < threads; i++) {
                if (!findersDone[i] && finders[i].isDone()) {
                    findersDone[i] = true;
                    result += finders[i].getResult();
                    allDone++;
                }
            }
        }

        //Aaaaaand output it
        System.out.println(result);
    }
}

Test 1

Group: 1

Verdict: WRONG ANSWER

Test 2

Group: 1

Verdict: WRONG ANSWER

Test 3

Group: 1

Verdict: WRONG ANSWER

Test 4

Group: 1

Verdict: WRONG ANSWER

Test 5

Group: 1

Verdict: WRONG ANSWER

Test 6

Group: 1

Verdict: WRONG ANSWER

Test 7

Group: 1

Verdict: WRONG ANSWER

Test 8

Group: 1

Verdict: WRONG ANSWER

Test 9

Group: 1

Verdict: WRONG ANSWER

Test 10

Group: 1

Verdict: WRONG ANSWER

Test 11

Group: 1

Verdict: WRONG ANSWER

Test 12

Group: 1

Verdict: WRONG ANSWER

Test 13

Group: 1

Verdict: WRONG ANSWER

Test 14

Group: 1

Verdict: WRONG ANSWER

Test 15

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 2

Verdict: WRONG ANSWER

Test 17

Group: 2

Verdict: WRONG ANSWER

Test 18

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: WRONG ANSWER

Test 21

Group: 2

Verdict: WRONG ANSWER

Test 22

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 23

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 24

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 25

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 26

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 27

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 28

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 29

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 30

Group: 3

Verdict: WRONG ANSWER

Test 31

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 32

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 33

Group: 3

Verdict: WRONG ANSWER

Test 34

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 35

Group: 3

Verdict: WRONG ANSWER

Test 36

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 37

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 38

Group: 4

Verdict: WRONG ANSWER

Test 39

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 40

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 41

Group: 4

Verdict: WRONG ANSWER

Test 42

Group: 4

Verdict: WRONG ANSWER

Test 43

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 44

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 45

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 46

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 47

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 48

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 49

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 50

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 51

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 52

Group: 4

Verdict: TIME LIMIT EXCEEDED