Graph on Hang Zhang

Clone Graph

Wed, 22 Jan 2025 00:00:00 +0000

133. 克隆图

分析

哈希表存储原节点与克隆节点的映射：
- 使用 hash 保存原图节点到克隆节点的映射关系，用于快速找到已克隆的节点，避免重复克隆
DFS 遍历图的所有节点：
- 对每个未访问过的节点，创建其克隆节点并存入 hash
- 遍历当前节点的所有邻居，如果邻居未被克隆，则递归处理
复制邻接关系：
- 遍历所有节点（已在 hash 中），将每个原节点的邻居对应的克隆节点添加到克隆节点的邻居列表中
最终返回起始节点的克隆版本，即为完整的深拷贝图

时间复杂度

图的所有节点和边都会被访问一次，因此时间复杂度为 O(N + E)，其中 N 是节点数，E 是边数

空间复杂度

递归调用栈的深度取决于图的结构，最坏情况下为 O(N)，加上哈希表的存储空间，总体复杂度为 O(N)

C++代码

class Solution
{
public:
    Node* cloneGraph(Node* node)
    {
        if (!node)
            return nullptr;

        std::unordered_map<Node*, Node*> hash; // 哈希表存储节点映射
        dfs(node, hash); // 深度优先搜索创建克隆节点

        // 第二次遍历复制邻接关系
        for (auto& [origin, copy] : hash)
            for (Node* neighbor : origin->neighbors)
                copy->neighbors.push_back(hash[neighbor]); // 将原节点的邻接点的克隆节点添加到克隆节点的邻接表中

        return hash[node]; // 返回克隆图的起点
    }

    void dfs(Node* node, std::unordered_map<Node*, Node*>& hash)
    {
        // 克隆当前节点
        hash[node] = new Node(node->val);

        // 递归克隆邻居节点
        for (Node* neighbor : node->neighbors)
            if (hash.count(neighbor) == 0) // 如果邻居未被克隆
                dfs(neighbor, hash); // 递归处理
    }
};

Evaluate Division

Fri, 03 Jan 2025 00:00:00 +0000

399. 除法求值

分析

构建图：
- 遍历 equations 和 values，构建邻接表表示的加权有向图 graph
- 如果 A / B = v，则添加边 A -> B 和 B -> A
Floyd-Warshall 算法：
- 利用三重循环，尝试通过任意中间节点 k 更新任意两节点 i 和 j 间的比值
- 如果 i -> k 和 k -> j 的路径存在，则更新 i -> j 的权重为 graph[i][k] * graph[k][j]
处理查询：
- 对于每个查询 [C, D]：
  - 如果 C 和 D 不在图中，或者两者之间无路径，则返回 -1.0
  - 否则返回图中存储的 C -> D 的权重

时间复杂度

构建图：遍历 equations，时间复杂度为 O(E)，其中 E 是等式的数量
Floyd-Warshall 算法：三重循环，时间复杂度为 O(V^3)，其中 V 是变量的数量
处理查询：遍历 queries，时间复杂度为 O(Q)，其中 Q 是查询的数量

总体时间复杂度为 O(V^3 + E + Q)

空间复杂度

总的空间复杂度为 O(V^2 + Q)

C++代码

class Solution {
public:
    vector<double> calcEquation(vector<vector<string>>& equations, vector<double>& values, vector<vector<string>>& queries)
    {
        // 构建图
        std::unordered_map<std::string, std::unordered_map<std::string, double>> graph;
        std::unordered_set<std::string> variables;
        for (int i = 0; i < equations.size(); ++i)
        {
            std::string A = equations[i][0], B = equations[i][1];
            variables.insert(A);
            variables.insert(B);
            graph[A][B] = values[i];         // A / B = values[i]
            graph[B][A] = 1 / values[i];     // B / A = 1 / values[i]
        }

        // Floyd-Warshall算法：更新所有节点对的路径比值
        for (std::string k : variables)
            for (std::string i : variables)
                for (std::string j : variables)
                    if (graph[i][k] && graph[k][j]) // 如果 i->k 和 k->j 存在路径
                        graph[i][j] = graph[i][k] * graph[k][j];

        // 处理查询
        std::vector<double> res;
        for (auto query : queries)
        {
            std::string A = query[0], B = query[1];
            if (graph[A][B])  // 如果 A->B 存在路径
                res.push_back(graph[A][B]);
            else
                res.push_back(-1.0);  // 不存在路径
        }
        return res;
    }
};

Keys And Rooms

Thu, 02 Jan 2025 00:00:00 +0000

841. 钥匙和房间

分析

转化为图的遍历问题：
- 将每个房间看作一个节点，钥匙之间的关系看作图的边
- 我们需要从节点 0 开始，遍历整个图，检查是否能够访问所有的节点
深度优先搜索（DFS）：
- 使用递归的方式遍历图，从起点 0 开始访问
- 每访问一个节点（房间），将其标记为已访问
- 对于当前房间中的钥匙（指向其他房间的边），检查对应的房间是否已访问，未访问则递归继续
检查结果：
- 遍历完成后，检查是否所有房间都被访问过。如果有任何房间未被访问，则返回 false；否则返回 true

时间复杂度

每个房间和每把钥匙都会被访问一次，因此时间复杂度为 O(n + m)，其中 n 是房间的数量，m 是所有钥匙的总数量

空间复杂度

图的存储需要 O(n + m) 的空间
访问标记数组占用 O(n) 的空间
递归栈的最大深度为 O(n)

总空间复杂度为 O(n + m)

C++代码

class Solution
{
public:
    void dfs(int room, std::vector<std::vector<int>>& rooms, std::vector<bool>& visited)
    {
      visited[room] = true;        // 标记房间 room 已访问
      for (int x : rooms[room])    // 遍历房间 room 中的钥匙
        if (!visited[x])           // 如果钥匙指向的房间尚未访问
          dfs(x, rooms, visited);  // 递归访问该房间
    }

    bool canVisitAllRooms(vector<vector<int>>& rooms)
    {
      int n = rooms.size();                 // 房间数量
      std::vector<bool> visited(n, false);  // 初始化访问标记数组
      dfs(0, rooms, visited);               // 从房间 0 开始进行深度优先搜索

      // 检查是否所有房间都被访问
      for (int i = 0; i < n; ++ i)
        if (!visited[i])  // 如果有房间未访问，返回 false
          return false;

      return true;  // 所有房间都被访问，返回 true
    }
};