Taulukko

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Scanner;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

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

    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() {
            for (int i = startIndex; i < endIndex; i++) {
                //Every i spot is a new number
                this.result.incrementAndGet();
                for (int j = i + 1; j < ints.length; j++) {
                    if (!tooManyDifferent(Arrays.copyOfRange(ints, i, j + 1), maxDifferent)) {
                        this.result.incrementAndGet();
                    } else {
                        //No need to continue checking, as there can't be longer sublists
                        break;
                    }
                }
            }

            this.done.lazySet(true);
        }
        private static final BitSet intsSeen = new BitSet(1000000000);
        public static final boolean tooManyDifferent(int[] ints, int maxDifferent) {
            //This is propably faster than any homebrewn solution I could make[/STRIKE] dare me
//            int count[] = {0};
//            Arrays.stream(ints).parallel().distinct().limit(maxDifferent + 1).forEach(t -> count[0]++);
//            return count[0] > maxDifferent;
            //welp, this is slightly slower, because of the stupid size the underlying set gets
            intsSeen.clear();
            for (int i : ints) {
                intsSeen.set(i);
                if (intsSeen.cardinality() > maxDifferent) {
                    return true;
                }
            }
            return false;
//            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
     * @throws java.io.IOException
     */
    public static void main(String[] args) throws IOException {
//        Scanner input = new Scanner(System.in);
        BufferedReader input = new BufferedReader(new InputStreamReader(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.readLine();
        //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.readLine();

        //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: could move the creation and such inside the string conversion above
        long result = 0;
        //The amount of threads we want to create and the size of the chunks we're dividing the array into
        int threads;
        //I figured this is more readable than nested if's
        switch (size) {
            case 1:
            case 2:
            case 3:
                threads = 1;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
                threads = 4;
                break;
            default:
                threads = 8;
                break;
        }
        int chunkSize = ((size - 1) + threads - 1) / threads; // divide by threads rounded up.

        SetFinder finders[] = new SetFinder[threads];
        boolean findersDone[] = new boolean[threads];

        for (int i = 0; i < threads; i++) {
            int start = i * chunkSize;
            int end = Math.min(start + chunkSize, size - 1);
            //Create and start the threads and mark their task as incomplete
            finders[i] = new SetFinder(tableInts, start, end, 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++;
                }
            }
        }

        //The logic above always skips the veeeeery last digit, so we add it here
        System.out.println(result + 1);
    }
}

Test 1

Group: 1

Verdict: ACCEPTED

Test 2

Group: 1

Verdict: ACCEPTED

Test 3

Group: 1

Verdict: ACCEPTED

Test 4

Group: 1

Verdict: ACCEPTED

Test 5

Group: 1

Verdict: ACCEPTED

Test 6

Group: 1

Verdict: ACCEPTED

Test 7

Group: 1

Verdict: ACCEPTED

Test 8

Group: 1

Verdict: ACCEPTED

Test 9

Group: 1

Verdict: ACCEPTED

Test 10

Group: 1

Verdict: ACCEPTED

Test 11

Group: 1

Verdict: ACCEPTED

Test 12

Group: 1

Verdict: ACCEPTED

Test 13

Group: 1

Verdict: ACCEPTED

Test 14

Group: 1

Verdict: ACCEPTED

Test 15

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 16

Group: 2

Verdict: ACCEPTED

Test 17

Group: 2

Verdict: ACCEPTED

Test 18

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 19

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 20

Group: 2

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: ACCEPTED

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: TIME LIMIT EXCEEDED

Test 31

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 32

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 33

Group: 3

Verdict: ACCEPTED

Test 34

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 35

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 36

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 37

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 38

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 39

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 40

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 41

Group: 4

Verdict: ACCEPTED

Test 42

Group: 4

Verdict: TIME LIMIT EXCEEDED

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