ВЫПУСКНАЯ КВАЛИФИКАЦИОННАЯ РАБОТА МАГИСТРА. Силина Дмитрий Игоревича. Бесконфликтная аггрегация даннных на основе дерева в беспроводных сетях.

Transcription

1 МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ АВТОНОМНОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ ВЫСШЕГО ОБРАЗОВАНИЯ «НОВОСИБИРСКИЙ НАЦИОНАЛЬНЫЙ ИССЛЕДОВАТЕЛЬСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ» (НОВОСИБИРСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ, НГУ) Факультет Кафедра Направление подготовки Механико-математический Теоретической кибернетики Прикладная математика ВЫПУСКНАЯ КВАЛИФИКАЦИОННАЯ РАБОТА МАГИСТРА Силина Дмитрий Игоревича Бесконфликтная аггрегация даннных на основе дерева в беспроводных сетях. «К защите допущена» Научный руководитель Заведующий кафедрой, д.ф.-м.н, проф., Ерзин А.И./.. (фамилия, И., О.) / (подпись, МП) 2016г. д.ф.-м.н, проф., в.н.с., им. С.Л. Соболева Ерзин А.И./.. (фамилия, И., О.) / (подпись, МП) 2016г. Дата защиты: 2016г. Новосибирск, 2016

2 Table of contents Introduction 1. Fixed tree case 1.1 Problem statement: 1.2 Linear programming problem formulation 1.3 Complexity 1.4 Polynomial solvable cases 1.5 Branch and Bound 1.6 Alternative approaches 2 Looking for SPT 2.1 Problem overview 2.2. Formulation, bad case 2.3. Numeric experiments Description Data set Algorithm Results Summary List of sources Application A. Source code

3 Introduction This work is about data aggregation in wireless sensor networks (WSN). WSN consists of the set of devices, which collect some data within the covered region. Once data is collected it should be transmitted to the base station. Communication environment is wireless, so a possibility of communication between the nodes directly depends on the transmission power of the sensors and of the physical location. Wireless environment has a limited throughput. It happens because of signals interference. Data goes through the channels (defined by signal frequency) during the sessions. Support for multichannel transmissions complicates the underlying protocols and increases the hardware requirements. Some papers [REF] describe optimization using multi-channel environment, but the most papers are focused on a fixed frequency [1, 2, 3]. One of the interesting problem in WSN is how to deliver the data from the nodes (sensors) to the sink (or base station). Usually, the objective functions are: a power consumption, a data transmission latency, a length of the full-cycle period. The tradeoff between power consumption and time latency was considered in [4]. Data aggregation process can be decomposed into two tasks: to define a topology and to build a schedule. The exact formulation of the problem depends on a lot of model's parameters. On the one hand power consumption is the most important characteristic, but on the other hand it mostly depends on the data flow topology. Scheduling impacts delivering time for one-shot process and latency for continuous one. The problem model studied in this work is defined as: single base station. one-shot [3] aggregation, i.e. data should be collected once. mergeable data - any number of packets can be merged into single one. Note compatible data case is well studied in [2]. data processing time is ignored. data transmission along one edge is a unit. transmissions never fails (except signal interference). interference happens if the receiver within the range of 2+ transmitters which broadcast their data at the same time. It's particular case of Convergecast Problem a problem, where data on sensors in the network are required to be sent and aggregated to the data sink (base station). First part is about scheduling in case of fixed tree topology. Different problem formulations and approaches are studied. The NP-completeness of the problem is proved. Developed different Branch and Bound approaches. Second part is about looking for aggregation tree which is better for scheduling length. Numeric experiments shows that minimum radius SPT are good for Euclidean graphs.

4 1 Fixed tree case 1.1 Problem statement: Consider an oriented graph G(V, E), where veracities and edges represent nodes and possible transmissions respectively. It's called communication graph [Picture 1.1]: We are looking for schedule of minimal length based on a fixed topology. Easy to see that any aggregation topology is a spanning tree ( in. [Picture 1.1, black edges]. This tree defines precedence constrains any station should be scheduled before its parent. The schedule is the time slot assignment to SPT edge, such that all model conditions are met. The schedule length is the number of distinct time slots used by the assignment. First ensure conflict-free assignment. Conflicts (resource constrains) appear between simultaneously transmissions, i.e. between edges. Consider the conflict graph Look at the [Picture 1.2] Cyan edges shows transmissions which conflict with red one.

