回溯算法总结JAVA

全排列，字符串切割，组合

package baseJava;

import java.util.ArrayList;
import java.util.List;

public class BackTrackingTest {

   static List<List<String>> res = new ArrayList<>();
    public static void main(String[] args) {

        String s = "abcdefgh";
        String[] s1 = {"A","B","C","D","E","F"};
        BackTrackingTest backTrackingTest = new BackTrackingTest();

        //字符串分割
        //backTrackingTest.backTracking(s,0, new ArrayList<>());
        for(List<String> list: res){
            for(String t: list){ System.out.println(t); }
        }


        // 全排列
//        backTrackingTest.backTrackingAll(s1,0,new ArrayList<>());
        for(List<String> list: res){
            for(String t: list){ System.out.print(t); }
            System.out.println();
        }

        //组合
        backTrackingTest.backTrackingCombin(s1,0,new ArrayList(), new int[s1.length]);
        for(List<String> list: res){
            for(String t: list){ System.out.print(t); }
            System.out.println();
        }

    }


    /**
     * 切割字符串
     * @param s
     * @param index
     * @param ls
     */
    void backTracking(String s, int index, List<String> ls){
        if(index == s.length()){
            res.add(new ArrayList<>(ls));
            return;
        }
        for(int i = index; i<s.length(); i++){
            ls.add(s.substring(index, i+1));
            backTracking(s,i+1,ls);
            ls.remove(ls.size()-1);
        }
    }

    /**
     * 字母全排列
      */

    private void backTrackingAll(String[] s, int index, List<String> ls) {
         res.add(new ArrayList<>(ls));
        for(int i =index; i< s.length;i++){
            ls.add(s[i]);
            backTrackingAll(s,i+1,ls);
            ls.remove(ls.size()-1);
        }
    }

    /**
     * 组合
     */

    private void backTrackingCombin(String[] s, int index, List ls, int[] b) {
        if(ls.size() == s.length){
            res.add(new ArrayList<>(ls));
            return;
        }
        for(int i = 0; i< s.length; i++){
            if(b[i] == 1) continue;
            ls.add(s[i]);
            b[i] =1;
            backTrackingCombin(s, i+1, ls, b);
            b[i] = 0;
            ls.remove(ls.remove(ls.size()-1));
        }
    }
}