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, 4);
    }

    /*s为需要划分的字符串，num为需要划分段数*/
    vector<string> getIpAddresses(string s, int num)
    {
        int len = s.length();
        if (s.empty() || num <= 0 || len > 3 * num || len < num)
            return vector<string>();
        vector<string> ips;
        if (num == 1)
        {
            if (isLegal(s))
                ips.push_back(s);
            return ips;
        }//if
        else{
            //得到首段，每段ip长度不超过3
            for (int i = 0; i < len && i < 3; ++i)
            {
                string ip1 = s.substr(0, i + 1);
                if (isLegal(ip1))
                {
                    vector<string> tmpIps = getIpAddresses(s.substr(i + 1), num - 1);
                    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[0] == '0')
            return ip.length() == 1;
        else{
            int pos = ip.length() - 1;
            int sum = 0 , tmp = 1;
            while (pos >= 0)
            {
                sum = sum + (ip[pos] - '0') * tmp;
                if (sum > 255)
                    return false;
                tmp *= 10;
                --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 = 0; i < len - 2; ++i)
        {
            for (int j = i + 1; j < len - 1; ++j)
            {
                for (int k = j + 1; k < len; ++k)
                {
                    string ip1 = s.substr(0, i + 1);
                    string ip2 = s.substr(i + 1, j - i);
                    string ip3 = s.substr(j + 1, k - j);
                    string ip4 = s.substr(k + 1);
                    if (isLegal(ip1) && isLegal(ip2) && isLegal(ip3) && isLegal(ip4))
                        ips.push_back(ip1 + "." + ip2 + "." + ip3 + "." + ip4);
                }//for
            }//for
        }//for

        return ips;
    }
};

GitHub测试程序源码