元素互不相邻的最大和子数组

探讨如何在数组中选取非邻接子数组使其元素和最大化,包括直线型和环形数组两种情况,采用递归及动态规划解决。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目

对于一个给定的数组,在其中选取其子数组,要求相邻的元素不能选取,且要保证选出的子数组元素和最大。输入数组长度及其元素,输出所选子数组的和。

line

  • 测试输入
    7
    4 2 6 1 3 5 8
  • 测试输出
    21

分析1

为了让子数组和最大,应该尽可能让它包含更多的元素,并且相邻元素不能选取,所以选取的任意两个数字之间最多间隔两个数,因为假设如果间隔了三个而子数组和最大,那么最中间的那个数一定可以选中,此时子数组和也一定比之前更大,产生矛盾。由此可见,本题只需要分析连续的三个元素的关系即可。
按照第iii个元素是否被选取,前iii个元素的和要么与前i−1i-1i1个元素的和相同(不选取),要么是前i−2i-2i2个元素的和加上此第iii个元素(选取),这两种情况取最大。这很容易通过递归实现出来,也可以使用动态规划实现。要用动态规划,子问题的选取需要具有无后效性,即前iii个元素的选取只能和之前的选取有关,和未来的情况无关。对于数组array[i]array[i]array[i]i=0∼n−1i=0\sim n-1i=0n1,定义s[i]s[i]s[i]表示前iii个元素的最大和,则递归式为

