There are N piles of stones arranged in a row.  The i-th pile has stones[i] stones.
A move consists of merging exactly K consecutive piles into one pile, and the cost of this move is equal to the total number of stones in these K piles.
Find the minimum cost to merge all piles of stones into one pile.  If it is impossible, return -1.
 

Example 1:
Input: stones = [3,2,4,1], K = 2
Output: 20
Explanation: 
We start with [3, 2, 4, 1].
We merge [3, 2] for a cost of 5, and we are left with [5, 4, 1].
We merge [4, 1] for a cost of 5, and we are left with [5, 5].
We merge [5, 5] for a cost of 10, and we are left with [10].
The total cost was 20, and this is the minimum possible.


Example 2:
Input: stones = [3,2,4,1], K = 3
Output: -1
Explanation: After any merge operation, there are 2 piles left, and we can't merge anymore.  So the task is impossible.


Example 3:
Input: stones = [3,5,1,2,6], K = 3
Output: 25
Explanation: 
We start with [3, 5, 1, 2, 6].
We merge [5, 1, 2] for a cost of 8, and we are left with [3, 8, 6].
We merge [3, 8, 6] for a cost of 17, and we are left with [17].
The total cost was 25, and this is the minimum possible.

 
Note:

1 <= stones.length <= 30
2 <= K <= 30
1 <= stones[i] <= 100

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

def _disabled_input(*args, **kwargs):
    raise RuntimeError("input() is disabled in callable mode")
builtins.input = _disabled_input

ns = {"__name__": "__judge__"}  # prevent if __name__ == "__main__" blocks
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'class Solution:\n    def mergeStones(self, stones, k):\n    \n        # quick check to see if this number of piles can be merged. \n        if (len(stones)-1)%(k-1): \n            return -1\n\n        cost = [[None]*len(stones) for _ in stones]\n\n        def subCost(left, right):\n\n            # Base case: there is no cost to \\"merging\\" one pile\n            if left == right: \n                return 0\n\n            if cost[left][right] != None: \n                return cost[left][right]\n\n            # Base case: a single merge is just the sum of the elements.  \n            if (right - left + 1) == k: \n                cost[left][right] = sum(stones[left:right+1])\n                return cost[left][right]\n\n            # find k-1 division points.  Each division except the last is the start index of a sub-array\n            # ie. if stones = [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ], left = 0 right = 8 divs = [0, 3, 8, 9]\n            # then sub-arrays are as follows: [0, 1, 2] [3, 4, 5, 6, 7]  [8] \n            # the above divs would incidentally be valid for k = 3. \n\n            divs = [ left + i for i in range(k+1)]\n            divs[-1] = right + 1  # set the last divider to one past the subarray. \n            # for example above, divs is initialized to -> [0, 1, 2, 9].  The first and last divider never change\n\n            def moveDividers():\n                # loop through dividers to move, starting at last one.  \n                # if the last one is at the end, move the next one up. \n\n                def moveDivider(i): \n                    if i == 0: \n                        return False\n\n                    # if the div we\'re looking at is smashing all dividers to its right against the right end of the array. \n                    # If k = 3, i = 1, we have 1 divider to our right.  Leave 1 space for each divider to our right.\n                    # division 0 stays at 0 \n                    # div 1 can go to 2.  = right - (k - 1 - i)\n                    if divs[i] == ( right - (k - 1 - i)):\n                        # switch to the next divider to the left\n                        return moveDivider(i-1)\n\n                    # move this divider to the next usable spot given where the left neighbor div is. \n                    divs[i] += 1\n                    while (divs[i] - divs[i-1] - 1)%(k-1):\n                        divs[i] += 1\n\n                    # stack all following divs next to each other and this one. []\n                    for j in range(i+1, len(divs)-1):\n                        divs[j] = divs[j-1] + 1\n\n                    return True\n\n                # start by moving the rightmost divider\n                return moveDivider(len(divs) - 2)\n\n            best = float(\'inf\')\n            while 1:\n                subSum = 0\n                for div_i in range(len(divs)-1):\n                    subSum += subCost(divs[div_i], divs[div_i+1] - 1) \n                best = min(best, subSum) \n                if not moveDividers():\n                    break\n\n            result = best + sum(stones[left:right+1])\n            cost[left][right] = result\n            return result\n\n        result = subCost(0, len(stones)-1)\n        #print(cost)\n        return result '
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'mergeStones'
if _fn_name:
    if "Solution" in ns:
        try:
            _obj = ns["Solution"]()
            if hasattr(_obj, _fn_name):
                _target = getattr(_obj, _fn_name)
        except Exception:
            _target = None
    if _target is None and _fn_name in ns and callable(ns[_fn_name]):
        _target = ns[_fn_name]
# Fallback: if there's exactly one user-defined function, use it
if _target is None:
    _cands = [v for k, v in ns.items() if callable(v) and getattr(v, "__module__", "") in ("__judge__", "__main__")]
    _user_funcs = [c for c in _cands if getattr(c, "__name__", "").startswith("_") is False]
    if len(_user_funcs) == 1:
        _target = _user_funcs[0]
if _target is None:
    raise RuntimeError(f"Could not resolve callable '{_fn_name}'")

_raw = sys.stdin.read().strip()
if _raw:
    _parsed = json.loads(_raw)
    if isinstance(_parsed, dict):
        _kwargs = _parsed.get("kwargs", {})
        _args = _parsed.get("args", [])
    else:
        _args, _kwargs = _parsed, {}
else:
    _args, _kwargs = [], {}
if not isinstance(_args, (list, tuple)):
    _args = [_args]
_res = _target(*_args, **_kwargs)
try:
    sys.stdout.write(repr(_res) + "\n")
except Exception:
    pass

```

Measured memory_bytes: 10818