├── demo
    ├── usa.pdf
    ├── .DS_Store
    ├── country.jpg
    ├── graph.tex
    ├── adj_matrix
    └── usa.tex
├── makefile
├── .gitignore
├── include
    ├── mst.h
    └── simplex.h
├── LICENSE
├── README.md
└── src
    ├── mst.cpp
    ├── simplex.cpp
    └── tsp_solver.cpp


/demo/usa.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PetarV-/Simplex-TSP-Solver/HEAD/demo/usa.pdf


--------------------------------------------------------------------------------
/demo/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PetarV-/Simplex-TSP-Solver/HEAD/demo/.DS_Store


--------------------------------------------------------------------------------
/demo/country.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PetarV-/Simplex-TSP-Solver/HEAD/demo/country.jpg


--------------------------------------------------------------------------------
/makefile:
--------------------------------------------------------------------------------
 1 | CC = clang++ -Iinclude/
 2 | CFLAGS = -std=c++11 -O3 -Wall -Wextra -Werror -Weffc++ -Wstrict-aliasing --pedantic
 3 | 
 4 | tsp_solver : src/mst.cpp src/simplex.cpp src/tsp_solver.cpp
 5 | 	$(CC) $(CFLAGS) src/mst.cpp src/simplex.cpp src/tsp_solver.cpp -o tsp_solver
 6 | 
 7 | .PHONY : clean
 8 | clean :
 9 | 	-rm -f tsp_solver &> /dev/null
10 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled Object files
 2 | *.slo
 3 | *.lo
 4 | *.o
 5 | *.obj
 6 | 
 7 | # Precompiled Headers
 8 | *.gch
 9 | *.pch
10 | 
11 | # Compiled Dynamic libraries
12 | *.so
13 | *.dylib
14 | *.dll
15 | 
16 | # Fortran module files
17 | *.mod
18 | 
19 | # Compiled Static libraries
20 | *.lai
21 | *.la
22 | *.a
23 | *.lib
24 | 
25 | # Executables
26 | *.exe
27 | *.out
28 | *.app
29 | 


--------------------------------------------------------------------------------
/include/mst.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  Petar 'PetarV' Velickovic
 3 |  Algorithm: MST-TSP approximation
 4 | */
 5 | 
 6 | #ifndef MST
 7 | #define MST
 8 | 
 9 | #include <vector>
10 | 
11 | #define MAX_N 5001
12 | 
13 | /*
14 |  This is a polynomial time 2-approximation algorithm to the Traveling
15 |  Salesman Problem, making advantage of a minimal spanning tree (MST)
16 |  subroutine. It proceeds as follows:
17 |     1. Compute the MST of the input graph;
18 |     2. Perform a preorder traversal of the MST;
19 |     3. Traverse vertices in that exact order, closing the circuit at the end.
20 | */
21 | 
22 | std::pair<double, std::vector<std::pair<int, int> > > tsp_mst(int n, double adj[MAX_N][MAX_N]);
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Petar Veličković
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/demo/graph.tex:
--------------------------------------------------------------------------------
 1 | \node[] (title) at (10, 25) {\Huge Objective value: $-701.000000$, $861$ variables, $952$ constraints, $2255$ iterations};
 2 | \draw[edge,black] (2) to node[lab]{1} (1);
 3 | \draw[edge,black] (3) to node[lab]{1} (2);
 4 | \draw[edge,black] (4) to node[lab]{1} (3);
 5 | \draw[edge,black] (5) to node[lab]{1} (4);
 6 | \draw[edge,black] (6) to node[lab]{1} (5);
 7 | \draw[edge,black] (7) to node[lab]{1} (6);
 8 | \draw[edge,black] (8) to node[lab]{1} (7);
 9 | \draw[edge,black] (9) to node[lab]{1} (8);
10 | \draw[edge,black] (12) to node[lab]{1} (10);
11 | \draw[edge,black] (12) to node[lab]{1} (11);
12 | \draw[edge,black] (14) to node[lab]{1} (13);
13 | \draw[edge,black] (15) to node[lab]{1} (14);
14 | \draw[edge,black] (16) to node[lab]{1} (15);
15 | \draw[edge,black] (17) to node[lab]{1} (13);
16 | \draw[edge,black] (18) to node[lab]{1} (16);
17 | \draw[edge,black] (19) to node[lab]{1} (18);
18 | \draw[edge,black] (20) to node[lab]{1} (19);
19 | \draw[edge,black] (21) to node[lab]{1} (20);
20 | \draw[edge,black] (22) to node[lab]{1} (17);
21 | \draw[edge,black] (23) to node[lab]{1} (11);
22 | \draw[edge,black] (23) to node[lab]{1} (22);
23 | \draw[edge,black] (25) to node[lab]{1} (9);
24 | \draw[edge,black] (25) to node[lab]{1} (10);
25 | \draw[edge,black] (26) to node[lab]{1} (24);
26 | \draw[edge,black] (27) to node[lab]{1} (24);
27 | \draw[edge,black] (27) to node[lab]{1} (26);
28 | \draw[edge,black] (28) to node[lab]{1} (21);
29 | \draw[edge,black] (29) to node[lab]{1} (28);
30 | \draw[edge,black] (30) to node[lab]{1} (29);
31 | \draw[edge,black] (31) to node[lab]{1} (30);
32 | \draw[edge,black] (32) to node[lab]{1} (31);
33 | \draw[edge,black] (33) to node[lab]{1} (32);
34 | \draw[edge,black] (34) to node[lab]{1} (33);
35 | \draw[edge,black] (35) to node[lab]{1} (34);
36 | \draw[edge,black] (36) to node[lab]{1} (35);
37 | \draw[edge,black] (37) to node[lab]{1} (36);
38 | \draw[edge,black] (38) to node[lab]{1} (37);
39 | \draw[edge,black] (39) to node[lab]{1} (38);
40 | \draw[edge,black] (40) to node[lab]{1} (39);
41 | \draw[edge,black] (41) to node[lab]{1} (40);
42 | \draw[edge,black] (42) to node[lab]{1} (1);
43 | \draw[edge,black] (42) to node[lab]{1} (41);
44 | 


--------------------------------------------------------------------------------
/include/simplex.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  Petar 'PetarV' Velickovic
 3 |  Algorithm: Simplex Algorithm
 4 | */
 5 | 
 6 | #ifndef SIMPLEX
 7 | #define SIMPLEX
 8 | 
 9 | #include <tuple>
