Question

我需要知道我是否正确地阅读了这个问题。我正在准备面试，我需要提高我的阅读理解能力。

问题是：

假设我们给出一系列整数对，其中每个整数表示某种类型的对象，我们将对pq解释为“p连接到q”我们假设关系“连接到”是传递的：如果p连接到q，并且q连接到r，则p连接到r。我们的目标是编写一个程序来从集合中过滤出无关的对：当程序输入一对p-q时，它应该只在它看到的那对对并不意味着p连接到q时才输出该对。如果先前的对确实意味着p连接到q，那么程序应该忽略p-q并且应该继续输入下一对。

我个人认为，我不认为我已经解决了下面代码中的及物性部分，但后来我倾向于让事情变得比他们需要的更复杂。我可以对“C ++中的算法”中提出的问题进行第二次解释。

/* 1 */ #include <iostream>
/* 2 */ #include <set>
/* 3 */ #include <algorithm>
/* 4 */ 
/* 5 */ using namespace std;
/* 6 */ 
/* 7 */ #define PAIRS 7
/* 8 */ 
/* 9 */ pair<int,int> pair_list[PAIRS] = {
/*10 */     pair<int,int>(0,2),
/*11 */     pair<int,int>(1,4),
/*12 */     pair<int,int>(2,5),
/*13 */     pair<int,int>(3,6),
/*14 */     pair<int,int>(0,4),
/*15 */     pair<int,int>(6,0),
/*16 */     pair<int,int>(2,0) 
/*17 */ };
/*18 */ 
/*19 */ void print( const pair<int,int> &out ) {
/*20 */     cout << "<" << out.first << ", " << out.second << ">" << endl;
/*21 */ }
/*22 */ 
/*23 */ bool contains( set<pair<int,int> > &_set, pair<int,int> &ordered_pair ) {
/*24 */     set<pair<int,int> >::iterator find = _set.find( ordered_pair );
/*25 */     bool ret = false;
/*26 */     if( find != _set.end( ) ) {
/*27 */         ret = true;
/*28 */     }
/*29 */     return ret;
/*30 */ }
/*31 */ 
/*32 */ int main( int argc, char **argv ) {
/*33 */     set<pair<int,int> > SET;
/*34 */     SET.clear( ); 
/*35 */     pair<int,int> *iter = &pair_list[0]; 
/*36 */     while( iter != &pair_list[PAIRS-1] ) {
/*37 */         if( !contains( SET,(*iter) ) ){
/*38 */                 SET.insert( (*iter) );
/*39 */         }
/*40 */         iter++;
/*41 */     }
/*42 */     
/*43 */     for_each( SET.begin( ), SET.end( ), print );
/*44 */     return ( 0 );
/*45 */ }

=============================================== ===================================

更新：1

好吧，我想我想出了一个我喜欢的解决方案。让我走了很长时间，这对采访来说会很糟糕，但我还是得到了。

#include <iostream>
#include <algorithm>
#include <queue>
#include <set>
#include <vector>
#include <iterator>

using namespace std;

void print_set( set<int>* _set ) {
    copy( _set->begin( ), _set->end( ), ostream_iterator<int>(cout, " ") );
    cout << endl;
}

void print_sets( set<set<int>*> _sets ) {
    for_each( _sets.begin( ), _sets.end( ), print_set );
}

void connectivity( queue<pair<int,int> > pairs ) {
    set<set<int>* > connected_items;
    while( pairs.size( ) ) {
        int first = pairs.front( ).first;
        int second = pairs.front( ).second;
        set<set<int>* >::iterator S=connected_items.begin( );
        bool found = false;
        bool dupli = false;
        set<int>* adj = new set<int>;
        while( S != connected_items.end( ) ) { //Go through all connected sets
            set<int>::iterator f=(*S)->find( first );
            set<int>::iterator s=(*S)->find( second );
            if( f!=(*S)->end( )&&s!=(*S)->end( ) ) {
                S++;
                dupli = true;
                continue;
            }
            if( f!=(*S)->end( )||s!=(*S)->end( ) ) {
                found = true;
                adj->insert( first );
                adj->insert( second );
                //copy( (*S)->begin( ), (*S)->end( ), ostream_iterator<int>( cout," ")  );
                set<int>::iterator num = (*S)->begin( );
                while( num != (*S)->end( ) ) {
                    adj->insert( (*num) );
                    num++;
                }
                connected_items.erase( S );
            }
            S++;
        }
        if( !found&&!dupli ) {
            set<int>* insert = new set<int>;
            connected_items.insert( insert );
            insert->insert( first );
            insert->insert( second );
        } else {
            connected_items.insert( adj );
        }
        pairs.pop( );
    }
    print_sets( connected_items );
}

