Project Euler 18/67 : Maximum Path using Memoization
Storage

A Map is most useful when the key values are not in a sequence,
but sparse, with smaller and bigger gaps between key values.

In this example, the key corresponds to a row of the triangle,
taking on values from 0 to size, and using all values in the range.
An array would be a more natural choice for storage,
in this example an int[][].

Note that a hash map has some storage overhead.
Also, accessing array elements is simpler to write than .get(...) and .put(...) calls.

Encapsulation

This is a bit unfortunate:


TriangularArray theArray = new TriangularArray(size);
theArray.acceptArray(in);
theArray.displayArray();
theArray.findMaximum();



Since findMaximum will modify the underlying storage,
if you call theArray.findMaximum() one more time,
it will produce different output,
which is unexpected.

It's best when you can call a method multiple times and get the same result consistently.
Unless of course it is by design that the call manipulates state,
for example in an iterator.
The name "findMaximum" doesn't hint at manipulating state,
which is misleading.

In fact, findMaximum is designed for one-time use.
It would be better to rewrite this in a way that the state manipulation becomes obvious.
Or throw an exception if the method is called a second time.
Or encapsulate the logic in a way that calling findMaximum repeatedly would produce the same result consistently.

I would also recommend to make findMaximum return the maximum instead of printing text.

Pointless statements

This variable is unused (and poorly named):


int someInt;



The map.put(i, currArray) statement at the end is unnecessary:


int[] currArray = map.get(i);
for(int j=0; j&lt;currArray.length; j++){
    currArray[j] = in.nextInt();
}
map.put(i, currArray);



Because currArray comes from map.get(i), and it is not reassigned.

Other redundancies

TriangleArray.size is redundant.
The same information is available through the underlying storage,
whether using a map or an array.

Instead of initializing the arrays in the constructor,
you could do it at the same time as parsing from Scanner,
to iterate over the lines only once.

Most of the comments are completely redundant, noise, for example:


// Display the array
public void displayArray() {



This helps nobody, omit such redundant comments.

Naming

acceptArray is a strange name for a method that parses numbers from a Scanner. How about parseFromScanner ?

displayArray is a strange name for method that prints the content of the triangle. How about simply print ? As the method is on the TriangleArray class, it's implied that it will print the triangle itself.

Alternative implementation

Consider this alternative implementation:

static class TriangularArray {
    private final int[][] rows;

    public TriangularArray(int size) {
        rows = new int[size][];
    }

    public void parseFromScanner(Scanner scanner) {
        for (int i = 0; i &lt; rows.length; i++) {
            rows[i] = new int[i + 1];
            for (int j = 0; j &lt; rows[i].length; j++) {
                rows[i][j] = scanner.nextInt();
            }
        }
    }

    // Finds the maximum using Memoization.
    public int findMaximum() {
        int[] below = rows[rows.length - 1];
        for (int i = rows.length - 2; i &gt;= 0; i--) {
            int[] current = rows[i].clone();
            for (int j = 0; j &lt; current.length; j++) {
                current[j] = Math.max(below[j], below[j + 1]) + current[j];
            }
            below = current;
        }
        return below[0];
    }
}