首先，给你一个初始数组 arr。然后，每天你都要根据前一天的数组生成一个新的数组。
第 i 天所生成的数组，是由你对第 i-1 天的数组进行如下操作所得的：
假如一个元素小于它的左右邻居，那么该元素自增 1。
假如一个元素大于它的左右邻居，那么该元素自减 1。
首、尾元素 永不 改变。
过些时日，你会发现数组将会不再发生变化，请返回最终所得到的数组。
示例 1：
输入：[6,2,3,4]
输出：[6,3,3,4]
解释：
第一天，数组从 [6,2,3,4] 变为 [6,3,3,4]。
无法再对该数组进行更多操作。
示例 2：
输入：[1,6,3,4,3,5]
输出：[1,4,4,4,4,5]
解释：
第一天，数组从 [1,6,3,4,3,5] 变为 [1,5,4,3,4,5]。
第二天，数组从 [1,5,4,3,4,5] 变为 [1,4,4,4,4,5]。
无法再对该数组进行更多操作。
提示：
1 <= arr.length <= 100
1 <= arr[i] <= 100
自我解答
题意很简单，但是我觉得应该不能直接循环模拟过程吧，一般这样都不行的。
如 1,100,2 这样情况，直接可以直接确定 1,2,2,不用经过98次 -1 操作。 但如果2 后面还有数，
如果 2是需要增加的，又如何呢？我尝试动态规划的思想：
当 arr[i-1] < arr[i] > arr[i+1] 时，似乎有 f(i) = max(f(i-1), f(i+1)) 的关系，
当 arr[i-1] > arr[i] < arr[i+1] 时，似乎有 f(i) = min(f(i-1), f(i+1)) 的关系
但 如果这样直接设计递归算法，可能会遇到这样的情况：
f(i) = max(f(i-1), f(i+1))，
f(i+1) = min(f(i), f(i+2)), 子问题相互依赖，导致程序进入无限的递归
而且，如 1,8,5,10,10
最后是 1,6,5,10,10; f(2) != f(1), 这证明这个规律不成立。
这些都是我以为自己找到了规律，写好代码，执行程序后发现的，费时又费脑的。
那到底怎么来做呢？要找到规律似乎挺难的，或者是我的水平还不够。
于是我满怀着不甘去看题解，发现大家似乎都是在简简单单的模拟过程... WTF...
...自己写的
class Solution:
def transformArray(self, arr: List[int]) -> List[int]:
length = len(arr)
settled = [0] * length
unsettled = length - 2 if length >= 2 else 0
while unsettled:
op = {}
for i in range(1, length - 1):
if settled[i]:
continue
if arr[i-1] < arr[i] > arr[i+1]:
op[i] = -1
elif arr[i-1] > arr[i] < arr[i+1]:
op[i] = 1
else:
settled[i] = 1
unsettled -= 1
for k, v in op.items():
arr[k] += v
return arr
执行用时：40 ms, 在所有 Python3 提交中击败了94.92%的用户