4月6号算法题解

4月6号算法题解

93. 复原 IP 地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

• 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

• 1 <= s.length <= 20
• s 仅由数字组成

这道题目属于切割类，需要用到回溯算法，在解题之前，依然可以先把树状图画出来，其实插入 ’ .’ ,对于字符串来说算是分割点，我们需要找出所有分割的情况，然后判断每一段字符串是否有效，但是在运行过程中这些问题就被解决了。

这个时候看题目要求，判断地址是否有效的关键是判断切割出来的字符串是否有效，所以需要用到另一个函数来判断字符串是否有效，下面是代码实现：

char** result;	//最后记录答案的数组
int resulttop;
int segment[3]; //这个是记录插入标点的位置，也就是分割点

int isValid(char* s, int start, int end) {	//这个函数是用来判断一段字符串是否有效
    if(start > end) {
        return 0;
    }
    if(s[start] == '0' && start != end) {	//如果第一个字符就为0，自然无效；但是如果单单一个0就是有效的
        return false;
    }
    int num = 0;
    for(int i = start; i <= end; i++) {
        if(s[i] > '9' || s[i] < '0') {	//不是数字字符的话也是无效的
            return false;
        }
        num = num * 10 + (s[i] - '0');	//这里是将每个字符转换为数字，然后相加得到这一字符串所代表的数字
        if(num > 255) {
            return false;	//超过了大小限制，返回0
        }
    }
    return true;
}

void backtracking(char* s, int startindex, int pointnum) {
    if(pointnum == 3) {	//当分割点等于三个的时候，就说明已经结束了，但是还剩最后一个字符串没判断，所以这里需要判断最后的字符串是否有效，有效的话就可以加入答案数组了
        if((isValid(s, startindex, strlen(s) - 1))) {
            char* temp = (char*)malloc(sizeof(char) * strlen(s) + 4);
            int j;
            int count = 0;	//这里指向temp数组记录到的位置
            int count1 = 0;	//这个记录已经填入句点的数量
            for(j = 0; j < strlen(s); j++) {
                temp[count++] = s[j];
                if(count1 < 3 && j == segment[count1]) {	//如果句点没用完，并且分割点数组记录了该位置，就说明要插入句点了
                    temp[count++] = '.';
                    count1++;
                }
            }
            temp[count] = '\0';	//在字符串后面加上终止符
            result[resulttop++] = temp;	//加入答案数组
        }
        return;
    }

    int i;
    for(i = startindex; i <strlen(s); i++) {	//这里从头开始遍历，尝试每种分割方式
        if(isValid(s, startindex, i)) {	//如果切割出的字符串有效，则记录分割点的位置，然后进行下一次的分割
            segment[pointnum] = i;
            backtracking(s, i + 1, pointnum + 1);
        }else {	//如果该段是无效字符串，则后面再怎么分割都无效了所以直接退出
            break;
        }
    }
}

char** restoreIpAddresses(char* s, int* returnSize) {
    result = (char**)malloc(sizeof(char*) * 10000);
    resulttop = 0;
    backtracking(s, 0, 0);
    *returnSize = resulttop;
    return result;
}

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的

子集

（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10

• -10 <= nums[i] <= 10

• nums 中的所有元素 互不相同

  依然是组合问题，但是按照之前的回溯思想，收集答案的时候都是从叶子节点上来收集的，但是对于这道题目，当我们把树状图画出来的时候，我们可以发现数上每一个节点都是答案的一种可能，所以在之前的回溯方法中，我们收集答案的时候都会添加一些判断，以此来判断是否是有效答案，但是这一题的关键就是每次进入一层递归时，都要直接将path数组中记录的答案加入答案数组中，不用添加别的判断，然后在超出数组范围时退出递归；

  int** ans;
   int anstop;
   int* path;
   int pathtop;
   int* length;
  
   void backtracking(int* nums, int numsSize, int startindex) {
      int* temp = (int*)malloc(sizeof(int) * pathtop);	//这里是将记录的叶子节点加入答案数组
      int i;
      for(i = 0; i < pathtop; i++) {
          temp[i] = path[i];
      }
      length[anstop] = pathtop;
      ans[anstop++] = temp;
      if(startindex >= numsSize) {
          return;
      }
      int j;
      for(j = startindex; j < numsSize; j++) {
          path[pathtop++] = nums[j];	//将当前的数字记录在path数组中
          backtracking(nums, numsSize, j + 1);	//进行下一次递归
          pathtop--;
      }
  
   }
  
  int** subsets(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
      path = (int*)malloc(sizeof(int) * numsSize);
      ans = (int**)malloc(sizeof(int*) * 100000);
      length = (int*)malloc(sizeof(int) * 1500);
      anstop = pathtop = 0;
      backtracking(nums, numsSize, 0);
      *returnSize = anstop;
      *returnColumnSizes = (int*)malloc(sizeof(int) * anstop);
      int i;
      for(i = 0; i < anstop; i++) {
          (*returnColumnSizes)[i] = length[i];
      }
      return ans;
  
  }
turnColumnSizes = (int*)malloc(sizeof(int) * anstop);
      int i;
      for(i = 0; i < anstop; i++) {
          (*returnColumnSizes)[i] = length[i];
      }
      return ans;
  
  }