ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

最长的可整合子数组的长度

2022-06-30 23:33:40  阅读:34  来源: 互联网

标签:arr int max len length 数组 长度 最长


最长的可整合子数组的长度

作者:Grey

原文地址: 最长的可整合子数组的长度

题目链接

牛客:最长的可整合子数组的长度

描述

先给出可整合数组的定义:如果一个数组在排序之后,每相邻两个数的差的绝对值都为1,或者该数组长度为1,则该数组为可整合数组。例如,[5, 3, 4, 6, 2]排序后为[2, 3, 4, 5, 6],符合每相邻两个数差的绝对值都为1,所以这个数组为可整合数组,给定一个数组arr, 请返回其中最大可整合子数组的长度。
例如,[5, 5, 3, 2, 6, 4, 3]的最大可整合子数组为[5, 3, 2, 6, 4],所以请返回5

数据范围:0 <n≤100000,数组中每个数都满足0≤val≤10^9

要求:时间复杂度为O(n^2),空间复杂度为O(n)
进阶:时间复杂度O(nlogn),空间复杂度O(n)

暴力解法

枚举每个子数组,然后对每个子数组进行排序,然后判断是否为可整合数组,完整代码如下

    public static int getLIL1(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int len = 0;
        // O(N^3 * log N)
        for (int start = 0; start < arr.length; start++) {
            for (int end = start; end < arr.length; end++) {
                if (isIntegrated(arr, start, end)) {
                    len = Math.max(len, end - start + 1);
                }
            }
        }
        return len;
    }

    public static boolean isIntegrated(int[] arr, int left, int right) {
        int[] newArr = Arrays.copyOfRange(arr, left, right + 1); // O(N)
        Arrays.sort(newArr); // O(N*logN)
        for (int i = 1; i < newArr.length; i++) {
            if (newArr[i - 1] != newArr[i] - 1) {
                return false;
            }
        }
        return true;
    }

暴力解法的时间复杂度是O(N^3*logN),显然超时。

优化解

某个数组如果属于可整合数组,则这个数组一定符合如下两个条件:

第一个条件:数组中的元素没有重复。

第二个条件:数组中的最大值和最小值的差值等于数组元素个数-1

如果满足上述两个条件,一定是可整合数组。

我们可以通过设置一个HashSet来判断元素是否重复。

完整代码

    public static int getLIL2(int[] arr) {
        if (arr == null || arr.length == 0) {
            return 0;
        }
        int len = 0;
        int max = 0;
        int min = 0;
        HashSet<Integer> set = new HashSet<Integer>();
        for (int l = 0; l < arr.length; l++) { 
            set.clear();
            max = arr[l];
            min = arr[l];
            for (int r = l; r < arr.length; r++) {
                if (set.contains(arr[r])) {
                    break;
                }
                set.add(arr[r]);
                max = Math.max(max, arr[r]);
                min = Math.min(min, arr[r]);
                if (max - min == r - l) {
                    len = Math.max(len, r - l + 1);
                }
            }
        }
        return len;
    }

整个算法时间复杂度O(N*logN),符合要求。

更多

算法和数据结构笔记

标签:arr,int,max,len,length,数组,长度,最长
来源: https://www.cnblogs.com/greyzeng/p/16429045.html

专注分享技术,共同学习,共同进步。侵权联系[admin#icode9.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有