20220512java算法笔试题------数组

1.如何求数组连续最大和

题目描述：

一个有n个元素的数组，这n个元素既可以是正数也可以是负数，数组中连续的一个或多个元素可以组成一个连续的子数组，一个数组可能有多个这种连续的子数组，求子数组和的最大值。例如，对于数组{1,-2, 4, 8,-4, 7,-1,-5}而言，其最大和的子数组为{4, 8,-4, 7}，最大值为15。

思路: 

方法一：

蛮力法最简单也是最容易想到的方法就是找出所有的子数组，然后求出子数组的和，在所有子数组的和中取最大值。

方法二：

重复利用已经计算的子数组和由于Sum[i,j]=Sum[i,j-1]+arr[j]，在计算Sum[i,j]时可以使用前面已计算出的Sum[i,j-1]而不需要重新计算，采用这种方法可以省去计算Sum[i,j-1]的时间，因此，可以提高程序的效率。

方法三：

动态规划方法可以采用动态规划的方法来降低算法的时间复杂度。实现思路如下。首先可以根据数组的最后一个元素arr[n-1]与最大子数组的关系分为以下三种情况讨论：1）最大子数组包含arr[n-1]，即最大子数组以arr[n-1]结尾。2）arr[n-1]单独构成最大子数组。3）最大子数组不包含arr[n-1]，那么求arr[1…n-1]的最大子数组可以转换为求arr[1…n-2]的最大子数组。

方法四：

优化的动态规划方法方法三中每次其实只用到了 End[i-1]与 All[i-1]，而不是整个数组中的值，因此，可以定义两个变量来保存End[i-1]与All[i-1]的值，并且可以反复利用

package array;

/**
 * @author 龙御修
 * @create 2022-05-12 22:15
 */
public class ContinuousArrays {
    public static int maxSubArray(int[] arr){
        if(arr==null||arr.length<1){
            System.out.println("参数不合法");
            return -1;
        }
        int nAll=arr[0];//最大子数组和
        int nEed=arr[0];//包含最后一个元素的最大子数组和
        for(int i=1;i<arr.length;i++){
            nEed=Integer.max(nEed+arr[i],arr[i]);
            nAll=Integer.max(nEed,nAll);
        }
        return nAll;
    }

    public static void main(String[] args) {
        int[] arr={1,-2,4,8,-4,7,-1,-5};
        System.out.println("连续最大和为:"+maxSubArray(arr));
    }
}

1.1.在知道子数组最大值后，如何才能确定最大子数组的位置。 (扩展)

分析与解答：

为了得到最大子数组的位置，首先介绍另外一种计算最大子数组和的方法。在上例的方法三中，通过对公式End[i] = max（End[i-1]+arr[i],arr[i]）的分析可以看出，当End[i-1]＜0时，End[i]=array[i]，其中End[i]表示包含array[i]的子数组和，如果某一个值使得End[i-1]＜0，那么就从arr[i]重新开始。可以利用这个性质非常容易地确定最大子数组的位置。

/**
 * @author 龙御修
 * @create 2022-05-12 22:15
 */
public class ContinuousArrays {
    private static int begin = 0;//记录最大子数组起始位置
    private static int end = 0; //记录最大子数组结束位置

    public int getBegin() {
        return begin;
    }

    public int getEnd() {
        return end;
    }

    public static int maxSubArray(int[] arr) {
        int n = arr.length;
        int maxSum = Integer.MIN_VALUE;//子数组最大值
        int nSum = 0;//包含子数组最后一位的最大值
        int nStart = 0;
        for(int i=0; i<n;i++){
            if(nSum<0){
                nSum=arr[i];
                nStart=i;
            }else {
                nSum+=arr[i];
            }
            if(nSum>maxSum){
                maxSum=nSum;
                begin=nStart;
                end=i;
            }
        }
        return maxSum;
    }

    public static void main(String[] args) {
        ContinuousArrays t=new ContinuousArrays();
        int[] arr = {1, -2, 4, 8, -4, 7, -1, -5};
        System.out.println("连续最大和为:" + t.maxSubArray(arr));
        System.out.println(t.getBegin());
        System.out.println(t.getEnd());
    }
}

2.如何判断请求能否在给定的存储条件下完成

题目描述：

给定一台有m个存储空间的机器，有n个请求需要在这台机器上运行，第i个请求计算时需要占R[i]空间，计算结果需要占O[i]个空间（O[i]＜R[i]）。设计一个算法，判断这n个请求能否全部完成？若能，给出这n个请求的安排顺序。

package array;

/**
 * @author 龙御修
 * @create 2022-05-13 22:35
 */
public class countArray {
    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    /*按照R[I] -O[I]由大到小进行排序*/
    private static void bubbleSort(int[]R,int[]O){
        int len=R.length;
        int i,j;
        for(i=0;i<len;++i){
            for(j=len-1;j>i;--j){
                if(R[j]-O[j]>R[j-i]-O[j-i]){
                    swap(R,j,j-1);
                    swap(O,j,j-1);
                }
            }
        }
    }
     public static boolean schedule(int[] R, int[] O, int M){
        bubbleSort(R,O);
        int left=M;//剩余可用可用空间数
         int len=R.length;
         int i;
         for(i=0;i<len;i++){
             if(left<R[i])
                 return false;
             else
                 left+=O[i];
         }
         return true;
     }

    public static void main(String[] args) {
        int[] R={10,15,23,20,6,9,7,16};
        int[] O ={2,7,8,4,5,8,6,8};
        int N=8;
        int M=50;
        int i;
        boolean scheduResult=schedule(R,O,M);
        if(scheduResult){
            System.out.println("按照如下请求序列可以完成:");
            for(i=0;i<N;i++)
                System.out.print(R[i]+","+O[i]+" ");

        }else
            System.out.println("无法完成调度");
    }
}

3.如何对任务进行调度

题目描述：

假设有一个中央调度机，有n个相同的任务需要调度到m台服务器上去执行，由于每台服务器的配置不一样，因此，服务器执行一个任务所花费的时间也不同。现在假设第 i 个服务器执行一个任务所花费的时间也不同。现在假设第 i 个服务器执行一个任务需要的时间为t[i]。例如，有2个执行机a与b，执行一个任务分别需要7min、10min，有6个任务待调度。如果平分这6个任务，即a与b各3个任务，则最短需要30min执行完所有。如果a分4个任务，b分2个任务，则最短28min执行完。设计调度算法，使得所有任务完成所需要的时间最短。输入m台服务器，每台机器处理一个任务的时间为t[i]，完成n个任务，输出n个任务在m台服务器的分布：int estimate_process_time（int[] t,int m,int n）。

package array;

/**
 * @author 龙御修
 * @create 2022-05-13 23:12
 */
public class taskArray {
    public static void main(String[] args) {
        int[] t={7,10};
        int n=6;
        int[] proTime=calculate_process_time(t,n);
        if(proTime==null){
            System.out.println("分配失败");
            return;
        }
        int totalTime=proTime[0];
        for(int i=0;i<proTime.length;i++){
            System.out.println("第"+(i+1)+"台服务器有"+proTime[i]/t[i]+"个任务,执行总时间为:"+proTime[i]);
            if(proTime[i]>totalTime)
                totalTime=proTime[i];
        }
        System.out.println("执行完所有任务所需的时间为"+totalTime);
    }
        //各个服务器执行完任务所需的时间  t:服务器处理的时间,n:任务个数
    
    private static int[] calculate_process_time(int[] t, int n) {
        if(t==null||n<=0)
            return null;
        int m=t.length;
        int minIndex;
        int minTime;
        int[] proTime=new int[m];
        for (int i = 0; i <n ; i++) {
            minTime=proTime[0]+t[0];//把任务给第j个机器上后这个机器的执行时间
            minIndex=0;
            for(int j=0;j<m;j++){
                //分配到第j台机器上后执行时间更短
                if(minTime>proTime[j]+t[j]){
                    minTime=proTime[j]+t[j];
                    minIndex=j;
                }
            }
            proTime[minIndex]+=t[minIndex];

        }
        return proTime;
    }
}

 4.如何对磁盘分区 

题目描述：

有N个磁盘，每个磁盘大小为D[i]（i=0...N-1），现在要在这N个磁盘上“顺序分配”M个分区，每个分区大小为 P[j]（j=0...M-1）。顺序分配的意思：分配一个分区 P[j]时，如果当前磁盘剩余空间足够，则在当前磁盘分配；如果不够，则尝试下一个磁盘，直到找到一个磁盘D[i+k]可以容纳该分区，分配下一个分区P[j+1]时，则从当前磁盘D[i+k]的剩余空间开始分配，不再使用D[i+k]之前磁盘未分配的空间，如果这M个分区不能在这N个磁盘完全分配，则认为分配失败。实现函数is_allocable判断给定N个磁盘（数组D）和M个分区（数组P），是否会出现分配失败的情况？举例，磁盘为[120,120,120]，分区为[60,60,80,20,80]可分配，如果为[60,80,80,20,80]，则分配失败。

public class Test1_1 {
    public static void main(String[] args) {
        int[] d={120,120,120};//磁盘
        int[] p={60,60,80,20,80};//分区
        if(is_allocable(d,p)){
            System.out.println("分配成功");
        }else {
            System.out.println("分配成功");
        }
    }

    private static boolean is_allocable(int[] d, int[] p) {
        int dIndex=0;//磁盘分区下标
        for(int i=0;i<p.length;i++){
            //找出符合条件的磁盘
            while (dIndex<d.length&&p[i]>d[dIndex]){
                dIndex++;
            }
            //没有可用的磁盘
            if(dIndex>=d.length)
                return false;
            //给分区分配磁盘
            d[dIndex]=p[i];
        }
        return true;
    }
}