字符串消除

    算法基本上还给老师了，CSDN看到编程挑战，心血来潮试了下《字符串消除》。个人觉得算法应该没错（用了递归，性能上似乎有点问题），但是一直提示“挑战失败”，有那么点disappointed ，请懂行的专家指导下。

题目详情（http://hero.pongo.cn/Question/Details?ExamID=83&ID=85&bsh_bid=278004606）

给定一个字符串，仅由a,b,c 3种小写字母组成。当出现连续两个不同的字母时，你可以用另外一个字母替换它，如

1. 有ab或ba连续出现，你把它们替换为字母c；
2. 有ac或ca连续出现时，你可以把它们替换为字母b；
3. 有bc或cb 连续出现时，你可以把它们替换为字母a。

你可以不断反复按照这个规则进行替换，你的目标是使得最终结果所得到的字符串尽可能短，求最终结果的最短长度。

输入：字符串。长度不超过200，仅由abc三种小写字母组成。

输出： 按照上述规则不断消除替换，所得到的字符串最短的长度。

例如：输入cab，输出2。因为我们可以把它变为bb或者变为cc。

          输入bcab，输出1。尽管我们可以把它变为aab -> ac -> b，也可以把它变为bbb，但因为前者长度更短，所以输出1。

我的代码

思路：核心是两个相同的字符能被旁边的其他字母消除，比如，aab->b,baa->b

public class StringEliminate extends TestCase  
{
    
    private static final char A='a';
    private static final char B='b';
    private static final char C='c';
    
    public static void main(String[]args){
        System.out.println(minLength("cab"));
        System.out.println(minLength("bcab"));
        System.out.println(minLength("bcacbbbbab"));
        System.out.println(minLength("bcacbbbbabacbcaabc"));
    }
    
    public static int minLength(String s){
        if(null==s||"".equals(s)){
            new RuntimeException("Input string is null!");
        }
        
        int length=s.length();
        for(int index=0;index<length;index++){
            char tempChar=s.charAt(index);
            if(tempChar!=A&&tempChar!=B&&tempChar!=C){
                new RuntimeException("Input string has invalid char!");
            }
        }
        
        String finalResult=minResult( s);
        return finalResult.length();
    }
   
    private static String minResult(String s){
        if(s.length()==1){
            return minOneCharResult(s);
        }
        
        if(s.length()==2){
            return minTwoCharResult(s);
        }
        
        // 遍历字符串分割方法，每次分割将字符串分割成两个字符串，分别求消除结果
        // 对消除结果分别进行求模,最终计算消除结果
        // 将每次分割的计算结果与最小数比较，保存最新的结果
        int splitLen=s.length()-2;
        int min=Integer.MAX_VALUE;
        String result="";
        for(int i=0;i<splitLen;i++){
            // 前一半字符串
            String firstHalf=s.substring(0,i+1);
            String firstHalfResult=minResult(firstHalf);
            // 后一半字符串
            String secondHalf=s.substring(i+1);
            String secondHalfResult=minResult(secondHalf);
            // 本次分割的计算结果字符串
            String resultStr="";
            
            if(firstHalfResult.charAt(0)==secondHalfResult.charAt(0)){
                // 两个结果字符串结果字符相同，那么直接相加
                resultStr=firstHalfResult+secondHalfResult;
            }else{
                // 分别对两个结果求模
                firstHalfResult=getModularedString(firstHalfResult);
                secondHalfResult=getModularedString(secondHalfResult);
                // 对求模后的两个结果字符串求结果
                resultStr=getOneSplitResult( firstHalfResult,secondHalfResult);
            }
            
            // 比较本次结果，记录最小结果
            if(resultStr.length()<min){
                result=resultStr;
                min=resultStr.length();
            }
        }
        
        return result;
    }
    
    
    /**
     * 作用：获得一个字符的消除结果字符串
     * @param s
     * @return
     * @created by martin
     */
    private static String minOneCharResult(String s){
        return s;
    }
    
    /**
     * 作用：获得两个字符的消除结果字符串，比如aa->c,aa->aa
     * @param s
     * @return
     * @created by martin
     */
    private static String minTwoCharResult(String s){
        boolean diffent=s.charAt(0)!=s.charAt(1);
        if(diffent){
            // ab
            char thirdChar=theThirdChar(s.charAt(0),s.charAt(1));
            return String.valueOf(thirdChar);
        }else{
            // aa
            return s;
        }
    }
    
    /**
     * 作用：获得消除字符，比如ab消除成c
     * @param one
     * @param two
     * @return
     * @created by martin
     */
    private static char theThirdChar(char one,char two){
        int abs=Math.abs(one-two);
        if(abs==1){
            if(one==A||two==A){
                return C;
            }else{
                return A;
            }
        }else{
            return B;
        }
    }
    
    /**
     * 作用：字符元素相同的字符串求模，比如aaaa求模成aa，aaa求模成a
     * @param s
     * @return
     * @created by martin
     */
    private static String getModularedString(String s){
        return s.length()%2==0?s.substring(0,2):s.substring(0,1);
    }
    
    /**
     * 作用：求模后两个字符串获得最终的消除结果
     * @param firstHalfResult
     * @param secondHalfResult
     * @return
     * @created by martin
     */
    private static String getOneSplitResult(String firstHalfResult,
                    String secondHalfResult){
        String resultStr="";
        if(firstHalfResult.length()==1&&
                        secondHalfResult.length()==1)
        {
            // a,b
            resultStr=String.valueOf(theThirdChar(
                            firstHalfResult.charAt(0),
                            secondHalfResult.charAt(0)));
        }
        else if(firstHalfResult.length()==2&&
                        secondHalfResult.length()==2)
        {
            // aa,bb
            resultStr= firstHalfResult;
        }
        else
        {
            if(firstHalfResult.length()==1){
                // a,bb
                resultStr=firstHalfResult;
            }else{
                // aa,b
                resultStr=secondHalfResult;
            }
        }
        return resultStr;
    }
    

    
    protected void setUp() throws Exception {
        super.setUp();
    }

    protected void tearDown() throws Exception {
        super.tearDown();
    }
    
    public void testOneCharResult()
    {
        assertEquals(minOneCharResult("a"),"a");
    }
    
    public void testTwoCharResult()
    {
        assertEquals(minTwoCharResult("aa"),"aa");
        assertEquals(minTwoCharResult("ab"),"c");
    }
    
    public void testModularedString()
    {
        assertEquals(getModularedString("a"),"a");
        assertEquals(getModularedString("aa"),"aa");
        assertEquals(getModularedString("aaa"),"a");
    }
    
    public void testOneSplitResult()
    {
        assertEquals(getOneSplitResult("a","b"),"c");
        assertEquals(getOneSplitResult("aa","bb"),"aa");
        assertEquals(getOneSplitResult("a","bb"),"a");
        assertEquals(getOneSplitResult("aa","b"),"b");
    }
    
}