2017年华为Fx计划在线机试题（详解）
来源：互联网 发布：喜剧网络剧他大舅 编辑：程序博客网 时间：2024/05/20 13:15
1，题目描述
小k是x区域的销售经理，他平时常驻“5”城市，并且经常要到“1”，“2”，“3”，“4”，“6”城市出差。当机场出现大雾的情况下，会导致对应城市的所有航班的起飞及降落均停止（即不能从该城市出发，其他城市也不能到达该城市）。小k希望知道如果他需要到x城市出差时，如果遇到y城市出现大雾，他最短的飞行时间及飞行路径。
注意：当两个城市不可达时，消耗时间默认取1000.
各城市间的飞行时间如下表所示，行代表始发城市，列代表终点城市，矩阵中的值代表从始发城市飞行到终点城市所消耗的时间（单位小时），M代表不可达（注意飞行路径是单向的，即A–>B不等于B–>A）
例如：
1）从1号城市飞行到4号城市花费5h，从4号城市飞到1号城市花费2h
2）从5号城市飞行到3号城市不可达，从3号城市飞行到5号城市花费7h 
输入描述：
输入出差城市x（x可以是1,2,3,4,6）
输入大雾城市y（y可以是0,1,2,3,4,5,6，为0时代表没有出现大雾）
输出描述：
输出最短飞行时间（不可达时为1000）
输出飞行路径，使用“[]”包围所有值，使用“,”分割数值（不可达时“[]”）
输入例子：
2
4
输出例子：
6
[5,1,2]
解题思路：
- 如果目标城市和大雾城市是同一个的话，依题意所知，一定不可达
- 如果大雾城市就是出发城市的话，依旧不可达
- 当没有城市有大雾，也就是说输入y=0时，首先设置最低时长为直达的时间，然后使用回溯法计算从出发城市到目标城市的所有路径，此路径包括不可达与可达路径，当路径不可达时，我们设置达到时长是M=1000，最后计算所有可能的路径时长，求最小值
- 当有大雾城市的时候，我们计算路径的时候直接移除该城市的所有路径的情况，也就是说在计算的路径的时候直接不考虑该城市。之后的情况也就和上面类似了。
- 注意细节，因为A城市到B城市的时长，与B城市到A城市的时长是不相同的，所以计算路径的时候，不能仅仅计算子集那么简单，还要计算该子集路径的全排列！
代码简单易懂！欢迎纠正。
public static void getMinPath(int x,int y){ int M=1000; int [][]matrix={{M,2,10,5,3,M},{M,M,12,M,M,10},{M,M,M,M,7,M}//初始化数组 ,{2,M,M,M,2,M},{4,M,M,1,M,M},{3,M,1,M,2,M}}; List<Integer> target=new ArrayList<Integer>();//初始化目标城市 target.add(1); target.add(2); target.add(3); target.add(4); target.add(6); if(!target.contains(x)||y>6||y<0){//非法输入的讨论 System.out.println("非法输入"); return; } if(x==y){//目标城市和大雾城市相同，肯定是不可达 System.out.println(1000); System.out.println("[]"); return; } if(y==5){//大雾城市就是出发城市，肯定不可达 System.out.println(1000); System.out.println("[]"); return; } if(y==0){//没有大雾的天气 target.remove((Integer)x); List<List<Integer>> result=new ArrayList<List<Integer>>();//取子集 List<Integer> tempList=new ArrayList<Integer>();//临时存储 List<List<Integer>> last=new ArrayList<List<Integer>>();//取所有的路径情况 for(int i=1;i<=target.size();i++) subSet(target, i, 0, result, tempList); for(int i=0;i<result.size();i++){ List<Integer> temp=result.get(i); rank(temp, tempList, last); } int min=matrix[4][x-1];//初始值为直达 String str="[5,"; int index=-1; for(int i=0;i<last.size();i++){ List<Integer> temp=last.get(i); int sum=matrix[4][temp.get(0)-1]; for(int j=1;j<temp.size();j++) sum+=matrix[temp.get(j-1)-1][temp.get(j)-1]; sum+=matrix[temp.get(temp.size()-1)-1][x-1]; if(min>sum){ min=sum; index=i; } } //输出处理start if(index==-1){//如果在直达的情况最小 if(min==1000){//如果直到最小值是1000的话，则说明这条路径是没有的 System.out.println(1000); System.out.println("[]"); }else{//反之输出直达路径 System.out.println(min); System.out.println(str+(x)+"]"); } }else{ System.out.println(min); for(int i=0;i<last.get(index).size();i++){ str+=last.get(index).get(i)+","; } System.out.println(str+x+"]"); } //输出处理end }else{//有大雾的天气，但是不是出发点，也不是目的地 target.remove((Integer)x); target.remove((Integer)y); List<List<Integer>> result=new ArrayList<List<Integer>>();//取子集 List<Integer> tempList=new ArrayList<Integer>();//临时存储 List<List<Integer>> last=new ArrayList<List<Integer>>();//取所有的路径情况 for(int i=1;i<=target.size();i++) subSet(target, i, 0, result, tempList); for(int i=0;i<result.size();i++){ List<Integer> temp=result.get(i); rank(temp, tempList, last); } int min=matrix[4][x-1];//初始值为直达 String str="[5,"; int index=-1; for(int i=0;i<last.size();i++){ List<Integer> temp=last.get(i); int sum=matrix[4][temp.get(0)-1]; for(int j=1;j<temp.size();j++) sum+=matrix[temp.get(j-1)-1][temp.get(j)-1]; sum+=matrix[temp.get(temp.size()-1)-1][x-1]; if(min>sum){ min=sum; index=i; } } //输出处理start if(index==-1){ if(min==1000){ System.out.println(1000); System.out.println("[]"); }else{ System.out.println(min); System.out.println(str+(x)+"]"); } }else{ System.out.println(min); for(int i=0;i<last.get(index).size();i++){ str+=last.get(index).get(i)+","; } System.out.println(str+x+"]"); } //输出处理end } } public static void subSet(List<Integer> target,int k,int start,List<List<Integer>> result,List<Integer> tempList){ //计算所有的路径 if(k<0) return; else if(k==0){ result.add(new ArrayList<Integer>(tempList)); }else{ for(int i=start;i<target.size();i++){ tempList.add(target.get(i)); subSet(target, k-1, i+1, result, tempList); tempList.remove(tempList.size()-1); } } } public static void rank(List<Integer> list,List<Integer> tempList,List<List<Integer>> result){ //路径的全排列 if(tempList.size()==list.size()){ result.add(new ArrayList(tempList)); }else{ for(int i=0;i<list.size();i++){ if(tempList.contains(list.get(i))) continue; tempList.add(list.get(i)); rank(list, tempList, result); tempList.remove(tempList.size()-1); } } }2,任务调度过程
题目描述：
输入五个任务的ID，任务优先级，开始运行时间和运行时长，其中调度过程是抢占式的，即优先级数值高的任务可以抢占正在运行的优先级值低的任务，最后输出前200秒，任务调度过程
输入描述：
任务信息输入格式：[任务ID.优先级.任务开始时间.任务时长]；任务与任务之间使用“|”隔开，5个任务ID为1-5；优先级范围是0-200
输出描述：
输出任务信息为：任务ID.任务时长;任务之间使用“|”隔离；如果无任何任务运行，则任务ID为0
输入例子：
[1.80.1.10]|[2.20.11.15]|[3.50.21.10]|[4.123.31.10]|[5.100.41.10]
输出例子：
0.1|1.10|2.10|3.10|4.10|5.10|2.5|0.144
题目解析：
1，该题目的输入输出处理起来相当不易，注意的是”|”和”.”在使用字符串截取的时候都需要转义字符“\\”；
2，因为任务是抢占式的，所以我们处理的时候优先级高者优先处理；
3，我们可以逐秒分析，分析该时刻应该是哪个任务所拥有执行，如果没有任务执行，则任务id为0；
废话不多说，代码够详细！
import java.util.*;public class FX002 { public static void main(String[] args) { Scanner sc=new Scanner(System.in); while(sc.hasNext()){ String str=sc.nextLine(); String []arr=str.split("\\|"); List<Job> list=new ArrayList<Job>();//存放任务 for(int i=0;i<arr.length;i++){ String temp=arr[i].substring(1, arr[i].length()-1); String []arrTemp=temp.split("\\."); int id=Integer.parseInt(arrTemp[0]); int priorty=Integer.parseInt(arrTemp[1]); int start=Integer.parseInt(arrTemp[2]); int lasting=Integer.parseInt(arrTemp[3]); Job job=new Job(id, priorty, start, lasting); list.add(job); } List<Job> postSort=sortByPriorty(list);//将任务按照优先级排序 List<Integer> q=new ArrayList<Integer>();//存放每刻时间的任务id for(int i=0;i<200;i++){ Job currentJob=null;//当前任务 for(Job job:postSort){ if(job.start<=i&&job.left>0){ currentJob=job;//选取此刻优先级最高的任务并且该任务剩余的工作量大于0 break;//获取之后即跳出，以防被低优先级的任务抢去 } } if(currentJob==null){ q.add(0);//如果此刻没有任务，则将此刻id赋值0 }else{ q.add(currentJob.id);//存放任务id currentJob.left--;//该任务的工作量递减 } } q.add(-1);//存放任务id的链表结束符 String s="";//返回结果 int count=1;//计数器：在链表中连续工作的时间数 for(int i=0;i<q.size()-1;i++){ if(q.get(i)==q.get(i+1)){ count++; }else{ s+=q.get(i)+"."+count+"|"; count=1; } } System.out.println(s.substring(0, s.length()-1));//输出结果 } } public static List<Job> sortByPriorty(List<Job> list){//任务按优先级排序 List<Integer> priortyList=new ArrayList<Integer>(); for(Job j:list) priortyList.add(j.priorty); Collections.sort(priortyList); List<Integer> index=new ArrayList<Integer>(); for(Integer i:priortyList){ int start=-1; loop:for(Job j:list){ start++; if(i==j.priorty){ index.add(start); start=-1; break loop; } } } List<Job> postSort=new ArrayList<Job>(); for(Integer i:index) postSort.add((list.get(i))); List<Job> result=new ArrayList<Job>(); for(int i=0;i<postSort.size();i++) result.add(postSort.get(postSort.size()-1-i)); return result; }}class Job{ int id;//任务id int priorty;//优先级 int start;//开始时间 int lasting;//工作时长 int left;//剩余工作时长 public Job(int id,int priorty,int start,int lasting){ this.id=id; this.priorty=priorty; this.start=start; this.lasting=lasting; this.left=lasting; }}测试样例，如图所示：
3，IP地址排序
题目描述：
一组IP地址可能包含A,B,C,D,E类型，请按照ip地址类型输出，相同ip地址类型的按照ip地址的大小排序，按照整数大小从小到达排序。错误ip地址不参与排序。
输入描述：
输入5行，每行均为一个ip地址，ip地址可能是错误的，错误ip地址不参与排序
输出描述：
输出N行，每行输出相同类型的IP地址且按照ip地址大小排序，使用“[]”包围所有值，使用“,”分割数值
输入例子：
80.1.1.1
90.1.1.1
180.1.1.1
190.1.1.1
200.1.1.1
输出描述：
A:[80.1.1.1,90.1.1.1]
B:[180.1.1.1,190.1.1.1]
C:[200.1.1.1]
解题分析：
- 第一步要做的就是合法性分析，此题目要求比较低，合法性分析咱们只需要分析其每位数字是否处于0-255之间即可
- 将ip地址分类
- 因为是需要对每组的IP地址进行排序，所有我们直接调用Collections.sort()，这给我们省去了很大的麻烦
- 当然排序算法如果觉得不可靠的话，可随意写了就行。
废话不说，直接上代码！
import java.util.ArrayList;import java.util.Collections;import java.util.List;import java.util.Scanner;public class FX003 { public static void main(String[] args) { Scanner sc=new Scanner(System.in); while(sc.hasNext()){ String s1=sc.nextLine(); String s2=sc.nextLine(); String s3=sc.nextLine(); String s4=sc.nextLine(); String s5=sc.nextLine(); List<String> list=new ArrayList<String>(); list.add(s1); list.add(s2); list.add(s3); list.add(s4); list.add(s5); classifyIP(list); } } public static void classifyIP(List<String> list){ List<String> A=new ArrayList<String>(); List<String> B=new ArrayList<String>(); List<String> C=new ArrayList<String>(); List<String> D=new ArrayList<String>(); List<String> E=new ArrayList<String>(); for(int i=0;i<list.size();i++){ if(isValid(list.get(i))){ String []arr=list.get(i).split("\\."); int x=Integer.parseInt(arr[0]); if(x>=0&&x<=127)//A A.add(list.get(i)); else if(x>=128&&x<=191)//B B.add(list.get(i)); else if(x>=192&&x<=223)//C C.add(list.get(i)); else if(x>=224&&x<=239)//D D.add(list.get(i)); else//E E.add(list.get(i)); } } if(!A.isEmpty()){ Collections.sort(A);//排序 System.out.print("A:"); System.out.println(A); } if(!B.isEmpty()){ Collections.sort(B); System.out.print("B:"); System.out.println(B); } if(!C.isEmpty()){ Collections.sort(C); System.out.print("C:"); System.out.println(C); } if(!D.isEmpty()){ Collections.sort(D); System.out.print("D:"); System.out.println(D); } if(!E.isEmpty()){ Collections.sort(E); System.out.print("E:"); System.out.println(E); } } public static boolean isValid(String s){//题干中指出：ip地址合法性的判断答题者只需负责数字的大小验证 String []arr=s.split("\\."); for(int i=0;i<arr.length;i++){ if(Integer.parseInt(arr[i])>255||Integer.parseInt(arr[i])<0) return false; } return true; }}
1 0
- 2017年华为Fx计划在线机试题（详解）
- 2016年华为机试题
- 2016年华为机试题（贪心算法）
- 2012年华为软件工程师机试题
- 2014 年华为校园招聘机试题
- 2013年华为机试题1
- 2016年华为校招机试题
- 2015年华为提前招聘机试题--奇数偶数排序（奇数偶数不同排序）
- 补充一道2015年华为校园招聘机试题（字符串处理）
- 2014年华为校园招聘机试题目
- 2013年华为校园招聘软件类机试题
- 2015年华为提前招聘机试题--查找完数
- 2015年华为提前招聘机试题--奇数偶数排序
- 2015年华为提前招聘机试题--奇偶排序
- 09年华为面试题及答案
- 2009年华为软件研发一笔试题
- 2014年华为校招成渝地区上机试题
- 2014年华为校招机试题目
- IMWeb第二次作业——Vue.js的select组件
- python tornado 操作 mysql
- 彻底根除“无法安装64位版本的Office，因为在您的PC上找到了以下32位程序：”的问题
- 栈的应用
- 一款不错的Android环形进度条
- 2017年华为Fx计划在线机试题（详解）
- JAVA属性和方法的继承与隐藏、final、super、abstract
- LeetCOde33. Search in Rotated Sorted Array
- hdu1421 搬寝室
- java中AWT和Swing的区别与联系
- 栈的应用
- ReactNative安卓首屏白屏优化
- STM32F429 CAN通信不成功
- MyEclipse整合Tomcat
