【发布时间】：2015-08-16 02:16:05
【问题描述】：
我有一个问题，非常感谢您的帮助。 我必须生成一个具有 2^N 个节点的 DAG，这些节点的值从 0 到 2^(N-1)，具有以下属性： 如果 x
#include <iostream>
#include <vector>
#include <math.h>
typedef unsigned int unint;
using namespace std;
class Node
{
friend class DAG;
private:
unint value;
vector<Node* > neighbourTo;
vector<Node* > neighbors;
public:
Node(unint );
};
Node::Node(unint _value)
: value(_value) {}
class DAG
{
private:
int noNodes;
vector<Node* > nodes;
public:
DAG(int );
void initializeNodes(int ,int );
int isPowerOf2(unsigned int );
int getMaxNaighbourTo(int );
int getMinNeighbor(int );
int numberOfPathsLengthK(int );
int recursion(Node& , int );
void print();
};
DAG::DAG(int size)
{
noNodes = size;
nodes.resize(noNodes);
int i, j;
initializeNodes(0, noNodes-1);
for(i = 0; i < noNodes-1; i++)
{
for(j = i+1; j < noNodes; j++)
{
if(isPowerOf2(i ^ j))
{
nodes[i]->neighbors.push_back(nodes[j]);
nodes[j]->neighbourTo.push_back(nodes[i]);
}
}
}
}
void DAG::initializeNodes(int min, int max)
{
if(max == min)
nodes[max] = new Node(max);
else
{
int s = (max + min)/2;
initializeNodes(min, s);
initializeNodes(s+1, max);
}
}
int DAG::isPowerOf2(unsigned int value)
{
return ((value != 0) && !(value & (value - 1)));
}
int DAG::getMaxNaighbourTo(int index)
{
if(index > 0 && index <= (noNodes-1))
{
int size = nodes[index]->neighbourTo.size();
return nodes[index]->neighbourTo[size-1]->value;
}
return -1;
}
int DAG::getMinNeighbor(int index)
{
if(index >= 0 && index < (noNodes-1))
return nodes[index]->neighbors[0]->value;
return -1;
}
int DAG::numberOfPathsLengthK(int K)
{
if(K <= 0)
return 0;
long int paths = 0;
for(int i = 0; i < nodes.size(); i++)
{
paths += recursion(*nodes[i], K - 1);
}
return (paths % 100003);
}
int DAG::recursion(Node& node, int K)
{
if( K <= 0 )
return node.neighbors.size();
else
{
long int paths = 0;
for(int i = 0; i < node.neighbors.size(); i++)
{
paths += recursion(*node.neighbors[i], K - 1);
}
return paths;
}
}
void DAG::print()
{
for(int i = 0; i < nodes.size(); i++)
{
cout << "Node: " << nodes[i]->value << "\tNeighbors: ";
for(int j = 0; j < nodes[i]->neighbors.size(); j++)
{
cout << nodes[i]->neighbors[j]->value << " ";
}
cout << endl;
}
}
int main()
{
int
N, M, K,
i, j;
cin >> N >> M >> K;
DAG graf(pow(2, N));
graf.print();
cout << "==1==" << endl;
cout << graf.getMaxNaighbourTo(M) << endl;
cout << "==2==" << endl;
cout << graf.getMinNeighbor(M) << endl;
cout << "==3==" << endl;
cout << graf.numberOfPathsLengthK(K) << endl;
return 0;
}
这是一个简单的输出：
4 3 2
Node: 0 Neighbors: 1 2 4 8
Node: 1 Neighbors: 3 5 9
Node: 2 Neighbors: 3 6 10
Node: 3 Neighbors: 7 11
Node: 4 Neighbors: 5 6 12
Node: 5 Neighbors: 7 13
Node: 6 Neighbors: 7 14
Node: 7 Neighbors: 15
Node: 8 Neighbors: 9 10 12
Node: 9 Neighbors: 11 13
Node: 10 Neighbors: 11 14
Node: 11 Neighbors: 15
Node: 12 Neighbors: 13 14
Node: 13 Neighbors: 15
Node: 14 Neighbors: 15
Node: 15 Neighbors:
2
7
48
nodes 是 Node 指针的向量，Node a 是保存节点值和两个向量的类，一个 Node 指向当前节点的邻居，另一个是指向当前节点所在节点的 Node 指针是邻居。上面的代码是用 C++ 编写的。 对于任何语法错误，我深表歉意。英语不是我的母语。
【问题讨论】：
-
与其生成
j并测试它们是否与i相差1 位，不如直接从i开始，只生成与它相差一位的数字？ -
所有的类方法和属性都是我的母语。翻译需要花点时间。我应该这样做吗？
-
@harold 在初始化当前 i 的邻居向量时，您的意思是遍历与 i 相差一位的数字吗？
-
如果我正确理解了这个问题，您可以将 2,4,8,16,32... 添加到 i 而不是测试。
-
是的。请注意，这与 anselm 建议的添加 2 的幂不同，您必须使用 2 的幂进行异或。
标签： c++ optimization directed-acyclic-graphs