5 As soon as we know next hop for each station, edge to edge conflict can be reduced to its sources conflict -. There is no reason to keep whole edges of anymore. The final graph is [Picture 1.3]. Now problem can be formulated as:,, t(v) integer function. Solution example is shown on [Picture 1.4]. T= 7, black numbers are values of function Next this problem statement will be referred as [1S]

6 1.2 Linear programming problem formulation: Define variable Unfortunately integer relaxation is useless. [Picture 1.5] demonstrates that any number of stations without precedence constrains can be scheduled in 2 time slots. It happens because of weak limitation:

7 1.3 Complexity Artem Pyatkin and Adil Erzin have proved NP-hardness for the problem described in section 2.1. The paper is not published yet. During analysis of [1S] one more proof was obtained. It s base on reduction from chromatic number of a graph, which is known as NP-hard. 1) Let - instance of chromatic number problem: Graph, find the smallest, such that vertices are colorable in colors, where endpoints for every edge have distinct colors. 2) Create copies of, call them. Define =. Value of k will be defined later. [Picture 1.7]. Easy to see that Let, then Let 3) Add vertices to. Call new graph Obviously chromatic number stays the same, i.e. 4) Build binary tree of height. Height of tree the number of vertices in the longest simple path started at the root. Create by hanging a new node for every leaf of. [Picture 1.8]

8 Consider problem [1S] where aggregation tree is between siblings.. All transmission conflicts are Lemma 1: Binary tree of height can be scheduled in time slots. Proof: by induction over height. Base case: All data are aggregated it the root. Induction step: Let binary tree has feasible schedule, where and uses time slots. Use time slot for the leaf of, if is the left child and - if the right. Unscheduled vertices of are, so use for them. The obtained is free of conflict and uses time slots. 5) Number of leafs in is, and it s the same to the number of vertices in. Let any bijective function. Create is a valid instance of [1S]. For any feasible schedule, holds: Thus, if is colorable in colors, then lemma 1 it can be scheduled in additional Use to schedule leaves; the rest is and by slots.

9 Let s define. is integer, so if < 1, there is only one integer in range ]. Let. Case 1: Case 2:, k =24 Thus, for any instance of chromatic number problem it s possible to build with. Obviously can be done in polynomial time and has polynomial size of, is the number of vertices in graph of. If there is a polynomial time algorithm for [1S] problem statement, then chromatic number is P. Contradiction. Corollary: constant absolute error algorithm for [1S] doesn t exist in class P: Proof:

10 Now, to solve any chromatic number problem it s enough to show that, s.t.: Easy to see that for any. Thus, is polynomial of and it s enough. 1) 2)

11 1.4 Polynomial solvable cases Although problem is NP complete, it's possible to solve restricted cases in polynomial time. Let's allow transmission conflicts, i.e. get rid of resources constrains. Then problem can be solved by calculating recursive function. Actually this function is required scheduling and f(root) it's length. The mean of when node received all packets from its aggregation subtree. is the earliest time Resource constrains may appear between ant pair of nodes, but there is always a conflict between siblings (the pair of node with the same predecessor). Fortunately the problem where every such pair conflict, has polynomial solution: Algorithm P-siblings [Application A: TreeConvergecast.evaluateTree()]: Idea is the same: calculate function for further transmission, i.e. value. which is the earliest time when node is ready received data form every node in corresponding subtree. Let's function which returns array of successors for node in non-descending order of Define - function which gets array and some number. returns the smallest time stamp when all data from first k nodes in be delivered to its common predecessor. Then Proposition 1: and its subtrees can Proposition 2: Proof is obvious by induction over., solves restricted problem optimally. Since g(m, k) optimality is proven, it needs to prove that transmission order based on non-descending values is correct. Lemma 1: if there is scheduling T, then exist scheduling T*, such that siblings send its data in non-descending order. Proof: find the deepest node where requirement is broken. Interchange time assignment between two siblings which break the order. Obviously the scheduling is still feasible and has the same length. Iterate this process until T* obtained. Corollary 1:

12 Any instance of original problem can be transformed into restricted one and any initially feasible solution is still feasible. Thus, P-siblings algorithm provides lower bound on schedule length. Corollary 2: Algorithm can be easily modified to solve the problem once all resource constrains are replaced by precedence ones, i.e. orientation is set for every conflict. 1.5 Branch and Bound

13 Since problem [1S] is NP-complete, it's interesting to try some heuristics. Quality of approximation can be either proved theoretically either estimated during experiment. For the last one it needs to know optimal solution. The most famous way to find exact solution - apply Brach and Bound methodology. Any B&B consists of 2 subtasks: how to branch split a solution space and to bound - estimate lower\upper bounds for a subspace. Lower bounds: Use P-siblings algorithm Perform heuristic, e.g. build scheduling iteratively, on each step schedule maximal independent set of leaves. Upper bounds: : each station transmit on its own time, no conflicts are expected. radius of plus number of transmission conflicts. There is duality between schedule and orientation for conflicts. To orient conflict means to set relative priority for conflicting transmissions. Any solution defines this priority. And once priority for every conflict is chosen it s possible to find optimal solution by Algorithm M-siblings [described in 1.4]. Thus, to obtain UB: first perform random orientation for every conflict (use transitive closure on each step to avoid cycle appearance), next apply M-Siblings algorithm and use result as UB. Branching should met 2 criteria: (1) Branching parameter should be chosen in a way to provide the smallest number of nodes in full B&B tree. (2) Introduce RTFV over solution space the range of minimal size which contains target function for the space. Then, intersection size for RTFVs over branched subspaces should go to zero. The native idea: make branching by choosing node and split space to subspaces, where is the upper bound on optimal schedule for the current space and consists of the schedules with, i.e. assign the exact time slot for some picked node. This approach is weak because of there are several absolute time assignments for the same scheduling order, i.e. it creates spaces which may contains no optimal solution. Further analysis showed that branching based on conflict orientation lead to B&B tree, where leaf number is equal to number of different scheduling. Algorithm was implemented but applicability was incredibly small. There are no interesting cases for heuristic analysis, due to low distance between OPT and random schedules.

14 1.6 Alternative approaches 1) 3-rd party solvers for ILP hasn n been tried. Potentially it can extend number of problems where optimal solution can be gained in adequate time. Therefore it would allow to play with heuristics. 2) Reduction rule: : Let's is feasible solution. It defines orientation for every resource constrain. Check if it has k constrains which reorientation lead us to better scheduling. Obiously the optimal one has no such constains sets for any k. 3) Randomization algorithms. How far random solution from the optimal? 4) Machine learning: try to present data in appropriate way and create Artificial Intelligence which resolves resource conflicts.

15 2 Looking for SPT 2.1 Problem overview Usually topology is chosen based on power efficiency characteristic [5]. Meanwhile, as we have seen aggregation topology is highly impact scheduling characteristics. Therefore it's worth to make next-hop decision carefully. This problem was well studied in [1]. Authors consider tree efficiency as a combination of: - Total tree interference (sum of in rank in communication graph for every edge endpoint in T) - Tree radius Suggested algorithm accept parameter alpha which define relative cost for target functions Formulation, bad case Let's return to the statement [1F], where are resource limitations are only between siblings, call it [2F] formulation. Next chapters are about analysis of applicability of minimumradius spanning trees (rspt) as aggregation tree. Other well-known trees have been checked, but nothing interesting was found. Easy to see that rspt is not the best topology in formulation [1], [Picture 3.1] demonstrates the root cause. Meanwhile for restricted problem rspt looks good. Especially for Euclidian space it has additional meaning - passing the data in base station direction.

16 2.3. Numeric experiments Description Numeric experiment was done for analysis of minr trees for usage as aggregation topology for [F1] problem statement. It s generated a set of problem instances. Next for every instance it went through all possible spanning trees. Optimal schedule was built for every tree. [Results 2.3.4] contains corollaries and hypothesis which leads from experiment Data set Test instance generation: Put N points into unit square randomly Set transmission range to unit. Use 15 iterations of binary search: - Pick left range if graph connected at midpoint - Pick right one otherwise. Check if the. If yes graph instance successfully generated. For every number is 2100 graphs. The limit for, was generated 100 graphs by the described algorithm. The overall was set because of it needs all trees to be generated. By [A. Cayley] theorem, the number of SPT in a complete graph over vertices is that s why most of built graphs are sparse. The number was estimated by Gauss base algorithm for determinant calculation of [Kirchhoff] matrix. Picture 2.2 describes test set structure.

17 2.3.3 Algorithm Tree generation [Application A: TreeGenerator] procedure based on Christofides s algorithm described in [6]. The algorithm was slightly modified to check on each step if there enough edges to finalize the tree. The modification provided 10 times boost for processed data set. Tree evaluation was done by P-siblings algorithm, it has complexity. Picture 2.3 shows algorithm performance [results are from AMD Athlon II, P320, 2.1 Hz, DDR3-1066, 2GB, gcc 4.9 -O3] Results Experiment shows that for any problem instance there is a minr tree which is optimal, i.e. the shortest schedule over some minr tree is optimal for an instance. Average length of optimal schedules for all minr SPTs is in a distance < 0.5 from optimal one. It s interesting all minr trees can be scheduled in at most OPT + 1 time slots. The optimal schedules length distribution can be found on Picture 2.5.

18 Hypothesis 1: for any instance [F2] problem, exists a minr spanning tree R and schedule S over R topology, such that length of S is optimal for the problem. Hypothesis 2: for any instance [F2] problem, doesn t exist a minr spanning tree R and schedule S over R topology, such that length of S greater then optimal + 1.

19 Summary For the problem [F1]: Analyzed linear programming formulation. Developed new proof of NP-hardness. Proved that there is no constant absolute error approximation algorithm. Implemented Branch and Bound algorithm for the problem. For the problem [F2]: Developed software for numeric experiment. Performed experiment which shows that minr trees are applicable as an aggregation topology. Formulated hypothesis.

20 List of sources [1] Evandro de Souza, Ioanis Nikolaidis (2013). An exploration of aggregation convergecast scheduling, Ad Hoc Networks vol.11, Issue 8, November 2013, Pages [2] Hongsik Choi, Ju Wang, Esther A. Hughes (2009). Scheduling for information gathering on sensor network, Wireless Networks vol.15, Issue 1, January [3] Özlem Durmaz Incel, Amitabha Ghosh, Bhaskar Krishnamachari, Krishnakant Chintalapudi (2012). Fast Data Collection in Tree-Based Wireless Sensor Networks, IEEE Transactions on Mobile Computing vol.11 Issue 1, January 2012 [4] Yu Y. Krishnamachari B., Prasanna (2004). V. Energy-latency tradeoffs for data gathering in wireless sensor networks, IEEE INFOCOM vol.1, [5] Gurwinder Kaur, Rachit Mohan Garg (2012). Power Efficient Topologies for Wireless Sensor Networks, IJDPS Vol.3, Issue 5, September 2012 [6] Nicos Christofides (1975). Graph Theory: An Algorithmic Approach, Academic Press, Incorporated, 1975

