Restore IP Addresses Java

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example:

Given 

"25525511135"

,

return 

["255.255.11.135", "255.255.111.35"]

. (Order
does not matter)

Two Approach: the problem can solve by recursion and non-recursion method

Solution_1: Recursion Method

This is kind of NP-problem, but actually it is not, since we only need to

    conduct String into 4 segments to check wether is valid IP Address,

     and the length will be range of between 4 and 12

    Idea: same approach as N-Queens => loop-recursion method

    Restore IP Addresses:

    i: indicate range of each segment 1<=i<=3

    index: current index of String, used by substring method

    curr: store Valid IP address and concatenate together

    res: result Valid IP address list
public class Solution {
public ArrayList<String> restoreIpAddresses(String s) {
ArrayList<String> res=new ArrayList<String>();
helper(s,0,1,"",res);
return res;
}
private void helper(String s, int index, int segment, String curr, ArrayList<String> res){
int len=s.length();
if(segment==4){ //the case of 4th segment
String str=s.substring(index);
if(isValid(str)){
res.add(curr+"."+str);
}
return;
}
for(int i=1;i<=3 && i+index<=len;i++){
String str=s.substring(index,index+i);
if(isValid(str)) {
if (segment == 1) { //the case of 1st segment
helper(s, index + i, segment + 1, str, res);
} else {
helper(s, index + i, segment + 1, curr + "." + str, res);
}
}
}
}
private boolean isValid(String str){
int len=str.length();
if(len==0 || len>3){
return false;
}
if(str.charAt(0)=='0' && len>1){
return false;
}
int num=Integer.parseInt(str);
if(num>=0 && num<=255){
return true;
}
return false;
}
}

Solution_2:Non-recursion method

    Solved by  the Nested loop with depth 3

    that considering up to 3 possibilities of making up the current part

    and we split each part iteratively by explicitly determining

    the positions of the dots.

    Check the coding in detail below: 

public class Solution {
public ArrayList<String> restoreIpAddresses(String s) {
ArrayList<String> result = new ArrayList<String>();
int len=s.length();
if(len<4 || len>12) return result;
//1st segment
for(int i=1;i<=3;i++){  //at most 3 digits at each segment
if((len-i)>9) continue; //the remaining part should less than 9
if(s.charAt(0)=='0' && i>1) break; //0x is not allow
String firstSeg=s.substring(0,i);
if(Integer.parseInt(firstSeg)<=255) { //>maximum ip number is 255
////2nd segment
for(int j=i+1;j<=i+3 && j<len;j++){
if((len-j)>6) continue; ////the remaining part should less than 6
if(s.charAt(i)=='0' && j>i+1) break;
String secondSeg=s.substring(i,j);
if(Integer.parseInt(secondSeg)<=255){
//3rd segment
for(int m=j+1;m<=j+3 && m<len;m++){
if((len-m)>3) continue;
if(s.charAt(j)=='0' && m>j+1) break;
String thirdSeg=s.substring(j,m);
if(Integer.parseInt(thirdSeg)<=255){
// If the fourth part is a single digit, or it does not begin with a '0' and <=255
if(m==len-1 || s.charAt(m)!='0' && (Integer.parseInt(s.substring(m))<=255)){
result.add(firstSeg+"."+secondSeg+"."+thirdSeg+"."+s.substring(m));
}
}
}
}
}
}
}
return result;
}
}