数字三角形上非素数的最大和

Question

I have a triangle of numbers. I want to find the largest sum of the NOT PRIME numbers starting from the top in this triangle. For example:

1. You will start from the top and move downwards to an adjacent number as in below.
2. You are only allowed to walk downwards and diagonally.
3. You can only walk over NON PRIME NUMBERS.
4. You have to reach at the end of the pyramid as much as possible.
5. You have to treat the input as pyramid.

According to above rules the maximum sum of the numbers from top to bottom in below example is 24.

      *1
     *8 4
    2 *6 9
   8 5 *9 3

As you can see this has several paths that fits the rule of NOT PRIME NUMBERS; 1>8>6>9, 1>4>6>9, 1>4>9>9 1 + 8 + 6 + 9 = 24. As you see 1, 8, 6, 9 are all NOT PRIME NUMBERS and walking over these yields the maximum sum.

My code is below. My code doesn't consider prime numbers. How can I do it like in the example above?

public class MaxPathSum {

    public static void main(String[] args) throws Exception {
        int[][] data = Files.lines(Paths.get("src/main/triangle.txt"))
                .map(s -> stream(s.trim().split("\\s+"))
                        .mapToInt(Integer::parseInt)
                        .toArray())
                .toArray(int[][]::new);

        for (int r = data.length - 1; r > 0; r--)
            for (int c = 0; c < data[r].length - 1; c++)
                data[r - 1][c] += Math.max(data[r][c], data[r][c + 1]);

        System.out.println(data[0][0]);
    }
}

Example data:

        1
       8 4
      2 6 9
     8 5 9 3

Answer 1

Somewhere at a value, row r , column c . You possibly could come from left parent [r-1][c-1] (c > 0) or right parent [r-1][c] (c < r).

You stop with failure when the value is a prime.

Going down in both cases you want the maximum, and with a solution of the subtree. When failure fail.

So going first down the subtree:

record Solution(int sum, List<Integer> path) {}

Optional<Solution> solve(int r, int c) {
    int value = data[r][c];
    if (isPrime(value)) {
        return Optional.empty();
    }
    if (r+1 >= data.length) {
        List<Integer> path = new ArrayList<>();
        path.add(value);
        return Optional.of(new Solution(value, path));
    }
    Solution left = solve(r+1, c);
    Solution right = solve(r+1, c+1);
    if (!left.isPresent()) {
        if (!right.isPresent()) {
            return Optional.empty();
        } else {
            List<Integer> path = left.path;
            path.add(0, value);
            return Optional.of(new Solution(value + left.sum, path));
        }
    } else {
        if (!right.isPresent()) {
            List<Integer> path = right.path;
            path.add(0, value);
            return Optional.of(new Solution(value + right.sum, path));
        } else {
            if (left.sum > right.sum) {
                List<Integer> path = left.path;
                path.add(0, value);
                return Optional.of(new Solution(value + left.sum, path));
            } else {
                List<Integer> path = right.path;
                path.add(0, value);
                return Optional.of(new Solution(value + right.sum, path));
            }
        }
    }
}

Of course you could also work with an int[][] sum at the bottom row filling primes with a -1, and a sum of the two values under when not -1.