随便写的不知道正不正确
package mh.test.common.autocloseable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
public class Test {
public static void main(String[] args) {
System.out.println("华为第三题,一二题在文件中");
new Test().test3();
}
// 测试题1
public void test1() {
Scanner cin = new Scanner(System.in);
int n;
long countResult = 2;
String hexResult = "";
if (cin.hasNext()) {
n = cin.nextInt();
if (n <= 31) {
countResult <<= (n - 1);
hexResult = Long.toHexString(countResult);
}
System.out.println("0x" + hexResult);
}
}
// 测试题2
public void test2() {
Scanner cin = new Scanner(System.in);
String presentString = "";
while (cin.hasNextLine()) {
presentString = cin.nextLine();
int plen = presentString.length();
int depth = 0;
for (int i = 0; i < plen; i++) {
if (presentString.charAt(i) == '(') {
depth = depth + 1;
} else if (presentString.charAt(i) == ')') {
depth = depth - 1;
} else {
System.out.println(depth);
break;
}
}
}
}
// 测试题3
public void test3() {
Scanner cin = new Scanner(System.in);
String presentString = "";
boolean isNewTree = true;
Node rootNode = new Node();
// 树的根节点
rootNode.value = "1";
// 所以节点的Map<节点的值,节点的Node对象>
HashMap<String, Node> nodHashMap = new HashMap<>();
// 将根节点放入Map中
nodHashMap.put("1", rootNode);
// 所有的边的列表
ArrayList<Edge> edgesList = new ArrayList<>();
// 循环检查输入的树
while (cin.hasNext()) {
// 构建新树
rootNode.chiArrayList.clear(); // 清空所有的节点
nodHashMap.clear(); // 清空所有的节点
edgesList.clear(); // 清空所以的边
int k = cin.nextInt();
cin.nextLine(); // 清空输入缓冲
isNewTree = false;
for (int i = 0; i < k - 1; i++) {
// System.err.println(k);
if (cin.hasNext()) {
String v = cin.nextLine();
// System.out.println(v);
String node[] = v.split(" ");
// 添加新的边到List中
Edge nEdge = new Edge(node[0], node[1]);
edgesList.add(nEdge);
// System.out.println(node[0]+"+"+node.length);
// 构建树
if (!nodHashMap.containsKey(node[0])) {
Node newNode = new Node();
Node chiNode = new Node();
newNode.value = node[0];
chiNode.value = node[1];
newNode.chiArrayList.add(chiNode);
chiNode.fatherNode = newNode;
nodHashMap.put(node[1], chiNode);
nodHashMap.put(node[0], newNode);
} else {
Node fatherNode = nodHashMap.get(node[0]);
Node chiNode = null;
if (!nodHashMap.containsKey(node[1])) {
chiNode = new Node();
chiNode.value = node[1];
nodHashMap.put(node[1], chiNode);
} else {
chiNode = nodHashMap.get(node[1]);
}
chiNode.fatherNode = fatherNode;
fatherNode.chiArrayList.add(chiNode);
}
}
}
// printTree(rootNode);
String searchSeq = cin.nextLine();
String sArray[] = searchSeq.split(" ");
// System.out.println("叶子节点顺序:"+searchSeq+","+sArray.length);
// 第一个叶子节点到根路径的所有边
Node firstNode = nodHashMap.get(sArray[0]);
Node tempNode = firstNode;
// searchPaht
LinkedList<String> nodeArrayList = new LinkedList<>();
// 所有边的全职加一
nodeArrayList.addFirst(firstNode.value);
while (tempNode.fatherNode != null) {
// System.out.println("遍历第一个节点");
Node faNode = tempNode.fatherNode;
// 路径的节点信息
nodeArrayList.addFirst(faNode.value);
Edge temp = new Edge(tempNode.value, faNode.value);
for (int i = 0; i < edgesList.size(); i++) {
Edge comEdge = edgesList.get(i);
if (comEdge.equals(temp)) {
comEdge.count++;
}
}
tempNode = faNode;
}
if (sArray.length == 1) {
// System.out.println("只有一个叶节点");
LinkedList<String> tempPathList = new LinkedList<>();
String leaveNodeString = nodeArrayList.removeLast();
tempPathList.addFirst(leaveNodeString);
while (nodeArrayList.size() != 0) {
String tempNodeString = nodeArrayList.removeLast();
tempPathList.addFirst(tempNodeString);
tempPathList.addLast(tempNodeString);
}
for (int i = 0; i < edgesList.size(); i++) {
Edge teEdge = edgesList.get(i);
teEdge.count++;
}
nodeArrayList = tempPathList;
} else {
// System.out.println("遍历其他叶节点");
// printPath(nodeArrayList);
tempNode = firstNode;
for (int l = 1; l < sArray.length; l++) {
Node seNode = nodHashMap.get(sArray[l]);
// 获取到共同的父节点
Node commonFather = getSameFatherNode(tempNode, seNode);
Node samTempNode = tempNode;
// System.out.println("遍历第"+l+"节点"+tempNode.value+","+seNode.value+","+commonFather.value);
// 计算当前节点到共同父亲的路径
while (samTempNode.fatherNode != null) {
Node faNode = samTempNode.fatherNode;
nodeArrayList.addLast(faNode.value);
Edge temp = new Edge(samTempNode.value, faNode.value);
for (int i = 0; i < edgesList.size(); i++) {
Edge comEdge = edgesList.get(i);
if (comEdge.equals(temp)) {
comEdge.count++;
}
}
if (samTempNode == commonFather) {
break;
}
samTempNode = faNode;
}
// 计算下一个节点到共同父亲的路径
samTempNode = seNode;
LinkedList<String> tempNLinkedList = new LinkedList<>();
tempNLinkedList.addFirst(seNode.value);
while (samTempNode.fatherNode != null) {
// System.out.println("111111111");
Node faNode = samTempNode.fatherNode;
Edge temp = new Edge(samTempNode.value, faNode.value);
for (int i = 0; i < edgesList.size(); i++) {
Edge comEdge = edgesList.get(i);
if (comEdge.equals(temp)) {
comEdge.count++;
}
}
if (faNode == commonFather) {
break;
} else {
tempNLinkedList.addFirst(faNode.value);
}
samTempNode = faNode;
}
while (tempNLinkedList.size() != 0) {
nodeArrayList.addLast(tempNLinkedList.removeFirst());
}
// 继续往下一个节点计算
tempNode = seNode;
// System.out.println("mmmmmmmmmmm");
}
}
// 验证边的访问次数是否都为2
ArrayList<Edge> oneCountEdgeList = new ArrayList<>();
String nextNode = getNextNode(tempNode.value, edgesList);
while (nextNode != null) {
nodeArrayList.addLast(nextNode);
nextNode = getNextNode(nextNode, edgesList);
}
// 输出边的访问次数和节点访问路径
// System.out.println("输出结果");
printEdgeListCount(edgesList);
printPath(nodeArrayList, edgesList);
}
}
// 节点的类
class Node {
Node fatherNode;
ArrayList<Node> chiArrayList = new ArrayList<>();
String value;
public ArrayList<Node> getChiArrayList() {
return chiArrayList;
}
public void setChiArrayList(ArrayList<Node> chiArrayList) {
this.chiArrayList = chiArrayList;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
// 边的类
class Edge {
String node1;
String node2;
int count = 0;
public Edge(String node1, String node2) {
// TODO Auto-generated constructor stub
this.node1 = node1;
this.node2 = node2;
}
public String getNode1() {
return node1;
}
public void setNode1(String node1) {
this.node1 = node1;
}
public String getNode2() {
return node2;
}
public void setNode2(String node2) {
this.node2 = node2;
}
@Override
public boolean equals(Object obj) {
Edge edge = (Edge) obj;
// TODO Auto-generated method stub
if (this.node1.equals(edge.getNode1())
&& this.node2.equals(edge.getNode2())) {
return true;
} else if (this.node1.equals(edge.getNode2())
&& this.node2.equals(edge.getNode1())) {
return true;
}
return false;
}
public boolean isContainNode(String node) {
if (node1.equals(node) || node2.equals(node))
return true;
return false;
}
public String getAnotherNode(String node) {
String anotherNode = null;
if (node1.equals(node)) {
anotherNode = node2;
} else if (node2.equals(node)) {
anotherNode = node1;
}
return anotherNode;
}
}
public static Node getSameFatherNode(Node node1, Node node2) {
// System.out.println("获取共同的父节点");
Node commonFatherNode = null;
HashMap<Node, Integer> fatherMap = new HashMap<>();
Node tempNode = node1;
while (tempNode.fatherNode != null) {
// System.out.println("ffffff("+node1.value+","+node2.value+")"+tempNode.value);
Node tempfaNode = tempNode.fatherNode;
if (!fatherMap.containsKey(tempfaNode)) {
fatherMap.put(tempfaNode, 1);
}
tempNode = tempfaNode;
}
tempNode = node2;
while (tempNode.fatherNode != null) {
// System.out.println("sssssssssssssssssssssssssssss");
Node tempfaNode = tempNode.fatherNode;
if (fatherMap.containsKey(tempfaNode)) {
commonFatherNode = tempfaNode;
break;
}
tempNode = tempfaNode;
}
return commonFatherNode;
}
public static void printTree(Node rootNode) {
System.out.println("输出构建的数的结构");
LinkedList<Node> linkedList = new LinkedList<>();
if (rootNode != null) {
linkedList.addLast(rootNode);
while (linkedList.size() != 0) {
Node tempNode = linkedList.removeFirst();
System.out.println(tempNode.value);
ArrayList<Node> childArrayList = tempNode.chiArrayList;
if (childArrayList.size() != 0) {
for (int i = 0; i < childArrayList.size(); i++) {
linkedList.addLast(childArrayList.get(i));
// System.out.print(childArrayList.get(i).value+" ");
}
// System.out.println();
}
}
}
System.out.println();
}
public static void printPath(LinkedList<String> path,
ArrayList<Edge> eArrayList) {
System.out.print("输出节点路径:");
for (int i = 0; i < path.size(); i++) {
System.out.print(path.get(i) + " ");
}
System.out.println();
}
public static void printEdgeListCount(ArrayList<Edge> edges) {
System.out.println("输出所有边访问次数");
boolean flag = true;
for (int i = 0; i < edges.size(); i++) {
Edge tempEdge = edges.get(i);
System.out.println("(" + tempEdge.node1 + "," + tempEdge.node2
+ ")" + "=" + tempEdge.count);
if (tempEdge.count != 2) {
flag = false;
}
}
System.out.println();
System.out.println("遍历结果:" + (flag == true ? 0 : -1));
}
// 检查是否有边的访问次数没有超过2
public static String getNextNode(String lefeNode,
ArrayList<Edge> elArrayList) {
String nextNode = null;
for (int i = 0; i < elArrayList.size(); i++) {
Edge tempEdge = elArrayList.get(i);
if (tempEdge.isContainNode(lefeNode)) {
if (tempEdge.count < 2) {
nextNode = tempEdge.getAnotherNode(lefeNode);
tempEdge.count++;
}
}
}
return nextNode;
}
}