LeetCode（93） Restore IP Addresses

题目

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)

分析

给定一个字符串，给出其可构成的所有ip集合；

下面用两种方法解决这个问题：

1. 首先，一种简单的做法便是三重循环，得到构成ip地址的四段子地址，然后判断合法与否；该方法效率比较低；但是容易想到；
2. 第二种方法，便是利用动态规划的思想；
   （1）对于给定的字符串，IP地址要分隔为4段，第一段有最多三种可能2、 25 、 255因为其最长只能为3个字符；
   （2）此时若我们划分的第一段为合法的，我们可以递归将剩余子串划分为3段；将ip1与集合中所有合法后三段ip链接即可；
   （3）明显的，利用以上理念很容易写出递归实现代码；

AC代码

 class Solution {
 public:
     /*方法一：动态规划方式*/
     vector<string> restoreIpAddresses(string s) {
         if (s.empty())
             return vector<string>();

         return getIpAddresses(s, );
     }

     /*s为需要划分的字符串，num为需要划分段数*/
     vector<string> getIpAddresses(string s, int num)
     {
         int len = s.length();
         if (s.empty() || num <=  || len >  * num || len < num)
             return vector<string>();
         vector<string> ips;
         if (num == )
         {
             if (isLegal(s))
                 ips.push_back(s);
             return ips;
         }//if
         else{
             //得到首段，每段ip长度不超过3
             for (int i = ; i < len && i < ; ++i)
             {
                 string ip1 = s.substr(, i + );
                 if (isLegal(ip1))
                 {
                     vector<string> tmpIps = getIpAddresses(s.substr(i + ), num - );
                     if (!tmpIps.empty())
                     {
                         auto iter = tmpIps.begin();
                         while (iter != tmpIps.end())
                         {
                             string ip = ip1 + "." + *iter;
                             ips.push_back(ip);
                             ++iter;
                         }//while
                     }//if
                 }//if
             }//for
             return ips;
         }
     }

     /*判断ip段是否合法*/
     bool isLegal(string ip)
     {
         if (ip.empty())
             return false;
         else if (ip[] == '')
             return ip.length() == ;
         else{
             int pos = ip.length() - ;
             int sum =  , tmp = ;
             while (pos >= )
             {
                 sum = sum + (ip[pos] - '') * tmp;
                 if (sum > )
                     return false;
                 tmp *= ;
                 --pos;
             }//while
         }//else
         return true;
     }

     /*方法二：三重循环，效率低*/
     vector<string> restoreIpAddresses2(string s) {
         vector<string> ips;
         if (s.empty())
             return vector<string>();

         int len = s.length();
         for (int i = ; i < len - ; ++i)
         {
             for (int j = i + ; j < len - ; ++j)
             {
                 for (int k = j + ; k < len; ++k)
                 {
                     string ip1 = s.substr(, i + );
                     string ip2 = s.substr(i + , j - i);
                     string ip3 = s.substr(j + , k - j);
                     string ip4 = s.substr(k + );
                     if (isLegal(ip1) && isLegal(ip2) && isLegal(ip3) && isLegal(ip4))
                         ips.push_back(ip1 + "." + ip2 + "." + ip3 + "." + ip4);
                 }//for
             }//for
         }//for

         return ips;
     }
 };

GitHub测试程序源码