10 | #include <vector>
11 | 
12 | /*
13 |  The Simplex algorithm aims to solve a linear program - optimising a linear function subject
14 |  to linear constraints. As such it is useful for a very wide range of applications.
15 |  
16 |  N.B. The linear program has to be given in *slack form*, which is as follows:
17 |  maximise
18 |  c_1 * x_1 + c_2 * x_2 + ... + c_n * x_n + v
19 |  subj. to
20 |  a_11 * x_1 + a_12 * x_2 + ... + a_1n * x_n + b_1 = s_1
21 |  a_21 * x_1 + a_22 * x_2 + ... + a_2n * x_n + b_2 = s_2
22 |  ...
23 |  a_m1 * x_1 + a_m2 * x_2 + ... + a_mn * x_n + b_m = s_m
24 |  and
25 |  x_1, x_2, ..., x_n, s_1, s_2, ..., s_m >= 0
26 |  
27 |  Every linear program can be translated into slack form; the parameters to specify are:
28 |  - the number of variables, n, and the number of constraints, m;
29 |  - the matrix A = [[A_11, A_12, ..., A_1n], ..., [A_m1, A_m2, ..., A_mn]];
30 |  - the vector b = [b_1, b_2, ..., b_m];
31 |  - the vector c = [c_1, c_2, ..., c_n] and the constant v.
32 |  
33 |  Complexity:    O(m^(n/2)) worst case
34 |                 O(n + m) average case (common)
35 | */
36 | 
37 | class Simplex
38 | {
39 | private:
40 |     int n, m;
41 |     double **A, *b, *c, v;
42 |     int *N, *B; // nonbasic & basic
43 |     
44 | public:
45 |     Simplex(int n, int m, double **A, double *b, double *c, double v);
46 |     
47 |     ~Simplex();
48 |     
49 |     // pivot yth variable around xth constraint
50 |     void pivot(int x, int y);
51 |     
52 |     // Run a single iteration of the simplex algorithm.
53 |     // Returns: 0 if OK, 1 if STOP, -1 if UNBOUNDED
54 |     int iterate_simplex();
55 |     
56 |     // (Possibly) converts the LP into a slack form with a feasible basic solution.
57 |     // Returns 0 if OK, -1 if INFEASIBLE
58 |     int initialise_simplex();
59 | 
60 |     // Runs the simplex algorithm to optimise the LP.
61 |     // Returns a vector of -1s if unbounded, -2s if infeasible.
62 |     std::tuple<std::vector<double>, double, int> simplex();
63 | };
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Simplex-TSP-Solver
 2 | Iterative exact solver of the Travelling Salesman Problem, taking advantage of the Simplex Algorithm (by methods of Dantzig, Fulkerson and Johnson). The topmost layer of the solver also interfaces to a demo folder, which can be used for plotting the current solution as successive solutions are found.
 3 | 
 4 | The current form has been used for demonstrations at the [mgcsweek](http://www.csnedelja.mg.edu.rs) seminar at the [High School of Mathematics](http://www.mg.edu.rs) in Belgrade and the [Advanced Algorithms](http://www.cl.cam.ac.uk/teaching/1516/AdvAlgo/) lecture course for Part II of the Computer Science Tripos at the [University of Cambridge](http://www.cam.ac.uk).
 5 | 
 6 | ## Building
 7 | Simply run
 8 | 
 9 |     $ make
10 | 
11 | while in the root directory of the repository, and the executable, `tsp_solver`, will be created therewith.
12 | 
13 | ## Usage
14 | In order to interface properly to a demo setting, four parameters need to be given right after executing
15 | 
16 |     $ ./tsp_solver
17 | 
18 | These are, in order:
19 | - A path to the adjacency matrix specifying the input graph (`demo/adj_matrix` in this case);
20 | - A path to the folder containing the demonstration .tex files (`demo/` in this case);
21 | - File name of the .tex file containing the edge-drawing commands (`graph.tex` in this case);
22 | - File name of the .tex file containing the map-drawing commands (`usa.tex` in this case);
23 | 
24 | Afterwards, an interactive window will open where one of the following commands may be performed repeatedly:
25 | - `SOLVE`: launch the Simplex algorithm on the constraints obtained so far;
26 | - `REM_LOOP`/`REM_LOOP_RNG`: add a cycle-eliminating constraint on a given set of nodes;
27 | - `SET`: add a constraint that sets a particular edge's indicator variable to 0/1;
28 | - `UNDO`: undo a number of previously added constraints (useful for branch&bound);
29 | - `APPROX_MST`: perform a 2-approximation of the optimal tour using Prim's MST algorithm;
30 | - `EXIT`: exit the program.
31 | 
32 | Upon each call to `SOLVE`, detailed information about all the useful iterations (that improve the objective value) will be printed on the terminal. Once a solution has been found, `pdflatex` will be called to regenerate the output PDF file (`demo/usa.pdf` in this case). Finally, if you are using Mac OS X, `qlmanage` will be called for automatically displaying the PDF.
33 | 
34 | ## License
35 | MIT
36 | 


--------------------------------------------------------------------------------
/src/mst.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <math.h>
  3 | #include <string.h>
  4 | #include <assert.h>
  5 | #include <iostream>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <string>
  9 | #include <algorithm>
 10 | #include <queue>
 11 | #include <stack>
 12 | #include <set>
 13 | #include <map>
 14 | #include <complex>
 15 | 
 16 | #include <mst.h>
 17 | 
 18 | typedef long long lld;
 19 | typedef unsigned long long llu;
 20 | typedef unsigned int uint;
 21 | using namespace std;
 22 | 
 23 | struct pq_entry
 24 | {
 25 |     double x;
 26 |     pair<int, int> e;
 27 |     bool operator <(const pq_entry &a) const
 28 |     {
 29 |         return (x > a.x);
 30 |     }
 31 | };
 32 | 
 33 | inline vector<int> prim(int n, double adj[MAX_N][MAX_N])
 34 | {
 35 |     vector<bool> mark(n + 1, false);
 36 |     vector<int> ret(n + 1, -1);
 37 |     priority_queue<pq_entry> pq_prim;
 38 |     int xt = 1;
 39 |     int amt = 0;
 40 |     while (amt < n - 1)
 41 |     {
 42 |         mark[xt] = true;
 43 |         for (int i=1;i<=n;i++)
 44 |         {
 45 |             if (!mark[i]) pq_prim.push({adj[max(xt, i)][min(xt, i)], {xt, i}});
 46 |         }
 47 |         while (!pq_prim.empty())
 48 |         {
 49 |             auto X = pq_prim.top();
 50 |             pq_prim.pop();
 51 |             if (!mark[X.e.second])
 52 |             {
 53 |                 ret[X.e.second] = X.e.first;
 54 |                 xt = X.e.second;
 55 |                 amt++;
 56 |                 break;
 57 |             }
 58 |         }
 59 |     }
 60 |     return ret;
 61 | }
 62 | 
 63 | inline pair<int, vector<vector<int> > > build_tree(vector<int> p)
 64 | {
 65 |     int root;
 66 |     vector<vector<int> > T(p.size(), vector<int>());
 67 |     for (uint i=1;i<p.size();i++)
 68 |     {
 69 |         if (p[i] == -1) root = i;
 70 |         else T[p[i]].push_back(i);
 71 |     }
 72 |     return {root, T};
 73 | }
 74 | 
 75 | void preorder(int x, vector<vector<int> > T, vector<int> &ret)
 76 | {
 77 |     ret.push_back(x);
 78 |     for (uint i=0;i<T[x].size();i++)
 79 |     {
 80 |         preorder(T[x][i], T, ret);
 81 |     }
 82 | }
 83 | 
 84 | pair<double, vector<pair<int, int> > > tsp_mst(int n, double adj[MAX_N][MAX_N])
 85 | {
 86 |     vector<int> mst = prim(n, adj);
 87 |     auto mst_t = build_tree(mst);
 88 |     vector<int> walk;
 89 |     preorder(mst_t.first, mst_t.second, walk);
 90 |     
 91 |     double val = 0.0;
 92 |     vector<pair<int, int> > used;
 93 |     
 94 |     for (uint i=0;i<walk.size();i++)
 95 |     {
 96 |         int x = walk[i];
 97 |         int y = walk[(i + 1) % walk.size()];
 98 |         val += adj[max(x, y)][min(x, y)];
 99 |         used.push_back({x, y});
100 |     }
101 |     
102 |     return {val, used};
103 | }
104 | 


--------------------------------------------------------------------------------
/demo/adj_matrix:
--------------------------------------------------------------------------------
 1 | 42
 2 | 8
 3 | 39 45
 4 | 37 47 9
 5 | 50 49 21 15
 6 | 61 62 21 20 17
 7 | 58 60 16 17 18 6
 8 | 59 60 15 20 26 17 10
 9 | 62 66 20 25 31 22 15 5
10 | 81 81 40 44 50 41 35 24 20
11 | 103 107 62 67 72 63 57 46 41 23
12 | 108 117 66 71 77 68 61 51 46 26 11
13 | 145 149 104 108 114 106 99 88 84 63 49 40
14 | 181 185 140 144 150 142 135 124 120 99 85 76 35
15 | 187 191 146 150 156 142 137 130 125 105 90 81 41 10
16 | 161 170 120 124 130 115 110 104 105 90 72 64 34 31 27
17 | 142 146 101 104 111 97 91 85 86 75 51 59 29 53 48 21
18 | 174 178 133 138 143 129 123 117 118 107 83 84 54 46 35 26 31
19 | 185 186 142 143 140 130 126 124 128 118 93 101 72 69 58 58 43 26
20 | 164 165 120 123 124 106 106 105 110 104 86 97 71 93 82 62 42 45 22
21 | 137 139 94 96 94 80 78 77 84 77 56 64 65 90 87 58 36 68 50 30
22 | 117 122 77 80 83 68 62 60 61 50 34 42 49 82 77 60 30 62 70 49 21
23 | 114 118 73 78 84 69 63 57 59 48 28 36 43 77 72 45 27 59 69 55 27 5
24 | 85 89 44 48 53 41 34 28 29 22 23 35 69 105 102 74 56 88 99 81 54 32 29
25 | 77 80 36 40 46 34 27 19 21 14 29 40 77 114 111 84 64 96 107 87 60 40 37 8
26 | 87 89 44 46 46 30 28 29 32 27 36 47 78 116 112 84 66 98 95 75 47 36 39 12 11
27 | 91 93 48 50 48 34 32 33 36 30 34 45 77 115 110 83 63 97 91 72 44 32 36 9 15 3
28 | 105 106 62 63 64 47 46 49 54 48 46 59 85 119 115 88 66 98 79 59 31 36 42 28 33 21 20
29 | 111 113 69 71 66 51 53 56 61 57 59 71 96 130 126 98 75 98 95 62 38 47 53 39 42 29 30 12
30 | 91 92 50 51 46 30 34 38 43 49 60 71 103 141 136 109 90 115 99 81 53 61 62 36 34 24 28 20 20
31 | 83 85 42 43 38 22 26 32 36 51 63 75 106 142 140 112 93 126 108 88 60 64 66 39 36 27 31 28 28 8
32 | 89 91 55 55 50 34 39 44 49 63 76 87 120 155 150 123 100 123 109 86 62 71 78 52 49 39 44 35 24 15 12
33 | 95 97 64 63 56 42 49 56 60 75 86 97 126 160 155 128 104 128 113 90 67 76 82 62 59 49 53 40 29 25 23 11
34 | 74 81 44 43 35 23 30 39 44 62 78 89 121 159 155 127 108 136 124 101 75 79 81 54 50 42 46 43 39 23 14 14 21
35 | 67 69 42 41 31 25 32 41 46 64 83 90 130 164 160 133 114 146 134 111 85 84 86 59 52 47 51 53 49 32 24 24 30 9
36 | 74 76 61 60 42 44 51 60 66 83 102 110 147 185 179 155 133 159 146 122 98 105 107 79 71 66 70 70 60 48 40 36 33 25 18
37 | 57 59 46 41 25 30 36 47 52 71 93 98 136 172 172 148 126 158 147 124 121 97 99 71 65 59 63 67 62 46 38 37 43 23 13 17
38 | 45 46 41 34 20 34 38 48 53 73 96 99 137 176 178 151 131 163 159 135 108 102 103 73 67 64 69 75 72 54 46 49 54 34 24 29 12
39 | 35 37 35 26 18 34 36 46 51 70 93 97 134 171 176 151 129 161 163 139 118 102 101 71 65 65 70 84 78 58 50 56 62 41 32 38 21 9
40 | 29 33 30 21 18 35 33 40 45 65 87 91 117 166 171 144 125 157 156 139 113 95 97 67 60 62 67 79 82 62 53 59 66 45 38 45 27 15 6
41 | 3 11 41 37 47 57 55 58 63 83 105 109 147 186 188 164 144 176 182 161 134 119 116 86 78 84 88 101 108 88 80 86 92 71 64 71 54 41 32 25
42 | 5 12 55 41 53 64 61 61 66 84 111 113 150 186 192 166 147 180 188 167 140 124 119 90 87 90 94 107 114 77 86 92 98 80 74 77 60 48 38 32 6
43 | 
44 | 


--------------------------------------------------------------------------------
/demo/usa.tex:
--------------------------------------------------------------------------------
 1 | \documentclass[american,9pt, landscape, a4paper, xcolor=table]{article}
 2 | %\usepackage{pgfpages}
 3 | %\pgfpagesuselayout{4 on 1}[a4paper,landscape,border shrink=4mm]
 4 | 
 5 | \usepackage{algcompatible}
 6 | %\usepackage{arrowsnew}
 7 | \usepackage{ulem,caption,longtable}
 8 | 
 9 | \newcommand{\high}[1]{\textcolor{red}{#1}}
10 | 
11 | \newcommand{\sk}[1]{}
12 | \newcommand{\skn}[1]{#1}
13 | \renewcommand{\sk}[1]{#1}
14 | \renewcommand{\tilde}{\widetilde}
15 | \newcommand{\lightning}{(contr.)}
16 | \newcommand{\ca}{\operatorname{cap}}
17 | 
18 | \newcommand{\comment}[1]{%
19 | \textcolor{black!40!white}{#1}}%
20 | \newcommand{\alertline}{%
21 |  \usebeamercolor[fg]{normal text}%
22 |  \only{\usebeamercolor[fg]{alerted text}}}
23 | 
24 | %\usepackage{cmbrightmath, scaleupmath]{tpslifonts}
25 | \newcommand\Loadedframemethod{default}
26 | \usepackage[framemethod=tikz]{mdframed}
27 | 
28 | \usepackage[thicklines]{cancel}
29 | 
30 | \usepackage{tikz,pgf}
31 | \usetikzlibrary{shapes.callouts,decorations.pathmorphing,arrows,snakes,shapes}
32 | \usepackage{tikz-3dplot}
33 | \usepgflibrary{shapes.callouts}
34 | 
35 | \usepackage[scale=0.9]{geometry}
36 | 
37 | \begin{document}
38 | 
39 | 
40 | \pagestyle{empty}
41 | ~\hspace{-1cm}
42 | \begin{tikzpicture}[scale=0.5,knoten/.style={circle, fill=yellow,scale=0.4},lab/.style={pos=0.5,fill=white,draw=black,scale=0.8,rectangle},edge/.style={thick,scale=0.1}]
43 | \node (1) at (12.5,6.5) {\includegraphics[scale=0.666]{country.jpg}};
44 | %\node (1) at (12.5,6.5) {\includegraphics[scale=0.79]{dantzig_big.jpg}};
45 | 
46 | \node[knoten][label=above:1] (1) at (36.5,15.5) {1};
47 | \node[knoten][label=above:2] (2) at (35.16,16.62) {2};
48 | \node[knoten][label=above:3] (3) at (25.6,12.2) {3};
49 | \node[knoten][label=above:4] (4) at (27.2,11.2) {4};
50 | \node[knoten][label=above:5] (5) at (27.8,7) {5};
51 | \node[knoten][label=above:6] (6) at (23.6,6.3) {6};
52 | \node[knoten][label=above:7] (7) at (23,8.5) {7};
53 |  \node[knoten][label=above:8] (8) at (21,11) {8};
54 |  \node[knoten][label=above:9] (9) at (20.5,12.5) {9};
55 |  \node[knoten][label=above:10] (10) at (15.5,15) {10};
56 |  \node[knoten][label=above:11] (11) at (9,14) {11};
57 |  \node[knoten][label=above:12] (12) at (8.5,17.5) {12};
58 |  \node[knoten][label=above:13] (13) at (-1.5,18.5) {13};
59 |  \node[knoten][label=above:14] (14) at (-10.5,21.5) {14};
60 |  \node[knoten][label=above:15] (15) at (-11.5,19) {15};
61 |  \node[knoten][label=above:16] (16) at (-6.5,15) {16};
62 |  \node[knoten][label=above:17] (17) at (-3,10.5) {17};
63 | \node[knoten][label=above:18] (18) at (-11,10) {18};
64 |  \node[knoten][label=above:19] (19) at (-11.5,3) {19};
65 |  \node[knoten][label=above:20] (20) at (-5,1) {20};
66 |  \node[knoten][label=above:21] (21) at (2.5,3) {21};
67 |  \node[knoten][label=above:22] (22) at (4,8.5) {22};
68 |  \node[knoten][label=above:23] (23) at (4,10) {23};
69 |  \node[knoten][label=above:24] (24) at (13,10) {24};
70 |  \node[knoten][label=above:25] (25) at (15.5,10.5) {25};
71 |  \node[knoten][label=above:26] (26) at (14.5,7) {26};
72 |  \node[knoten][label=above:27] (27) at (13.5,7) {27};
73 | \node[knoten][label=above:28] (28) at (11.5,2) {28};
74 |  \node[knoten][label=above:29] (29) at (12,-1.5) {29};
75 | 
76 |  \node[knoten][label=above:30] (30) at (17,1) {30};
77 |  \node[knoten][label=above:31] (31) at (19.5,2) {31};
78 |  \node[knoten][label=above:32] (32) at (19.5,-2) {32};
79 |  \node[knoten][label=above:33] (33) at (20,-5) {33};
80 |  \node[knoten][label=above:34] (34) at (23,0) {34};
81 |  \node[knoten][label=above:35] (35) at (25.5,0.5) {35};
82 |  \node[knoten][label=above:36] (36) at (29.5,-3.5) {36};
83 |  \node[knoten][label=above:37] (37) at (29.5,1.5) {37};
84 | \node[knoten][label=above:38] (38) at (31.5,4) {38};
85 |  \node[knoten][label=above:39] (39) at (32,6.5) {39};
86 | 
87 |  \node[knoten][label=above:40] (40) at (32.5,8.5) {40};
88 |  \node[knoten][label=above:41] (41) at (37,14.5) {41};
89 |  \node[knoten][label=above:42] (42) at (37.5,16.5) {42};
90 | 
91 | \input{graph.tex}
92 | \end{tikzpicture}
93 | 
94 | 
95 | 
96 | 
97 | \end{document}
98 | 


--------------------------------------------------------------------------------
/src/simplex.cpp:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <math.h>
  3 | #include <string.h>
  4 | #include <assert.h>
  5 | #include <iostream>
  6 | #include <vector>
  7 | #include <list>
  8 | #include <string>
  9 | #include <algorithm>
 10 | #include <queue>
 11 | #include <stack>
 12 | #include <set>
 13 | #include <map>
 14 | #include <complex>
 15 | #include <tuple>
 16 | 
 17 | #include <simplex.h>
 18 | 
 19 | #define EPS 1e-3
 20 | 
 21 | typedef long long lld;
 22 | typedef unsigned long long llu;
 23 | using namespace std;
 24 | 
 25 | int total_steps = 0;
 26 | 
 27 | Simplex::Simplex(int n, int m, double **A, double *b, double *c, double v) : n(n), m(m), v(v)
 28 | {
 29 |     this -> A = new double*[m];
 30 |     for (int i=0;i<m;i++)
 31 |     {
 32 |         this -> A[i] = new double[n+1]; // allocate +1 because of aux. LP
 33 |         for (int j=0;j<n;j++)
 34 |         {
 35 |             this -> A[i][j] = A[i][j];
 36 |         }
 37 |     }
 38 |     
 39 |     this -> b = new double[m];
 40 |     for (int i=0;i<m;i++)
 41 |     {
 42 |         this -> b[i] = b[i];
 43 |     }
 44 |     
 45 |     this -> c = new double[n+1]; // allocate +1 because of aux. LP
 46 |     for (int i=0;i<n;i++)
 47 |     {
 48 |         this -> c[i] = c[i];
 49 |     }
 50 |     
 51 |     this -> N = new int[n+1]; // allocate +1 because of aux. LP
 52 |     this -> B = new int[m];
 53 | }
 54 | 
 55 | Simplex::~Simplex()
 56 | {
 57 |     for (int i=0;i<m;i++) delete[] A[i];
 58 |     delete[] A;
 59 |     delete[] b;
 60 |     delete[] c;
 61 |     delete[] N;
 62 |     delete[] B;
 63 | }
 64 | 
 65 | // pivot yth variable around xth constraint
 66 | void Simplex::pivot(int x, int y)
 67 | {
 68 |     //printf("Pivoting variable %d around constraint %d.\n", y, x);
 69 |     total_steps++;
 70 |     
 71 |     // first rearrange the x-th row
 72 |     for (int j=0;j<n;j++)
 73 |     {
 74 |         if (j != y)
 75 |         {
 76 |             A[x][j] /= -A[x][y];
 77 |         }
 78 |     }
 79 |     b[x] /= -A[x][y];
 80 |     A[x][y] = 1.0 / A[x][y];
 81 |     
 82 |     // now rearrange the other rows
 83 |     for (int i=0;i<m;i++)
 84 |     {
 85 |         if (i != x)
 86 |         {
 87 |             for (int j=0;j<n;j++)
 88 |             {
 89 |                 if (j != y)
 90 |                 {
 91 |                     A[i][j] += A[i][y] * A[x][j];
 92 |                 }
 93 |             }
 94 |             b[i] += A[i][y] * b[x];
 95 |             A[i][y] *= A[x][y];
 96 |         }
 97 |     }
 98 |     
 99 |     // now rearrange the objective function
100 |     for (int j=0;j<n;j++)
101 |     {
102 |         if (j != y)
103 |         {
104 |             c[j] += c[y] * A[x][j];
105 |         }
106 |     }
107 |     v += c[y] * b[x];
108 |     c[y] *= A[x][y];
109 |     
110 |     // finally, swap the basic & nonbasic variable
111 |     swap(B[x], N[y]);
112 | }
113 | 
114 | // Run a single iteration of the simplex algorithm.
115 | // Returns: 0 if OK, 1 if STOP, -1 if UNBOUNDED
116 | int Simplex::iterate_simplex()
117 | {
118 |     /*
119 |      printf("--------------------\n");
120 |      printf("State:\n");
121 |      printf("Maximise: ");
122 |      for (int j=0;j<n;j++) printf("%lfx_%d + ", c[j], N[j]);
123 |      printf("%lf\n", v);
124 |      printf("Subject to:\n");
125 |      for (int i=0;i<m;i++)
126 |      {
127 |          for (int j=0;j<n;j++) printf("%lfx_%d + ", A[i][j], N[j]);
128 |          printf("%lf = x_%d\n", b[i], B[i]);
129 |      }
130 |     */
131 |     // getchar(); // uncomment this for debugging purposes!
132 |     
133 |     double v_prev = v;
134 |     
135 |     vector<int> vars;
136 |     int best_var = -1;
137 |     for (int j=0;j<n;j++)
138 |     {
139 |         if (c[j] > 0)
140 |         {
141 |             vars.push_back(j);
142 |             /* Bland's Rule
143 |             if (best_var == -1 || N[j] < ind)
144 |             {
145 |                 ind = N[j];
146 |                 best_var = j;
147 |             }
148 |             */
149 |         }
150 |     }
151 |     if (vars.empty()) return 1;
152 |     
153 |     best_var = vars[rand() % vars.size()];
154 |     
155 |     double max_constr = INFINITY;
156 |     int best_constr = -1;
157 |     for (int i=0;i<m;i++)
158 |     {
159 |         if (A[i][best_var] < 0)
160 |         {
161 |             double curr_constr = -b[i] / A[i][best_var];
162 |             if (curr_constr < max_constr)
163 |             {
164 |                 max_constr = curr_constr;
165 |                 best_constr = i;
166 |             }
167 |         }
168 |     }
169 |     if (std::isinf(max_constr)) return -1;
170 |     else pivot(best_constr, best_var);
171 |     
172 |     // underflow avoiding: round all entries that are at most 1e-3 away from an integer
173 |     for (int i=0;i<m;i++)
174 |     {
175 |         for (int j=0;j<n;j++)
176 |         {
177 |             if (fabs(ceil(A[i][j]) - A[i][j]) < EPS) A[i][j] = ceil(A[i][j]);
178 |             else if (fabs(floor(A[i][j]) - A[i][j]) < EPS) A[i][j] = floor(A[i][j]);
179 |         }
180 |     }
181 |     
182 |     for (int i=0;i<m;i++)
183 |     {
184 |         if (fabs(ceil(b[i]) - b[i]) < EPS) b[i] = ceil(b[i]);
185 |         if (fabs(floor(b[i]) - b[i]) < EPS) b[i] = floor(b[i]);
186 |     }
187 |     for (int j=0;j<n;j++)
188 |     {
189 |         if (fabs(ceil(c[j]) - c[j]) < EPS) c[j] = ceil(c[j]);
190 |         if (fabs(floor(c[j]) - c[j]) < EPS) c[j] = floor(c[j]);
191 |     }
192 |     
193 |     if (fabs(ceil(v) - v) < EPS) v = ceil(v);
194 |     if (fabs(floor(v) - v) < EPS) v = floor(v);
195 |     
196 |     if (fabs(v - v_prev) > EPS) cout << "Iteration " << total_steps << ": " << v << endl;
197 |     
198 |     return 0;
199 | }
200 | 
201 | // (Possibly) converts the LP into a slack form with a feasible basic solution.
202 | // Returns 0 if OK, -1 if INFEASIBLE
203 | int Simplex::initialise_simplex()
204 | {
205 |     total_steps = 0;
206 |     
207 |     int k = -1;
208 |     double min_b = -1;
209 |     for (int i=0;i<m;i++)
210 |     {
211 |         if (k == -1 || b[i] < min_b)
212 |         {
213 |             k = i;
214 |             min_b = b[i];
215 |         }
216 |     }
217 |     
218 |     if (b[k] >= 0) // basic solution feasible!
219 |     {
220 |         for (int j=0;j<n;j++) N[j] = j;
221 |         for (int i=0;i<m;i++) B[i] = n + i;
222 |         return 0;
223 |     }
224 |     
225 |     // generate auxiliary LP
226 |     n++;
227 |     for (int j=0;j<n;j++) N[j] = j;
228 |     for (int i=0;i<m;i++) B[i] = n + i;
229 |     
230 |     // store the objective function
231 |     double *c_old = new double[n];
232 |     for (int j=0;j<n-1;j++) c_old[j] = c[j];
233 |     double v_old = v;
234 |     
235 |     // aux. objective function
236 |     c[n-1] = -1;
237 |     for (int j=0;j<n-1;j++) c[j] = 0;
238 |     v = 0;
239 |     // aux. coefficients
240 |     for (int i=0;i<m;i++) A[i][n-1] = 1;
241 |     
242 |     // perform initial pivot
243 |     pivot(k, n - 1);
244 |     
245 |     // now solve aux. LP
246 |     int code;
247 |     while (!(code = iterate_simplex()));
248 |     
249 |     assert(code == 1); // aux. LP cannot be unbounded!!!
250 |     
251 |     if (v != 0)
252 |     {
253 |         delete[] c_old;
254 |         return -1; // infeasible!
255 |     }
256 |     
257 |     int z_basic = -1;
258 |     for (int i=0;i<m;i++)
259 |     {
260 |         if (B[i] == n - 1)
261 |         {
262 |             z_basic = i;
263 |             break;
264 |         }
265 |     }
266 |     
267 |     // if x_n basic, perform one degenerate pivot to make it nonbasic
268 |     if (z_basic != -1) pivot(z_basic, n - 1);
269 |     
270 |     int z_nonbasic = -1;
271 |     for (int j=0;j<n;j++)
272 |     {
273 |         if (N[j] == n - 1)
274 |         {
275 |             z_nonbasic = j;
276 |             break;
277 |         }
278 |     }
279 |     assert(z_nonbasic != -1);
280 |     
281 |     for (int i=0;i<m;i++)
282 |     {
283 |         A[i][z_nonbasic] = A[i][n-1];
284 |     }
285 |     swap(N[z_nonbasic], N[n - 1]);
286 |     
287 |     n--;
288 |     for (int j=0;j<n;j++) if (N[j] > n) N[j]--;
289 |     for (int i=0;i<m;i++) if (B[i] > n) B[i]--;
290 |     
291 |     for (int j=0;j<n;j++) c[j] = 0;
292 |     v = v_old;
293 |     
294 |     for (int j=0;j<n;j++)
295 |     {
296 |         bool ok = false;
297 |         for (int jj=0;jj<n;jj++)
298 |         {
299 |             if (j == N[jj])
300 |             {
301 |                 c[jj] += c_old[j];
302 |                 ok = true;
303 |                 break;
304 |             }
305 |         }
306 |         if (ok) continue;
307 |         for (int i=0;i<m;i++)
308 |         {
309 |             if (j == B[i])
310 |             {
311 |                 for (int jj=0;jj<n;jj++)
312 |                 {
313 |                     c[jj] += c_old[j] * A[i][jj];
314 |                 }
315 |                 v += c_old[j] * b[i];
316 |                 break;
317 |             }
318 |         }
319 |     }
320 |     
321 |     delete[] c_old;
322 |     return 0;
323 | }
324 | 
325 | // Runs the simplex algorithm to optimise the LP.
326 | // Returns a vector of -1s if unbounded, -2s if infeasible.
327 | tuple<vector<double>, double, int> Simplex::simplex()
328 | {
329 |     printf("Running the Simplex algorithm with %d variables and %d constraints.\n", n, m);
330 |     
331 |     if (initialise_simplex() == -1)
332 |     {
333 |         return {vector<double>(n + m, -2), INFINITY, total_steps};
334 |     }
335 |     
336 |     int code;
337 |     while (!(code = iterate_simplex()));
338 |     
339 |     if (code == -1) return {vector<double>(n + m, -1), INFINITY, total_steps};
340 |     
341 |     vector<double> ret;
342 |     ret.resize(n + m);
343 |     for (int j=0;j<n;j++)
344 |     {
345 |         ret[N[j]] = 0;
346 |     }
347 |     for (int i=0;i<m;i++)
348 |     {
349 |         ret[B[i]] = b[i];
350 |     }
351 |     
352 |     printf("Finished in %d iterations.\n", total_steps);
353 |     
354 |     return {ret, v, total_steps};
355 | }
356 | 


--------------------------------------------------------------------------------
/src/tsp_solver.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  Petar 'PetarV' Velickovic
  3 |  Linear Programming TSP Solver (Dantzig-Fulkerson-Johnson)
  4 | */
  5 | 
  6 | #include <stdio.h>
  7 | #include <math.h>
  8 | #include <string.h>
  9 | #include <assert.h>
 10 | #include <unistd.h>
 11 | #include <iostream>
 12 | #include <vector>
 13 | #include <list>
 14 | #include <string>
 15 | #include <algorithm>
 16 | #include <queue>
 17 | #include <stack>
 18 | #include <set>
 19 | #include <map>
 20 | #include <complex>
 21 | 
 22 | #include <mst.h>
 23 | #include <simplex.h>
 24 | 
 25 | #define MAX_N 5001
 26 | #define EPS 1e-5
 27 | 
 28 | typedef long long lld;
 29 | typedef unsigned long long llu;
 30 | typedef unsigned int uint;
 31 | using namespace std;
 32 | 
 33 | char path_adj[150], path_demo[150], file_graph[150], file_map[150];
 34 | char path_graph[150], path_map[150], path_pdf[150];
 35 | FILE *f_adj, *f_graph, *f_lp;
 36 | 
 37 | char cmd[150];
 38 | char cmd_map[150];
 39 | char cmd_prev[150];
 40 | 
 41 | int n;
 42 | double adj[MAX_N][MAX_N];
 43 | 
 44 | int simp_n;
 45 | double c[MAX_N * MAX_N];
 46 | 
 47 | // Constraints
 48 | vector<vector<double> > Ap;
 49 | vector<double> bp;
 50 | 
 51 | int curr_pos = 0;
 52 | stack<int> positions;
 53 | 
 54 | inline void print_delimiter()
 55 | {
 56 |     printf("---------------------------------------------------------------\n");
 57 | }
 58 | 
 59 | inline int encode_edge(int i, int j)
 60 | {
 61 |     // Precondition: i > j
 62 |     assert(i > j);
 63 |     return (((i - 1) * (i - 2)) >> 1) + (j - 1);
 64 | }
 65 | 
 66 | inline pair<int, int> decode_edge(int x)
 67 | {
 68 |     int i = 2, j = 1;
 69 |     
 70 |     while (((i * (i - 1)) >> 1) <= x) i++;
 71 |     j = x - (((i - 1) * (i - 2)) >> 1) + 1;
 72 |     
 73 |     return make_pair(i, j);
 74 | }
 75 | 
 76 | inline void dump_lp(int n, int m, double **A, double *b, double *c, double v)
 77 | {
 78 |     fprintf(f_lp, "minimise %.2lf ", v);
 79 |     for (int i=0;i<n;i++)
 80 |     {
 81 |         if (fabs(c[i]) > EPS)
 82 |         {
 83 |             fprintf(f_lp, "%c %.2lf * x_{%02d, %02d} ", (c[i] >= 0.0 ? '+' : '-'), fabs(c[i]), decode_edge(i).first, decode_edge(i).second);
 84 |         }
 85 |     }
 86 |     fprintf(f_lp, "\nsubject to\n");
 87 |     for (int i=0;i<m;i++)
 88 |     {
 89 |         fprintf(f_lp, "s_{%03d} = %.2lf ", i, b[i]);
 90 |         for (int j=0;j<n;j++)
 91 |         {
 92 |             if (fabs(A[i][j]) > EPS)
 93 |             {
 94 |                 fprintf(f_lp, "%c %.2lf * x_{%02d, %02d} ", (A[i][j] >= 0.0 ? '+' : '-'), fabs(A[i][j]), decode_edge(j).first, decode_edge(j).second);
 95 |             }
 96 |         }
 97 |         fprintf(f_lp, "\n");
 98 |     }
 99 | }
100 | 
101 | inline void dump_title(double obj, int n, int m, int iter)
102 | {
103 |     fprintf(f_graph, "\\node[] (title) at (10, 25) {\\Huge Objective value: $%lf$, $%d$ variables, $%d$ constraints, $%d$ iterations};\n", obj, n, m, iter);
104 | }
105 | 
106 | inline void dump_edge(int x, double val)
107 | {
108 |     fprintf(f_graph, "\\draw[edge,%s] (%d) to node[lab]{%g} (%d);\n", ((fabs(1.0 - val) < EPS) ? "black" : "red"), decode_edge(x).first, val, decode_edge(x).second);
109 | }
110 | 
111 | inline void write_full_edge(int x, int y)
112 | {
113 |     fprintf(f_graph, "\\draw[edge] (%d) to node[lab]{%d} (%d);\n", x, 1, y);
114 | }
115 | 
116 | char *rep_ext(char *name, const char *ext)
117 | {
118 |     char *ret = new char[150];
119 |     strcpy(ret, name);
120 |     int ii = strlen(ret) - 1;
121 |     while (ii >= 0 && ret[ii] != '.') ii--;
122 |     assert(ii >= 0);
123 |     int l = strlen(ext);
124 |     for (int i=0;i<=l;i++) // takes care of '\0' at the end as well
125 |     {
126 |         ret[ii + i] = ext[i];
127 |     }
128 |     
129 |     return ret;
130 | }
131 | 
132 | int main()
133 | {
134 |     srand(time(NULL));
135 |     
136 |     printf("Linear Programming TSP Solver, implemented by Petar Veličković.\n");
137 |     printf("Thanks to Thomas Sauerwald for the visualisation data!\n");
138 |     print_delimiter();
139 |     
140 |     printf("Enter the path to the file containing the adjacency matrix:\n");
141 |     scanf("%s", path_adj);
142 |     
143 |     if ((f_adj = fopen(path_adj, "r")) == NULL)
144 |     {
145 |         printf("Error: Adjacency matrix file could not be opened!\n");
146 |         return 1;
147 |     }
148 |     
149 |     printf("Processing adjacency matrix...\n");
150 |     if (fscanf(f_adj, "%d", &n) == 0)
151 |     {
152 |         printf("Error: Improper adjacency matrix format!\n");
153 |         return 2;
154 |     }
155 |     
156 |     printf("The graph has %d nodes.\n", n);
157 |     
158 |     for (int i=2;i<=n;i++)
159 |     {
160 |         for (int j=1;j<i;j++)
161 |         {
162 |             if (fscanf(f_adj, "%lf", &adj[i][j]) == 0)
163 |             {
164 |                 printf("Error: Improper adjacency matrix format!\n");
165 |                 return 3;
166 |             }
167 |         }
168 |     }
169 |     
170 |     fclose(f_adj);
171 |     
172 |     printf("Adjacency matrix successfully read!\n");
173 |     print_delimiter();
174 |     
175 |     printf("Generating basic constraints...\n");
176 |     
177 |     simp_n = (n * (n-1)) >> 1; // the number of edges
178 |     
179 |     // Generating objective function
180 |     for (int i=0;i<simp_n;i++)
181 |     {
182 |         c[i] = -adj[decode_edge(i).first][decode_edge(i).second];
183 |     }
184 |     
185 |     // Generating constraints
186 |     for (int i=1;i<=n;i++)
187 |     {
188 |         vector<double> constr_1(simp_n, 0.0), constr_2(simp_n, 0.0);
189 |         
190 |         for (int j=1;j<=n;j++)
191 |         {
192 |             if (j < i)
193 |             {
194 |                 constr_1[encode_edge(i, j)] = -1.0;
195 |                 constr_2[encode_edge(i, j)] = 1.0;
196 |             }
197 |             else if (j > i)
198 |             {
199 |                 constr_1[encode_edge(j, i)] = -1.0;
200 |                 constr_2[encode_edge(j, i)] = 1.0;
201 |             }
202 |         }
203 |         
204 |         Ap.push_back(constr_1);
205 |         bp.push_back(2.0);
206 |         
207 |         Ap.push_back(constr_2);
208 |         bp.push_back(-2.0);
209 |     }
210 |     
211 |     for (int i=0;i<simp_n;i++)
212 |     {
213 |         vector<double> constr(simp_n, 0.0);
214 |         constr[i] = -1.0;
215 |         
216 |         Ap.push_back(constr);
217 |         bp.push_back(1.0);
218 |     }
219 |     
220 |     curr_pos = Ap.size();
221 |     
222 |     printf("Constraints generated!\n");
223 |     print_delimiter();
224 |     
225 |     printf("Enter the path to the folder containing the demo .tex files:\n");
226 |     scanf("%s", path_demo);
227 |     print_delimiter();
228 |     
229 |     printf("Enter the name of the file containing the graph:\n");
230 |     scanf("%s", file_graph);
231 |     print_delimiter();
232 |     
233 |     strcpy(path_graph, path_demo);
234 |     strcat(path_graph, file_graph);
235 |     
236 |     printf("Enter the name of the file containing the map:\n");
237 |     scanf("%s", file_map);
238 |     print_delimiter();
239 |     
240 |     strcpy(path_map, path_demo);
241 |     strcat(path_map, file_map);
242 |     
243 |     strcpy(path_pdf, path_demo);
244 |     strcat(path_pdf, rep_ext(file_map, ".pdf"));
245 |     
246 |     
247 |     while (true)
248 |     {
249 |         printf("Enter one of the following:\n");
250 |         printf("- SOLVE : to launch the Simplex Algorithm on the constraints given thus far;\n");
251 |         printf("- REM_LOOP N x_1 x_2 ... x_N : to add a loop-removing constraint for the subset of N nodes x_1, x_2, ..., x_N;\n");
252 |         printf("- REM_LOOP_RNG lo hi : to add a loop-removing constraint for the contiguous interval of nodes [lo, hi];\n");
253 |         printf("- SET x_1 x_2 v : to add constraints that set the edge between x_1 and x_2 to v (where v is either 0 or 1);\n");
254 |         printf("- UNDO N : to remove the N previously generated constraint sets;\n");
255 |         printf("- APPROX_MST : to run the MST-based 2-approximation algorithm;\n");
256 |         printf("- EXIT : to stop the program.\n");
257 |         scanf("%s", cmd);
258 |         
259 |         if (strcmp(cmd, "SOLVE") == 0)
260 |         {
261 |             int constr_n = curr_pos;
262 |             
263 |             double **A = new double*[constr_n];
264 |             for (int i=0;i<constr_n;i++)
265 |             {
266 |                 A[i] = new double[simp_n];
267 |                 for (int j=0;j<simp_n;j++)
268 |                 {
269 |                     A[i][j] = Ap[i][j];
270 |                 }
271 |             }
272 |             
273 |             double *b = new double[constr_n];
274 |             for (int i=0;i<constr_n;i++)
275 |             {
276 |                 b[i] = bp[i];
277 |             }
278 |             
279 |             if ((f_lp = fopen("lp.txt", "w")) == NULL)
280 |             {
281 |                 printf("Error: LP dump file could not be opened\n");
282 |                 return 4;
283 |             }
284 |             
285 |             dump_lp(simp_n, constr_n, A, b, c, 0);
286 |             
287 |             fclose(f_lp);
288 |             
289 |             Simplex *s = new Simplex(simp_n, constr_n, A, b, c, 0);
290 |             auto ret = s -> simplex();
291 |             
292 |             while (std::isnan(get<1>(ret)))
293 |             {
294 |                 delete s;
295 |                 s = new Simplex(simp_n, constr_n, A, b, c, 0);
296 |                 ret = s -> simplex();
297 |             }
298 |             
299 |             delete s;
300 |             for (int i=0;i<constr_n;i++) delete[] A[i];
301 |             delete[] A;
302 |             delete[] b;
303 |             
304 |             printf("Simplex subroutine finished!\n");
305 |             
306 |             vector<double> xs = get<0>(ret);
307 |             double val = get<1>(ret);
308 |             int iters = get<2>(ret);
309 |             
310 |             if (std::isinf(val))
311 |             {
312 |                 if (xs[0] == -1) printf("Objective function unbounded!\n");
313 |                 else if (xs[0] == -2) printf("Linear program infeasible!\n");
314 |             }
315 |             
316 |             else
317 |             {
318 |                 printf("Objective value: %lf\n", val);
319 |                 
320 |                 //for (int i=0;i<simp_n;i++) if (ret.first[i] != 0) cout << ret.first[i] << endl;
321 |         
322 |                 if ((f_graph = fopen(path_graph, "w")) == NULL)
323 |                 {
324 |                     printf("Error: Graph file could not be opened!\n");
325 |                     return 4;
326 |                 }
327 |                 
328 |                 dump_title(val, simp_n, constr_n, iters);
329 |                 
330 |                 for (int i=0;i<simp_n;i++)
331 |                 {
332 |                     if (xs[i] > 0) dump_edge(i, xs[i]);
333 |                 }
334 |             
335 |                 fclose(f_graph);
336 |             
337 |                 printf("Results written to the graph file! Compiling the map...\n");
338 |                 
339 |                 sprintf(cmd_map, "(cd %s && exec pdflatex %s &> /dev/null)", path_demo, file_map);
340 |                 
341 |                 system(cmd_map);
342 |                 
343 |                 printf("Map compiled!\n");
344 | #ifdef __APPLE__
345 |                 // These shell instructions will work only on OS X
346 |                 sprintf(cmd_prev, "killall qlmanage &> /dev/null; qlmanage -p %s &> /dev/null &", path_pdf);
347 |                 
348 |                 printf("%s\n", cmd_prev);
349 |                 
350 |                 system(cmd_prev);
351 | #endif
352 |             }
353 |             
354 |             print_delimiter();
355 |         }
356 |         
357 |         else if (strcmp(cmd, "REM_LOOP") == 0)
358 |         {
359 |             int num;
360 |             scanf("%d", &num);
361 |             
362 |             vector<int> vals(num);
363 |             for (int i=0;i<num;i++) scanf("%d", &vals[i]);
364 |             
365 |             vector<double> constr(simp_n, 0.0);
366 |             
367 |             for (int i=0;i<num;i++)
368 |             {
369 |                 for (int j=i+1;j<num;j++)
370 |                 {
371 |                     if (vals[i] > vals[j]) constr[encode_edge(vals[i], vals[j])] = -1.0;
372 |                     else if (vals[i] < vals[j]) constr[encode_edge(vals[j], vals[i])] = -1.0;
373 |                 }
374 |             }
375 |             
376 |             double val = num - 1.0;
377 |             
378 |             if (curr_pos == (int)Ap.size())
379 |             {
380 |                 Ap.push_back(constr);
381 |                 bp.push_back(val);
382 |             }
383 |             else
384 |             {
385 |                 Ap[curr_pos] = constr;
386 |                 bp[curr_pos] = val;
387 |             }
388 |             
389 |             positions.push(curr_pos);
390 |             curr_pos++;
391 |             
392 |             printf("Loop-removing constraint added!\n");
393 |             print_delimiter();
394 |         }
395 |         
396 |         else if (strcmp(cmd, "REM_LOOP_RNG") == 0)
397 |         {
398 |             int lo, hi;
399 |             scanf("%d%d", &lo, &hi);
400 |             
401 |             assert(hi >= lo);
402 |             
403 |             int num = hi - lo + 1;
404 |             vector<int> vals(num);
405 |             for (int i=0;i<num;i++) vals[i] = lo + i;
406 |             
407 |             vector<double> constr(simp_n, 0.0);
408 |             
409 |             for (int i=0;i<num;i++)
410 |             {
411 |                 for (int j=i+1;j<num;j++)
412 |                 {
413 |                     if (vals[i] > vals[j]) constr[encode_edge(vals[i], vals[j])] = -1.0;
414 |                     else if (vals[i] < vals[j]) constr[encode_edge(vals[j], vals[i])] = -1.0;
415 |                 }
416 |             }
417 |             
418 |             double val = num - 1.0;
419 |             
420 |             if (curr_pos == (int)Ap.size())
421 |             {
422 |                 Ap.push_back(constr);
423 |                 bp.push_back(val);
424 |             }
425 |             else
426 |             {
427 |                 Ap[curr_pos] = constr;
428 |                 bp[curr_pos] = val;
429 |             }
430 |             
431 |             positions.push(curr_pos);
432 |             curr_pos++;
433 |             
434 |             printf("Loop-removing constraint added!\n");
435 |             print_delimiter();
436 |         }
437 |         
438 |         else if (strcmp(cmd, "SET") == 0)
439 |         {
440 |             // x(i, j) = v
441 |             int x, y, v;
442 |             scanf("%d%d%d", &x, &y, &v);
443 |             
444 |             vector<double> constr1(simp_n, 0.0), constr2(simp_n, 0.0);
445 |             
446 |             if (x > y)
447 |             {
448 |                 constr1[encode_edge(x, y)] = -1.0;
449 |                 constr2[encode_edge(x, y)] = 1.0;
450 |             }
451 |             else if (x < y)
452 |             {
453 |                 constr1[encode_edge(y, x)] = -1.0;
454 |                 constr2[encode_edge(y, x)] = 1.0;
455 |             }
456 |             
457 |             positions.push(curr_pos);
458 |             
459 |             if (curr_pos == (int)Ap.size())
460 |             {
461 |                 Ap.push_back(constr1);
462 |                 bp.push_back(v);
463 |             }
464 |             else
465 |             {
466 |                 Ap[curr_pos] = constr1;
467 |                 bp[curr_pos] = v;
468 |             }
469 |             
470 |             curr_pos++;
471 |             
472 |             if (v == 1)
473 |             {
474 |                 if (curr_pos == (int)Ap.size())
475 |                 {
476 |                     Ap.push_back(constr2);
477 |                     bp.push_back(-1.0);
478 |                 }
479 |                 else
480 |                 {
481 |                     Ap[curr_pos] = constr2;
482 |                     bp[curr_pos] = -1.0;
483 |                 }
484 |                 
485 |                 curr_pos++;
486 |             }
487 |             
488 |             printf("Value setting constraints added!\n");
489 |             print_delimiter();
490 |         }
491 |         
492 |         else if (strcmp(cmd, "UNDO") == 0)
493 |         {
494 |             int steps;
495 |             scanf("%d", &steps);
496 |             
497 |             bool done = true;
498 |             
499 |             while (steps--)
500 |             {
501 |                 if (positions.empty())
502 |                 {
503 |                     printf("There's nothing to undo!\n");
504 |                     print_delimiter();
505 |                     done = false;
506 |                     break;
507 |                 }
508 |             
509 |                 curr_pos = positions.top();
510 |                 positions.pop();
511 |             }
512 |             
513 |             if (!done) continue;
514 |             
515 |             printf("Previous generated constraint set(s) removed!\n");
516 |             print_delimiter();
517 |         }
518 |         
519 |         else if (strcmp(cmd, "APPROX_MST") == 0)
520 |         {
521 |             auto mst_sol = tsp_mst(n, adj);
522 |             
523 |             printf("Objective value: %lf\n", mst_sol.first);
524 |             
525 |             //for (int i=0;i<simp_n;i++) if (ret.first[i] != 0) cout << ret.first[i] << endl;
526 |             
527 |             if ((f_graph = fopen(path_graph, "w")) == NULL)
528 |             {
529 |                 printf("Error: Graph file could not be opened!\n");
530 |                 return 4;
531 |             }
532 |             
533 |             for (uint i=0;i<mst_sol.second.size();i++)
534 |             {
535 |                 write_full_edge(mst_sol.second[i].first, mst_sol.second[i].second);
536 |             }
537 |             
538 |             fclose(f_graph);
539 |             
540 |             printf("Results written to the graph file! Compiling the map...\n");
541 |             
542 |             sprintf(cmd_map, "(cd %s && exec pdflatex %s &> /dev/null)", path_demo, file_map);
543 |             
544 |             system(cmd_map);
545 |             
546 |             printf("Map compiled!\n");
547 | #ifdef __APPLE__
548 |             // These shell instructions will work only on OS X
549 |             sprintf(cmd_prev, "killall qlmanage &> /dev/null; qlmanage -p %s &> /dev/null &", path_pdf);
550 |             
551 |             printf("%s\n", cmd_prev);
552 |             
553 |             system(cmd_prev);
554 | #endif
555 |             print_delimiter();
556 |         }
557 |         
558 |         else if (strcmp(cmd, "EXIT") == 0)
559 |         {
560 |             break;
561 |         }
562 |         
563 |         else
564 |         {
565 |             printf("Incorrectly entered command! Try again.\n");
566 |             print_delimiter();
567 |         }
568 |     }
569 |     
570 |     return 0;
571 | }
572 | 


--------------------------------------------------------------------------------