鍒嗘瀽錛?br />
榪欎釜闂鏄痝oogle鐨勯潰璇曢銆傜敱浜庝竴涓瓧絎︿覆鏈夊緢澶氱浜屽弶琛ㄧず娉曪紝璨屼技寰堥毦鍒ゆ柇涓や釜瀛楃涓叉槸鍚﹀彲浠ュ仛榪欐牱鐨勫彉鎹€?br />瀵逛粯澶嶆潅闂鐨勬柟娉曟槸浠庣畝鍗曠殑鐗逛緥鏉ユ濊冿紝浠庤屾壘鍑鴻寰嬨?br />鍏堣冨療綆鍗曟儏鍐碉細(xì)
瀛楃涓查暱搴︿負(fù)1錛氬緢鏄庢樉錛屼袱涓瓧絎︿覆蹇呴』瀹屽叏鐩稿悓鎵嶅彲浠ャ?br />瀛楃涓查暱搴︿負(fù)2錛氬綋s1="ab", s2鍙湁"ab"鎴栬?ba"鎵嶅彲浠ャ?br />瀵逛簬浠繪剰闀垮害鐨勫瓧絎︿覆錛屾垜浠彲浠ユ妸瀛楃涓瞫1鍒嗕負(fù)a1,b1涓や釜閮ㄥ垎錛宻2鍒嗕負(fù)a2,b2涓や釜閮ㄥ垎錛屾弧瓚籌紙(a1~a2) && (b1~b2)錛夋垨鑰?nbsp;錛?a1~b2) && (a1~b2)錛?br />
濡傛錛屾垜浠壘鍒頒簡瑙ｅ喅闂鐨勬濊礬銆傞鍏堟垜浠皾璇曠敤閫掑綊鏉ュ啓銆?br />
瑙ｆ硶涓錛堥掑綊錛?br />
涓や釜瀛楃涓茬殑鐩鎬技鐨勫繀澶囨潯浠舵槸鍚湁鐩稿悓鐨勫瓧絎﹂泦銆傜畝鍗曠殑鍋氭硶鏄妸涓や釜瀛楃涓茬殑瀛楃鎺掑簭鍚庯紝鐒跺悗姣旇緝鏄惁鐩稿悓銆?br />鍔犱笂榪欎釜媯鏌ュ氨鍙互澶уぇ鐨勫噺灝戦掑綊嬈℃暟銆?br />浠ｇ爜濡備笅錛?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;
}
瑙ｆ硶浜岋紙鍔ㄦ佽鍒掞級
鍑忓皯閲嶅璁＄畻鐨勬柟娉曞氨鏄姩鎬佽鍒掋傚姩鎬佽鍒掓槸涓縐嶇濂囩殑綆楁硶鎶鏈紝涓嶄翰鑷幓鍐欙紝鏄緢闅懼畬鍏ㄦ帉鎻″姩鎬佽鍒掔殑銆?br />
榪欓噷鎴戜嬌鐢ㄤ簡涓涓笁緇存暟緇刡oolean result[len][len][len],鍏朵腑絎竴緇翠負(fù)瀛愪覆鐨勯暱搴︼紝絎簩緇翠負(fù)s1鐨勮搗濮嬬儲寮曪紝絎笁緇翠負(fù)s2鐨勮搗濮嬬儲寮曘?br />result[k][i][j]琛ㄧずs1[i...i+k]鏄惁鍙互鐢眘2[j...j+k]鍙樺寲寰楁潵銆?br />
浠ｇ爜濡備笅錛岄潪甯哥畝媧佷紭緹庯細(xì)
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];
}
}
]]>
鍒嗘瀽錛?br />鍥犱負(fù)瑕佹眰緇撴灉闆嗘槸鍗囧簭鎺掑垪錛屾墍浠ラ鍏堟垜浠瀵規(guī)暟緇勮繘琛屾帓搴忋?br />
瀛愰泦鐨勯暱搴﹀彲浠ヤ粠0鍒版暣涓暟緇勭殑闀垮害銆傞暱搴︿負(fù)n+1鐨勫瓙闆嗗彲浠ョ敱闀垮害涓簄鐨勫瓙闆嗗啀鍔犱笂鍦ㄤ箣鍚庣殑涓涓厓绱犵粍鎴愩?br />
榪欓噷鎴戜嬌鐢ㄤ簡涓変釜鎶宸?br />1銆備嬌鐢ㄤ簡涓涓猧ndex鏁扮粍鏉ヨ褰曟瘡涓瓙闆嗙殑鏈澶х儲寮曪紝榪欐牱娣誨姞鏂板厓绱犲氨寰堢畝鍗曘?br />2銆備嬌鐢ㄤ簡涓や釜鍙橀噺start鍜宔nd鏉ヨ褰曚笂涓涓暱搴︾殑瀛愰泦鍦ㄧ粨鏋滀腑鐨勮搗濮嬪拰緇堟浣嶇疆銆?br />3銆傚幓閲嶅鐞嗕嬌鐢ㄤ簡涓涓猯ast鍙橀噺璁板綍鍓嶄竴嬈＄殑鍊鹼紝瀹冪殑鍒濆鍊艱涓篠[0]-1,榪欐牱灝變繚璇佷簡鍜屾暟緇勭殑浠諱綍涓涓厓绱犱笉鍚屻?br />
浠ｇ爜濡備笅錛?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;
}
}
]]>
鍒嗘瀽錛?br />棰樼洰涓嶉毦錛屼絾鏄湪闈㈣瘯鏃訛紝鍦ㄦ湁闄愮殑鏃墮棿鍐咃紝娌℃湁bug鍐欏嚭錛岃繕鏄緢鑰冮獙鍔熷姏鐨勩?br />
瑙ｅ喅榪欎釜闂鐨勬濊礬鏄愬眰鎵弿錛屼笂涓灞傝緗ソ涓嬩竴灞傜殑next鍏崇郴錛屽湪澶勭悊絀烘寚閽堢殑鏃跺欒鏍煎灝忓績銆?br />浠ｇ爜濡備笅錛屾湁娉ㄩ噴錛屽簲璇ュ緢瀹規(guī)槗鐪嬫噦錛?br />浣跨敤浜嗕笁涓寚閽堬細(xì)
node:褰撳墠鑺傜偣
firstChild:涓嬩竴灞傜殑絎竴涓潪絀哄瓙鑺傜偣
lastChild:涓嬩竴灞傜殑鏈鍚庝竴涓緟澶勭悊錛堟湭璁劇疆next)鐨勫瓙鑺傜偣
public void connect(TreeLinkNode root) {
TreeLinkNode node = root;
TreeLinkNode firstChild = null;
TreeLinkNode lastChild = null;
while(node!=null){
if(firstChild == null){ //璁板綍絎竴涓潪絀哄瓙鑺傜偣
firstChild = node.left!=null?node.left:node.right;
}
//璁劇疆瀛愯妭鐐圭殑next鍏崇郴錛?縐嶆儏鍐?/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;
}
//璁劇疆涓嬩竴涓妭鐐癸紝濡傛灉鏈眰宸茬粡閬嶅巻瀹屾瘯錛岀Щ鍒頒笅涓灞傜殑絎竴涓瓙鑺傜偣
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){ //璁板綍絎竴涓潪絀哄瓙鑺傜偣
firstChild = node.left!=null?node.left:node.right;
}
//璁劇疆瀛愯妭鐐圭殑next鍏崇郴錛?縐嶆儏鍐?/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;
}
//璁劇疆涓嬩竴涓妭鐐癸紝濡傛灉鏈眰宸茬粡閬嶅巻瀹屾瘯錛岀Щ鍒頒笅涓灞傜殑絎竴涓瓙鑺傜偣
if(node.next!=null){
node = node.next;
}
else{
node = firstChild;
firstChild = null;
lastChild = null;
}
}
}
]]>
璁捐涓涓畻娉曞鎵炬渶澶х殑鏀剁泭銆備綘鍙互鏈澶氳繘琛屼袱嬈′氦鏄撱?br />娉ㄦ剰錛氫綘涓嶈兘鍚屾椂榪涜澶氭浜ゆ槗錛屼篃灝辨槸璇翠綘涔拌偂紲ㄤ箣鍓嶏紝蹇呴』鍗栨帀鎵嬩腑鑲＄エ銆?/span>
鍒嗘瀽錛?br />榪欓亾棰樼浉姣斾箣鍓嶇殑涓ら亾棰橈紝闅懼害鎻愰珮浜嗕笉灝戙?br />
鍥犱負(fù)闄愬埗浜嗗彧鑳戒氦鏄撲袱嬈★紝鎵浠ユ垜浠彲浠ユ妸n澶╁垎涓轟袱孌碉紝鍒嗗埆璁＄畻榪欎袱孌電殑鏈澶ф敹鐩婏紝灝卞彲浠ュ緱鍒頒竴涓渶澶ф敹鐩娿傜┓涓炬墍鏈夎繖鏍風(fēng)殑鍒嗘硶錛屽氨鍙互寰楀埌鍏ㄥ眬鐨勬渶澶ф敹鐩娿?br />
涓轟簡鎻愰珮鏁堢巼錛岃繖閲屼嬌鐢ㄥ姩鎬佽鍒掞紝鍗蟲妸涓棿鐘舵佽褰曚笅鏉ャ備嬌鐢ㄤ簡涓や釜鏁扮粍profits錛宯profits鍒嗗埆璁板綍浠?..i鍜宨..n鐨勬渶澶ф敹鐩娿?br />
浠ｇ爜濡備笅錛?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;
}
]]>
浣犲彧鑳借繘琛屼竴嬈′氦鏄擄紙涓嬈′拱榪涘拰涓嬈″崠鍑猴級錛岃璁′竴涓畻娉曟眰鍑烘渶澶х殑鏀剁泭銆?nbsp; 闃呰鍏ㄦ枃
]]>
1.姣忔鍙兘鍙樻崲涓涓瓧姣?
2.鎵鏈夌殑涓棿鍗曡瘝蹇呴』瀛樺湪浜庡瓧鍏鎬腑
姣斿錛?
杈撳叆錛?
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
閭ｄ箞鏈鐭殑鍙樺寲搴忓垪鏈変袱涓?
["hit","hot","dot","dog","cog"],
["hit","hot","lot","log","cog"]銆?
娉ㄦ剰錛?
1. 鎵鏈夊崟璇嶇殑闀垮害閮芥槸鐩稿悓鐨?
2. 鎵鏈夊崟璇嶉兘鍙惈鏈夊皬鍐欑殑瀛楁瘝銆?nbsp; 闃呰鍏ㄦ枃
]]>
public class Solution {
public void merge(int A[], int m, int B[], int n) {
//write your code here }
}
娉ㄦ剰錛?
鍋囧畾A鏈夎凍澶熺殑棰濆鐨勫閲忓偍瀛楤鐨勫唴瀹癸紝m鍜宯鍒嗗埆涓篈鍜孊鐨勫垵濮嬪寲鍏冪礌鐨勪釜鏁般傝姹傜畻娉曞鏉傚害鍦∣(m+n)銆?nbsp; 闃呰鍏ㄦ枃
]]>
1.姣忔鍙兘鍙樻崲涓涓瓧姣?
2.鎵鏈夌殑涓棿鍗曡瘝蹇呴』瀛樺湪浜庡瓧鍏鎬腑
姣斿錛?
杈撳叆錛?
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]
閭ｄ箞鏈鐭殑鍙樺寲搴忓垪鏄?hit" -> "hot" -> "dot" -> "dog" -> "cog"錛屾墍浠ヨ繑鍥為暱搴︽槸5銆?
娉ㄦ剰錛?
1. 濡傛灉鎵句笉鍒拌繖鏍風(fēng)殑搴忓垪錛岃繑鍥?
2. 鎵鏈夊崟璇嶇殑闀垮害閮芥槸鐩稿悓鐨?
3. 鎵鏈夊崟璇嶉兘鍙惈鏈夊皬鍐欑殑瀛楁瘝銆?nbsp; 闃呰鍏ㄦ枃
]]>
姣斿錛屽浜庡瓧絎︿覆s="aab",
榪斿洖:
[
["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)
------------------------------------------------------------鎴戠殑瑙ｆ硶濡備笅----------------------------------------
鎯蟲硶寰堢畝鍗曪紝榪欓亾棰樻湰璐ㄤ笂鏄竴閬撴帓搴忛棶棰橈紝鎴戜滑鍙渶瑕佸畾涔夊ソ鎺掑簭鐨勯昏緫錛岀劧鍚庡簲鐢ㄥ揩鎺掑氨鍙互浜嗐?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;
}
}
]]>