feat(src): add 93-restoreIpAddresses and enhance common.h

Author: kwu130

include/common.h

@@ -1,7 +1,7 @@
 #ifndef LEETCODE_COMMON_H
 #define LEETCODE_COMMON_H
 
-#include <cassert>
+#include <ranges>
 
 namespace listHelper {
 struct ListNode {
@@ -10,17 +10,17 @@ struct ListNode {
     ListNode()
         : val(0),
           next(nullptr) {}
-    ListNode(int x)
+    explicit ListNode(int x)
         : val(x),
           next(nullptr) {}
-    ListNode(int x, ListNode* next)
+    ListNode(const int x, ListNode* next)
         : val(x),
           next(next) {}
 };
 
-ListNode* build(const std::vector<int>& vec) {
+inline ListNode* build(const std::vector<int>& vec) {
     if (vec.empty()) return nullptr;
-    ListNode* head = new ListNode(vec[0]);
+    auto* head = new ListNode(vec[0]);
     ListNode* cur = head;
     for (size_t i = 1; i < vec.size(); i++) {
         cur->next = new ListNode(vec[i]);
@@ -30,7 +30,7 @@ ListNode* build(const std::vector<int>& vec) {
     return head;
 }
 
-bool equal(const ListNode* lhs, const ListNode* rhs) {
+inline bool equal(const ListNode* lhs, const ListNode* rhs) {
     while (lhs != nullptr && rhs != nullptr) {
         if (lhs->val != rhs->val) {
             return false;
@@ -42,15 +42,15 @@ bool equal(const ListNode* lhs, const ListNode* rhs) {
     return lhs == nullptr && rhs == nullptr;
 }
 
-void print(const ListNode* head) {
+inline void print(const ListNode* head) {
     while (head != nullptr) {
         std::cout << head->val << " -> ";
         head = head->next;
     }
     std::cout << "nullptr" << std::endl;
 }
 
-void free(ListNode* head) {
+inline void free(ListNode* head) {
     while (head != nullptr) {
         ListNode* tmp = head;
         head = head->next;
@@ -61,15 +61,25 @@ void free(ListNode* head) {
 
 
 namespace compareHelper {
+template <typename T>
+bool equalIgnoreOrder(std::vector<T> a, std::vector<T> b) {
+    if (a.size() != b.size()) return false;
+
+    std::ranges::sort(a);
+    std::ranges::sort(b);
+
+    return a == b;
+}
+
 template <typename T>
 bool equalIgnoreOrder(std::vector<std::vector<T>> a, std::vector<std::vector<T>> b) {
     if (a.size() != b.size()) return false;
 
-    for (auto& v : a) std::sort(v.begin(), v.end());
-    for (auto& v : b) std::sort(v.begin(), v.end());
+    for (auto& v : a) std::ranges::sort(v);
+    for (auto& v : b) std::ranges::sort(v);
 
-    std::sort(a.begin(), a.end());
-    std::sort(b.begin(), b.end());
+    std::ranges::sort(a);
+    std::ranges::sort(b);
 
     return a == b;
 }

src/93-restoreIpAddresses.cpp

@@ -0,0 +1,62 @@
+//
+// Created by 1412 on 2025/11/23.
+//
+
+#include <bits/stdc++.h>
+#include "common.h"
+
+using namespace std;
+
+class Solution {
+public:
+    vector<string> restoreIpAddresses(string s) {
+        vector<string> res;
+        dfs(s, 0, {}, res);
+        return res;
+    }
+
+private:
+    void dfs(const string s, int index, vector<string>&& path, vector<string>& res) {
+        if (path.size() == 4) {
+            if (index == static_cast<int>(s.size())) {
+                res.emplace_back(path[0] + "." + path[1] + "." + path[2] + "." + path[3]);
+            }
+            return;
+        }
+        for (int l = 1; l <= 3; ++l) {
+            if (index + l > static_cast<int>(s.size())) {
+                return;
+            }
+            if (l != 1 && s[index] == '0') {
+                return;
+            }
+            string segment = s.substr(index, l);
+            if (l == 3 && stoi(segment) > 255) {
+                return;
+            }
+            path.push_back(segment);
+            dfs(s, index + l, std::move(path), res);
+            path.pop_back();
+        }
+    }
+};
+
+void test() {
+    Solution s;
+    vector<string> expected = {"255.255.11.135", "255.255.111.35"};
+    vector<string> res = s.restoreIpAddresses("25525511135");
+    assert(compareHelper::equalIgnoreOrder(res, expected));
+
+    expected = {"0.0.0.0"};
+    res = s.restoreIpAddresses("0000");
+    assert(compareHelper::equalIgnoreOrder(res, expected));
+
+    expected = {"1.0.10.23", "1.0.102.3", "10.1.0.23", "10.10.2.3", "101.0.2.3"};
+    res = s.restoreIpAddresses("101023");
+    assert(compareHelper::equalIgnoreOrder(res, expected));
+}
+
+int main() {
+    test();
+    return 0;
+}