拼多多提前批（7月28号笔试题

      看到昨天同学拼多多的笔试题，今天试着写了写，因为自己并没有参加过笔试，写出来的只是我自己能想到的测试用例都过了的，如果有错误，欢迎各位大神指出，仅仅是提供一个解题的想法。而且因为自己基本功不够，写出的程序基本事件复杂度都比较高，也欢迎大神提出优化改进的方法。

1. 给定两个数组A和B。其中数组A是几乎严格升序排列的，几乎的定义是只需改变其中一个数，即可满足完全升序排列。
   你的任务是从数组A中找到这个数字，并从数组B中选取一个数将其替换，使得数组A是完全严格升序排列的。(严 格升序排列，即不允许相邻两个为相同的数)
   请找出数组B中满足要求的最大数字，并输出最终有序的数组。如果不存在就输出NO. 
   输入描述:
          共两行，第一行是数组A，第二行是数组B，元素之间用空格分隔(数组A的长度，数组B的长度< 100)
   输出描述:
          共一行，为最终有序的数组。不存在则输出NO
   示例1

输入

1       3       7       4       10

2      1       5       8       9

输出：

1      3       7       9       0

输入:

20     1       23

50      26     7

输出：

NO

 

         解题思路：这个的解题思路的重点在于改变A[index]和A[index-1]都有可能组成一个升序数组，其中index是定位到的A[index]

import java.util.Scanner;
public class First {
    public static void main(String ars[]){
        Scanner scanner=new Scanner(System.in);
        int[] arrA = parseInts(scanner.nextLine().split(" "));
        int[] arrB = parseInts(scanner.nextLine().split(" "));

        int res[]=changeToSort(arrA,arrB);
        if(res==null){
            System.out.println("No");
        }else{
            for(int r:res){
                System.out.print(r+" ");
            }
        }

    }

    public static int[] changeToSort(int A[],int B[]){
        if(A==null||B==null||A.length==0||B.length==0)
            return null;
        int index=Integer.MAX_VALUE;
        for(int i=1;ilength;i++){
            if(A[i]1]){
                index=i;
                break;
            }
        }
        int max=Integer.MIN_VALUE;
        if(index==A.length-1){
            for(int i=0;ilength;i++){
                if(B[i]>A[index-1]&&max                     max=B[i];
            }
            if(max==Integer.MIN_VALUE){
                index--;
                for(int i=0;ilength;i++){
                    if(B[i]>max&&B[i]>A[index-1]&&B[i]1])
                        max=B[i];
                }
               
            }
        }else{
            for(int i=0;ilength;i++){
                if(B[i]>A[index-1]&&B[i]1]&&max                     max=B[i];
            }
            if(max==Integer.MIN_VALUE&&A[index]1]){
                index--;
                for(int i=0;ilength;i++){
                    if(index-1>0){
                        if(B[i]>A[index-1]&&B[i]1]&&max                             max=B[i];
                    }else{
                        if(B[i]1]&&max                             max=B[i];
                    }
                }

            }
        }
        if(max==Integer.MIN_VALUE){
            return null;
        }
        A[index]=max;
        return A;
    }
//这边只是一个函数转换，把字符串变成int类的数组
    private static int[] parseInts(String[] strArr) {
        if (strArr == null || strArr.length == 0) {
            return new int[0];
        }
        int[] intArr = new int[strArr.length];
        for (int i = 0; i < intArr.length; i++) {
            intArr[i] = Integer.parseInt(strArr[i]);
        }
        return intArr;
    }

}

 

 

2.给定一个字符串数组(字符串长度和数组的长度均大于1且小于1024)，所有字符均为大写字母。请问，给定的字符串数组是否能通过更换数组中元素的顺序，从而首尾相连，形成一个环，环上相邻字符串首尾衔接的字符相同。
输入描述:
         一行输入，空格分隔，表示字符串数组。
输出描述:
         一行输出， 返回true或者false,表示是否可以形成环。
例：

输入：

CAT    TIGER   RPC

输出：

true

输入：

CAT   RPC

输出：

False

 

这个题我的想法是只要每一个字符串可以找到与之相连的字符串并且和别人找到的不重复就可以，所以用了两个循环

import java.util.Scanner;

public class Second {

    public static void main(String ars[]){

        Scanner scanner=new Scanner(System.in);

        String string=scanner.nextLine();

        String[] str=string.split(" ");

        System.out.println(test(str));



    }



