连接组件 std::pair<std::int, std::int> 如何</std::int,>

Question

I have a pair representation std::pair<std::int,std::int> of an adjacency list like so:

(0,0)
(0,3)
(1,0)
(1,1)
(2,3)
(3,0)
(3,1)
(3,2)
(3,3)

(so node 0 is connected to nodes 0 and 3, node 1 is connected to nodes 0 and 1, and so forth).

What is the smartest way to find connected components with this representation?

I'm not supposed to change the input, so converting it to a matrix (for example) and running DFS on it is not an option.

How do I best approach this?

Answer 1

Thanks all (particularly BessieTheCow for pointing out the disjoint-set data structure).

In the end, it turned out to be just an ordinary DFS:

typedef std::unordered_set<std::pair<int,int>, Pairhash> adjacencySet;

//Needed for unordered_set
struct Pairhash {
public:
  template <typename T, typename U>
  std::size_t operator()(const std::pair<T, U> &x) const
  {
    return std::hash<T>()(x.first) ^ std::hash<U>()(x.second);
  }
};

void dfs(std::shared_ptr<adjacencySet> visited, const std::pair<int, int> &pair, const adjacencySet &adjacencies)
{
    if (visited->find(pair) != visited->end())
    {
        return;
    }
    visited->emplace(pair);
    std::pair<int,int> temp;
    if (pair.first > 0)
    {
        temp = std::make_pair(pair.first -1, pair.second); //Look up
        if (adjacencies.find(temp) != adjacencies.end())
        {
            dfs(visited, temp, adjacencies);
        }
    }
    if (pair.second > 0)
    {
        temp = std::make_pair(pair.first, pair.second-1); //Look left
        if (adjacencies.find(temp) != adjacencies.end())
        {
            dfs(visited, temp, adjacencies);
        }
    }
    temp = std::make_pair(pair.first +1, pair.second); //Look down
    if (adjacencies.find(temp) != adjacencies.end())
    {
        dfs(visited, temp, adjacencies);
    }
    temp = std::make_pair(pair.first, pair.second +1); //Look right
    if (adjacencies.find(temp) != adjacencies.end())
    {
        dfs(visited, temp, adjacencies);
    }
}

int countComponents(const adjacencySet &adjacencies)
{
    std::shared_ptr<adjacencySet> visited = std::make_shared<adjacencySet>(adjacencies.size());
    auto count(0);
    for (auto pair : adjacencies)
    {
        if (visited->find(pair) == visited->end())
        {
            dfs(visited, pair, adjacencies);
            count += 1;
        }
    }
    return count;
}

With an example set like so:

(0,0)   
(0,3)   
(1,0)    
(1,1)   
(2,3)   
(3,0)   
(3,1)   
(3,2)   
(3,3)   

(this would be represented as

{1,0,0,1}   
{1,1,0,0}   
{0,0,0,1}   
{1,1,1,1} 

in a matrix representation).