首页 > 试题广场 >

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

[编程题]最长的可整合子数组的长度
  • 热度指数:16974 时间限制:C/C++ 2秒,其他语言4秒 空间限制:C/C++ 256M,其他语言512M
  • 算法知识视频讲解
先给出可整合数组的定义:如果一个数组在排序之后,每相邻两个数的差的绝对值都为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

数据范围:,数组中每个数都满足 

要求:时间复杂度为,空间复杂度为
进阶:时间复杂度 ,空间复杂度

注意:本题中子数组的定义是数组中连续的一段区间,例如 [1,2,3,4,5] 中 [2,3,4] 是子数组,[2,4,5] 和 [1,3] 不是子数组

输入描述:
第一行一个整数N,表示数组长度
第二行N个整数,分别表示数组内的元素


输出描述:
输出一个整数,表示最大可整合子数组的长度
示例1

输入

7
5 5 3 2 6 4 3

输出

5
示例2

输入

3
1 4 2

输出

1
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;

public class Main{
    public static void main(String[] args ) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine().trim());//第一行整数
        String[] words = br.readLine().trim().split(" ");
        int[] nums = new int[n];
        for(int i=0; i<n; i++){
            nums[i] = Integer.parseInt(words[i]);
        }
        int len = 0;
        //逐个获取子数组
        for(int i=0; i<n; i++){
            //以nums[i]为子数组的第一个数字,找到满足该要求的所有子数组
            //保存该子数组中的最大最小值
            int min = Integer.MAX_VALUE;
            int max = Integer.MIN_VALUE;
            for(int j=i; j<n; j++){
                min = Math.min(min, nums[j]);
                max = Math.max(max, nums[j]);
                if((max-min)==j-i){
                    //因为求的是最长的可整合数组,所以,要将len去最大值
                    len = Math.max( j-i+1, len );
                }
            }
        }
        System.out.print(len);
    }
}
发表于 2021-05-23 20:54:14 回复(0)

Java实现

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        int n= scanner.nextInt();
        int [] array = new int [n];
        for(int i=0; i< n ; i++){
            array[i]=scanner.nextInt();
        }
        System.out.println(maxMergeArray(n,array));
    }

    public static int maxMergeArray(int n,int[] array){
        if(n==1){
            return 1;
        }
        int len=0;
        int maxLen=0;
        int j=0;
        Arrays.sort(array);
        for(int i = 0;i<n;i=j){
            for(j=i+1;j<n;j++){
                if(Math.abs(array[j]-array[j-1])==1){
                    len++;
                    maxLen = maxLen >len ? maxLen:len;
                }else{

                    len=0;
                    break;
                }
            }
        }
        return ++maxLen;
    }
}
发表于 2020-03-31 13:49:57 回复(0)

import java.util.Scanner;
//可整合数的长度确认,时间复杂都n^3 没排序
public class IntegrateArr {
	public static void main(String[] args) {
		
		//设置间隔和arr的大小
		int interval = 1, N;
		
		Scanner x = new Scanner(System.in);
		N = x.nextInt();
		
		int[] arr = new int[N];
		//定义一个保存记录可整合数长度的数组
		int[] count = new int[N];
		
		for(int i= 0; i<N; i++) {
			arr[i] = x.nextInt();
			count[i] = 1;	//初始化记录可整合数
		}
		
		//定义临时比较操作数
		int temp;
		for(int i = 0;i<arr.length;i++) {
			temp = arr[i];
			for(int j=0 ;j < arr.length; j++) {
				if(temp - arr[j] == interval) {					
					count[i]++;					
					temp = arr[j];
					j = -1;//重头循环找下一个
				}			
			}			
		}
		//取最大保存的可整合数长度的数组的记录
		int max = count[0];
		for(int i = 1 ;i<count.length; i++) {
			if(count[i]>max) {
				max = count[i];
			}
		}
		//输出长度
		System.out.println(max);		
	}
}


发表于 2019-12-08 20:30:39 回复(0)
import java.util.HashSet;
import java.util.Scanner;

public class Main {

    public static int getMaxLIL(int[] arr) {

        HashSet<Integer> set = new HashSet<>();
        int len = 0;

        for (int i = 0; i < arr.length; i++) {
            int max = Integer.MIN_VALUE;
            int min = Integer.MAX_VALUE;

            for (int j = i; j < arr.length; j++) {
                if (set.contains(arr[j])) {
                    break;
                }
                set.add(arr[j]);
                max = Math.max(max, arr[j]);
                min = Math.min(min, arr[j]);
                if (max - min == j - i) {
                    len = Math.max(len, j - i + 1);
                }
            }
            set.clear();
        }
        return len;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = sc.nextInt();
        }
        System.out.println(getMaxLIL(arr));
    }

}
发表于 2019-10-11 15:30:27 回复(0)
public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
    int n=scanner.nextInt();
    int[] ma = new int[n];
    for(int i=0;i<n;i++)
        ma[i] = scanner.nextInt();
    for(int i=0;i<n-1;i++){
        int temp=i;
        for(int j=i+1;j<n;j++)
            if(ma[j]<ma[temp])
                temp=j;
        if(temp!=i){
            int x=ma[i];ma[i]=ma[temp];ma[temp]=x;
        }
    }
    int sum = 1,max=0;
    for(int i=1;i<n;i++){
        if(ma[i]-ma[i-1]==1)
            sum++;
        else{
            max = Math.max(max,sum);
            sum=1;
        }
    }
    System.out.println(max);
}

发表于 2019-09-07 14:53:43 回复(0)
import java.util.Scanner;
import java.util.Arrays;

public class Main{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        int n=in.nextInt();
        int[] a=new int[n];
        for(int i=0;i<n;i++){
            a[i]=in.nextInt();
        }
        Arrays.sort(a);
        int len=0;
        int max=a[0];
        int min=a[0];
       for(int i=1;i<n;i++){
            if(a[i]-max<=1){
                max=a[i];
            }else{
               len=(max-min+1)>len?(max-min+1):len;
                min=a[i];
                max=a[i];
           }
        }
        len=(max-min+1)>len?(max-min+1):len;
        System.out.println(len);
    }
}
(如果允许改变数组的话)
另外也可以不用Arrays.sort自己写快排,一样可以O(nlogn)

发表于 2019-08-10 06:41:24 回复(0)