978. Longest Turbulent Subarray [Medium]

/**
 * 自己的做法，用downFlg标志当前的判断是否需要是下降or上升来保持和前面的连续
 * Runtime: 5 ms, faster than 49.88%
 * Memory Usage: 42.2 MB, less than 84.99%
 */
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int len = arr.length, curr = 1, max = 1;
        Boolean downFlg = null;
        if (len == 0 || len == 1) {
            return len;
        }
        for (int i = 1; i < len; i++) {
            if (downFlg == null) {
                if (arr[i] != arr[i - 1]) {
                    curr++;
                    downFlg = arr[i] > arr[i - 1] ? true : false;
                } else {
                    curr = 1;
                }
            } else if (downFlg && arr[i] < arr[i - 1] || !downFlg && arr[i] > arr[i - 1]) {
                curr++;
                downFlg = !downFlg;
            } else {
                max = Math.max(max, curr);
                curr = 1;
                downFlg = null;
                if (arr[i] != arr[i - 1]) {
                    i--;
                }
            }
        }
        max = Math.max(max, curr);
        return max;
    }
}

/**
 * discuss的解法
 * every element in the turbulent array should be either peak or valley
 * Runtime: 4 ms, faster than 91.45%
 * Memory Usage: 42.3 MB, less than 68.82%
 */
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int max = 0, curr = 0;
        for (int i = 0; i < arr.length; i++) {
            if (i >= 2 && (arr[i - 2] > arr[i - 1] && arr[i - 1] < arr[i] || arr[i - 2] < arr[i - 1] && arr[i - 1] > arr[i])) {
                curr++;
            } else if(i >= 1 && arr[i-1] != arr[i]) {
                max = Math.max(max, curr);
                curr = 2;
            } else {
                max = Math.max(max, curr);
                curr = 1;
            }
        }
        max = Math.max(max, curr);
        return max;
    }
}

/**
 * 或者直接每次更新都max = Math.max(max, curr)，代码更简洁，运行结果效率无差别
 */
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int max = 0, curr = 0;
        for (int i = 0; i < arr.length; i++) {
            if (i >= 2 && (arr[i - 2] > arr[i - 1] && arr[i - 1] < arr[i] || arr[i - 2] < arr[i - 1] && arr[i - 1] > arr[i])) {
                curr++;
            } else if(i >= 1 && arr[i-1] != arr[i]) {
                curr = 2;
            } else {
                curr = 1;
            }
            max = Math.max(max, curr);
        }
        return max;
    }
}

/**
 * 滑动窗口法，discuss看到的
 * 和第一种解法思路基本一样
 * Runtime: 3 ms, faster than 100.00%
 * Memory Usage: 42.3 MB, less than 78.52%
 */
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int start = 0, end = 1, max = 1, dir = 0;
        for ( ; end < arr.length; end++) {
            if (arr[end] > arr[end - 1]) {
                if (dir == -1) {
                    max = Math.max(max, end - start);
                    start = end - 1;
                }
                dir = -1;
            } else if (arr[end] < arr[end - 1]) {
                if (dir == 1) {
                    max = Math.max(max, end - start);
                    start = end - 1;
                }
                dir = 1;
            } else {
                dir = 0;
                max = Math.max(max, end - start);
                start = end;
            }
        }
        max = Math.max(max, end - start);
        return max;
    }
}

/**
 * 每次更新都max = Math.max(max, curr)，代码更简洁，效率低一点点
 * Runtime: 4 ms, faster than 91.45%
 * Memory Usage: 42.5 MB, less than 50.12%
 */
class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int start = 0, end = 1, max = 1, dir = 0;
        for ( ; end < arr.length; end++) {
            if (arr[end] > arr[end - 1]) {
                if (dir == -1) {
                    start = end - 1;
                }
                dir = -1;
            } else if (arr[end] < arr[end - 1]) {
                if (dir == 1) {
                    start = end - 1;
                }
                dir = 1;
            } else {
                dir = 0;
                start = end;
            }
            max = Math.max(max, end - start + 1);
        }       
        return max;
    }
}