华为笔试09.08，编程题详解

华为笔试，第二题，会议室安排题解。JAVA版本，通过率100%。 代码有点多，时间仓促，直接暴力求解，没有优化

之后再贴第一题和第三题吧

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//分析：优先顺序从持续时间——》开始时间。
//先存储所有输入

while (in.hasNext()) {
String line = in.nextLine();
boolean flag = true;
if (line.equals("0")) {         //结束所有用例
break;
} else {
ArrayList<Node> dList = new ArrayList<>();
while (in.hasNext()) {
if (!flag) {
line = in.nextLine();
} else {
flag = false;
}
if (line.equals("0,0")) {         //结束当前用例
break;
} else {
int i = 0;
//针对每一个用例
String[] list = line.split(",");
int s = Integer.valueOf(list[0]);
int e = Integer.valueOf(list[1]);
if (s >= 8 && e <= 21) {
int d = e - s;
Node node = new Node(i, s, e, d);
dList.add(node);
}
}
}
//调用函数处理，并打印结果
func(dList);
//输出结果
//构造排序的类进行输出
ArrayList<ResultNode> resList = new ArrayList<>();
for (int i = 0; i < res.size() - 1; i = i + 2) {
int st = res.get(i);
int end = res.get(i + 1);
ResultNode node = new ResultNode(st, end);
resList.add(node);
}


//打印结果
Collections.sort(resList);
for (ResultNode node : resList) {
System.out.print(node.statr + "");
System.out.print("," + node.end);
System.out.println();
}
}

}
}

/**
* 处理每一个用例
*/
private static LinkedList<Integer> res = new LinkedList<>();  //存储结果

private static void func(ArrayList<Node> dList) {
//先在d中找最大的。
//定义一个数组，存储最大持续时间的位置下标
int[] a = new int[dList.size()];
int max = 0;
Collections.sort(dList);        //按照规则排序
res.clear();
//之后按照顺序选择
res.add(dList.get(0).start);
res.add(dList.get(0).end);
for (int i = 1; i < dList.size(); i++) {
Node node = dList.get(i);
//判断是否在区间内
int j = 0;
while (j < res.size() && node.start >= res.get(j)) {
j++;
}

if (j % 2 == 0) {
if (j == res.size() || node.end <= res.get(j)) {
//直接加到最后
res.add(node.start);
res.add(node.end);
Collections.sort(res);
}
}
}

}

private static class ResultNode implements Comparable {
private int statr;
private int end;

public ResultNode(int statr, int end) {
this.statr = statr;
this.end = end;
}

@Override
public int compareTo(Object o) {
ResultNode n = (ResultNode) o;
if (this.end > n.end) {
return 1;
} else {
return -1;
}
}
}

private static class Node implements Comparable {
private int id;
private int start;
private int end;
private int len;

public Node(int id, int start, int end, int len) {
this.id = id;
this.start = start;
this.len = len;
this.end = end;
}


@Override
public int compareTo(Object o) {
Node n = (Node) o;
if (this.len > n.len) {
return -1;
} else if (this.len < n.len) {
return 1;
} else {
if (this.start <= n.start) {
return -1;
} else {
return 1;
}
}
}
}
}