3D模型文件中存储了三角形面片数据，由顶点数组和索引数组两部分构成。例如： 顶点数组：[V{x0,y0,z0}, V{x1,y1,z1}, V{x2,y2,z2}...]，每个元素是1个顶点坐标 索引数组：[(0,1,2), (0,2,3), (4.5,6)…]。每个元素是1个三角形的3个顶点的index 其中有1条公共边的2个三角形称为相连，例如 (0,1,2) 和 (0.2,3) 求解以下最大的三角形相连集合的问题 [输入：索引数组、数组size； 输出：最大的三角形相连集合的size；说明：索引数组中没有重复的、非法的三角形]

解题思路：

1. 使用哈希表存储每个顶点连接的所有三角形，以加快查找速度。

2. 遍历所有三角形，对于每个三角形，遍历其三个顶点连接的所有三角形，记录所有相邻三角形。

3. 对于每个三角形，遍历所有与它相邻的三角形，找到它们之间的公共边，将它们组成一个集合。

4. 对于每个集合，计算它包含的三角形数，找到最大的集合。

实现细节：

1. 哈希表的键为三角形的每个顶点，值为连接该顶点的所有三角形。

2. 记录相邻三角形的过程中，应该去重，避免重复记录相邻三角形。

3. 组成集合时，需要维护一个标记数组，标记每个三角形是否已经被加入到某个集合中。

4. 最大集合的计算可以在遍历集合时实现，每次更新最大值即可。

代码实现：

#include <unordered_map>
#include <vector>

struct Triangle {
  int v1;
  int v2;
  int v3;
};

int TriangleConnectivity(const Triangle* indices, int count) {
  // 构建哈希表
  std::unordered_map<int, std::vector<int>> hash_table;
  for (int i = 0; i < count; i++) {
    int v1 = indices[i].v1;
    int v2 = indices[i].v2;
    int v3 = indices[i].v3;
    hash_table[v1].push_back(i);
    hash_table[v2].push_back(i);
    hash_table[v3].push_back(i);
  }

  // 计算相邻三角形
  std::vector<std::vector<int>> neighbors(count);
  for (int i = 0; i < count; i++) {
    int v1 = indices[i].v1;
    int v2 = indices[i].v2;
    int v3 = indices[i].v3;
    for (auto j : hash_table[v1]) {
      if (i != j) {
        int n1 = indices[j].v1;
        int n2 = indices[j].v2;
        int n3 = indices[j].v3;
        if ((n1 == v1 || n1 == v2 || n1 == v3) &&
            (n2 == v1 || n2 == v2 || n2 == v3) &&
            (n3 == v1 || n3 == v2 || n3 == v3)) {
          neighbors[i].push_back(j);
        }
      }
    }
    for (auto j : hash_table[v2]) {
      if (i != j) {
        int n1 = indices[j].v1;
        int n2 = indices[j].v2;
        int n3 = indices[j].v3;
        if ((n1 == v1 || n1 == v2 || n1 == v3) &&
            (n2 == v1 || n2 == v2 || n2 == v3) &&
            (n3 == v1 || n3 == v2 || n3 == v3)) {
          neighbors[i].push_back(j);
        }
      }
    }
    for (auto j : hash_table[v3]) {
      if (i != j) {
        int n1 = indices[j].v1;
        int n2 = indices[j].v2;
        int n3 = indices[j].v3;
        if ((n1 == v1 || n1 == v2 || n1 == v3) &&
            (n2 == v1 || n2 == v2 || n2 == v3) &&
            (n3 == v1 || n3 == v2 || n3 == v3)) {
          neighbors[i].push_back(j);
        }
      }
    }
  }

  // 查找最大集合
  std::vector<bool> visited(count, false);
  int max_size = 0;
  for (int i = 0; i < count; i++) {
    if (!visited[i]) {
      std::vector<int> queue{ i };
      visited[i] = true;
      int size = 0;
      while (!queue.empty()) {
        int t = queue.back();
        queue.pop_back();
        size++;
        for (auto j : neighbors[t]) {
          if (!visited[j]) {
            queue.push_back(j);
            visited[j] = true;
          }
        }
      }
      if (size > max_size) {
        max_size = size;
      }
    }
  }

  return max_size;
}