int dijkstra(const AdjList& graph, const vertex_t src, const vertex_t dst) {
vector<uint32_t> minCostTo(graph.size(), numeric_limits<uint32_t>::max());
priority_queue<Path> pq;
pq.push(Path(src, 0));
minCostTo[src] = 0;
while (!pq.empty()) {
Path p = pq.top();
pq.pop();
if (p.total > minCostTo[p.node]) {
continue;
}
if (p.node == dst) {
return p.total;
}
const vector<Edge>& edges = graph.edges(p.node);
for (vector<Edge>::const_iterator eIt(edges.begin()), eItEnd(edges.end()); eIt != eItEnd; ++eIt) {
const vertex_t tgt = eIt->dst;
if (p.total + eIt->weight < minCostTo[tgt]) {
minCostTo[tgt] = p.total + eIt->weight;
pq.push(Path(tgt, minCostTo[tgt]));
}
}
}
return -1;
}
void dijkstra(AdjList &G, int start)
{
VertexList V;
list<int> S; // Discovered shortest paths
list<int> Q; // Pool of unknown vertices
V[start] = Vertex(0, 0, 1);
S.push_back(start);
for(AdjList::iterator i = G.begin(); i != G.end(); ++i)
if (i->first != start)
{
V[i->first] = Vertex(INT_MAX, 0, 0);
Q.push_back(i->first);
}
cout << "Shortest path discovered " << start << endl;
while (!Q.empty())
{
int u = extract_min(G, V, S);
cout << "Shortest path discovered " << u << endl;
V[u].known = 1;
S.push_back(u);
Q.remove(u);
}
print_out(V);
}
int solve(const int src, const int dst, const int num, const AdjList& graph) {
int visited[graph.getSz()];
fill (visited, visited + graph.getSz(), 0);
queue<int> q;
q.push(src);
visited[src] = numeric_limits<int>::max();
// aim to maximise visited[dst]
while (!q.empty()) {
const int currNode = q.front();
const int currScore = visited[currNode];
q.pop();
for (size_t i = 0; i < graph.getLinks(currNode).size(); ++i) {
const int tgtNode = graph.getLinks(currNode)[i].dst;
const int tgtScore = min(currScore, graph.getLinks(currNode)[i].weight);
if (visited[tgtNode] < tgtScore) {
visited[tgtNode] = tgtScore;
q.push(tgtNode);
}
}
}
double f = num / (double)(visited[dst] - 1);
return f == (int) f ? f : f + 1;
}
void floodFill(int i, int j, int color) {
if((i < 0) || (j < 0) || (i > (int) adjList.size()) || (j > (int) (adjList[i]).size()) || ((visited[i])[j]) || (color != 2)) {
if(color == 3 && !((visited[i])[j])) {
area++;
//std::cout << "calling flood fillx " << i << " , " << j << std::endl;
floodFill3(i, j, 3);
} else {
return;
}
}
((visited[i])[j]) = true;
if(((i - 1) >= 0) && (j >= 0) && ((i - 1) < (int) adjList.size()) && (j < (int) (adjList[i]).size())) {
floodFill(i - 1, j, ((adjList[i - 1])[j]).second);
}
if(((i + 1) >= 0) && (j >= 0) && ((i + 1) < (int) adjList.size()) && (j < (int) (adjList[i]).size())) {
floodFill(i + 1, j, ((adjList[i + 1])[j]).second);
}
if((i >= 0) && ((j - 1) >= 0) && (i < (int) adjList.size()) && ((j - 1) < (int) (adjList[i]).size())) {
floodFill(i, j - 1, ((adjList[i])[j - 1]).second);
}
if((i >= 0) && ((j + 1) >= 0) && (i < (int) adjList.size()) && ((j + 1) < (int) (adjList[i]).size())) {
floodFill(i, j + 1, ((adjList[i])[j + 1]).second);
}
}
void AlienDictionary::topologicalSort() {
//and perform topological sort
vector<VisitType> visited(adjList.size(), UNVISITED);
for (int i=0;i<adjList.size(); i++) {
if (visited[i] == PERM) continue;
dfs(i, visited);
}
}
void print_AdjList(AdjList &adj_list) {
for(AdjList::iterator it = adj_list.begin(); it != adj_list.end(); ++it) {
vector<int> exist_list = it->second;
cout << " " << it->first << " -> ";
for(int i = 0; i < exist_list.size(); i++) {
cout << " " << exist_list[i] << ",";
}
cout << endl;
}
}
int solve(const AdjList& graph) {
if (graph.getSize() == 1) {
return 1;
}
AdjList sTree(graph.getSize());
dfs(graph, 0, CreateSpanningTree(sTree));
map<pair<vertex_t, bool>, int> eval;
return min(vertex_cover(sTree, 0, true, eval), vertex_cover(sTree, 0, false, eval));
}
int main( int argc, char ** argv ) {
AdjList G;
G.read(argv[1]);
int lowest = 10000;
int tmp = 10000;
for(int i = 0; i < 10000; i++ ) {
tmp = G.run_karger();
if( tmp < lowest ) { lowest = tmp; };
};
cout << "result " << lowest << endl;
};
void augmentPath(AdjList& graph, const vertex_t sink,
const vector<uint32_t>& parent, uint32_t flow) {
vertex_t curr = sink;
while (parent[curr] != curr) {
Edge* e = graph.getEdge(parent[curr], curr);
assert(e);
e->weight -= flow;
e = graph.getEdge(curr, parent[curr]);
assert(e);
e->weight += flow;
curr = parent[curr];
}
}
uint32_t bfs(const AdjList& graph, const vertex_t src, const vertex_t dst,
vector<uint32_t>& parent) {
fill(parent.begin(), parent.end(), numeric_limits<uint32_t>::max());
queue<pair<vertex_t, uint32_t> > q;
parent[src] = src;
q.push(make_pair(src, INFINITY));
while (!q.empty()) {
const pair<vertex_t, uint32_t> node = q.front();
q.pop();
if (node.first == dst) {
return node.second;
}
const vector<Edge>& edges = graph.edges(node.first);
for (vector<Edge>::const_iterator eIt(edges.begin()), eItEnd(edges.end()); eIt != eItEnd; ++eIt) {
if (parent[eIt->dst] != numeric_limits<uint32_t>::max()) { // visited
continue;
}
if (!eIt->weight) {
continue;
}
assert(eIt->weight > 0);
parent[eIt->dst] = node.first;
q.push(make_pair(eIt->dst, min(node.second, eIt->weight)));
}
}
return 0;
}
std::vector< std::pair<int, unsigned> >& AdjList::operator [](int i)
{
return G[i];
}
std::istream& operator>> (std::istream& in, AdjList &list)
{
int n, m;
in >> n >> m;
list.resize(n);
Edge edge;
for (int i = 0; i < m; ++i)
{
in >> edge;
list.addEdge(edge, false);
}
return in;
}
// calculate flow on the graph
void edmonds_karp(AdjList& graph, const vertex_t source, const vertex_t sink) {
vector<uint32_t> parent(graph.size());
while (true) {
uint32_t augment = bfs(graph, source, sink, parent);
if (!augment) {
break;
}
augmentPath(graph, sink, parent, augment);
}
}
void dfs(const AdjList& graph, vertex_t root, T func) {
vector<int> isVisited(graph.getSize());
stack<int> s;
s.push(root);
isVisited[root] = true;
while (!s.empty()) {
vertex_t curr = s.top();
s.pop();
const vector<int>& links = graph.getLinks(curr);
for (size_t i = 0; i < links.size(); ++i) {
vertex_t next = links[i];
if (!isVisited[next]) {
isVisited[next] = true;
s.push(next);
func.visitNode(curr, next);
}
}
}
}
int main() {
int nEmployees;
while (cin >> nEmployees) {
if (!nEmployees) break;
string bigBoss;
cin >> bigBoss;
AdjList graph;
string name, boss;
for (int i = 1; i < nEmployees; ++i) {
cin >> name >> boss;
graph.link(boss, name);
}
cache.clear();
pair<int, bool> result = countMaxIndepSet(bigBoss, true, graph);
cout << result.first << " " << (result.second ? "Yes" : "No") << endl;
}
return 0;
}
pair<int, bool> countMaxIndepSet(const string& root, bool canSelect, const AdjList& graph) {
if (!graph.hasLinked(root)) {
return canSelect ? make_pair(1, true) : make_pair(0, true);
}
map<pair<string, bool>, pair<int, bool> >::const_iterator it = cache.find(make_pair(root, canSelect));
if (it != cache.end()) {
return it->second;
}
pair<int, bool> resultWithout = make_pair(0, true);
// assume not selected
for (int i = 0; i < (int)graph.getLinked(root).size(); ++i) {
pair<int, bool> c = countMaxIndepSet(graph.getLinked(root)[i], true, graph);
resultWithout.first += c.first;
resultWithout.second &= c.second;
}
pair<int, bool> resultWith = make_pair(0, true);
if (canSelect) {
++resultWith.first;
for (int i = 0; i < (int)graph.getLinked(root).size(); ++i) {
pair<int, bool> c = countMaxIndepSet(graph.getLinked(root)[i], false, graph);
resultWith.first += c.first;
resultWith.second &= c.second;
}
}
if (resultWithout.first > resultWith.first) {
return cache[make_pair(root, canSelect)] = resultWithout;
}
else if (resultWithout.first < resultWith.first) {
return cache[make_pair(root, canSelect)] = resultWith;
}
else { // same
return cache[make_pair(root, canSelect)] = make_pair(resultWith.first, false);
}
}
int get_DAG(AdjList &adj_list, TaskDAG &dag, string clientid) {
InDegree indegree;
for(AdjList::iterator it = adj_list.begin(); it != adj_list.end(); ++it) {
vector<int> exist_list = it->second;
int source_vertex = it->first;
if(indegree.find(source_vertex) == indegree.end()) {
indegree[source_vertex] = 0;
}
stringstream adj_ss;
for(int i = 0; i < exist_list.size(); i++) {
int dest_vertex = exist_list[i];
// add each vertex to string
adj_ss << exist_list[i] << clientid << "\'";
// update indegree count of each vertex in adjacency list
if(indegree.find(dest_vertex) == indegree.end()) {
indegree[dest_vertex] = 1;
}
else {
indegree[dest_vertex] = indegree[dest_vertex] + 1;
}
if(dag.find(dest_vertex) != dag.end()) {
TaskDAG_Value &value = dag[dest_vertex];
value.first = indegree[dest_vertex];
}
}
adj_ss << "\"";
string adjliststring(adj_ss.str()); // list of vertices delimited by \' with a final \"
// store info into DAG
TaskDAG_Value value(indegree[source_vertex], adjliststring);
dag[source_vertex] = value;
}
return indegree.size();
}
uint32_t findMinCut(const AdjList& graph, const vertex_t src, const vertex_t sink) {
// dfs from the src, find uncrossable edges
stack<vertex_t> s;
vector<bool> isVisited(graph.size(), false);
s.push(src);
isVisited[src] = true;
set<pair<vertex_t, vertex_t> > vedges;
while (!s.empty()) {
const vertex_t curr = s.top(); s.pop();
const vector<Edge>& edges = graph.edges(curr);
for (vector<Edge>::const_iterator it(edges.begin()), itEnd(edges.end()); it != itEnd; ++it) {
if (!it->weight) {
vedges.insert(make_pair(curr < it->dst ? curr : it->dst,
curr < it->dst ? it->dst : curr));
continue;
}
if (isVisited[it->dst]) {
continue;
}
isVisited[it->dst] = true;
s.push(it->dst);
}
}
uint32_t r = 0;
for (set<pair<vertex_t, vertex_t> >::const_iterator it(vedges.begin()), itEnd(vedges.end());
it != itEnd;
++it) {
if (isVisited[it->first] + isVisited[it->second] == 1 &&
(it->second == src || it->second == sink)) { // check to not process back edges
++r;
}
}
return r;
}
void AlienDictionary::addDependency(char from, char to) {
auto fit = charToNode.find(from);
if (fit == charToNode.end()) {
charToNode.insert(make_pair(from, nodeCtr));
nodeToChar.insert(make_pair(nodeCtr, from));
nodeCtr++;
adjList.push_back(Bucket());
}
auto tit = charToNode.find(to);
if (tit == charToNode.end()) {
charToNode.insert(make_pair(to, nodeCtr));
nodeToChar.insert(make_pair(nodeCtr, to));
nodeCtr++;
adjList.push_back(Bucket());
}
if (from == to) return;
if (adjList[charToNode[from]].find(charToNode[to]) != adjList[charToNode[from]].end()) return;
adjList[charToNode[from]].insert(charToNode[to]);
}
int main()
{
printf("SHIPPING ROUTES OUTPUT\n");
int ds, m, n, p, arr[26][26] = {-1};
cin >> ds;
int tot = ds;
while (ds > 0) {
ds--;
adjlist.empty();
printf("DATA SET %d\n", tot - ds);
cin >> m >> n >>p;
string wh;
for (int i = 0; i < m; ++i) {
cin >> wh;
arr[wh[0] - 'A'][wh[1] - 'B'] = i;
}
string legL, legR;
int index;
for (int j = 0; j < n; ++j) {
cin >> legL >> legR;
//index = arr[legL[0] - 'A'][legL[1] - 'A'];
adjlist[arr[legL[0] - 'A'][legL[1] - 'A']].push_back(make_pair(arr[legR[0] - 'A'][legR[1] - 'A'], 0));
adjlist[arr[legR[0] - 'A'][legR[1] - 'A']].push_back(make_pair(arr[legL[0] - 'A'][legL[1] - 'A'], 0));
}
int size;
string qa, qb;
for (int k = 0; k < p; ++k) {
cin >> size >> qa >> qb;
int res = Legs(arr[qa[0] - 'A'][qa[1] - 'A'], arr[qb[0] - 'A'][qb[1] - 'A']);
if (res >= 0)
cout << "$" << (size * res * 100) << endl;
else cout << "NO SHIPMENT POSSIBLE" << endl;
}
}
cout << "END OF OUTPUT";
cin.get();
return 0;
}
int vertex_cover(const AdjList& graph, vertex_t root, bool include, map<pair<vertex_t, bool>, int>& eval) {
map<pair<vertex_t, bool>, int>::const_iterator it = eval.find(make_pair(root, include));
if (it != eval.end()) {
return it->second;
}
const vector<int>& links = graph.getLinks(root);
int s;
if (!include) { // have to include child
s = 0;
for (size_t i = 0; i < links.size(); ++i) {
s += vertex_cover(graph, links[i], true, eval);
}
}
else { // may or may not include child
s = 1;
for (size_t i = 0; i < links.size(); ++i) {
s += min(vertex_cover(graph, links[i], true, eval), vertex_cover(graph, links[i], false, eval));
}
}
return eval[make_pair(root, include)] = s;
}
int main(int argc, char* argv[])
{
ifstream in;
in.open(argv[1]);
boost::regex re_start("^\\s*s\\s+(\\d+)\\s*$", boost::regex::perl);
boost::regex re_vertex("^\\s*v\\s+(\\d+)\\s+(\\d+)\\s+(\\d+)\\s*$", boost::regex::perl);
boost::cmatch matches;
AdjList G;
int start;
string str;
getline(in, str);
while ( in )
{
if (boost::regex_match(str.c_str(), matches, re_start))
start = boost::lexical_cast<int>(matches[1]);
else if (boost::regex_match(str.c_str(), matches, re_vertex))
{
int vertex = boost::lexical_cast<int>(matches[1]);
int node = boost::lexical_cast<int>(matches[2]);
int weight = boost::lexical_cast<int>(matches[3]);
// if node doesn't exist, create a linked list and attach the next item
if (G.find(vertex) == G.end()) // key doesn't exist
G[vertex] = new list<AdjNode>;
// if it does exist just add the next item and distance to the appropriate node
G[vertex]->push_back(AdjNode(node, weight));
}
getline(in, str);
}
in.close();
dijkstra(G, start);
cout << "Loops " << loop << endl;
for (AdjList::iterator i = G.begin(); i != G.end() ; ++i)
delete i->second;
G.clear();
return 0;
}
int main(int argc, char *argv[]) {
std::string input;
int width;
int height;
int row = 0;
int attempt = 0;
while(std::getline(std::cin, input)) {
char c = input.at(0);
if(c == '.' || c == 'X' || c == '*') {
++row;
neighbors.clear();
for(int pos = 0; pos < (int) input.length(); ++pos) {
VertexWeight vertexWeight;
vertexWeight.first = pos;
char temp = input.at(pos);
if(temp == '.') {
vertexWeight.second = 1;
} else if(temp == '*') {
vertexWeight.second = 2;
} else {
vertexWeight.second = 3;
}
neighbors.push_back(vertexWeight);
}
adjList.push_back(neighbors);
if(height == row) {
visited.clear();
for(int index = 0; index < height; ++index) {
visited.push_back(std::vector<bool>(width, false));
}
for(int i = 0; i < height; ++i) {
for(int j = 0; j < width; ++j) {
if((visited[i])[j] == false && ((adjList[i])[j]).second != 1) {
area = 0;
floodFill(i, j, ((adjList[i])[j]).second);
if(area)
areas.push_back(area);
}
}
}
std::cout << "Throw " << ++attempt << std::endl;
std::sort(areas.begin(), areas.end());
int numAreas = (int)areas.size() - 1;
for(std::vector<int>::iterator it = areas.begin(); it != areas.end(); ++it) {
std::cout << *it;
if(numAreas--) {
std::cout << " ";
}
}
std::cout << std::endl;
std::cout << std::endl;
}
} else {
row = 0;
std::stringstream sbuf;
sbuf << input;
sbuf >> width >> height;
adjList.clear();
areas.clear();
if(width == 0 && height == 0) {
break;
}
}
}
return 0;
}
int main(int argc, char *argv[]) {
if (argc != 2) {
printf("Correct usage is: ./inputTest <filepath>\n");
return 0;
}
char* filename = argv[1];
AdjMatrix adjM (filename);
AdjList adjL (filename);
int size = adjM.getSize();
// Prints out the adjacency matrix (to check)
printf("The adjancency matrix is:\n");
for (int i=0; i < size; i++) {
for (int j=0; j < size; j++) {
if (adjM.edgeExists(i,j)){
printf("1 ");
}else{
printf("0 ");
}
}
printf("\n");
}
printf("\n");
// Prints out the adjaceny list (to check)
printf("The adjancency list is:\n");
for (int i=0; i < size; i++) {
printf("%d ", i);
for (int j=0; j < size; j++) {
if (adjL.edgeExists(i,j)) {
printf("->%d", j);
}
}
printf("\n");
}
int countl=0;
int countm=0;
for (int i=0; i<size; i++) {
for (int j=0; j<size; j++) {
bool m = adjM.edgeExists(i, j);
bool l = adjL.edgeExists(i, j);
assert(m==l);
if (l) {
countl++;
}
if (m) {
countm++;
}
}
}
printf("final list count was: %d\n", countl);
printf("final matrix count was: %d\n", countm);
printf("success\n");
return 0;
}
int main(int argc, char** argv) {
AdjList *al = new AdjList;
cout << "Adding Vertices 1,2,3,4,5,6\n";
al->addVertex("1");
al->addVertex("2");
al->addVertex("3");
al->addVertex("4");
al->addVertex("5");
al->addVertex("6");
cout << "\nAdding duplicate vertex:\n";
al->addVertex("1");
cout << "\nAdding valid edges 1->2,1->3,2->4,2->5,3->2,3->5,5->4,4->6,5->6\n";
al->addEdge("1","2");
al->addEdge("1","3");
al->addEdge("2","4");
al->addEdge("2","5");
al->addEdge("3","2");
al->addEdge("3","5");
al->addEdge("5","4");
al->addEdge("4","6");
al->addEdge("5","6");
cout << "\nAdding invalid edges:\n";
al->addEdge("1","A");
al->addEdge("A","4");
cout << "\nPrinting Graph:\n";
al->printGraph();
cout << "\nTraversing Graph in BFS from valid source:\n";
al->traverseBFS("1");
cout << "\nTraversing Graph in BFS from invalid source:\n";
al->traverseBFS("A");
cout << "\nTraversing Graph in DFS:\n";
al->traverseDFS();
if(al->isDAG()){
cout << "Graph is a DAG\n";
}else{
cout << "Graph is NOT a DAG\n";
}
cout << "\nMaking a copy graph\n";
AdjList *copy = al->copyGraph();
cout << "\nDeleting valid vertex 2 from original\n";
al->deleteVertex("2");
cout << "\nDeleting invalid vertex from original:\n";
al->deleteVertex("2");
cout << "\nPrinting Copied Graph:\n";
copy->printGraph();
cout << "\nPrinting Original Graph:\n";
al->printGraph();
cout << "\nTraversing Original Graph in BFS from valid source:\n";
al->traverseBFS("1");
cout << "\nTraversing Original Graph in BFS from invalid source:\n";
al->traverseBFS("2");
cout << "\nTraversing Original Graph in DFS:\n";
al->traverseDFS();
cout << "\nDeleting valid edge 4->6 from Original Graph\n";
al->deleteEdge("4","6");
cout << "\nDeleting invalid edge 4->6 from Original Graph\n";
al->deleteEdge("4","6");
cout << "\nDeleting invalid edge 1->2 from Original Graph\n";
al->deleteEdge("1","2");
cout << "\nPrinting Original Graph:\n";
al->printGraph();
cout << "\nPrinting Copied Graph:\n";
copy->printGraph();
cout << "\nTraversing Copied Graph in BFS from valid source:\n";
copy->traverseBFS("1");
cout << "\nTraversing Copied Graph in DFS:\n";
copy->traverseDFS();
cout << "\nDeleting Vertices from original graph:\n";
al->deleteVertices();
cout << "\nAdding Vertices and edges to form cycle to original graph:\n";
al->addVertex("1");
al->addVertex("2");
al->addEdge("1","2");
al->addEdge("2","1");
cout << "\nPrinting original Graph:\n";
al->printGraph();
cout << "\nTraversing Original Graph in BFS from valid source:\n";
al->traverseBFS("1");
cout << "\nTraversing Original Graph in BFS from invalid source:\n";
al->traverseBFS("3");
cout << "\nTraversing Original Graph in DFS:\n";
al->traverseDFS();
if(al->isDAG()){
cout << "Original Graph is a DAG\n";
}else{
cout << "Original Graph is NOT a DAG\n";
}
cout << "\nPrinting Copied Graph:\n";
copy->printGraph();
if(copy->isDAG()){
cout << "Copied Graph is a DAG\n";
}else{
cout << "Copied Graph is NOT a DAG\n";
}
cout << endl;
delete al;
delete copy;
return 0;
}
void get_adjlist(int num_tasks, AdjList &adj_list, int DAG_choice) {
#define MAX_CHILDREN 100
if(DAG_choice == 0) { // bag of tasks
for (int i = 0; i < num_tasks; i++) { // New nodes of 'higher' rank than all nodes generated till now
// Edges from old nodes ('nodes') to new ones ('new_nodes')
vector<int> new_list;
adj_list.insert(make_pair(i, new_list));
}
}
else if(DAG_choice == 1) { // random DAG
#define MIN_PER_RANK 1 // Nodes/Rank: How 'fat' the DAG should be
#define MAX_PER_RANK 5
#define MIN_RANKS 3 // Ranks: How 'tall' the DAG should be
#define MAX_RANKS 5
#define PERCENT 30 // Chance of having an Edge
srand (time (NULL));
int height = floor(sqrt(num_tasks)); //height = MIN_RANKS + (rand () % (MAX_RANKS - MIN_RANKS + 1));
int new_nodes = ceil(sqrt(num_tasks)); //new_nodes = MIN_PER_RANK + (rand () % (MAX_PER_RANK - MIN_PER_RANK + 1));
int nodes = 0;
for (int i = 0; i < height; i++) { // New nodes of 'higher' rank than all nodes generated till now
// Edges from old nodes ('nodes') to new ones ('new_nodes')
for (int j = 0; j < nodes; j++) {
for (int k = 0; k < new_nodes; k++) {
if ( (rand () % 100) < PERCENT) {
if(adj_list.find(j) == adj_list.end()) {
vector<int> new_list;
new_list.push_back(k + nodes);
adj_list.insert(make_pair(j, new_list));
}
else {
vector<int> &exist_list = adj_list[j];
if(exist_list.size() < MAX_CHILDREN)
exist_list.push_back(k + nodes);
}
if(adj_list.find(k + nodes) == adj_list.end()) {
adj_list.insert(make_pair(k + nodes, vector<int>()));
}
}
}
}
nodes += new_nodes; // Accumulate into old node set
}
}
else if(DAG_choice == 2) { // pipeline DAG
int nodes = 0;
int num_pipeline = floor(sqrt(num_tasks));
int pipeline_height = ceil(sqrt(num_tasks));
for (int i = 0; i < num_pipeline; i++) {
for (int j = 0; j < pipeline_height; j++) { // New nodes of 'higher' rank than all nodes generated till now
// Edges from old nodes ('nodes') to new ones ('new_nodes')
if(adj_list.find(nodes) == adj_list.end()) {
vector<int> new_list;
new_list.push_back(nodes+1);
adj_list.insert(make_pair(nodes, new_list));
}
else {
vector<int> &exist_list = adj_list[nodes];
exist_list.push_back(nodes+1);
}
if(adj_list.find(nodes+1) == adj_list.end()) {
adj_list.insert(make_pair(nodes+1, vector<int>()));
}
nodes++; // Accumulate into old node set
}
nodes++;
}
}
else if(DAG_choice == 3) { // fan in DAG
AdjList adj_list1;
adj_list1.insert(make_pair(0, vector<int>()));
int index = 0; int count = pow(MAX_CHILDREN, 0);
int num_level = floor(log(num_tasks)/log(MAX_CHILDREN));
int j = 0; int num = 1;
while(j <= num_level) {
while(index < count) {
vector<int> &exist_list = adj_list1[index];
for (int i = num; i < num+MAX_CHILDREN; i++) {
exist_list.push_back(i);
if(adj_list1.find(i) == adj_list1.end()) {
adj_list1.insert(make_pair(i, vector<int>()));
}
if(i >= num_tasks) {
index = count; j = num_level+1; break;
}
} num += MAX_CHILDREN;
index++;
}
count += pow(MAX_CHILDREN, ++j);
}
for(AdjList::iterator it = adj_list1.begin(); it != adj_list1.end(); ++it) {
int vertex = it->first;
if(adj_list.find(vertex) == adj_list.end()) {
adj_list.insert(make_pair(vertex, vector<int>()));
}
vector<int> &alist = it->second; int alist_size = alist.size();
for(int i = 0; i < alist_size; i++) {
int v = alist[i];
if(adj_list.find(v) == adj_list.end()) {
adj_list.insert(make_pair(v, vector<int>()));
}
vector<int> &exist_list = adj_list[v]; exist_list.push_back(vertex);
}
}
}
else if(DAG_choice == 4) { // fan out DAG
adj_list.insert(make_pair(0, vector<int>()));
int index = 0; int count = pow(MAX_CHILDREN, 0);
int num_level = floor(log(num_tasks)/log(MAX_CHILDREN));
int j = 0; int num = 1;
while(j <= num_level) {
while(index < count) {
vector<int> &exist_list = adj_list[index];
for (int i = num; i < num+MAX_CHILDREN; i++) {
exist_list.push_back(i);
if(adj_list.find(i) == adj_list.end()) {
adj_list.insert(make_pair(i, vector<int>()));
}
if(i >= num_tasks)
return;
} num += MAX_CHILDREN;
index++;
}
count += pow(MAX_CHILDREN, ++j);
}
}
else {
cout << "Enter proper choice for DAG" << endl;
exit(1);
}
}