int main( int argc, char **argv ) {
    queue<pair<int,int> > pairs;
    pairs.push( pair<int,int>( 1,2 ) );
    pairs.push( pair<int,int>( 2,3 ) );
    pairs.push( pair<int,int>( 2,4 ) );
    pairs.push( pair<int,int>( 2,5 ) );
    pairs.push( pair<int,int>( 6,7 ) );
    pairs.push( pair<int,int>( 6,8 ) );
    pairs.push( pair<int,int>( 6,9 ) );
    pairs.push( pair<int,int>( 9,10 ) );
    pairs.push( pair<int,int>( 11,12 ) );
    pairs.push( pair<int,int>( 12,13 ) );
    pairs.push( pair<int,int>( 14,15 ) );
    pairs.push( pair<int,int>( 2,12) );
    pairs.push( pair<int,int>( 2,1) );
    connectivity( pairs );
}


[mehoggan@desktop Connectivity]$ g++ -o connected -Wall connected.cpp; ./connected
6 7 8 9 10 
14 15 
1 2 3 4 5 11 12 13

Answer 1

您实际上并未测试您的功能。根据问题，该功能应该拒绝冗余对。但是数据集中没有冗余对。尝试在（2,5）之后插入（0,5）到列表中。这应该被拒绝，因为我们已经看过（0,2）和（2,5）。（我认为他们打算将连接改为可交换，而不仅仅是传递，但这个例子不需要它。）

一旦这样做，您将看到您的代码未通过测试。你使用一个函数，contains（名称中的线索），它检查以前是否看过一个特定的对，而不是从之前看到的那个推断出它。

修改：
不，你没有解决它。阅读我上面写的内容;你仍然没有像（0,5）这样的对测试，一旦你这样做，你会发现你的代码仍然失败。

修改：
抱歉，是我的错。您的新代码有效。但是，如果你不介意我的说法，那么你为自己做的工作比必要的多，这是一些采访者注意到的事情。看看这个，进行比较：

void connectivity_adj(int first, int second,
                      set<set<int> > &connected_items){
  set<int> adj;
  adj.insert( first );
  adj.insert( second );

  for(set<set<int> >::iterator S=connected_items.begin( );
      S != connected_items.end( ); ++S){ //Go through all connected sets
          if( S->find(first) != S->end() || S->find( second ) != S->end( )){
        adj.insert(S->begin(), S->end());
        connected_items.erase( S );
      }
    }
  connected_items.insert( adj );
}

Answer 2

不，这不正确。

输入是（1,2），（2,3），（1,3）。那么输出应该是（1,2），（2,3），而在你的代码中它将是（1,2），（2,3），（3,1）。

提示：你使用套装是正确的（事实上不止一个）。集合将包含整数，而不是整数对。集合中的整数将全部相互连接。（希望不要过多地放弃解决方案）。

Answer 3

在输入对时，不检查传递性，也不检查路径是否正确输入。

如果你使用了Boost的图库，你可以创建一个无向图并以深度优先搜索（DFS）顺序遍历它：

// Boost DFS example on an undirected graph.
// Create a sample graph, traverse its nodes
// in DFS order and print out their values.

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/depth_first_search.hpp>
#include <iostream>
using namespace std;

typedef boost::adjacency_list<boost::listS, boost::vecS, boost::undirectedS> MyGraph;
typedef boost::graph_traits<MyGraph>::vertex_descriptor MyVertex;

class MyVisitor : public boost::default_dfs_visitor
{
public:
  void discover_vertex(MyVertex v, const MyGraph& g) const
  {
    cerr << v << endl;
    return;
  }
};

int main()
{
  MyGraph g;
  boost::add_edge(0, 1, g);
  boost::add_edge(0, 2, g);
  boost::add_edge(1, 2, g);
  boost::add_edge(1, 3, g);

  MyVisitor vis;
  boost::depth_first_search(g, boost::visitor(vis));

  return 0;
}

Answer 4

假设，如果a连接到b，那么b连接到a，那么这看起来应该是http://en.wikipedia.org/wiki/Disjoint-set_data_structure上的问题。请注意，带有路径压缩的最终改进版本比不太专业的集合结构更有效。

连通性问题

4 个答案: