Question

假设我有一组10000点，他们随机相互连接。例如，让我们拿10分。他们像图片一样连接 - enter image description here

相似点的定义：

相同数量的链接的点称为类似点。从图中我们可以看到 -

节点1与节点[2]和[10]

连接

节点2与节点[1}，[3]，[4]，[5]，[6]，[7]，[8]

连接

节点3仅与节点[2]

连接

节点4仅与节点[2]

连接

节点5仅与节点[2]

连接

节点6仅与节点[2]

连接

节点7仅与节点[2]

连接

节点8与节点[2]和[9]

连接

节点9仅与节点[8]

连接

节点10仅与节点[1]

连接

因此根据定义，Node-3,4,5,6,7,9,10是相似的，因为它们中的每一个只有一个链接。 Node-1＆amp; 8是相似的，因为它们每个都有两个链接。

我的问题

现在我想计算相似点的链接总和。例如 -

节点1有8个相似。

对于节点1：

它连接到节点2（具有 7 链接）

并且还连接到节点10（具有 1 链接）

对于节点8：

它连接到节点2（具有 7 链接）

还连接到节点9（ 1 链接）

因此对于具有两个链接的组，总链接数应为= 7 + 1 + 7 + 1 = 16 。像这样我想计算其他类似点的总链接。

我的代码

这是我的代码。它给出了每个点的总链接的结果。

#include <cstdlib>
#include <cmath>
#include <fstream>
#include <iostream>
#include <vector>


using namespace std;

struct Node {

    vector< int > links_to;
    Node(void){};
    Node(int first_link){
        links_to.push_back(first_link);
    };
};

class Links : public vector<Node> {

public:
    void CreateLinks(int n,int m);
    void OutputNodes();

};

int RandGenerate(int max) {

    return int(drand48()*double(max));
}

void CreateRandom(int *nums,int m,int max) {

    bool clear;
    for(int i=0;i<m;i++) {

        clear=true;
        while(clear) {

            clear=false;
            nums[i]=RandGenerate(max);
            for(int j=0;j<i;j++) {

                if(nums[i]==nums[j]){
                    clear=true;break;
                }
            }
        }
    }
}

void Links::CreateLinks(int n,int m) {

    clear();
    for(int i=0;i<m;i++) {
        push_back(Node());
    }

    int edge_targets[m],nums[m];
    for(int i=0;i<m;i++) { 
        edge_targets[i]=i;
    }
    vector<int> repeated_nodes;

    int source=m;
    while(source<n) {

        push_back(Node());
        Node &node=*(end()-1);
        for(int i=0;i<m;i++) {

            node.links_to.push_back(edge_targets[i]);
            at(edge_targets[i]).links_to.push_back(source);
            repeated_nodes.push_back(edge_targets[i]);
            repeated_nodes.push_back(source);
        }

        CreateRandom(nums,m,repeated_nodes.size());
        for(int i=0;i<m;i++) {
            edge_targets[i]=repeated_nodes[nums[i]];
        }
        source++;
    }
}

void Links::OutputNodes() {

    for(int i=0;i<size();i++){
        cout<<endl;

        for(int j=0;j<at(i).links_to.size();j++){

            cout<<"Node "<<(i+1)<<" is connected with ["<<(at(i).links_to[j]+1)<<"]"<<endl;


        }

        cout<<"For Node: "<<(i+1)<<"\t"<<"Total links: "<<at(i).links_to.size()<<endl;
    }
}



int main() {



    srand48(46574621);
    Links network;

    network.CreateLinks(10,1); //(nodes,minimum value of link) 
    network.OutputNodes();

    return 0;
}

生成像这样的结果 -

Node 1 is connected with [2]
Node 1 is connected with [10]
For Node: 1 Total links: 2

Node 2 is connected with [1]
Node 2 is connected with [3]
Node 2 is connected with [4]
Node 2 is connected with [5]
Node 2 is connected with [6]
Node 2 is connected with [7]
Node 2 is connected with [8]
For Node: 2 Total links: 7

Node 3 is connected with [2]
For Node: 3 Total links: 1

Node 4 is connected with [2]
For Node: 4 Total links: 1 ... etc

我想添加一个函数，以便对相似的点进行分组，并为每个组提供总链接的输出。我怎么能这样做？

根据Pixelchemist的回答更新

假设我将数据存储在文件名“MyLinks.txt”中，如下所示 -

从文件中获取输入。这是代码 -

