BlogJava-小明思考-随笔分类-数据结构和算法

Scramble String

小明 — Wed, 22 May 2013 14:25:00 GMT

Problem

Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.

Below is one possible representation of s1 = "great":

great

/ \

gr eat

/ \ / \

g r e at

/ \

a t

To scramble the string, we may choose any non-leaf node and swap its two children.

For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".

rgeat

/ \

rg eat

/ \ / \

r g e at

/ \

a t

We say that "rgeat" is a scrambled string of "great".

Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".

rgtae

/ \

rg tae

/ \ / \

r g ta e

/ \

t a

We say that "rgtae" is a scrambled string of "great".

Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.

分析：

这个问题是google的面试题。由于一个字符串有很多种二叉表示法，貌似很难判断两个字符串是否可以做这样的变换。
对付复杂问题的方法是从简单的特例来思考，从而找出规律。
先考察简单情况：
字符串长度为1：很明显，两个字符串必须完全相同才可以。
字符串长度为2：当s1="ab", s2只有"ab"或者"ba"才可以。
对于任意长度的字符串，我们可以把字符串s1分为a1,b1两个部分，s2分为a2,b2两个部分，满足（(a1~a2) && (b1~b2)）或者（(a1~b2) && (a1~b2)）

如此，我们找到了解决问题的思路。首先我们尝试用递归来写。

解法一（递归）

两个字符串的相似的必备条件是含有相同的字符集。简单的做法是把两个字符串的字符排序后，然后比较是否相同。
加上这个检查就可以大大的减少递归次数。
代码如下：

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            if(c1[i]!=c2[i]){
                return false;
            }
        }

        boolean result = false;
        for(int i=1;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;
    }

解法二（动态规划）
减少重复计算的方法就是动态规划。动态规划是一种神奇的算法技术，不亲自去写，是很难完全掌握动态规划的。

这里我使用了一个三维数组boolean result[len][len][len],其中第一维为子串的长度，第二维为s1的起始索引，第三维为s2的起始索引。
result[k][i][j]表示s1[i...i+k]是否可以由s2[j...j+k]变化得来。

代码如下，非常简洁优美：

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            for(int j=0;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                      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];
    }
}

小明 2013-05-22 22:25 发表评论

Subsets

小明 — Tue, 21 May 2013 14:50:00 GMT

Problem

Given a collection of integers that might contain duplicates, S, return all possible subsets.

Note:

Elements in a subset must be in non-descending order.
The solution set must not contain duplicate subsets.

For example,
If S = [1,2,2], a solution is:

[   [2],   [1],   [1,2,2],   [2,2],   [1,2],   [] ]

分析：
因为要求结果集是升序排列，所以首先我们要对数组进行排序。

子集的长度可以从0到整个数组的长度。长度为n+1的子集可以由长度为n的子集再加上在之后的一个元素组成。

这里我使用了三个技巧
1。使用了一个index数组来记录每个子集的最大索引，这样添加新元素就很简单。
2。使用了两个变量start和end来记录上一个长度的子集在结果中的起始和终止位置。
3。去重处理使用了一个last变量记录前一次的值，它的初始值设为S[0]-1,这样就保证了和数组的任何一个元素不同。

代码如下：

public class Solution {
    public ArrayList> subsetsWithDup(int[] S) {
        Arrays.sort(S);

        ArrayList> result = new ArrayList>();
        ArrayList indexs = new ArrayList();
        result.add(new ArrayList());
        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 ss = result.get(i);
                int index = indexs.get(i).intValue();
                int last = S[0]-1;
                for(int j = index+1;j                    int v = S[j];
                    if(v!=last){
                        ArrayList newss = new ArrayList(ss);
                        newss.add(v);
                        result.add(newss);
                        indexs.add(j);
                        ++e;
                        last = v;
                    }
                }
            }

            start = end+1;
            end = e;
        }
        return result;
    }
}

小明 2013-05-21 22:50 发表评论

格雷码

小明 — Mon, 20 May 2013 13:09:00 GMT

问题格雷码是一个二进制的编码系统，相邻的两个数只有一位是不同的。
给定一个非负的整数n，代表了格雷码的位的总数。输出格雷码的序列，这个序列必须以0开始。

比如，给定n=2,输出［0，1，3，2］，格雷码是
0 ＝ 00
1 ＝ 01
3 ＝ 11
2 ＝ 10

注：格雷码的序列并不是唯一，比如n=2时，［0，2，3，1］也满足条件。

分析：
格雷码的序列中应包含2^n个数。这个问题初看起来不容易，我们要想出一个生成方法。

对于n=2,序列是：
00，01，11，10
那对于n=3,如何利用n=2的序列呢？一个方法是，先在n=2的四个序列前加0（这其实是保持不变），然后再考虑把最高位变成1，只需要把方向反过来就可以了
000，001，011，010
100，101，111，110－> 110,111,101,100
把这两行合起来就可以得到新的序列。

想通了，写代码就很容易了。

public class Solution {
    public ArrayList grayCode(int n) {
        ArrayList result = new ArrayList();
        result.add(0);
        if(n>0){
            result.add(1);
        }

        int mask = 1;
        for(int i=2;i<=n;++i){
            mask *= 2;
            for(int j=result.size()-1;j>=0;--j){
                int v = result.get(j).intValue();
                v |= mask;
                result.add(v);
            }
        }
        return result;
    }
}

小明 2013-05-20 21:09 发表评论

交叉字符串

小明 — Fri, 10 May 2013 12:47:00 GMT

问题给定字符串s1,s2,s3,判断s3是否可以由s1和s2交叉组成得到。

例如：

s1 = "aabcc",
s2 = "dbbca",

When s3 = "aadbbcbcac", return true.
When s3 = "aadbbbaccc", return false.

解法一：（递归）

一个简单的想法，是遍历s3的每个字符，这个字符必须等于s1和s2的某个字符。如果都不相等，则返回false
我们使用3个变量i,j,k分别记录当前s1,s2,s3的字符位置。
如果s3[k] = s1[i], i向后移动一位。如果s3[k]=s2[j],j向后移动一位。
这个题目主要难在如果s1和s2的字符出现重复的时候，就有两种情况，i,j都可以向后一位。
下面的算法在这种情况使用了递归，很简单的做法。但是效率非常差，是指数复杂度的。

public class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        int l1 = s1.length();
        int l2 = s2.length();
        int l3 = s3.length();

        if(l1+l2!=l3){
            return false;
        }

        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        char[] c3 = s3.toCharArray();

        int i=0,j=0;
        for(int k=0;k            char c = c3[k];
            boolean m1 = i            boolean m2 = j            if(!m1 && !m2){
                return false;
            }
            else if(m1 && m2){
                String news3 =  s3.substring(k+1);
                return isInterleave(s1.substring(i+1),s2.substring(j),news3)
                                || isInterleave(s1.substring(i),s2.substring(j+1),news3);
            }
            else if(m1){
                ++i;
            }
            else{
                ++j;
            }
        }

        return true;
    }
}

解法二：（动态规划）
为了减少重复计算，就要使用动态规划来记录中间结果。

这里我使用了一个二维数组result[i][j]来表示s1的前i个字符和s2的前j个字符是否能和s3的前i+j个字符匹配。

状态转移方程如下：
result[i,j] = (result[i-1,j] && s1[i] = s3[i+j]) || (result[i,j-1] && s2[j] = s3[i+j]);
其中0≤i≤len(s1) ,0≤j≤len(s2)

这样算法复杂度就会下降到O(l1*l2)

