matrix multiply

import java.io.*;
import java.security.SecureRandom;
import java.time.LocalTime;
import java.util.Arrays;

class Main {
    private static final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private static final PrintWriter writer = new PrintWriter(System.out, true);
    private static final SecureRandom randomizer = new SecureRandom();

    private static final int[] intArrayInput() throws IOException {
        return Arrays
                .stream(reader.readLine().trim().split(" "))
                .mapToInt(Integer::parseInt)
                .toArray();
    }

    private static final void exitOnLess1(final int a, final int b) {
        if (a <= 0 || b <= 0) {
            writer.println("Size must be bigger than zero");
            System.exit(0);
        }
    }

    private static final void printMatrix(final int[][] matrix) {
        Arrays.stream(matrix).forEach(row -> {
            Arrays.stream(row).forEach(x -> writer.print(x + " "));
            writer.print('\n');
        });
    }

    private static final int[][] generateMatrix(final int n, final int m) {
        final var matrix = new int[n][m];

        for (int i = 0; i < n; i++)
            for (int q = 0; q < m; q++)
                matrix[i][q] = randomizer.nextInt(1000);

        return matrix;
    }

    private static final int[][] matrixMultiplyST(final int[][] first, final int[][] second) {
        final int n = first.length;
        final int m = second[0].length;
        final int k = second.length;
        final var ans = new int[n][m];

        for (int i = 0; i < n; i++)
            for (int q = 0; q < m; q++)
                for (int r = 0; r < k; r++)
                    ans[i][q] += first[i][r] * second[r][q];

        return ans;
    }

    private static final int[][] matrixMultiplyMT(
            final int[][] first,
            final int[][] second,
            final int threadsAmount
    ) {
        final int n = first.length;
        final int m = second[0].length;
        final int k = second.length;
        final var ans = new int[n][m];

        final var threads = new Thread[threadsAmount];
        final var cellsInThreads = new int[threadsAmount];
        final var ost = n * m % threadsAmount;
        Arrays.fill(cellsInThreads, n * m / threadsAmount);

        for (int i = 0; i < ost; i++)
            cellsInThreads[i]++;

        int cur = 0;

        for (int i = 0; i < threadsAmount; cur += cellsInThreads[i], i++) {
            final int finalI = i;
            final int finalCur = cur;

            threads[i] = new Thread(() -> {
                for (int t = finalCur; t < finalCur + cellsInThreads[finalI]; t++)
                    for (int r = 0; r < k; r++)
                        ans[t / n][t % n] += first[t / n][r] * second[r][t % n];
            });

            threads[i].start();
        }

        Arrays.stream(threads).forEach(x -> {
            try {
                x.join();
            } catch (final InterruptedException e) {
                e.printStackTrace();
            }
        });

        return ans;
    }

    public static final void main(final String[] args) throws IOException {
        writer.println("First matrix's size: ");
        final var inp1 = intArrayInput();
        final var n1 = inp1[0];
        final var m1 = inp1[1];

        exitOnLess1(n1, m1);

        writer.println("Second matrix's size: ");
        final var inp2 = intArrayInput();
        final var n2 = inp2[0];
        final var m2 = inp2[1];

        exitOnLess1(n2, m2);

        if (m1 != n2 && m2 != n1) {
            writer.println("Colums amount of 1-st matrix must be equal to rows amount of 2-nd matrix or vice versa");
            return;
        }

        writer.println("Amount of threads:");
        final int threadsAmount = Integer.parseInt(reader.readLine().trim());

        if (threadsAmount < 1) {
            writer.println("Threads amount must be bigger than zero");
            return;
        }

        final var matrix1 = generateMatrix(n1, m1);
        final var matrix2 = generateMatrix(n2, m2);

        // writer.println("First matrix:");
        // printMatrix(matrix1);

        // writer.println("Second matrix:");
        // printMatrix(matrix2);

        final var start1 = LocalTime.now().getNano();
        final var firstMul = matrixMultiplyST(matrix1, matrix2);
        final var finish1 = LocalTime.now().getNano();
        writer.println("Single Thread: " + (Math.max(start1, finish1) - Math.min(start1, finish1)) + " nanos");

        // writer.println("Single Thread matrix:");
        // printMatrix(firstMul);

        final var start2 = LocalTime.now().getNano();
        final var secondMul = matrixMultiplyMT(matrix1, matrix2, threadsAmount);
        final var finish2 = LocalTime.now().getNano();
        writer.println("Multi Thread:  " + (Math.max(start2, finish2) - Math.min(start2, finish2)) + " nanos");

        // writer.println("Multi Thread matrix:");
        // printMatrix(secondMul);

        assert(Arrays.deepEquals(firstMul, secondMul));

        reader.close();
        writer.close();
    }
}