2021-08-22：定义什么是可整合数组：一个数组排完序之后，除了最左侧的数外，有arr[i] = arr[i-1]+1，则称这个数组为可整合数组，比如{5,1,2,4,3}、{6,2,3,1,5,

2021-08-22：定义什么是可整合数组：一个数组排完序之后，除了最左侧的数外，有arr[i] = arr[i-1]+1，则称这个数组为可整合数组，比如{5,1,2,4,3}、{6,2,3,1,5,4}都是可整合数组。返回arr中最长可整合子数组的长度。

福大大 答案2021-08-22：

可整合数组条件如下：
1.不重复。
2.【最大值】-【最小值】=个数-1。
时间复杂度：O(N^2)。
空间复杂度：O(N)。

代码用golang编写。代码如下：

package main

import (
    "fmt"
    "math"
)

func main() {
    arr := []int{6, 2, 3, 4, 5}
    ret := getLIL2(arr)
    fmt.Println(ret)
}

func getLIL2(arr []int) int {
    if len(arr) == 0 {
        return 0
    }
    len2 := 0
    max := 0
    min := 0
    set := make(map[int]struct{})
    for L := 0; L < len(arr); L++ { // L 左边界
        // L .......
        set = make(map[int]struct{})
        max = math.MinInt64
        min = math.MaxInt64
        for R := L; R < len(arr); R++ { // R 右边界
            // arr[L..R]这个子数组在验证 l...R L...r+1 l...r+2
            if _, ok := set[arr[R]]; ok {
                // arr[L..R]上开始 出现重复值了，arr[L..R往后]不需要验证了，
                // 一定不是可整合的
                break
            }
            // arr[L..R]上无重复值
            set[arr[R]] = struct{}{}
            max = getMax(max, arr[R])
            min = getMin(min, arr[R])
            if max-min == R-L { // L..R 是可整合的
                len2 = getMax(len2, R-L+1)
            }
        }
    }
    return len2
}

func getMax(a int, b int) int {
    if a > b {
        return a
    } else {
        return b
    }
}

func getMin(a int, b int) int {
    if a < b {
        return a
    } else {
        return b
    }
}

执行结果如下：

---

左神java代码