分析Q?br />
q个问题是google的面试题。由于一个字W串有很多种二叉表示法，貌似很难判断两个字符串是否可以做q样的变换?br />对付复杂问题的方法是从简单的特例来思考，从而找律?br />先考察单情况：
字符串长度ؓ1Q很明显Q两个字W串必须完全相同才可以?br />字符串长度ؓ2Q当s1="ab", s2只有"ab"或?ba"才可以?br />对于L长度的字W串Q我们可以把字符串s1分ؓa1,b1两个部分Qs2分ؓa2,b2两个部分Q满I(a1~a2) && (b1~b2)Q或?nbsp;Q?a1~b2) && (a1~b2)Q?br />
如此Q我们找C解决问题的思\。首先我们尝试用递归来写?br />
解法一Q递归Q?br />
两个字符串的怼的必备条件是含有相同的字W集。简单的做法是把两个字符串的字符排序后，然后比较是否相同?br />加上q个查就可以大大的减递归ơ数?br />代码如下Q?br />
public boolean isScramble(String s1, String s2) {
int l1 = s1.length();
int l2 = s2.length();
if(l1!=l2){
return false;
}
if(l1==0){
return true;
}
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
if(l1==1){
return c1[0]==c2[0];
}
Arrays.sort(c1);
Arrays.sort(c2);
for(int i=0;i<l1;++i){
if(c1[i]!=c2[i]){
return false;
}
}
boolean result = false;
for(int i=1;i<l1 && !result;++i){
String s11 = s1.substring(0,i);
String s12 = s1.substring(i);
String s21 = s2.substring(0,i);
String s22 = s2.substring(i);
result = isScramble(s11,s21) && isScramble(s12,s22);
if(!result){
String s31 = s2.substring(0,l1-i);
String s32 = s2.substring(l1-i);
result = isScramble(s11,s32) && isScramble(s12,s31);
}
}
return result;
}
int l1 = s1.length();
int l2 = s2.length();
if(l1!=l2){
return false;
}
if(l1==0){
return true;
}
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
if(l1==1){
return c1[0]==c2[0];
}
Arrays.sort(c1);
Arrays.sort(c2);
for(int i=0;i<l1;++i){
if(c1[i]!=c2[i]){
return false;
}
}
boolean result = false;
for(int i=1;i<l1 && !result;++i){
String s11 = s1.substring(0,i);
String s12 = s1.substring(i);
String s21 = s2.substring(0,i);
String s22 = s2.substring(i);
result = isScramble(s11,s21) && isScramble(s12,s22);
if(!result){
String s31 = s2.substring(0,l1-i);
String s32 = s2.substring(l1-i);
result = isScramble(s11,s32) && isScramble(s12,s31);
}
}
return result;
}
解法二（动态规划）
减少重复计算的方法就是动态规划。动态规划是一U神奇的法技术，不亲自去写，是很隑֮全掌握动态规划的?br />
q里我用了一个三l数lboolean result[len][len][len],其中W一lؓ子串的长度，W二lؓs1的v始烦引，W三lؓs2的v始烦引?br />result[k][i][j]表示s1[i...i+k]是否可以由s2[j...j+k]变化得来?br />
代码如下Q非常简z优：
public class Solution {
public boolean isScramble(String s1, String s2) {
int len = s1.length();
if(len!=s2.length()){
return false;
}
if(len==0){
return true;
}
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
boolean[][][] result = new boolean[len][len][len];
for(int i=0;i<len;++i){
for(int j=0;j<len;++j){
result[0][i][j] = (c1[i]==c2[j]);
}
}
for(int k=2;k<=len;++k){
for(int i=len-k;i>=0;--i){
for(int j=len-k;j>=0;--j){
boolean r = false;
for(int m=1;m<k && !r;++m){
r = (result[m-1][i][j] && result[k-m-1][i+m][j+m]) || (result[m-1][i][j+k-m] && result[k-m-1][i+m][j]);
}
result[k-1][i][j] = r;
}
}
}
return result[len-1][0][0];
}
}
public boolean isScramble(String s1, String s2) {
int len = s1.length();
if(len!=s2.length()){
return false;
}
if(len==0){
return true;
}
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
boolean[][][] result = new boolean[len][len][len];
for(int i=0;i<len;++i){
for(int j=0;j<len;++j){
result[0][i][j] = (c1[i]==c2[j]);
}
}
for(int k=2;k<=len;++k){
for(int i=len-k;i>=0;--i){
for(int j=len-k;j>=0;--j){
boolean r = false;
for(int m=1;m<k && !r;++m){
r = (result[m-1][i][j] && result[k-m-1][i+m][j+m]) || (result[m-1][i][j+k-m] && result[k-m-1][i+m][j]);
}
result[k-1][i][j] = r;
}
}
}
return result[len-1][0][0];
}
}
]]>
分析Q?br />因ؓ要求l果集是升序排列Q所以首先我们要Ҏ(gu)l进行排序?br />
子集的长度可以从0到整个数l的长度。长度ؓn+1的子集可以由长度为n的子集再加上在之后的一个元素组成?br />
q里我用了三个技?br />1。用了一个index数组来记录每个子集的最大烦引，q样d新元素就很简单?br />2。用了两个变量start和end来记录上一个长度的子集在结果中的v始和l止位置?br />3。去重处理用了一个last变量记录前一ơ的|它的初始D为S[0]-1,q样׃证了和数l的M一个元素不同?br />
代码如下Q?br />
public class Solution {
public ArrayList<ArrayList<Integer>> subsetsWithDup(int[] S) {
Arrays.sort(S);
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> indexs = new ArrayList<Integer>();
result.add(new ArrayList<Integer>());
indexs.add(-1);
int slen = S.length;
int start=0,end=0;
for(int len=1;len<=slen;++len){
int e = end;
for(int i=start;i<=end;++i){
ArrayList<Integer> ss = result.get(i);
int index = indexs.get(i).intValue();
int last = S[0]-1;
for(int j = index+1;j<slen;++j){
int v = S[j];
if(v!=last){
ArrayList<Integer> newss = new ArrayList<Integer>(ss);
newss.add(v);
result.add(newss);
indexs.add(j);
++e;
last = v;
}
}
}
start = end+1;
end = e;
}
return result;
}
}
public ArrayList<ArrayList<Integer>> subsetsWithDup(int[] S) {
Arrays.sort(S);
ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> indexs = new ArrayList<Integer>();
result.add(new ArrayList<Integer>());
indexs.add(-1);
int slen = S.length;
int start=0,end=0;
for(int len=1;len<=slen;++len){
int e = end;
for(int i=start;i<=end;++i){
ArrayList<Integer> ss = result.get(i);
int index = indexs.get(i).intValue();
int last = S[0]-1;
for(int j = index+1;j<slen;++j){
int v = S[j];
if(v!=last){
ArrayList<Integer> newss = new ArrayList<Integer>(ss);
newss.add(v);
result.add(newss);
indexs.add(j);
++e;
last = v;
}
}
}
start = end+1;
end = e;
}
return result;
}
}
]]>
分析Q?br />题目不难Q但是在面试Ӟ在有限的旉内，没有bug写出Q还是很考验功力的?br />
解决q个问题的思\是逐层扫描Q上一层设|好下一层的next关系Q在处理I指针的时候要格外心?br />代码如下Q有注释Q应该很Ҏ(gu)看懂Q?br />使用了三个指针：
node:当前节点
firstChild:下一层的W一个非I子节点
lastChild:下一层的最后一个待处理Q未讄next)的子节点
public void connect(TreeLinkNode root) {
TreeLinkNode node = root;
TreeLinkNode firstChild = null;
TreeLinkNode lastChild = null;
while(node!=null){
if(firstChild == null){ //记录W一个非I子节点
firstChild = node.left!=null?node.left:node.right;
}
//讄子节点的next关系Q?U情?/span>
if(node.left!=null && node.right!=null){
if(lastChild!=null){
lastChild.next = node.left;
}
node.left.next = node.right;
lastChild = node.right;
}
else if(node.left!=null){
if(lastChild!=null){
lastChild.next = node.left;
}
lastChild = node.left;
}
else if(node.right!=null){
if(lastChild!=null){
lastChild.next = node.right;
}
lastChild = node.right;
}
//讄下一个节点，如果本层已经遍历完毕Q移C一层的W一个子节点
if(node.next!=null){
node = node.next;
}
else{
node = firstChild;
firstChild = null;
lastChild = null;
}
}
}
TreeLinkNode node = root;
TreeLinkNode firstChild = null;
TreeLinkNode lastChild = null;
while(node!=null){
if(firstChild == null){ //记录W一个非I子节点
firstChild = node.left!=null?node.left:node.right;
}
//讄子节点的next关系Q?U情?/span>
if(node.left!=null && node.right!=null){
if(lastChild!=null){
lastChild.next = node.left;
}
node.left.next = node.right;
lastChild = node.right;
}
else if(node.left!=null){
if(lastChild!=null){
lastChild.next = node.left;
}
lastChild = node.left;
}
else if(node.right!=null){
if(lastChild!=null){
lastChild.next = node.right;
}
lastChild = node.right;
}
//讄下一个节点，如果本层已经遍历完毕Q移C一层的W一个子节点
if(node.next!=null){
node = node.next;
}
else{
node = firstChild;
firstChild = null;
lastChild = null;
}
}
}
]]>
设计一个算法寻找最大的收益。你可以最多进行两ơ交易?br />注意Q你不能同时q行多次交易Q也是说你买股之前，必须卖掉手中股票?/span>
分析Q?br />q道题相比之前的两道题，隑ֺ提高了不?br />
因ؓ限制了只能交易两ơ，所以我们可以把n天分ZD，分别计算q两D늚最大收益，可以得C个最大收益。穷举所有这L(fng)分法Q就可以得到全局的最大收益?br />
Z提高效率Q这里用动态规划，x中间状态记录下来。用了两个数组profitsQnprofits分别记录?..i和i..n的最大收益?br />
代码如下Q?br />
public int maxProfit(int[] prices) {
int days = prices.length;
if(days<2){
return 0;
}
int[] profits = new int[days];
int min = prices[0];
int max = min;
for(int i=1;i<days;++i){
int p = prices[i];
if(min>p){
max = min = p;
}
else if(max<p){
max = p;
}
int profit = max - min;
profits[i] = (profits[i-1]>profit)?profits[i-1]:profit;
}
int[] nprofits = new int[days];
nprofits[days-1] = 0;
max = min = prices[days-1];
for(int i=days-2;i>=0;--i){
int p = prices[i];
if(min>p){
min =p;
}
else if(max<p){
max = min = p;
}
int profit = max - min;
nprofits[i] = (nprofits[i+1]>profit)?nprofits[i+1]:profit;
}
int maxprofit = 0;
for(int i=0;i<days;++i){
int profit = profits[i]+nprofits[i];
if(maxprofit<profit){
maxprofit = profit;
}
}
return maxprofit;
}
int days = prices.length;
if(days<2){
return 0;
}
int[] profits = new int[days];
int min = prices[0];
int max = min;
for(int i=1;i<days;++i){
int p = prices[i];
if(min>p){
max = min = p;
}
else if(max<p){
max = p;
}
int profit = max - min;
profits[i] = (profits[i-1]>profit)?profits[i-1]:profit;
}
int[] nprofits = new int[days];
nprofits[days-1] = 0;
max = min = prices[days-1];
for(int i=days-2;i>=0;--i){
int p = prices[i];
if(min>p){
min =p;
}
else if(max<p){
max = min = p;
}
int profit = max - min;
nprofits[i] = (nprofits[i+1]>profit)?nprofits[i+1]:profit;
}
int maxprofit = 0;
for(int i=0;i<days;++i){
int profit = profits[i]+nprofits[i];
if(maxprofit<profit){
maxprofit = profit;
}
}
return maxprofit;
}
]]>
你只能进行一ơ交易（一ơ买q和一ơ卖出）Q设计一个算法求出最大的收益?nbsp; 阅读全文
]]>
1.每次只能变换一个字?
2.所有的中间单词必须存在于字怸
比如Q?
输入Q?
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
那么最短的变化序列有两?
["hit","hot","dot","dog","cog"],
["hit","hot","lot","log","cog"]?
注意Q?
1. 所有单词的长度都是相同?
2. 所有单词都只含有小写的字母?nbsp; 阅读全文
]]>
public class Solution {
public void merge(int A[], int m, int B[], int n) {
//write your code here }
}
注意Q?
假定A有够的额外的容量储存B的内容，m和n分别为A和B的初始化元素的个数。要求算法复杂度在O(m+n)?nbsp; 阅读全文
]]>
1.每次只能变换一个字?
2.所有的中间单词必须存在于字怸
比如Q?
输入Q?
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
那么最短的变化序列?hit" -> "hot" -> "dot" -> "dog" -> "cog"Q所以返回长度是5?
注意Q?
1. 如果找不到这L(fng)序列Q返?
2. 所有单词的长度都是相同?
3. 所有单词都只含有小写的字母?nbsp; 阅读全文
]]>
比如Q对于字W串s="aab",
q回:
[
["aa","b"],
["a","a","b"]
]
阅读全文
]]>
public int[] plusOne(int[] digits) {
}
} 阅读全文
]]>
]]>
]]>
Problem Statement
THIS PROBLEM WAS TAKEN FROM THE SEMIFINALS OF THE TOPCODER INVITATIONAL
TOURNAMENT
DEFINITION
Class Name: MatchMaker
Method Name: getBestMatches
Paramaters: String[], String, int
Returns: String[]
Method signature (be sure your method is public): String[]
getBestMatches(String[] members, String currentUser, int sf);
PROBLEM STATEMENT
A new online match making company needs some software to help find the "perfect
couples". People who sign up answer a series of multiple-choice questions.
Then, when a member makes a "Get Best Mates" request, the software returns a
list of users whose gender matches the requested gender and whose answers to
the questions were equal to or greater than a similarity factor when compared
to the user's answers.
Implement a class MatchMaker, which contains a method getBestMatches. The
method takes as parameters a String[] members, String currentUser, and an int
sf:
- members contains information about all the members. Elements of members are
of the form "NAME G D X X X X X X X X X X"
* NAME represents the member's name
* G represents the gender of the current user.
* D represents the requested gender of the potential mate.
* Each X indicates the member's answer to one of the multiple-choice
questions. The first X is the answer to the first question, the second is the
answer to the second question, et cetera.
- currentUser is the name of the user who made the "Get Best Mates" request.
- sf is an integer representing the similarity factor.
The method returns a String[] consisting of members' names who have at least sf
identical answers to currentUser and are of the requested gender. The names
should be returned in order from most identical answers to least. If two
members have the same number of identical answers as the currentUser, the names
should be returned in the same relative order they were inputted.
TopCoder will ensure the validity of the inputs. Inputs are valid if all of
the following criteria are met:
- members will have between 1 and 50 elements, inclusive.
- Each element of members will have a length between 7 and 44, inclusive.
- NAME will have a length between 1 and 20, inclusive, and only contain
uppercase letters A-Z.
- G can be either an uppercase M or an uppercase F.
- D can be either an uppercase M or an uppercase F.
- Each X is a capital letter (A-D).
- The number of Xs in each element of the members is equal. The number of Xs
will be between 1 and 10, inclusive.
- No two elements will have the same NAME.
- Names are case sensitive.
- currentUser consists of between 1 and 20, inclusive, uppercase letters, A-Z,
and must be a member.
- sf is an int between 1 and 10, inclusive.
- sf must be less than or equal to the number of answers (Xs) of the members.
NOTES
The currentUser should not be included in the returned list of potential mates.
EXAMPLES
For the following examples, assume members =
{"BETTY F M A A C C",
"TOM M F A D C A",
"SUE F M D D D D",
"ELLEN F M A A C A",
"JOE M F A A C A",
"ED M F A D D A",
"SALLY F M C D A B",
"MARGE F M A A C C"}
If currentUser="BETTY" and sf=2, BETTY and TOM have two identical answers and
BETTY and JOE have three identical answers, so the method should return
{"JOE","TOM"}.
If currentUser="JOE" and sf=1, the method should return
{"ELLEN","BETTY","MARGE"}.
If currentUser="MARGE" and sf=4, the method should return [].
Definition
Class:
MatchMaker
Method:
getBestMatches
Parameters:
String[], String, int
Returns:
String[]
Method signature:
String[] getBestMatches(String[] param0, String param1, int param2)
(be sure your method is public)
================================================================我的代码=============
================================================================我的代码=============
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class MatchMaker {
enum GENDER{MALE,FEMALE};
//"NAME G D X X X X X X X X X X"
private static class Member{
String name;
GENDER gender;
GENDER mate;
String[] answers;
int index;
int matched = 0;
}
String[] getBestMatches(String[] members, String currentUser, int sf){
List<Member> allMembers = new ArrayList<Member>();
Member cu = null;
for(int i=0;i<members.length;++i){
String m = members[i];
String[] c = m.split(" ");
Member mem = new Member();
mem.name= c[0];
mem.gender = c[1].equals("M")?GENDER.MALE:GENDER.FEMALE;
mem.mate = c[2].equals("M")?GENDER.MALE:GENDER.FEMALE;
mem.index = i;
mem.matched = 0;
String[] answers = mem.answers = new String[c.length-3];
for(int j=3;j<c.length;++j){
answers[j-3] = c[j];
}
allMembers.add(mem);
if(c[0].equals(currentUser)){
cu = mem;
}
}
List<Member> matched = new ArrayList<Member>();
if(cu!=null){
for(Member mem:allMembers){
if(mem!=cu && mem.gender==cu.mate){
for(int i=0;i<mem.answers.length;++i){
if(mem.answers[i].equals(cu.answers[i])){
++mem.matched;
}
}
if(mem.matched>=sf){
matched.add(mem);
}
}
}
Collections.sort(matched, new Comparator<Member>(){
public int compare(Member ma, Member mb) {
if(ma.matched!=mb.matched){
return mb.matched - ma.matched;
}
return ma.index-mb.index;
}
});
String[] result = new String[matched.size()];
for(int i=0;i<result.length;++i){
result[i] = matched.get(i).name;
}
return result;
}
return new String[0];
}
}
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class MatchMaker {
enum GENDER{MALE,FEMALE};
//"NAME G D X X X X X X X X X X"
private static class Member{
String name;
GENDER gender;
GENDER mate;
String[] answers;
int index;
int matched = 0;
}
String[] getBestMatches(String[] members, String currentUser, int sf){
List<Member> allMembers = new ArrayList<Member>();
Member cu = null;
for(int i=0;i<members.length;++i){
String m = members[i];
String[] c = m.split(" ");
Member mem = new Member();
mem.name= c[0];
mem.gender = c[1].equals("M")?GENDER.MALE:GENDER.FEMALE;
mem.mate = c[2].equals("M")?GENDER.MALE:GENDER.FEMALE;
mem.index = i;
mem.matched = 0;
String[] answers = mem.answers = new String[c.length-3];
for(int j=3;j<c.length;++j){
answers[j-3] = c[j];
}
allMembers.add(mem);
if(c[0].equals(currentUser)){
cu = mem;
}
}
List<Member> matched = new ArrayList<Member>();
if(cu!=null){
for(Member mem:allMembers){
if(mem!=cu && mem.gender==cu.mate){
for(int i=0;i<mem.answers.length;++i){
if(mem.answers[i].equals(cu.answers[i])){
++mem.matched;
}
}
if(mem.matched>=sf){
matched.add(mem);
}
}
}
Collections.sort(matched, new Comparator<Member>(){
public int compare(Member ma, Member mb) {
if(ma.matched!=mb.matched){
return mb.matched - ma.matched;
}
return ma.index-mb.index;
}
});
String[] result = new String[matched.size()];
for(int i=0;i<result.length;++i){
result[i] = matched.get(i).name;
}
return result;
}
return new String[0];
}
}
]]>
Class Name: Prerequisites
Mathod Name: orderClasses
Parameters: String[]
Returns: String[]
You are a student at a college with the most unbelievably complex prerequisite
structure ever. To help you schedule your classes, you decided to put together
a program that returns the order in which the classes should be taken.
Implement a class Prerequisites which contains a method orderClasses. The
method takes a String[] that contains the classes you must take and returns a
String[] of classes in the order the classes should be taken so that all
prerequisites are met.
String[] elements will be of the form (and TopCoder will ensure this):
"CLASS: PRE1 PRE2 ..." where PRE1 and PRE2 are prerequisites of CLASS. CLASS,
PRE1, PRE2, ... consist of a department name (3 or 4 capital letters, A-Z
inclusive) followed by a class number (an integer between 100 and 999,
inclusive). The department name should be immediately followed by the class
number with no additional characters, numbers or spaces (i.e. MATH217). It is
not necessary for a class to have prerequisites. In such a case, the colon is
the last character in the String.
You can only take one class at a time, therefore, use the following rules to
determine which class to take :
1) Any prerequisite class(es) listed for a class must be taken before the class
can be taken.
2) If multiple classes can be taken at the same time, you take the one with the
lowest number first, regardless of department.
3) If multiple classes with the same number can be taken at the same time, you
take the department name which comes first in alphabetical order.
4) If the inputted course schedule has errors, return a String[] of length 0.
There is an error if it is impossible to return the classes in an order such
that all prerequisites are met, or if a prerequisite is a course that does not
have its own entry in the inputted String[].
Examples of valid input Strings are:
"CSE111: CSE110 MATH101"
"CSE110:"
Examples of invalid input Strings are:
"CS117:" (department name must consist of 3 - 4 capital letters, inclusive)
"cs117:" (department name must consist of 3 - 4 capital letters, inclusive)
"CS9E11:" (department name must be letters only)
"CSE110: " (no trailing spaces allowed)
"CSE110: CSE101 " (no trailing spaces allowed)
"MATH211: MAM2222" (class number to large)
"MATH211: MAM22" (class number to small)
"ENGIN517: MATH211" (department name to large)
Here is the method signature (be sure your method is public):
String[] orderClasses(String[] classSchedule);
TopCoder will make sure classSchedule contains between 1 and 20 Strings,
inclusive, all of the form above. The Strings will have between 1 and 50
characters, inclusive. TopCoder will check that the syntax of the Strings are
correct: The Strings will contain a valid class name, followed by a colon,
possibly followed by a series of unique prerequisite classes separated by
single spaces. Also, TopCoder will ensure that each class has at most one
entry in the String[].
Examples:
If classSchedule={
"CSE121: CSE110",
"CSE110:",
"MATH122:",
}
The method should return: {"CSE110","CSE121","MATH122"}
If classSchedule={
"ENGL111: ENGL110",
"ENGL110: ENGL111"
}
The method should return: {}
If classSchedule=[
"ENGL111: ENGL110"
}
The method should return: {}
If classSchedule={
"CSE258: CSE244 CSE243 INTR100"
"CSE221: CSE254 INTR100"
"CSE254: CSE111 MATH210 INTR100"
"CSE244: CSE243 MATH210 INTR100"
"MATH210: INTR100"
"CSE101: INTR100"
"CSE111: INTR100"
"ECE201: CSE111 INTR100"
"ECE111: INTR100"
"CSE243: CSE254"
"INTR100:"
}
The method should return:
{"INTR100","CSE101","CSE111","ECE111","ECE201","MATH210","CSE254","CSE221","CSE2
43","CSE244","CSE258"}
Definition
Class: Prerequisites
Method: orderClasses
Parameters: String[]
Returns: String[]
Method signature: String[] orderClasses(String[] param0)
(be sure your method is public)
------------------------------------------------------------我的解法如下----------------------------------------
x很简单，q道题本质上是一道排序问题，我们只需要定义好排序的逻辑Q然后应用快排就可以了?br />
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Prerequisites {
private static final String[] EMPTY = {};
Map<String,Klass> classes = new HashMap<String,Klass>();
static class Klass implements Comparable<Klass>{
String name;
int number;
String dept;
List<Klass> pres = new ArrayList<Klass>();
boolean exist = false;
Klass(String name){
this.name = name;
int len = name.length();
this.number = Integer.parseInt(name.substring(len-3));
this.dept =name.substring(0,len-3);
}
private boolean isPre(Klass k){
if(k==this) return false;
for(Klass p:this.pres){
if(k == p || p.isPre(k)) return true;
}
return false;
}
@Override
public int compareTo(Klass that) {
boolean pre = this.isPre(that);
boolean sub = that.isPre(this);
if(pre && sub){
throw new RuntimeException("circle detected");
}
else if(pre){
return 1;
}
else if(sub){
return -1;
}
if(this.number!=that.number) return this.number-that.number;
return this.dept.compareTo(that.dept);
}
}
private Klass getClass(String name){
Klass k = classes.get(name);
if(k==null){
k = new Klass(name);
classes.put(name, k);
}
return k;
}
public String[] orderClasses(String[] classSchedule){
classes.clear();
//parse the input
for(String s:classSchedule){
int idx = s.indexOf(":");
String name = s.substring(0,idx);
Klass k = getClass(name);
k.exist = true;
if(idx!=s.length()-1){
String[] pres = s.substring(idx+1).split(" ");
for(String pre:pres){
if(pre.length()>0){
Klass p = getClass(pre);
k.pres.add(p);
}
}
}
}
Klass [] sortedClasses = (Klass[]) classes.values().toArray(new Klass[0]);
for(Klass k:sortedClasses){
if(!k.exist){
return EMPTY;
}
}
try {
Arrays.sort(sortedClasses);
} catch (Exception e) {
return EMPTY;
}
String[] result = new String[sortedClasses.length];
int c = 0;
for(Klass k:sortedClasses){
result[c++] = k.name;
}
return result;
}
}
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Prerequisites {
private static final String[] EMPTY = {};
Map<String,Klass> classes = new HashMap<String,Klass>();
static class Klass implements Comparable<Klass>{
String name;
int number;
String dept;
List<Klass> pres = new ArrayList<Klass>();
boolean exist = false;
Klass(String name){
this.name = name;
int len = name.length();
this.number = Integer.parseInt(name.substring(len-3));
this.dept =name.substring(0,len-3);
}
private boolean isPre(Klass k){
if(k==this) return false;
for(Klass p:this.pres){
if(k == p || p.isPre(k)) return true;
}
return false;
}
@Override
public int compareTo(Klass that) {
boolean pre = this.isPre(that);
boolean sub = that.isPre(this);
if(pre && sub){
throw new RuntimeException("circle detected");
}
else if(pre){
return 1;
}
else if(sub){
return -1;
}
if(this.number!=that.number) return this.number-that.number;
return this.dept.compareTo(that.dept);
}
}
private Klass getClass(String name){
Klass k = classes.get(name);
if(k==null){
k = new Klass(name);
classes.put(name, k);
}
return k;
}
public String[] orderClasses(String[] classSchedule){
classes.clear();
//parse the input
for(String s:classSchedule){
int idx = s.indexOf(":");
String name = s.substring(0,idx);
Klass k = getClass(name);
k.exist = true;
if(idx!=s.length()-1){
String[] pres = s.substring(idx+1).split(" ");
for(String pre:pres){
if(pre.length()>0){
Klass p = getClass(pre);
k.pres.add(p);
}
}
}
}
Klass [] sortedClasses = (Klass[]) classes.values().toArray(new Klass[0]);
for(Klass k:sortedClasses){
if(!k.exist){
return EMPTY;
}
}
try {
Arrays.sort(sortedClasses);
} catch (Exception e) {
return EMPTY;
}
String[] result = new String[sortedClasses.length];
int c = 0;
for(Klass k:sortedClasses){
result[c++] = k.name;
}
return result;
}
}
]]>