leetcode 131. Palindrome Partitioning回文子串+DFS

Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = "aab",
Return

[
  ["aa","b"],
  ["a","a","b"]
]

import copy

class Solution(object):
    def partition(self, s):
        self.s = s
        n = len(s)
        self.n = n
        self.dp = [([False]*n) for i in range(0 , n)]
        for r in range(0 , n):
            for l in range(0 , r+1):
                if s[l] == s[r] and ((r - l <= 2) or self.dp[l+1][r-1]):
                    self.dp[l][r] = True
        self.reslut = []
        self.dfs(-1 , [])
        return self.reslut

    def dfs(self, father , h):
        if father == self.n - 1 :
            self.reslut.append(copy.copy(h))
            return
        for i in range(father+1 , self.n):
            if self.dp[father+1][i]:
                h.append(self.s[father+1:i+1])
                self.dfs(i , h)
                h.pop()

if __name__ == '__main__':
    s = Solution() ;
    print(s.partition("aab"))

JAVA版

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;


public class Solution {
	
	boolean[][] dp ;
	String word ;
	int n ;
	List<List<String>> result ;
	
	public List<List<String>> partition(String s) {
        n = s.length() ;
        word = s ; 
        dp = new boolean[n][n] ;
        for(int i = 0 ; i < n ; i++){
        	Arrays.fill(dp[i] , false) ;
        }
        for(int r = 0 ; r < n ; r++){
        	for(int l = 0 ; l <= r ; l++){
        		if(word.charAt(l) == word.charAt(r) && ((r - l <= 2) || dp[l+1][r-1])){
        			dp[l][r] = true ;
        		}
        	}
        }
        result = null ;
        dfs(-1 , new LinkedList<String>()) ;
        return result ; 
    }
	
	void dfs(int father , LinkedList<String> h){
		if(father == n-1){
			if(result == null){
				result = new ArrayList<List<String>>() ;
			}
			result.add(new ArrayList<String>(h)) ;
			return ; 
		}
		for(int i = father + 1 ; i < n ; i++){
			if(dp[father+1][i]){
				h.addLast(word.substring(father+1 , i+1)) ; 
				dfs(i , h) ;
				h.removeLast() ;
			}
		}
	}
	
	public static void main(String[] args) {
		Solution s = new Solution() ;
		s.partition("aab") ;
		System.out.println(s.result) ;
	}

}