小米2014年校园招聘笔试题目（排队问题）

2014年9月25日，下午两点，去参加了小米的笔试，在这里分享一下最后一道编程题目。

这道题目的意思大概是：小米有几千位员工，现在要将所有的员工排成一队，但每个人可能会提出特定的要求：要站在某些人的后面，要站在某些人的前面。当然也可以没有要求。现在给出所有员工的要求，问是否存在一种排队方式，能满足所有员工提出的排队要求。若存在，则返回一种排队方式；若不存在，则返回null。

题目给出了两个类：

类Rule的对象是一条规则，targetName是此条规则对应的那个人，isFront代表规则要求站在他的前面还是后面。
class Rule
{
public String targetName; // 规则中的那个人
public boolean isFront; // 要求排在这个人前面为true;要求排在这个人后面为false
}
类Rules刻画了一个人提出的一些规则，name是提出规则的那个人的名字，ArrayList中是这个人提出的规则。

class Rules
{
public String name; // 提出规则的那个人
ArrayList<Rule> theRules; // 该人提出的规则
}


我将这个问题转化为有向图是否存在有向回路的问题。
首先，构造一个有向图，将每个员工看作图中的一个结点，若员工A要求站在员工B的前面，则有一条有向边由A指向B；若员工A要求站在员工C的后面，则有一条边从C指向A。

然后，对图进行深度优先周游，判断是否存在有向回路。

如果存在，则不可能有满足所有规则的排队方式；

如果不存在有向回路，则有满足所有规则的排队方式，这时只需从“没有要求站在他前面”的那些结点遍历该图，按结点完成遍历的顺序加入到一个栈中，待完成整个图的遍历之后，从栈中取出结点的顺序就是一种可能的排队方式。

我写的代码如下：

package xiaomi;

//2014.9.25小米笔试，排队问题
//小米公司共有N名员工，现在要对这N名员工排序，每个员工可能有一些排序要求，如必须站在某些人后面，或必须站在某些人前面
//给出所有人的要求，问是否有一种排序，能满足所有员工的要求。若有，则返回这种排序；若没有则返回null。

import java.util.ArrayList;
import java.util.HashMap;

//排队的规则
class Rule
{
public String targetName; // 规则中的那个人
public boolean isFront; // 要求排在这个人前面为true;要求排在这个人后面为false
}

class Rules
{
public String name; // 提出规则的那个人
ArrayList<Rule> theRules; // 该人提出的规则
}

public class XiaoMi
{
// 内部类，定义结点
class MemNode
{
String memName;
boolean isFrontNode = true; // 记录该人是否为最前面的人，即是否要求站在某人后面，或被要求站在某人后面
ArrayList<String> afterMemName; // 记录那些要求站在memName后面的人
String color = "white"; // 记录结点在图遍历时候的状态

// int nodeIndex = 0; //记录node在排队中的位置，初始为0

public MemNode(String memName, ArrayList<String> afterMemName)
{
this.memName = memName;
this.afterMemName = afterMemName;
}
}

// memNodes存储结点的列表
ArrayList<MemNode> memNodes = new ArrayList<>();

// nameMap是结点的名字到其在memNodes下标的映射
HashMap<String, Integer> nameMap = new HashMap<>();

// doneNode是按照结点遍历顺序存储结点的列表
ArrayList<MemNode> doneNodes = new ArrayList<>();

// isQueue代表是否有满足所有规则的结果，默认是存在的，如果在图的遍历中发现有向回路，则该成false
boolean isQueue = true;

// 建图
void buildGraph(ArrayList<String> allMember, ArrayList<Rules> allRules)
{
for (int i = 0; i < allMember.size(); i++)
{
MemNode memNode = new MemNode(allMember.get(i), new ArrayList<String>());
memNodes.add(memNode);
nameMap.put(allMember.get(i), i);
}

for (int j = 0; j < allRules.size(); j++)
{
for (int k = 0; k < allRules.get(j).theRules.size(); k++)
{
if (allRules.get(j).theRules.get(k).isFront == true)
{
// 说明该人要站在某人的前面
memNodes.get(nameMap.get(allRules.get(j).name)).afterMemName
.add(allRules.get(j).theRules.get(k).targetName);
memNodes.get(nameMap.get(allRules.get(j).theRules.get(k).targetName)).isFrontNode = false;

} else if (allRules.get(j).theRules.get(k).isFront == false)
{
// 说明该人要站在某人后面
memNodes.get(nameMap.get(allRules.get(j).name)).isFrontNode = false;
memNodes.get(nameMap.get(allRules.get(j).theRules.get(k).targetName)).afterMemName
.add(allRules.get(j).name);
}
}
}
}

// 图的深度优先遍历
void dfs(ArrayList<MemNode> nodes, MemNode cur)
{
// nodes是所有的结点数组，cur是当前结点
cur.color = "gray";
for (int i = 0; i < cur.afterMemName.size(); i++)
{
if (nodes.get(nameMap.get(cur.afterMemName.get(i))).color
.equals("gray"))
{
isQueue = false;
} else if (nodes.get(nameMap.get(cur.afterMemName.get(i))).color
.equals("white"))
{
dfs(nodes, nodes.get(nameMap.get(cur.afterMemName.get(i))));
}
}
cur.color = "black";
doneNodes.add(cur);
}

String findQueue(ArrayList<String> allMember, ArrayList<Rules> allRules)
{
buildGraph(allMember, allRules);
for (int i = 0; i < allMember.size(); i++)
{
if (memNodes.get(i).color == "white"
&& memNodes.get(i).isFrontNode == true)
{
dfs(memNodes, memNodes.get(i));
}
}
if (isQueue == true)
{
String res = " ";
for (int i = doneNodes.size() - 1; i >= 0; i--)
{
res = res + doneNodes.get(i).memName + " ";
}
return res;
} else
{
return null;
}
}

public static void main(String[] args)
{
ArrayList<String> allmember = new ArrayList<>();
allmember.add("Node-1");
allmember.add("Node-2");
allmember.add("Node-3");
allmember.add("Node-4");

Rule rule11 = new Rule();
rule11.targetName = "Node-1";
rule11.isFront = true;

Rule rule12 = new Rule();
rule12.targetName = "Node-3";
rule12.isFront = true;

Rule rule13 = new Rule();
rule13.targetName = "Node-4";
rule13.isFront = true;

Rule rule21 = new Rule();
rule21.targetName = "Node-1";
rule21.isFront = true;

Rule rule22 = new Rule();
rule22.targetName = "Node-4";
rule22.isFront = false;

Rules rules1 = new Rules();
ArrayList<Rule> therules1 = new ArrayList<>();
rules1.theRules = therules1;

rules1.name = "Node-2";
rules1.theRules.add(rule11);
rules1.theRules.add(rule12);
rules1.theRules.add(rule13);

Rules rules2 = new Rules();
ArrayList<Rule> therules2 = new ArrayList<>();
rules2.theRules = therules2;

rules2.name = "Node-3";
rules2.theRules.add(rule21);
rules2.theRules.add(rule22);

ArrayList<Rules> allrules = new ArrayList<>();
allrules.add(rules1);
allrules.add(rules2);
XiaoMi xiaoMi = new XiaoMi();
System.out.println(xiaoMi.findQueue(allmember, allrules));

}
}