111 complex problems

Cargo.toml

@@ -13,6 +13,12 @@ members = [
 	"problems/problems_3106",
 	"problems/problems_34",
 	"problems/problems_102",
+    "problems/problems_1379",
+    "problems/problems_236",
+	"problems/problems_116",
+	"problems/problems_117",
+	"problems/problems_133",
+	"problems/problems_138",
 	"problems/problems_699",
 	"problems/problems_39",
 	"problems/problems_215",
@@ -60,6 +66,12 @@ solution_239 = { path = "problems/problems_239", features = ["solution_239"] }
 solution_3106 = { path = "problems/problems_3106", features = ["solution_3106"] }
 solution_34 = { path = "problems/problems_34", features = ["solution_34"] }
 solution_102 = { path = "problems/problems_102", features = ["solution_102"] }
+solution_1379 = { path = "problems/problems_1379", features = ["solution_1379"] }
+solution_236 = { path = "problems/problems_236", features = ["solution_236"] }
+solution_116 = { path = "problems/problems_116", features = ["solution_116"] }
+solution_117 = { path = "problems/problems_117", features = ["solution_117"] }
+solution_133 = { path = "problems/problems_133", features = ["solution_133"] }
+solution_138 = { path = "problems/problems_138", features = ["solution_138"] }
 solution_699 = { path = "problems/problems_699", features = ["solution_699"] }
 solution_39 = { path = "problems/problems_39", features = ["solution_39"] }
 solution_215 = { path = "problems/problems_215", features = ["solution_215"] }

cpp/models/BUILD

@@ -2,11 +2,20 @@ cc_library(
     name = "models",
     srcs = [
         "ListNode.cpp",
+        "NodeNeighbors.cpp",
+        "NodeRandom.cpp",
         "TreeNode.cpp",
+        "TreeNodeNext.cpp",
     ],
-    hdrs = ["ListNode.h", "TreeNode.h"],
+    hdrs = [
+        "ListNode.h",
+        "NodeNeighbors.h",
+        "NodeRandom.h",
+        "TreeNode.h",
+        "TreeNodeNext.h",
+    ],
+    visibility = ["//visibility:public"],
     deps = [
         "@nlohmann_json//:json",
     ],
-    visibility = ["//visibility:public"],
 )

cpp/models/ListNode.cpp

@@ -37,18 +37,18 @@ ListNode *IntArrayToListNodeCycle(std::vector<int> &arr, int pos) {
 }
 
 std::tuple<ListNode *, ListNode *>
-IntArrayToIntersectionListNode(std::vector<int> &arr1, std::vector<int> &arr2, int iv, int idxA, int idxB) {
+IntArrayToIntersectionListNode(int iv, std::vector<int> &arr1, std::vector<int> &arr2, int idx_a, int idx_b) {
     auto headA = IntArrayToListNode(arr1);
-    if (iv == 0 || idxA == static_cast<int>(arr1.size()) || idxB == static_cast<int>(arr2.size())) {
+    if (iv == 0 || idx_a == static_cast<int>(arr1.size()) || idx_b == static_cast<int>(arr2.size())) {
         return {headA, IntArrayToListNode(arr2)};
     }
     auto pa = headA;
-    for (int i = 0; i < idxA; i++) {
+    for (int i = 0; i < idx_a; i++) {
         pa = pa->next;
     }
-    auto headB = idxB == 0 ? pa : new ListNode(arr2[0]);
+    auto headB = idx_b == 0 ? pa : new ListNode(arr2[0]);
     auto pb = headB;
-    for (int i = 1; i < idxB - 1; i++) {
+    for (int i = 1; i < idx_b - 1; i++) {
         pb->next = new ListNode(arr2[i]);
         pb = pb->next;
     }

cpp/models/ListNode.h

@@ -30,6 +30,6 @@ std::vector<int> &ListNodeToIntArray(ListNode *head);
 ListNode *IntArrayToListNodeCycle(std::vector<int> &arr, int pos);
 
 std::tuple<ListNode *, ListNode *>
-IntArrayToIntersectionListNode(std::vector<int> &arr1, std::vector<int> &arr2, int iv, int idxA, int idxB);
+IntArrayToIntersectionListNode(int iv, std::vector<int> &arr1, std::vector<int> &arr2, int idx_a, int idx_b);
 
 #endif //LEETCODECPP_LISTNODE_H

cpp/models/NodeNeighbors.cpp

@@ -0,0 +1,54 @@
+//
+// Created by BenHao on 2024/7/29.
+//
+
+#include "NodeNeighbors.h"
+#include <unordered_set>
+
+Node *JsonArrayToNodeNeighbors(vector<vector<int>> arr) {
+    if (arr.empty()) {
+        return nullptr;
+    }
+    vector<Node *> nodes = vector<Node *>(arr.size() + 1);
+    for (size_t i = 1; i <= arr.size(); i++) {
+        nodes[i] = new Node(static_cast<int>(i));
+    }
+    for (size_t i = 0; i < arr.size(); i++) {
+        for (size_t j = 0; j < arr[i].size(); j++) {
+            nodes[i + 1]->neighbors.emplace_back(nodes[arr[i][j]]);
+        }
+    }
+    return nodes[1];
+}
+
+void dfs(Node* cur, vector<vector<int>>& ans, std::unordered_set<int>& visited) {
+    if (ans.size() < cur->val) {
+        for (auto i = ans.size(); i < cur->val; i++) {
+            ans.emplace_back();
+        }
+        for (auto neighbor : cur->neighbors) {
+            ans.back().emplace_back(neighbor->val);
+        }
+    } else {
+        for (auto neighbor : cur->neighbors) {
+            ans[cur->val - 1].emplace_back(neighbor->val);
+        }
+    }
+    for (auto neighbor : cur->neighbors) {
+        if (visited.find(neighbor->val) == visited.end()) {
+            visited.insert(neighbor->val);
+            dfs(neighbor, ans, visited);
+        }
+    }
+}
+
+vector<vector<int>> NodeNeighborsToJsonArray(Node *root) {
+    vector<vector<int>> ans;
+    if (root == nullptr) {
+        return ans;
+    }
+    std::unordered_set<int> visited;
+    visited.insert(root->val);
+    dfs(root, ans, visited);
+    return ans;
+}

cpp/models/NodeNeighbors.h

@@ -0,0 +1,40 @@
+//
+// Created by BenHao on 2024/7/29.
+//
+
+#ifndef LEETCODE_NODENEIGHBORS_H
+#define LEETCODE_NODENEIGHBORS_H
+
+#include <utility>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+using std::vector;
+
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    vector<Node *> neighbors;
+
+    Node() {
+        val = 0;
+        neighbors = vector<Node *>();
+    }
+
+    explicit Node(int _val) {
+        val = _val;
+        neighbors = vector<Node *>();
+    }
+
+    Node(int _val, vector<Node *> _neighbors) {
+        val = _val;
+        neighbors = std::move(_neighbors);
+    }
+};
+
+Node *JsonArrayToNodeNeighbors(vector<vector<int>> arr);
+vector<vector<int>> NodeNeighborsToJsonArray(Node *root);
+
+#endif //LEETCODE_NODENEIGHBORS_H

cpp/models/NodeRandom.cpp

@@ -0,0 +1,52 @@
+//
+// Created by BenHao on 2024/7/29.
+//
+
+#include "NodeRandom.h"
+#include <unordered_map>
+
+Node* JsonArrayToNodeRandom(json arr) {
+    if (arr.empty()) {
+        return nullptr;
+    }
+    vector<Node*> nodes = vector<Node*>(arr.size());
+    for (int i = 0; i < static_cast<int>(arr.size()); i++) {
+        nodes[i] = new Node(0);
+    }
+    for (int i = 0; i < static_cast<int>(arr.size()); i++) {
+        auto node = nodes[i];
+        node->val = arr[i][0];
+        if (i < static_cast<int>(arr.size()) - 1) {
+            node->next = nodes[i + 1];
+        }
+        if (!arr[i][1].is_null()) {
+            node->random = nodes[arr[i][1]];
+        }
+    }
+    return nodes[0];
+}
+
+json NodeRandomToJsonArray(Node* head) {
+    json arr = json::array();
+    std::unordered_map<Node*, int> nodeMap;
+    int index = 0;
+    Node* node = head;
+    while (node != nullptr) {
+        nodeMap[node] = index;
+        node = node->next;
+        index++;
+    }
+    node = head;
+    while (node != nullptr) {
+        json item = json::array();
+        item.push_back(node->val);
+        if (node->random != nullptr) {
+            item.push_back(nodeMap[node->random]);
+        } else {
+            item.push_back(nullptr);
+        }
+        arr.push_back(item);
+        node = node->next;
+    }
+    return arr;
+}

cpp/models/NodeRandom.h

@@ -0,0 +1,31 @@
+//
+// Created by BenHao on 2024/7/29.
+//
+
+#ifndef LEETCODE_NODERANDOM_H
+#define LEETCODE_NODERANDOM_H
+
+#include "nlohmann/json.hpp"
+#include <vector>
+
+using std::vector;
+using nlohmann::json;
+
+// Definition for a Node.
+class Node {
+public:
+    int val;
+    Node* next;
+    Node* random;
+
+    explicit Node(int _val) {
+        val = _val;
+        next = nullptr;
+        random = nullptr;
+    }
+};
+
+Node* JsonArrayToNodeRandom(json arr);
+json NodeRandomToJsonArray(Node* head);
+
+#endif //LEETCODE_NODERANDOM_H

cpp/models/TreeNode.cpp

@@ -32,7 +32,7 @@ TreeNode *JsonArrayToTreeNode(json arr) {
 
 vector<TreeNode *> JsonArrayToTreeNodeWithTargets(json arr, vector<int> targets) {
     if (arr.empty()) {
-        return vector<TreeNode *>(targets.size() + 1, nullptr);
+        return {targets.size() + 1, nullptr};
     }
     vector<TreeNode *> ans = vector<TreeNode *>(targets.size() + 1);
     auto root = new TreeNode(arr[0]);