s[i]={0,i=0array[1],i=1max(s[i−1],s[i−2]+array[i]),2≤i≤n s[i]=\left\{\begin{array}{ll} 0, & i=0\\ array[1], & i=1\\ \textrm{max}(s[i-1], s[i-2]+array[i]), & 2\le i\le n \end{array}\right. s[i]=0,array[1],max(s[i1],s[i2]+array[i]),i=0i=12in

代码1

import java.util.Scanner;

public class NotAdjacentLine {
    static int solution(int[] array, int n) {
        if (n < 1) return 0;
        if (n == 1) return array[0];
        return Math.max(solution(array, n - 1), 
				        solution(array, n - 2) + array[n - 1]);
    }

    static int solution2(int[] array, int n) {
        int[] s = new int[n + 1];
        s[0] = 0;
        s[1] = array[0];
        for (int i = 2; i < n + 1; i++) {
            int takei = s[i - 2] + array[i - 1];
            int skipi = s[i - 1];
            s[i] = Math.max(takei, skipi);
        }
        return s[n];
    }

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

变形

将上述的数组变成一个环,其他条件保持不变。

circle

  • 测试输入
    7
    4 2 6 1 3 5 8
  • 测试输出
    17

分析2

对于环的情况,仍然可以利用上述直线的方法完成,只是有一些变化。首先要保证首尾元素不能同时选取,它们也属于相邻元素,这可以通过构造最优解来判断:如果首尾元素同时选取,则删除尾元素而保留首元素;其次为了找到所有可取的情况,需要对数组不断进行循环移位,从每一个元素开始,找出能够取得的最大和。这里对数组的循环移位实际上只需要做两次即可,因为我们求解s[i]s[i]s[i]时,只与s[i−1]s[i-1]s[i1]s[i−2]s[i-2]s[i2]有关,环上的每一个元素位置等价,即都要能够成为这三项中的任意一项,这里位置不等价的只有四个元素:首位元素不能成为s[i−1]s[i-1]s[i1]s[i]s[i]s[i],第二元素不能成为s[i]s[i]s[i],而倒数第二元素不能成为s[i−2]s[i-2]s[i2],末尾元素不能成为s[i−2]s[i-2]s[i2]s[i−1]s[i-1]s[i1]。所以为了满足环上元素位置等价的条件,只需要再循环移动数组两次即可,最后比较这三种情况取最大值。

代码2

import java.util.Scanner;

public class NotAdjacentCircle {
    static int solution(int[] array, int n) {
        int[] s = new int[n + 1];
        boolean[] isUsed = new boolean[n];// 元素是否使用,用于构造最优解
        s[0] = 0;
        s[1] = array[0];
        isUsed[0] = true;
        for (int i = 2; i < n + 1; i++) {
            int takei = s[i - 2] + array[i - 1];
            int skipi = s[i - 1];
            if (takei > skipi) {
                s[i] = takei;
                isUsed[i - 1] = true;
            } else {
                s[i] = skipi;
                isUsed[i - 1] = false;
            }
        }
        return makeCircle(s, isUsed, n);
    }

    static int makeCircle(int[] s, boolean[] isUsed, int n) {
        if (!isUsed[n - 1]) return s[n];// 最后一个元素没用,首尾不会相邻
        int i = n - 1;
        boolean isFirstUsed = false;// 第一个元素是否使用
        while (i >= 0) {// 构造最优解的过程
            if (isUsed[i]) {
                if (i == 0) isFirstUsed = true;
                i -= 2;
            } else {
                i -= 1;
            }
        }
        return isFirstUsed ? s[n - 1] : s[n];// 如果首尾相邻,则删除尾元素
    }

    static int[] leftShift(int[] array, int steps) {
        int n = array.length;
        int[] newArray = new int[n];
        System.arraycopy(array, steps, newArray, 0, n - steps);
        System.arraycopy(array, 0, newArray, n - steps, steps);
        return newArray;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
            array[i] = sc.nextInt();
        }
        int r1 = circleSolution(array, n);
        array = leftShift(array, 1);
        int r2 = circleSolution(array, n);
        r2 = Math.max(r1, r2);
        array = leftShift(array, 1);
        int r3 = circleSolution(array, n);
        r3 = Math.max(r2, r3);
        System.out.println(r3);
    }
}
<think>好的,用户想知道如何对两个数组元素进行排序,并且需要编程实现。首先,我需要明确用户的需求。可能用户有两个数组,想分别排序,或者合并后排序?或者需要同步排序两个数组?需要进一步分析。 根据用户提供的引用内容,站内引用提到了简单排序算法和先进排序算法,比如冒泡排序和快速排序。用户可能希望了解如何用这些方法对两个数组进行排序。 首先,我需要考虑两种情况:独立排序两个数组,或者关联排序两个数组(比如根据一个数组的顺序调整另一个数组)。用户的问题描述不太明确,可能需要假设是独立排序两个数组。但为了全面,或许应该都涵盖。 在编程实现中,如果是独立排序,那么分别对每个数组调用排序函数即可。例如,使用冒泡排序分别处理两个数组。但用户可能希望了解如何同时处理两个数组,比如一个数组作为键,另一个数组根据第一个数组的顺序调整。这种情况常见于需要保持两个数组元素对应的情况,比如排序姓名和分数。 根据引用[^2]中的冒泡排序示例,代码中有错误,比如交换部分使用了未定义的变量k,应该是交换h[j]和h[j+1]。需要指出这个错误,并在示例中修正。 用户可能需要具体的代码示例,因此要提供两种情况的实现:独立排序和关联排序。同时,选择哪种排序算法?可能冒泡排序比较简单,适合示例,而快速排序效率更高,但代码稍复杂。 另外,引用[^1]提到快速排序属于先进排序算法,时间复杂度O(n logn),适合大规模数据。用户可能对性能也有需求,所以可以比较不同算法的适用场景。 总结步骤: 1. 确定排序需求:独立排序还是关联排序。 2. 选择排序算法(冒泡、快速等)。 3. 编写代码示例,并解释关键步骤。 4. 指出引用中的代码错误并修正。 5. 比较不同算法的优缺点,帮助用户选择合适的方法。 现在需要检查用户提供的引用内容中的冒泡排序代码是否有误。在引用的代码中,交换部分的代码有错误: 原代码: temp= h[i]; h[i] = h[k]; h[k] = temp; 但这里的k未定义,应该是j和j+1。正确交换应为: temp = h[j]; h[j] = h[j+1]; h[j+1] = temp; 需要在回答中指出这个错误,并修正示例代码。 对于关联排序的情况,比如根据数组A的顺序同时调整数组B,可以使用结构体或并行数组,并在排序时交换两个数组的元素。或者使用索引数组来记录排序顺序。 在Python中,可以使用zip函数将两个数组合并,根据其中一个数组排序,再解压。例如: a = [3,1,2] b = ['c', 'a', 'b'] sorted_pairs = sorted(zip(a, b)) a_sorted, b_sorted = zip(*sorted_pairs) 但如果是用冒泡排序手动实现,则需要在交换时同时交换两个数组的元素。 需要确保代码示例正确,并解释清楚。同时,提醒用户注意算法的时间复杂度,根据数据量选择合适的排序方法。 最后,生成相关问题,可能涉及不同排序算法的比较、优化方法、应用场景等。</think>### 如何对两个数组元素进行排序(编程实现) 对两个数组进行排序需明确需求场景,可分为两种典型情况: #### 一、独立排序两个数组 分别对两个数组进行排序,互不影响。 **实现步骤**(以冒泡排序为例): 1. 分别对两个数组执行冒泡排序 2. 每次比较相邻元素,按需交换位置 ```python def bubble_sort(arr): n = len(arr) for i in range(n-1): for j in range(n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值