public class Solution {

public boolean isInterleave(String s1, String s2, String s3) {
        int l1 = s1.length();
        int l2 = s2.length();
        int l3 = s3.length();

        if(l1+l2!=l3){
            return false;
        }

        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        char[] c3 = s3.toCharArray();

        boolean[][] result = new boolean[l1+1][l2+1];
        result[0][0] = true;

        for(int i=0;i            if(c1[i]==c3[i]){
                result[i+1][0] = true;
            }
            else{
                break;
            }
        }

        for(int j=0;j            if(c2[j]==c3[j]){
                result[0][j+1] = true;
            }
            else{
                break;
            }
        }


        for(int i=1;i<=l1;++i){
            char ci = c1[i-1];
            for(int j=1;j<=l2;++j){
                char cj = c2[j-1];
                char ck = c3[i+j-1];
                   result[i][j] = (result[i][j-1] && cj==ck) || (result[i-1][j] && ci==ck);
            }
        }

        return result[l1][l2];
   }
}

小明 2013-05-10 20:47 发表评论

三个数之和

小明 — Wed, 01 May 2013 15:13:00 GMT

摘要: 给定一个由n个整数组成的数组S，是否存在S中的三个数a,b,c使得 a+b+c=0?找出所有的不重复的和为0的三元组。

注意：
1.三元组的整数按照升序排列 a2.给出的结果中不能含有相同的三元组阅读全文

小明 2013-05-01 23:13 发表评论

子序列计数

小明 — Fri, 26 Apr 2013 15:33:00 GMT

摘要: 给定两个字符串S和T，计算S的子序列为T的个数。

这里的字符串的子序列指的是删除字符串的几个字符（也可以不删）而得到的新的字符串，但是不能改变字符的相对位置。

比如“ACE”是“ABCDE”的子序列，但是“AEC”就不是。

如果S＝“rabbbit” T＝“rabit”，有3种不同的子序列为T的构成方法，那么结果应该返回3。阅读全文

小明 2013-04-26 23:33 发表评论

设置二叉树的next节点

小明 — Fri, 26 Apr 2013 03:23:00 GMT

问题给定一颗二叉树：

class TreeLinkNode {

TreeLinkNode left;

TreeLinkNode right;

TreeLinkNode next;

}

要求把所有节点的next节点设置成它右边的节点，如果没有右节点，设置成空。初始状态，所有的next的指针均为null.

要求:你只能使用常数的空间。

比如：

/ \

2 3

/ \ \

4 5 7
应该输出：

1 -> NULL

/ \

2 -> 3 -> NULL

/ \ \

4-> 5 -> 7 -> NULL

分析：
题目不难，但是在面试时，在有限的时间内，没有bug写出，还是很考验功力的。

解决这个问题的思路是逐层扫描，上一层设置好下一层的next关系，在处理空指针的时候要格外小心。
代码如下，有注释，应该很容易看懂：
使用了三个指针：
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关系，3种情况
            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;
            }
        }
    }

小明 2013-04-26 11:23 发表评论

最佳的股票买卖时间III

小明 — Thu, 25 Apr 2013 14:22:00 GMT

问题假设你有一个数组包含了每天的股票价格，它的第i个元素就是第i天的股票价格。

设计一个算法寻找最大的收益。你可以最多进行两次交易。
注意：你不能同时进行多次交易，也就是说你买股票之前，必须卖掉手中股票。

分析：
这道题相比之前的两道题，难度提高了不少。

因为限制了只能交易两次，所以我们可以把n天分为两段，分别计算这两段的最大收益，就可以得到一个最大收益。穷举所有这样的分法，就可以得到全局的最大收益。

为了提高效率，这里使用动态规划，即把中间状态记录下来。使用了两个数组profits，nprofits分别记录从0..i和i..n的最大收益。

代码如下：

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            int p = prices[i];
            if(min>p){
                max = min = p;
            }
            else if(max                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                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            int profit = profits[i]+nprofits[i];
            if(maxprofit                maxprofit = profit;
            }
        }

        return maxprofit;
    }

小明 2013-04-25 22:22 发表评论

最佳的股票买卖时间II

小明 — Fri, 19 Apr 2013 13:50:00 GMT

问题假设你有一个数组包含了每天的股票价格，它的第i个元素就是第i天的股票价格。

设计一个算法寻找最大的收益。你可以进行任意多次交易。但是，你不能同时进行多次交易，也就是说你买股票之前，必须卖掉手中股票。

分析：为了得到最大收益，必须在所有上升的曲线段的开始点买入，在最高点卖出。而在下降阶段不出手。

实现代码如下：

public class Solution {
    public int maxProfit(int[] prices) {
        int len = prices.length;
        if(len<2){
            return 0;
        }

        int min=0;
        int result = 0;
        boolean inBuy = false;
        for(int i=0;i            int p = prices[i];
            int q = prices[i+1];
            if(!inBuy){
                if(q>p){
                    inBuy = true;
                    min=p ;
                }
            }
            else{
                if(q                    result += (p-min);
                    inBuy = false;
                }
            }
        }
        if(inBuy){
            result += ((prices[len-1])-min);
        }
        return result;
    }
}

小明 2013-04-19 21:50 发表评论

最佳的股票买卖时间

小明 — Fri, 19 Apr 2013 07:03:00 GMT

摘要: 假设你有一个数组包含了每天的股票价格，它的第i个元素就是第i天的股票价格。

你只能进行一次交易（一次买进和一次卖出），设计一个算法求出最大的收益。阅读全文

小明 2013-04-19 15:03 发表评论

二叉树最大的路径和

小明 — Thu, 18 Apr 2013 13:31:00 GMT

摘要: 给定一个二叉树，寻找最大的路径和.
路径可以从任意节点开始到任意节点结束。（也可以是单个节点）

比如：对于二叉树
1
/ \
2 3
和最大的路径是2->1->3，结果为6
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/ 阅读全文

小明 2013-04-18 21:31 发表评论

字梯游戏II

小明 — Thu, 18 Apr 2013 09:32:00 GMT

摘要: 给定两个单词(一个开始，一个结束）和一个字典，找出所有的最短的从开始单词到结束单词的变换序列的序列（可能不止一个），并满足：

1.每次只能变换一个字母
2.所有的中间单词必须存在于字典中

比如：
输入：
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

那么最短的变化序列有两个
["hit","hot","dot","dog","cog"],
["hit","hot","lot","log","cog"]。
注意：
1. 所有单词的长度都是相同的
2. 所有单词都只含有小写的字母。阅读全文

小明 2013-04-18 17:32 发表评论

合并排序好的数组

小明 — Thu, 18 Apr 2013 05:44:00 GMT

摘要: 给定两个排序好的数组A和B,把B合并到A并保持排序。

public class Solution {
public void merge(int A[], int m, int B[], int n) {
//write your code here }
}

注意：
假定A有足够的额外的容量储存B的内容，m和n分别为A和B的初始化元素的个数。要求算法复杂度在O(m+n)。阅读全文

小明 2013-04-18 13:44 发表评论

字梯游戏

小明 — Thu, 18 Apr 2013 04:46:00 GMT

摘要: 给定两个单词(一个开始，一个结束）和一个字典，找出最短的从开始单词到结束单词的变换序列的长度，并满足：

1.每次只能变换一个字母
2.所有的中间单词必须存在于字典中

比如：
输入：
start = "hit"
end = "cog"
dict = ["hot","dot","dog","lot","log"]

那么最短的变化序列是"hit" -> "hot" -> "dot" -> "dog" -> "cog"，所以返回长度是5。
注意：
1. 如果找不到这样的序列，返回0
2. 所有单词的长度都是相同的
3. 所有单词都只含有小写的字母。阅读全文

小明 2013-04-18 12:46 发表评论

二叉树求和问题

小明 — Tue, 16 Apr 2013 03:37:00 GMT

摘要: 给定一个二叉树，每个节点的值是一个数字（0-9），每个从根节点到叶节点均能组成一个数字。
比如如果从根节点到叶节点的路径是1-2-3，那么这代表了123这个数字。
求出所有这样从根节点到叶节点的数字之和。

比如，对于二叉树
1
/ \
2 3

一共有两条路径1->2和1->3，那么求和的结果就是12+13=25
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public int sumNumbers(TreeNode root) {
//write c 阅读全文

小明 2013-04-16 11:37 发表评论

包围的区域

小明 — Mon, 15 Apr 2013 10:17:00 GMT

摘要: 给定一个2D的棋盘，含有‘X'和’O'，找到所有被‘X'包围的’O'，然后把该区域的‘O’都变成'X'。

例子-输入：
X X X X
X O O X
X X O X
X O X X

应该输出：

X X X X
X X X X
X X X X
X O X X

public void solve(char[][] board) {
} 阅读全文

小明 2013-04-15 18:17 发表评论

回文字符串的切割问题2

小明 — Mon, 15 Apr 2013 05:52:00 GMT

摘要: 给定一个字符串s，切割字符串使得每个子串都是回文的。（比如aba，对称）
要求返回所有可能的分割。

比如，对于字符串s="aab",
返回:

[
["aa","b"],
["a","a","b"]
]
阅读全文

小明 2013-04-15 13:52 发表评论

+1

小明 — Mon, 15 Apr 2013 03:22:00 GMT

摘要: 给定一个有由数字构成的数组表示的数，求该数加1的结果。
public class Solution {
public int[] plusOne(int[] digits) {
}
} 阅读全文

小明 2013-04-15 11:22 发表评论

快速开平方

小明 — Mon, 15 Apr 2013 02:19:00 GMT

摘要: 实现 int sqrt(int x);
计算和返回x的平方根。阅读全文

小明 2013-04-15 10:19 发表评论

最长连续序列问题

小明 — Fri, 12 Apr 2013 07:58:00 GMT

摘要: 给定一个未排序的整数数组，求最长的连续序列的长度。要求算法的时间复杂度在O(n)
比如对于数组[100, 4, 200, 1, 3, 2]，其中最长序列为[1,2,3,4]，所以应该返回4

public class Solution {
public int longestConsecutive(int[] num) {
//write your code here
}
} 阅读全文

小明 2013-04-12 15:58 发表评论

回文字符串的切割问题

小明 — Thu, 11 Apr 2013 03:24:00 GMT

摘要: 给定一个字符串s，分割s使得每个子串都是回文的（即倒过来和原字符串是一样的，如aba）
求最少的分割次数。阅读全文

小明 2013-04-11 11:24 发表评论

TopCoder MatchMaker解法

小明 — Tue, 02 Apr 2013 06:04:00 GMT

问题描述：

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 allMembers = new ArrayList();
        Member cu = null;
        for(int i=0;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                answers[j-3] = c[j];
            }
            allMembers.add(mem);
            if(c[0].equals(currentUser)){
                cu = mem;
            }
        }
        List matched = new ArrayList();
        if(cu!=null){
            for(Member mem:allMembers){
                if(mem!=cu && mem.gender==cu.mate){
                    for(int i=0;i                        if(mem.answers[i].equals(cu.answers[i])){
                            ++mem.matched;
                        }
                    }
                    if(mem.matched>=sf){
                        matched.add(mem);
                    }
                }
            }

            Collections.sort(matched, new Comparator(){
                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[i] = matched.get(i).name;
            }
            return result;
        }
        return new String[0];
    }
}

小明 2013-04-02 14:04 发表评论

TopCoder Prerequisites解法

小明 — Tue, 25 Oct 2011 05:28:00 GMT

原题：

http://community.topcoder.com/stat?c=problem_statement&pm=164&rd=50

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)

------------------------------------------------------------我的解法如下----------------------------------------

想法很简单，这道题本质上是一道排序问题，我们只需要定义好排序的逻辑，然后应用快排就可以了。

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;
    }
}

小明 2011-10-25 13:28 发表评论