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代码

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