    public static boolean test(String strs[]){

        int length=strs.length;

        //这边把数组里面少于1的都算作false；

        if(length<=1||strs==null)

            return false;

        if(length==2)

            return strs[0].charAt(strs[0].length()-1)==strs[1].charAt(0)&&strs[1].charAt(strs[0].length()-1)==strs[0].charAt(0);

        int[] nums=new int[length];

        boolean[] isEmpty=new boolean[length];

        for(int i=0;i

         3  多多鸡在公司负责一个分布式任务执行平台的维护。夏天到了，平台的服务器都因中暑而无法执行任务了。所以多多鸡必须自己手动来执行每个任务!
      现在一共有N个待执行的任务，每个任务多多鸡需要P1的时间完成执行。同时，任务之间可能会有一些依赖关系。比如任务1可能依赖任务2和任务3，那么任务1必须在任务2和任务3都执行完成后才能执行。
      多多鸡只有一个人，所以同时只能执行一个任务，并且在任务完成之前不能暂停切换去执行其他任务。 为了提升平台用户的使用体验，多多鸡希望最小化任务的平均返回时长。一个任务的返回时长定义为任务执行完成时刻减去平台接收到该任务的时刻。在零时间，所有N个任务都已经被平台接收。请你帮多多鸡安排下任务执行顺序，使得平均返回时长最
小。
 输入描述:
      第一行包含2个正整数N、M，分别表示任务数量以及M个任务依赖关系。
      第二行包含N个正整数，第i(1<=1<=N)个数表示第i个任务的处理时间Pi。
    接下来的M行，每行表示一个任务依赖关系。每行包含2个整数Ai(1<=Ai<=N)、B1(1<=Bi<=N)，表示第B1个任务依赖于第A1个任务。数据保证不会出现循环依赖的情况。数据范围:
         1<=N<=1000

1<=M<=50000

1<=P1<=10000
 输出描述:
      输出一行，包含N个整数(两两之间用一个空格符分隔)，其中第i(1<=i<=N)个整数表示多多鸡执行的第i个任务的编号。若有多种可行方案,则输出字典序最小(优先执行编号轮小的任务的方案。

例：

输入：

5   6

1   2    1     1    1                     

1   2

1   3      

1   4

2   5

3   5

4    5

输出：

1        3       4       2       5   （输出的是执行顺序）；

解题思路：这就是个优先级加编号和时间的问题。先对所有的排优先级，在优先级相同的情况下选出时间短的和编号在前的。

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;
public class Third {



    public static void main(String args[]){

        Scanner sc=new Scanner(System.in);

        int N=sc.nextInt();

        int M=sc.nextInt();

        int times[]=new int[N];

        int dependencies[][]=new int[M][2];

        for(int i=0;i(依赖)j，则isDes[i][j]=true

        for(int i=0;i0){

            //肯定有优先级为1的，不然没法开始

            Listlist=new ArrayList<>();

            for (int i=0;i0){

                int max=Integer.MAX_VALUE,index=-1;

                for(int i=0;itimes[list.get(i)]){

                        max=times[list.get(i)];

                        index=i;

                    }

                }

                res[k++]=list.get(index)+1;

                list.remove(index);

            }

        }

        return res;

    }

}

 

 4.   多多鸡宝宝在玩搭积木游戏。有N个长方体积木，每个积木的高都是1，长宽都为Li，重量为Wi。
      现在多多鸡宝宝想要用这些积木搭一个高高的金字塔。他打算金字塔的每一层是由且仅由一块积木组成，同时每一层的积木边长都严格比在其下方的积木小。
      在多次尝试之后，多多鸡宝宝发现每块积木只能承受自身重量的7倍重量,一若超过7倍自重，搭建的金字塔会因此变得不稳定。具体来说即:对于每一块积木，在其上方的积木重量之和必须小于等于其自重的7倍。
      多多鸡宝宝想请你帮他计算一下最高可以搭一个多高的金字塔?
 数据范围:
 1<=N<=100

1<=Li<=1000

1<=Wi<=1000
输入描述:
 第一行包含1个正整数N，表示积木的数量。

第二行包含N个正整数，第i个数表示第i个积木的长度Li。

第三行包含N个正整数，第i个数表示第i个积木的重量Wi
输出描述：

输出占一行，近包含一个整数，表示可以搭出金字塔的最高高度。

例：

输入：

10

1    2       3       4       5       6       7       8       9      10

1    1       1        1       1        1      1       1        1      10                                                      

输出：

9

解题思路：我个人觉得这个跟动态规划里面的信封问题类似，甚至说他比信封问题更简单，信封问题要考虑长和宽，由于这个长宽是一致的，考虑长就可以。他在信封问题的改变在于多加了一个重量的参数，考虑长和宽就变成了考虑体积和重量。这个题目可以从上面往下面堆，这样做的好处就是你可以仅仅考虑当前块能不能承受，而不用考虑前一块。因为前一块能够成立的话，在计算他的时候肯定就已经确定了他可以承受前面的重量。用动态规划来做。

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Four {

    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int work[][]=new int[n][2];
        for(int i=0;i(){
            public int compare(int[] o1,int [] o2){
                //判断第一个元素是否相等
                if (o1[0] == o2[0]) {
                    return o1[1] - o2[1];
                } else {
                    return o1[0] - o2[0];
                }
            }
        });
        
        //一个二维数组，nums[i][0]用来记录当前最多叠了几层，nums[i][1]用来表示当前积木所有的重量
        int nums[][]=new int[length][2];
        for(int i=0;inums[i][0]){
                      nums[i][0]=nums[j][0]+1;
                      nums[i][1]=nums[j][1]+arr[i][1];
                  //下面的主要是为了替换得到更少的重量。
              }else if(nums[j][0]+1==nums[i][0]&&nums[j][1]+arr[i][1]max)
                max=nums[i][0];
        }
        return max;

    }

}