Alice and Bob continue their games with piles of stones. There are several stones arranged in a row, and each stone has an associated value which is an integer given in the array stoneValue.
Alice and Bob take turns, with Alice starting first. On each player's turn, that player can take 1, 2 or 3 stones from the first remaining stones in the row.
The score of each player is the sum of values of the stones taken. The score of each player is 0 initially.
The objective of the game is to end with the highest score, and the winner is the player with the highest score and there could be a tie. The game continues until all the stones have been taken.
Assume Alice and Bob play optimally.
Return "Alice" if Alice will win, "Bob" if Bob will win or "Tie" if they end the game with the same score.
 
Example 1:
Input: values = [1,2,3,7]
Output: "Bob"
Explanation: Alice will always lose. Her best move will be to take three piles and the score become 6. Now the score of Bob is 7 and Bob wins.

Example 2:
Input: values = [1,2,3,-9]
Output: "Alice"
Explanation: Alice must choose all the three piles at the first move to win and leave Bob with negative score.
If Alice chooses one pile her score will be 1 and the next move Bob's score becomes 5. The next move Alice will take the pile with value = -9 and lose.
If Alice chooses two piles her score will be 3 and the next move Bob's score becomes 3. The next move Alice will take the pile with value = -9 and also lose.
Remember that both play optimally so here Alice will choose the scenario that makes her win.

Example 3:
Input: values = [1,2,3,6]
Output: "Tie"
Explanation: Alice cannot win this game. She can end the game in a draw if she decided to choose all the first three piles, otherwise she will lose.

Example 4:
Input: values = [1,2,3,-1,-2,-3,7]
Output: "Alice"

Example 5:
Input: values = [-1,-2,-3]
Output: "Tie"

 
Constraints:

1 <= values.length <= 50000
-1000 <= values[i] <= 1000

```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 stoneGameIII(self, stoneValue: List[int]) -> str:\n        # Get the highest socre of Alice s1, \n        # then score of Bob is sum(stoneValue) - s.\n        # If s1 > s2 => Alice, if s1 == s2 => Tie, else\n        # Bob\n        \n        # [1,2,3,6]\n        # TLE, because in getScore we have to sum(stoneValue) since we \n        # don't need to get the explict score. Instead we only need to\n        # consider the highest score that the first player win over the\n        # other. Therefore, we can optimize it, which is the second \n        # approach. DP solution also uses this idea.\n#         memo = {}\n#         def getScore(start):\n#             if start >= len(stoneValue):\n#                 return 0\n#             if start in memo:\n#                 return memo[start]\n#             res = -math.inf\n#             front = 0\n#             behind = sum(stoneValue[start:])\n#             for i in range(start, min(start+3, len(stoneValue))):\n#                 front += stoneValue[i]\n#                 behind -= stoneValue[i]\n#                 cur = front + behind - getScore(i+1)\n#                 res = max(cur, res)\n            \n#             return res\n                \n#         s1 = getScore(0)\n#         s2 = sum(stoneValue) - s1\n        \n#         if s1 > s2:\n#             return 'Alice'\n#         elif s1 == s2:\n#             return 'Tie'\n#         else:\n#             return 'Bob'\n        \n#         # Second approach\n#         memo = {}\n#         def dfs(start):\n#             if start >= len(stoneValue):\n#                 return 0\n#             if start in memo:\n#                 return memo[start]\n#             memo[start] = -math.inf\n#             score = 0\n#             for i in range(start, min(len(stoneValue), start+3)):\n#                 score += stoneValue[i]\n#                 memo[start] = max(memo[start], score - dfs(i+1))\n            \n#             return memo[start]\n#         score = dfs(0)\n        \n#         if score > 0:\n#             return 'Alice'\n#         elif score == 0:\n#             return 'Tie'\n#         else:\n#             return 'Bob'\n            \n        # DP solution\n        n = len(stoneValue)\n        dp = [-math.inf] * n\n        for i in range(n-1, -1, -1):\n            take = 0\n            for j in range(i, min(i+3, n)):\n                take += stoneValue[j]\n                if j + 1 == n:\n                    dp[i] = max(dp[i], take)\n                else:\n                    dp[i] = max(dp[i], take - dp[j+1])\n        if dp[0] > 0:\n            return 'Alice'\n        elif dp[0] == 0:\n            return 'Tie'\n        else:\n            return 'Bob'"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

_target = None
_fn_name = 'stoneGameIII'
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: 5754