秋招笔试题集合

题目链接https://pan.baidu.com/s/1jcJaEwJqNvAannliEuMr2g 

 完美世界秋招--一个船上最多能坐2人，不超过限度的情况下，可用几条船装完所有人--双指针

import java.util.Arrays;
import java.util.Scanner;

public class BoatNum {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		while(in.hasNext()) {
			String str=in.nextLine();
			int n=in.nextInt();
			String[] arr=str.split(" ");
			int len=arr.length;
			int[]intArr=new int[len];
			for(int i=0;i<len;i++) {
				intArr[i]=Integer.parseInt(arr[i]);
			}
			Arrays.sort(intArr);
			int count=0;
			int j=len-1;
			for(int i=0;i<len;i++) {
				while(j>i) {
					if(intArr[i]+intArr[j]<=n) {
						count++;
						j--;
						break;
					}else {
						j--;
						continue;
					}
						
				}
				
			}
			System.out.println(count);
		}
	}

}

 

 完美世界秋招--图论加权最短路径--Floyd Warshall算法

import java.util.Scanner;
//完美世界秋招
/**
 * @基本功能:
 * @program:summary
 * @author:peicc
 * @create:2019-08-24 10:11:20
 **/
public class ShortestPath {
    private static final int max=99999999;
    /**
     * @功能：定点i到顶点j的最短路径
     * @Param: [distance]
     * @return: int[][]
     * @Date: 2019/8/24
     */
    public static int[][] solutionByFloyd(int distance[][]){
        int len=distance.length;
        for (int i = 0; i <len ; i++) {//
            for (int j = 0; j <len ; j++) {
                for (int k = 0; k <len ; k++) {
                    if(distance[j][k]>distance[j][i]+distance[i][k]){
                        distance[j][k]=distance[j][i]+distance[i][k];
                    }
                }
            }
        }
        return distance;
    }
    //主函数
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String[] temp=sc.nextLine().split(" ");
        int len=temp.length;
        int[][] distance=new int[len][len];
        for (int i = 0; i <len ; i++) {
            int num=Integer.parseInt(temp[i]);
            if(num==-1){
                num=max;
            }
            distance[0][i]=num;
        }
        for (int i = 1; i < len; i++) {
            String[] temp1=sc.nextLine().split(" ");
            for (int j = 0; j <len ; j++) {
                int num=Integer.parseInt(temp1[j]);
                if(num==-1){
                    num=max;
                }
                distance[i][j]=num;
            }
        }
        for (int i = 0; i <len ; i++) {
            System.out.println();
            for (int j = 0; j <len ; j++) {
                System.out.print(distance[i][j]+" ");
            }
        }
        System.out.println();
        int[][] result=solutionByFloyd(distance);
        for (int i = 1; i <result.length ; i++) {
            System.out.println(result[0][i]);
        }
    }
}

 

 猿辅导第一题--大于界限的数剔除

import java.io.File;
import java.util.*;
import java.util.Map.Entry;
//way1：用map，将数作为key，出现次数作为value，>m的不输出，<=m的，按value的个数循环输出
//但有个问题，map里会对key做自然排序
//way2：用两个数组，一个记key，一个记次数，不ok

public abstract class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        while(in.hasNext()) {
        	int n=in.nextInt();
            int arr[]=new int[n];
            int m=in.nextInt();
            for (int i = 0; i <n; i++) {
            	arr[i]=in.nextInt();
            }
            getFilteredNum(arr,m);
        }
        
    }
    public static void getFilteredNum(int[] array,int m){
        int len=array.length;
        Map<Integer, Integer> map=new HashMap<>();
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<len;i++) {
        	if(map.containsKey(array[i])) {
        		map.put(array[i], map.get(array[i])+1);
        	}else {
        		map.put(array[i], 1);
        	}
        }
        ArrayList<Map.Entry<Integer, Integer>> list=new ArrayList<>(map.entrySet());
        Collections.sort( list,new Comparator<Map.Entry<Integer, Integer>>() {
		} );
        for(Map.Entry<Integer, Integer> entry:list) {
        	if(entry.getValue()>m) {
        		continue;
        	}else {
        		for(int j=0;j<entry.getValue();j++) {
        			sb.append(entry.getKey()+" ");
        		}
        	}
        }
        System.out.println(sb.delete(sb.length()-1, sb.length()).toString());
    }
}

猿辅导第二题--有几个角色，挑出3个不同角色，为一组，求问可以组成多少组

//第一行给出有n组测试用例
//接下来的n行，第一个数给出有几个角色，挑出3个不同角色，为一组，求问可以组成多少组
//输入案例1：    
//3
//3 1 1 1
//3 2 2 3
//4 0 2 3 99
//输出：
//1
//2
//2
import java.io.File;
import java.util.*;

public abstract class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int c=sc.nextInt();
        int result[]=new int[c];
        for (int i = 0; i <c; i++) {
            int T=sc.nextInt();
            int[]  temp=new int[T];
            for (int j = 0; j <T ; j++) {
                temp[j]=sc.nextInt();
            }
            result[i]=getMax(temp);
        }
        for (int i = 0; i <c ; i++) {
            System.out.println(result[i]);
        }


    }
    public static int getMax(int[] array){
        int len=array.length;
        if(len<3){
            return 0;
        }
        Arrays.sort(array);
        int count=0;
        while(array[len-3]!=0){
            count++;
            array[len-3]--;//后3个
            array[len-2]--;
            array[len-1]--;
            Arrays.sort(array);//排序
        }
        return count;
    }
}

阿里--最幸福男生位置，和最大团队男生数

import java.util.Scanner;
//最幸福男生的位置--两个指针分别向两边查找
//最大团队数--找到第一个男生，往后查找，遇边界换向
public class BoyProblem {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		while(in.hasNext()) {
			String str=in.nextLine();
			char[] arr=str.toCharArray();
			int girlNum=in.nextInt();
			System.out.println(happinessBoy(arr));
			System.out.println(maxBoyNum(arr, girlNum));
		}
	}
	private static int happinessBoy(char[] arr){
		int loc=-1,max=-1;
		int len=arr.length;
		for(int i=0;i<len;i++) {
			int num=0;
			if(arr[i]=='b') {
				for(int j=i-1;j>=0;j--) {
					if(arr[j]=='g') {
						num++;
					}else
						break;
				}
				for(int k=i+1;k<len;k++) {
					if(arr[k]=='g') {
						num++;
					}else
						break;
				}	
			}
			if(max<num) {
				max=num;
				loc=i;
			}
		}
		return loc;
	}
	private static int maxBoyNum(char[] arr,int girlNum) {
		int gNum=0,max=-1;
		int len=arr.length;
		for(int i=0;i<len;i++) {
			int num=1;
			if(arr[i]=='b') {
				int k=i+1;
				while(k!=i) {
					if(k>=len)k=0;
					if(gNum<=girlNum) {
						if(arr[k]=='g') {
							k++;
							gNum++;
						}
						if(arr[k]=='b') {
							k++;
							num++;
						}
					}else
						break;
				}
			}
			if(max<num)
				max=num;
		}
		return max;
	}
}

最大公共子序列，输出长度和子序列

 

public class LCS {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = Integer.parseInt(scanner.nextLine());
		int[] x = new int[n];
		int[] y = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = scanner.nextInt();
		}
		for (int i = 0; i < n; i++) {
			y[i] = scanner.nextInt();
		}
		int[][] c = new int[n + 1][n + 1];
		int[][] b = new int[n + 1][n + 1];
		/*
		 * for(int i=0;i<=n;i++){ for(int j=0;j<=n;j++){ c[i][j]=0; } }
		 */
		getLength(c, b, x, y, n);
		display(b, x, n, n);
	}

	private static void getLength(int[][] c, int[][] b, int[] x, int[] y, int n) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (x[i - 1] == y[j - 1]) {
					c[i][j] = c[i - 1][j - 1] + 1;
					b[i][j] = 1;
				} else {
					if (c[i - 1][j] >= c[i][j - 1]) {
						c[i][j] = c[i - 1][j];
						b[i][j] = 0;
					}
					// 对应第二或者第三个性质
					else {
						c[i][j] = c[i][j - 1];
						b[i][j] = -1;
					}
				}
			}
		}
		System.out.println(c[n][n]);// 最长公共子序列的长度
	}

	// 回溯的基本实现，采用递归方式
	private static void display(int[][] b, int[] x, int n,int m) {
		if(n == 0||m==0)
		      return;
		if(b[n][m] == 1)
	    {
	      display(b, x, n-1, m-1);
	      System.out.print(x[n] + " ");
	    }
	    else if(b[n][m] == 0)
	    {
	    	display(b, x, n-1, m);
	    }
	    else if(b[n][m] == -1)
	    {
	    	display(b, x, n, m-1);
	    }
	}
}