Here is a top down DP solution :
Points worth noting:

Any breakable string must also be breakable if we divide it into two substrings properly.
There are only N  1 ways of dividing a string into two parts, with N the length of the string.
So our task is to find a proper way out of these N  1 ones. (only one will do since the problem does not
ask us to find all ways.)

To avoid repetition, we use a HashMap to store the results for each substring, which are obtained in turn by calling wordBreak() method.

The total string is breakable if its two complementary substrings are breakable. Once we get the results for both parts, we can check this by getting the results from the HashMap.
In total the program will run in O(n^2) time with n the length of the string. Here is the program:
public class WordBreak {
private Map<String, Boolean> myMap = new HashMap<>();
public boolean wordBreak(String s, Set<String> dict) {
// check if the dictionary contains the whole string
if (dict.contains(s)) {
return true;
}
// divide the string and check for each substring
for (int i = 1; i < s.length(); i++) {
// check for the left half substring
if (!myMap.containsKey(s.substring(0,i))) {
myMap.put(s.substring(0,i), wordBreak(s.substring(0,i), dict));
}
// check for the right half substring
if (!myMap.containsKey(s.substring(i, s.length()))) {
myMap.put(s.substring(i, s.length()), wordBreak(s.substring(i, s.length()), dict));
}
// if both substrings are breakable, then the total string is also breakable
if (myMap.get(s.substring(0,i)) && myMap.get(s.substring(i, s.length()))) {
return true;
}
}
// else the string is not breakable
return false;
}
}