leetcode978

 1 class Solution(object):
 2     def maxTurbulenceSize(self, A: 'List[int]') -> int:
 3         n = len(A)    
 4         if n == 1:
 5             return 1
 6         elif n == 2:
 7             if A[0]!=A[1]:
 8                 return 2
 9             else:
10                 return 1
11         else:#n >= 3
12             maxsize = 1
13             size = 1
14             LowHighLow = True
15             i = 0
16             while i<n:
17                 NeedJudge = False
18                 for j in range(i,n):
19                     if j == n-1:
20                         maxsize = max(maxsize,size)
21                         return maxsize
22                     if not NeedJudge:
23                         if A[j] < A[j+1]:
24                             LowHighLow = True
25                             size += 1
26                             NeedJudge = True
27                         elif A[j] > A[j+1]:
28                             LowHighLow = False
29                             size += 1
30                             NeedJudge = True
31                         else:
32                             NeedJudge = False
33                             i += 1
34                             break
35                     else:
36                         if LowHighLow:
37                             if A[j] > A[j+1]:
38                                 LowHighLow = False
39                                 size += 1
40                             else:
41                                 NeedJudge = False
42                                 maxsize = max(maxsize,size)
43                                 size = 1
44                                 if i==j:
45                                     i += 1
46                                 else:
47                                     i = j
48                                     break
49                                         
50                         else:
51                             if A[j] < A[j+1]:
52                                 LowHighLow = True
53                                 size += 1
54                             else:
55                                 NeedJudge = False
56                                 maxsize = max(maxsize,size)
57                                 size = 1
58                                 if i==j:
59                                     i += 1
60                                 else:
61                                     i = j
62                                     break
63         return maxsize

思路：滑动窗口。

这种线性的程序，再长一倍，问题也不大。不过可读性就比较差了。

简单说一下用到的变量的作用：NeedJudge就是是否需要判断，对于每次滑动窗口的其实位置(i==j)，NeedJudge都是False，这样只需要根据起始的两个位置的元素的大小，来确定是凹凸凹型还是凸凹凸型。变量LowHighLow=True表示凹凸凹型，LowHighLow=False表示凸凹凸型。这样就可以判断，当前滑动窗口后续的值是否是合法的。

如果遇到不合法，记录当前滑动窗口的大小size，并更新maxsize保留最大的滑动窗口。

也许这个版本程序比较粗糙，但是能正确执行，也是重要的成果，代码的优化，也是由粗到精，一步一步的完成的嘛。