21 Application A. Source code M-siblings TreeGenerator TreeConvergecast.h #pragma once #ifndef TreeConvergecast_h #define TreeConvergecast_h #include "GraphStructures.h" #include<map> class TreeConvergecast { public: TreeConvergecast(); ~TreeConvergecast(); int evaluatetree(tree *tree); int evaluatetree(simpletree *tree); map<int, int>* getschedule(tree *tree); int getradius(simpletree *tree); private: int evaluatevetrex(treenode *node); int getvertexdistance(int id, SimpleTree *tree); std::map<int, int> dp; int *disttoroot; int disttorootsz; ; #endif TreeConvergecast.cpp #pragma once #include "TreeConvergecast.h" #include "GraphStructures.h" #include <cstring> #include <algorithm> #include <iostream> #include <map> TreeConvergecast::TreeConvergecast() { disttorootsz=0; disttoroot=null; TreeConvergecast::~TreeConvergecast() { disttorootsz=0; delete(disttoroot); int TreeConvergecast::evaluateTree(SimpleTree *stree) { Tree *tree = new Tree(*sTree); dp.clear(); int ret = evaluatevetrex(tree->getroot()); delete(tree); return ret; int TreeConvergecast::evaluateTree(Tree *tree) { dp.clear(); return evaluatevetrex(tree->getroot()); map<int, int>* TreeConvergecast::getSchedule(Tree *tree) { evaluatetree(tree); return new map<int, int>(dp); int TreeConvergecast::evaluateVetrex(TreeNode* node) { int id = node->getidx(); if(dp.find(id) == dp.end()) { int ret = 0; vector<int> *childrentimes = new vector<int>(); vector<treenode*> children = node- >GetChildren(); for(vector<treenode*>::iterator it = children.begin(); it!= children.end(); it++) { childrentimes- >push_back(evaluatevetrex(*it)); std::sort(childrentimes->begin(), childrentimes- >end()); for(vector<int>::iterator it = childrentimes- >begin(); it!= childrentimes->end(); it++) { int time = *it; if(ret < time + 1) { ret = time + 1; else { ret++; delete(childrentimes); dp[id] = ret; return dp[id]; int TreeConvergecast::getRadius(SimpleTree *tree) { int sz = tree->size(); if(sz > disttorootsz) { delete(disttoroot); disttorootsz = sz * 2; disttoroot = new int[disttorootsz]; for(int i = 0; i < sz; i++) { disttoroot[i] = -1; int radius = 0; for(int i = 0; i < sz; i++) { int vr = getvertexdistance(i, tree); radius = max(vr, radius); return radius; int TreeConvergecast::getVertexDistance(int id, SimpleTree *tree) { if(disttoroot[id]!= -1) return disttoroot[id]; int prev = tree->at(id); if(id == prev) return disttoroot[id] = 0; return disttoroot[id] = 1 + getvertexdistance(prev, tree);

22 SpanningTreeGenerator.h #pragma once #ifndef SpanningTreeGenerator_h #define SpanningTreeGenerator_h #include "GraphStructures.h" #include "DataKeeper.h" #include<map> //[Christofides] class SpanningTreeGenerator; class DSU; // generates SPT over grah rooted at rootid. class SpanningTreeGenerator { public: SpanningTreeGenerator(int rootidext, Graph* graph); ~SpanningTreeGenerator(); SimpleTree* getnexttree(); long long gettreecount(); private: int nverticies; long long ntrees; long long latestbuildedtreeindex; int rootidext; EdgesSet *edges; long long calctreecount(); int getinternalid(int external); int getexternalid(int internal); std::map<int, int> idconvertor; std::map<int, int> idrevertor; DSU *dsu, *dsu_tmp; vector<int> *pickedstack; bool appendedge(int lastused); int revertlastedge(); bool switchtonexttree(); bool restisclosable(int lastused); SimpleTree* buildtree(dsu *inst); long long determinant(int n, int *arr); long long determinantinteger(int n, int *arr); long long gcd(long long a, long long b); public: SimpleTree* getspt_minw(datakeeper* pdk); // CAUTION - SLOW implementation, don't call frequently SimpleTree* getspt_minww(datakeeper* pdk); // CAUTION - SLOW implementation, don't call frequently SimpleTree* getspt_minr(); // CAUTION - SLOW implementation, don't call frequently ; // disjoint set union class DSU { public: DSU(int nvertecies); ~DSU(); bool addedge(int ida, int idb); void removeedge(int ida, int idb); bool isconnected(); void setasroot(int id, bool updaterootchanges = true); int getprevid(int id); int getrootid(int id); void reset(); void set(dsu *inst); private: // : j -> [root(j), prev(j)] int cntcomponents; int sz; int *rootid; int *previd; ; #endif SpanningTreeGenerator.cpp #pragma once #include "SpanningTreeGenerator.h" #include "GraphStructures.h" #include "GraphAlgorithms.h" #include <algorithm> #include <map> #include <utility> #include <assert.h> #include <iostream> #include <cstring> #include <queue> SpanningTreeGenerator::SpanningTreeGenerator(int rootid, Graph *graph) { this->rootidext = rootid; if(!graph->isconnected()) { throw std::invalid_argument("graph is not connected, cannot build any SpanningTree"); this->nverticies = graph->getverticescount(); edges = new EdgesSet();

23 for(vector<graphedge*>::iterator it = graph- >_aedges.begin(); it!= graph->_aedges.end(); it++) { int a = (*it)->getv1idx(); int b = (*it)->getv2idx(); GraphVertex *internala = new GraphVertex(getInternalId(a)); GraphVertex *internalb = new GraphVertex(getInternalId(b)); edges->push_back(new GraphEdge(internalA, internalb)); this->ntrees = calctreecount(); latestbuildedtreeindex = 0L; dsu = new DSU(graph->GetVerticesCount()); dsu_tmp = new DSU(graph->GetVerticesCount()); pickedstack = new vector<int>(); SpanningTreeGenerator::~SpanningTreeGenerator() { delete(dsu); delete(dsu_tmp); delete(pickedstack); for(vector<graphedge*>::iterator it = edges- >begin(); it!= edges->end(); it++) { GraphEdge *edge = (*it); delete(edge->getv1()); delete(edge->getv2()); delete(edge); delete(edges); SimpleTree* SpanningTreeGenerator::getNextTree() { if(switchtonexttree()){ latestbuildedtreeindex++; if(latestbuildedtreeindex % == 0) { cout << "New tree builded " << latestbuildedtreeindex << "out of " << ntrees << " " << * latestbuildedtreeindex / ntrees << endl; return buildtree(dsu); return NULL; SimpleTree* SpanningTreeGenerator::buildTree(DSU *inst) { SimpleTree* ret = new SimpleTree(); inst->setasroot(getinternalid(this->rootidext), true); for(int i = 0; i < nverticies; i++) { int internal = getinternalid(i); int prev = inst->getprevid(internal); ret->push_back(getexternalid(prev)); return ret; long long SpanningTreeGenerator::getTreeCount() { return ntrees; long long SpanningTreeGenerator::calcTreeCount() { int n = nverticies - 1; int arr[n][n]; for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) arr[i][j] = 0; for(vector<graphedge*>::iterator it = edges- >begin(); it!= edges->end(); it++) { int a = (*it)->getv1idx(); int b = (*it)->getv2idx(); if(a < n && b < n) { arr[a][b]--; arr[b][a]--; if(a < n) arr[a][a]++; if (b < n) arr[b][b]++; // cout << " " << endl; // for(int i = 0; i < n; i++) { // cout << endl; // for(int j = 0; j < n; j++) { // cout << arr[i][j] << " "; // // // cout << " " << endl; long long ret = determinant(n, &arr[0][0]); return ret; int SpanningTreeGenerator::getInternalId(int external) { if(idconvertor.find(external) == idconvertor.end()) { int newid = idconvertor.size(); idconvertor[external] = newid; idrevertor[newid] = external; // cout << "Added mapping: " << external << " -> " << newid << endl; return idconvertor[external]; int SpanningTreeGenerator::getExternalId(int internal) { if(idrevertor.find(internal) == idconvertor.end()) { throw std::invalid_argument("element with id: " + std::to_string(internal) + " hasn't been mapped"); return idrevertor[internal];

24 bool SpanningTreeGenerator::appendEdge(int lastused){ if(lastused < -1) { throw std::invalid_argument("lastused [" + std::to_string(lastused) + "] should be >= -1"); // cout << "point Z " << lastused << " " << edges->size() << endl; for(vector<graphedge*>::size_type i = lastused + 1; i < edges->size(); i++) { int a = (*edges)[i]->getv1idx(); int b = (*edges)[i]->getv2idx(); // cout << "point 0 " << a << " " << b << endl; // cout.flush(); if(dsu->addedge(a, b)) { pickedstack->push_back(i); // cout << "appended " << a << " " << b << endl; return true; // cout << "cannot append " << endl; return false; int SpanningTreeGenerator::revertLastEdge() { //cout << pickedstack->size() << "???????????? " << endl; if(pickedstack->begin() == pickedstack->end()) return -1; int edgedid = pickedstack->back(); GraphEdge *edge = (*edges)[edgedid]; pickedstack->pop_back(); dsu->removeedge(edge->getv1idx(), edge- >GetV2Idx()); // cout << "reverted " << edge->getv1idx() << " " << edge->getv2idx() << endl; return edgedid; bool SpanningTreeGenerator::switchToNextTree() { bool prebuilded = true; while(appendedge(-1)) { prebuilded = false; if(!prebuilded && dsu->isconnected()) { return true; int index = -1; while((index = revertlastedge()) >= 0) { if(!restisclosable(index)) continue; while(appendedge(index)); // add as many edges as possible if(dsu->isconnected()){ return true; return false; bool SpanningTreeGenerator::restIsClosable(int lastused) { dsu_tmp->set(dsu); for(vector<graphedge*>::size_type i = lastused + 1; i < edges->size(); i++) { int a = (*edges)[i]->getv1idx(); int b = (*edges)[i]->getv2idx(); dsu_tmp->addedge(a, b); if(dsu_tmp->isconnected()) return true; return false; // utils long long SpanningTreeGenerator::gcd(long long a, long long b) { return a == 0? b : gcd(b % a, a); double dabs(double x) { return x > 0? x : -x; long long SpanningTreeGenerator::determinant(int n, int *arr1) { double *arr = new double[n * n]; for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) arr[i * n + j] = arr1[n * i + j]; int *rowindexes = new int[n]; for(int i = 0; i < n; i++) rowindexes[i] = i; const double eps = 1e-9; double multiplicator = 1L; for(int diag = 0; diag < n; diag++) { int j = diag + 1; while(j < n ) { if(dabs(arr[rowindexes[j] * n + diag]) > dabs(arr[rowindexes[diag] * n + diag])) { int tmp = rowindexes[diag]; rowindexes[diag] = rowindexes[j]; rowindexes[j] = tmp; j++; if(dabs(arr[rowindexes[diag] * n + diag]) < eps) return 0; // all the rest rows contains 0 in [diag]- column. multiplicator *= arr[rowindexes[diag] * n + diag];

25 for(int row = diag + 1; row < n; row++) { double A = arr[rowindexes[diag] * n + diag]; double B = arr[rowindexes[row] * n + diag]; if(dabs(b) < eps) continue; for(int col = diag; col < n; col++) { arr[rowindexes[row] * n + col] = arr[rowindexes[row] * n + col] - arr[rowindexes[diag] * n + col] * B / A; multiplicator = dabs(multiplicator); delete(rowindexes); delete(arr); if(multiplicator > 1L << 60) return 1L << 60; return (long long) (multiplicator + 0.5); // other trees::: SimpleTree* SpanningTreeGenerator::getSPT_minR() { dsu_tmp->reset(); queue<int> qu; qu.push(getinternalid(this->rootidext)); while(!qu.empty()) { int v = qu.front(); qu.pop(); for(vector<graphedge*>::size_type i = 0; i < edges->size(); i++) { int a = (*edges)[i]->getv1idx(); int b = (*edges)[i]->getv2idx(); if(a == v b == v) { int c = a ^ b ^ v; if(dsu_tmp->addedge(v, c)) qu.push(c); if(!dsu_tmp->isconnected()) throw std::invalid_argument("minr is not connected"); return buildtree(dsu_tmp); SimpleTree* SpanningTreeGenerator::getSPT_minW(DataKeeper *pdk) { dsu_tmp->reset(); bool changed = true; while(changed) { changed = false; GraphEdge *best=null; double weight = -1; for(vector<graphedge*>::size_type i = 0; i < edges->size(); i++) { int a = (*edges)[i]->getv1idx(); int b = (*edges)[i]->getv2idx(); if(dsu_tmp->getrootid(a) == dsu_tmp- >getrootid(b)) continue; int exta = getexternalid(a); int extb = getexternalid(b); double tmp = pdk->getweight(exta, extb); if(weight < 0 tmp < weight) { weight = tmp; best = (*edges)[i]; if(best!= NULL) { dsu_tmp->addedge(best->getv1idx(), best- >GetV2Idx()); changed = true; if(!dsu_tmp->isconnected()) throw std::invalid_argument("minw is not connected"); return buildtree(dsu_tmp); SimpleTree* SpanningTreeGenerator::getSPT_minWW(DataKeep er *pdk) { dsu_tmp->reset(); bool changed = true; while(changed) { changed = false; GraphEdge *best=null; double weight = -1; for(vector<graphedge*>::size_type i = 0; i < edges->size(); i++) { int a = (*edges)[i]->getv1idx(); int b = (*edges)[i]->getv2idx(); if(dsu_tmp->getrootid(a) == dsu_tmp- >getrootid(b)) continue; int exta = getexternalid(a); int extb = getexternalid(b); double tmp = pdk->getweight(exta, extb); tmp *= tmp; if(weight < 0 tmp < weight) { weight = tmp; best = (*edges)[i]; if(best!= NULL) { dsu_tmp->addedge(best->getv1idx(), best- >GetV2Idx()); changed = true; if(!dsu_tmp->isconnected()) throw std::invalid_argument("minww is not connected"); return buildtree(dsu_tmp);

26 // DSU // BUILD tree, setasroot(getinternalid(this->rootid)), create simple tree based on DSU prev DSU::DSU(int nvertecies) { sz = nvertecies; previd = new int[sz]; rootid = new int[sz]; reset(); DSU::~DSU() { delete(previd); delete(rootid); bool DSU::addEdge(int ida, int idb) { if(rootid[ida] == rootid[idb]) return false; if(rand() & 1) { int tmp = ida; ida = idb; idb = tmp; int ra = rootid[ida]; int rb = rootid[idb]; setasroot(idb, false); // root changed: need to update rb -> idb previd[idb] = ida; // trees merged: need to update idb -> ra for(int i = 0; i < sz; i++) if(rootid[i] == rb) rootid[i] = ra; cntcomponents--; return true; void DSU::removeEdge(int ida, int idb) { if(rootid[ida]!= rootid[idb]) throw std::invalid_argument("dsu: cannot remove edged. Vertecies in the different components " + std::to_string(ida) + "[root:" + std::to_string(rootid[ida]) + "], " + std::to_string(idb) + "[root:" + std::to_string(rootid[idb]) + "]"); if(previd[idb]!= ida) { int tmp = ida; ida = idb; idb = tmp; if(previd[idb]!= ida) { throw std::invalid_argument("dsu: cannot remove edged. Vertecies are not neighbours " + std::to_string(ida) + "[prev:" + std::to_string(previd[ida]) + "], " + std::to_string(idb) + "[prev:" + std::to_string(previd[idb]) + "]"); cntcomponents++; previd[idb] = idb; vector<int> queue; queue.push_back(idb); while(!queue.empty()) { int elem = queue.back(); queue.pop_back(); rootid[elem] = idb; for(int i = 0; i < sz; i++) if(previd[i] == elem && rootid[i]!= idb) queue.push_back(i); bool DSU::isConnected() { return cntcomponents == 1; void DSU::setAsRoot(int id, bool updaterootchanges) { int from = id; int pos = previd[id]; previd[id] = id; while(from!= pos) { int next = previd[pos]; previd[pos] = from; from = pos; pos = next; if(updaterootchanges) { int tmp = rootid[id]; for(int i = 0; i < sz; i++) if(rootid[i] == tmp) rootid[i] = id; int DSU::getPrevId(int id) { return previd[id]; int DSU::getRootId(int id) { return rootid[id]; void DSU::reset() { cntcomponents = sz; for(int i = 0; i < sz; i++) rootid[i] = previd[i] = i; void DSU::set(DSU *inst) { if(sz!= inst->sz) throw std::invalid_argument("dsu: cannot fill - size mismatch" + std::to_string(inst->sz) + " ->" + std::to_string(sz)); std::memcpy(rootid, inst->rootid, sz * sizeof(int)); std::memcpy(previd, inst->previd, sz * sizeof(int)); cntcomponents = inst->cntcomponents;