Question

我有一个数组说{-1,2,3,4,-3,-2,1,5}

现在我想找到最近K次交换的给定数组的最小连续和子数组。

在上面的数组中，最小连续总和为-5，子数组为{-3,-2}

说K=1我应该如何交换元素

我应该交换子数组i的左元素，e;在4处交换元素a[3]，-1留给它{再次使用哪个号码（我脑子里突然出现子问题）？

一个。是否是剩余元素中的最低元素（使用除子阵列之外的其余元素的任何排序技术）。如果我这样做，我会将-1与4交换，最小金额为{-1,-3,-2} 根据“ atmost ”K交换，我可以返回这个子阵列只有一个交换甚至数组的长度
我应该将位置1上的元素a[6]与-1交换，并将最小和的子数组作为{-3,-2,-1}。再次按照上述第a点的相同问题。

这整个过程我想用递归来做。因为我正在处理具有N整数的数组。哪种方法最好我应该遵循递归或迭代？

Answer 1

import java.io. ; import java.util。;

class TestClass {

   static Scanner scanner;
    public static void main(String args[] ) throws Exception {


    scanner=new Scanner(System.in);
    int t=scanner.nextInt();

    while(t>0){
        t--;
    int n=scanner.nextInt();
    int k=scanner.nextInt();
    int[] array=new int[n];
     for(int i=0;i<array.length;i++)
     {
        array[i]=scanner.nextInt();
    }
    int ans=findingMinimumSumSubarray(array,k);
     System.out.println(ans);
    }


}

public static int findingMinimumSumSubarray(int[] values, int k) {
 int len = values.length;
 int res = values[0]; 
 for (int l = 0; l < len; l++) {
     for (int r = l; r < len; r++) {
         List<Integer> A= new ArrayList<Integer>();
         List<Integer> B = new ArrayList<Integer>(); 
         int abc = 0; 
         for (int i = 0; i < len; i++) {
             if (i >= l && i <= r) {
              A.add(values[i]);
                 abc += values[i];
             } else {
                 B.add(values[i]);
             }
         }

         Collections.sort(A);

         Collections.sort(B);
         Collections.reverse(B);
         res = Math.min(res, abc); 
         for (int t = 1; t <= k; t++) {

             if (t > A.size() || t > B.size()) break;

             abc -= A.get(A.size() - t);
             abc += B.get(B.size() - t);
             res = Math.min(res, abc);
         }
     }
 }
 return res;

} }

最小连续和与最多K个交换的程序是什么

1 个答案: