2017年华为Fx计划在线机试题（详解）

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;
}
}