int main (void)
{
ifstream inputFile("MyLinks.txt");
double Temp[2];
Links links_object;
while (true) {
  for (unsigned i = 0; i < 2; i++){
  inputFile>>Temp[i];
}
  for (size_t i(0u); i<10; ++i)
  {
    links_object.add(Node());
  }

  links_object.link_nodes(Temp[0], Temp[1]);
  /*
  links_object.link_nodes(0u, 9u);
  links_object.link_nodes(1u, 2u);
  links_object.link_nodes(1u, 3u);
  links_object.link_nodes(1u, 4u);
  links_object.link_nodes(1u, 5u);
  links_object.link_nodes(1u, 6u);
  links_object.link_nodes(1u, 7u);
  links_object.link_nodes(7u, 8u);
  */
}

  std::vector<size_t> linksum;
  for (auto const & node : links_object.nodes())
  {
    size_t const linksum_index(node.links().size()-1u);
    if (linksum.size() < node.links().size()) 
    {
      size_t const nls(node.links().size());
      for (size_t i(linksum.size()); i<nls; ++i) 
      {
        linksum.push_back(0u);
      }
    }
    for (auto linked : node.links())
    {
      linksum[linksum_index] += linked->links().size();
    }
  }

  for (size_t i(0u); i<linksum.size(); ++i)
  {
    std::cout << "Sum of secondary links with " << i+1;
    std::cout << "-link nodes is: " << linksum[i] << std::endl;
  }
}

更新了我的代码，将“连接”的结果存储在文本文件中，并尝试从中获取值。但现在它给了我分段错误。我该如何解决？

Answer 1

我会使用地图。链接数量是关键，其值将是一个包含具有该链接数的节点ID的向量。

typedef std::map<size_t,std::vector<size_t> SimilarNodeMap;

SimilarNodeMap myMap;

... // fill up the map

for (SimilarNodeMap::iterator it=mymap.begin(); it!=mymap.end(); ++it)
{
  std::cout << "Nodes with " it->first << " links: ";

  for ( size_t i = 0; i < second->size(); ++i )
  {
     std::cout << second->at(i) << std::endl;
  }
}

Answer 2

您可以浏览属于“对”的节点并将它们放入列表中。如果你要添加的元素已经在列表中添加，请不要添加它。（e.x if statement check）然后在浏览完所有元素后检查列表大小，这应该是你的链接。

如果这不是你要求的话，请纠正我。

我确信有更好的方法可以做到这一点。我相信这是O（n ^ 2）时间的复杂性。

Answer 3

我使用std::vector<size_t>，其中向量的索引是相应节点类型的链接数。

迭代所有节点，并将与此节点的链接数对应的std::vector<size_t> - 条目与链接到当前节点的所有节点的链接数递增。

此代码：

#include <vector>
#include <stdexcept>

class Node 
{
  std::vector< Node const * > m_links;
public:
  Node(void) { }
  void link_to (Node const &n) 
  { 
    m_links.push_back(&n); 
  }
  std::vector< Node const * > const & links (void) const 
  { 
    return m_links; 
  }
};

class Links
{
  std::vector<Node> m_nodes;
public:
  void add (Node const &node) { m_nodes.push_back(node); }
  void link_nodes (size_t node_a, size_t node_b)
  {
    size_t ns(m_nodes.size());
    if (node_a >= ns || node_b >= ns) 
    {
      throw std::logic_error("Requested invalid link.");
    }
    m_nodes[node_a].link_to(m_nodes[node_b]);
    m_nodes[node_b].link_to(m_nodes[node_a]);
  }
  std::vector<Node> const & nodes (void) const 
  { 
    return m_nodes; 
  }
};

int main (void)
{
  Links links_object;
  for (size_t i(0u); i<10; ++i)
  {
    links_object.add(Node());
  }

  links_object.link_nodes(0u, 1u);
  links_object.link_nodes(0u, 9u);
  links_object.link_nodes(1u, 2u);
  links_object.link_nodes(1u, 3u);
  links_object.link_nodes(1u, 4u);
  links_object.link_nodes(1u, 5u);
  links_object.link_nodes(1u, 6u);
  links_object.link_nodes(1u, 7u);
  links_object.link_nodes(7u, 8u);

  std::vector<size_t> linksum;
  for (auto const & node : links_object.nodes())
  {
    size_t const linksum_index(node.links().size()-1u);
    if (linksum.size() < node.links().size()) 
    {
      size_t const nls(node.links().size());
      for (size_t i(linksum.size()); i<nls; ++i) 
      {
        linksum.push_back(0u);
      }
    }
    for (auto linked : node.links())
    {
      linksum[linksum_index] += linked->links().size();
    }
  }

  for (size_t i(0u); i<linksum.size(); ++i)
  {
    std::cout << "Sum of secondary links with " << i+1;
    std::cout << "-link nodes is: " << linksum[i] << std::endl;
  }
}

打印：

Sum of secondary links with 1-link nodes is: 39
Sum of secondary links with 2-link nodes is: 16
Sum of secondary links with 3-link nodes is: 0
Sum of secondary links with 4-link nodes is: 0
Sum of secondary links with 5-link nodes is: 0
Sum of secondary links with 6-link nodes is: 0
Sum of secondary links with 7-link nodes is: 9

你应该明白这一点。

Answer 4

您可以遍历所有节点并进行计数。伪代码：

std::map<std::size_t, std::size_t> counter;
for each node
    ++counter[node.links().size]

计算相似点的链接总和

4 个答案: