Leetcode:131. 分割回文串

题目：
给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
返回 s 所有可能的分割方案。
示例:
输入: “aab”
输出:
[
[“aa”,“b”],
[“a”,“a”,“b”]
]

思路：分为三个函数，主方法函数，递归函数，检查是否为回文函数

重点：

//new ArrayList<>(list))是因为，如不new，则list在后来被修改后，此时存储的值也会被修改。
 					reslist.add(new ArrayList<>(list));
//这一句话，是必须的。所有的主递归函数和往下的子递归函数都是用的同一个list，他们有着明确的地址。用的是一个list，而不是list的复制。只是用的顺序不同，通过+上后进行递归，又remove的操作实现了一个list大家都用。
                    list.remove(list.size()-1);

class Solution {
    //new  List<List<String>>(); 这样写不对
	//new ArrayList<>();List是接口ArrayList才是可以实例化的类的名字
	//前面能List或者ArrayList后面只能写为ArrayList；
	ArrayList<List<String>> reslist=new ArrayList<>();
    
    public List<List<String>> partition(String s) {
        List<String>list= new ArrayList<String>();
        dgpar(s,0,list);
        return reslist;      
    }
    //dg的英文：recursion
    public  void  dgpar(String s,int a,List<String>list){    
         if(a==s.length()){          
            reslist.add(new ArrayList<>(list));     
         }
   for(int i=a;i<s.length();i++){
           
        // 判断是否是回文，是：加到列表中，否：i++
        //是：（1）加到列表中，开并进行下一次递归.（2）b的值继续前进，查找另一种可能
        //否：（1）b的值继续前进，直到找到回文，或者搜索完毕
        //substring，S不用大写
            String s1=s.substring(a,i+1);
            if(checkpar(s1)){ 
                    list.add(s1);
                    dgpar(s,i+1,list);
                    //remove
                    list.remove(list.size()-1);  
                }
            }
        }
    //boolean 不是boollean
    public boolean checkpar(String s){
        StringBuilder strb=new StringBuilder(s);
        //
        return strb.toString().equals(strb.reverse().toString());
    }
}

第二个方法和第一种大致一样，只是把当回文数到达最后的判定放在for循环中

class Solution {
    //new  List<List<String>>(); 这样写不对
	//new ArrayList<>();List是接口ArrayList才是可以实例化的类的名字
	//前面能List或者ArrayList后面只能写为ArrayList；
	ArrayList<List<String>> reslist=new ArrayList<>();
    
    public List<List<String>> partition(String s) {
        List<String>list= new ArrayList<String>();
        dgpar(s,0,list);
        return reslist;
        
    }
    
    //dg的英文
    public  void  dgpar(String s,int a,List<String>list){
        
        
        for(int i=a+1;i<=s.length();i++){
           
        // 判断是否是回文，是：加到列表中，否：b++,
        //是：（1）加到列表中，开并进行下一次递归.（2）b的值继续前进，查找另一种可能
        //否：（1）b的值继续前进，直到找到回文，或者搜索完毕
        //substring，S不用大写
            String s1=s.substring(a,i);
            if(checkpar(s1)){ 
            
                if(i==s.length()){
                    list.add(s1);
                    reslist.add(new ArrayList<>(list));
                    //这一句话，是必须的
                    list.remove(list.size()-1);
                }
                else{
                    list.add(s1);
                    dgpar(s,i,list);
                    //remove
                    list.remove(list.size()-1);
                    
                }
            }

        
        }
    }
    //boolean 不是boollean
    public boolean checkpar(String s){
        StringBuilder strb=new StringBuilder(s);
        //toString,S要大写，substring，S不用大写
        return strb.toString().equals(strb.reverse().toString());
    }
    
    
}

第三种方法试图通过不for只通过递归来实现。
这样的写法出现了错误，查询了一下，可能出现无线递归了？
Line 23: java.lang.StackOverflowError

class Solution {
    //new  List<List<String>>(); 这样写不对
	//new ArrayList<>();List是接口ArrayList才是可以实例化的类的名字
	//前面能List或者ArrayList后面只能写为ArrayList；
	ArrayList<List<String>> reslist=new ArrayList<>();
    
    public List<List<String>> partition(String s) {
        List<String>list= new ArrayList<String>();
        dgpar(s,0,1,list);
        return reslist;
        
    }
    
    //dg的英文
    public  void  dgpar(String s,int a,int b,List<String>list){
        
        // 判断是否是回文，是：加到列表中，否：b++,
        //是：（1）加到列表中，开并进行下一次递归.（2）b的值继续前进，查找另一种可能
        //否：（1）b的值继续前进，直到找到回文，或者搜索完毕
        //substring，S不用大写
        //Line 21: java.lang.StackOverflowError
        String s1= new String();
        s1=s.substring(a,b);
        if(checkpar(s1)){ 
            
            if(b==s.length()){
               list.add(s1);
               reslist.add(new ArrayList<>(list));
               list.remove(list.size()-1);
                
            }
            else{
                list.add(s1);
                dgpar(s,b,b+1,list);
                //remove
                list.remove(list.size()-1);
                dgpar(s,a,b+1,list);
            }
        }
        else{
            if(b!=s.length())
            
            dgpar(s,a,b++,list);
        }
        
        
    }
    //boolean 不是boollean
    public boolean checkpar(String s){
        StringBuilder strb=new StringBuilder(s);
        //
        return strb.toString().equals(strb.reverse().toString());
    }
    
    
}