├── .gitignore ├── 1sem ├── task1 │ ├── 1_1.cpp │ ├── 2_1.cpp │ ├── 3_1.cpp │ ├── 4_1.cpp │ ├── 5_1.cpp │ └── 6_1.cpp ├── task2 │ ├── 1_1.cpp │ ├── 2_1.cpp │ ├── 3_1.cpp │ ├── 4_1.cpp │ └── 5_1.cpp ├── task3 │ ├── 4 │ │ ├── Huffman.cpp │ │ └── Huffman.h │ ├── 1_1.cpp │ ├── 2_1.cpp │ └── 3_2.cpp └── task4 │ ├── 1.cpp │ ├── 2_1.cpp │ ├── 3_1.cpp │ └── 4_1.cpp ├── 2sem ├── task1 │ ├── 1 │ │ ├── include │ │ │ ├── CArcGraph.h │ │ │ ├── CListGraph.h │ │ │ ├── CMatrixGraph.h │ │ │ ├── CSetGraph.h │ │ │ └── IGraph.h │ │ └── src │ │ │ ├── CArcGraph.cpp │ │ │ ├── CListgraph.cpp │ │ │ ├── CMatrixGraph.cpp │ │ │ ├── CSetGraph.cpp │ │ │ └── main.cpp │ ├── 2 │ │ └── main.cpp │ ├── 3 │ │ ├── a.out │ │ └── main.cpp │ ├── 4 │ │ └── main.cpp │ ├── 5 │ │ ├── main.cpp │ │ └── temp │ └── 6 │ │ └── main.cpp ├── task2 │ ├── 1 │ │ ├── int_main │ │ └── main.cpp │ ├── 2 │ │ └── main.cpp │ ├── 3 │ │ ├── main.cpp │ │ ├── puzzle.in │ │ └── puzzle.out │ ├── 4 │ │ ├── input.txt │ │ ├── main.cpp │ │ └── output.txt │ ├── 5 │ │ ├── main.cpp │ │ ├── puzzle.in │ │ ├── puzzle.out │ │ └── working │ └── 6 │ │ ├── floyd.in │ │ ├── floyd.out │ │ └── main.cpp ├── task3 │ ├── 1 │ │ ├── kruskal.in │ │ ├── kruskal.out │ │ └── main.cpp │ ├── 2 │ │ ├── 2_Traveling_Salesman_Problem_Valentinov.zip │ │ ├── dots.txt │ │ ├── include │ │ │ ├── MST.h │ │ │ ├── TSP_BF.h │ │ │ ├── TSP_MST.h │ │ │ ├── checker.h │ │ │ ├── dots.h │ │ │ └── graph.h │ │ ├── log.txt │ │ └── src │ │ │ ├── MST.cpp │ │ │ ├── TSP_BF.cpp │ │ │ ├── TSP_MST.cpp │ │ │ ├── checker.cpp │ │ │ ├── dots.cpp │ │ │ ├── graph.cpp │ │ │ └── main.cpp │ ├── 3 │ │ ├── main.cpp │ │ ├── maxflow.in │ │ └── maxflow.out │ └── 4 │ │ ├── input.txt │ │ ├── main.cpp │ │ └── output.txt └── task4 │ ├── 1 │ └── main.cpp │ ├── 2 │ └── main.cpp │ ├── 3 │ └── main.cpp │ └── 4 │ └── main.cpp ├── 3sem ├── task1 │ ├── 1 │ │ └── main.cpp │ ├── 2 │ │ ├── a.out │ │ ├── input.txt │ │ ├── main.cpp │ │ └── output.txt │ ├── 3 │ │ ├── input.txt │ │ └── main.cpp │ └── 4 │ │ └── main.cpp ├── task2 │ └── 1 │ │ └── main.cpp ├── task3 │ ├── 1 │ │ └── main.cpp │ ├── 2 │ │ ├── a.out │ │ ├── input.txt │ │ └── main.cpp │ ├── 3 │ │ └── main.cpp │ └── 4 │ │ ├── input.txt │ │ └── main.cpp └── task4 │ ├── 1 │ ├── biginteger.h │ └── main.cpp │ ├── 2 │ └── fft.ipynb │ ├── 3 │ └── main.cpp │ └── 3a │ └── main.cpp ├── README.md └── algorithms_and_structures ├── algotithms ├── Huffman │ ├── Huffman.cpp │ ├── Huffman.h │ └── main.cpp └── kStat.cpp ├── other ├── Tim.cpp └── treeTests └── structures ├── AVL.cpp ├── BST.cpp ├── Deque.cpp ├── HashTable.cpp ├── Heap.cpp ├── MaxHeap.cpp ├── MinHeap.cpp ├── Queue.cpp ├── Stack.cpp ├── StackQueue.cpp ├── Treap.cpp └── bad ├── BST_Recursive ├── Ditch ├── HT └── dinMassive /.gitignore: -------------------------------------------------------------------------------- 1 | .idea 2 | cmake-build-debug 3 | CMakeLists.txt 4 | -------------------------------------------------------------------------------- /1sem/task1/1_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | int main(){ 7 | int n; 8 | cin >> n; 9 | cout << n / 5 + n / 25 + n / 125 + n / 625; 10 | } 11 | -------------------------------------------------------------------------------- /1sem/task1/2_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | int main(){ 7 | int n; 8 | cin >> n; 9 | int * a = new int[n]; 10 | int * b = new int[n]; 11 | 12 | for(int i = 0; i < n; i++) 13 | cin >> a[i]; 14 | for(int i = 0; i < n; i++) 15 | cin >> b[i]; 16 | 17 | int aCurrMax = 0; 18 | int aMax = 0; 19 | int bMax = 0; 20 | for(int i = 1; i < n; i++){ 21 | if(a[i] > a[aCurrMax]) 22 | aCurrMax = i; 23 | if(a[aCurrMax] + b[i] > a[aMax] + b[bMax]){ 24 | aMax = aCurrMax; 25 | bMax = i; 26 | } 27 | } 28 | 29 | cout << aMax << ' ' << bMax; 30 | 31 | delete[] a; 32 | delete[] b; 33 | } 34 | -------------------------------------------------------------------------------- /1sem/task1/3_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | int find(int * const arr, int key, int p, int r){ 7 | int c = (p + r)/2; 8 | if(arr[c] < key) 9 | return find(arr, key, c + 1, p); 10 | else if(key <= arr[c] && (c - 1 < 0 || arr[c - 1] < key)) 11 | return c; 12 | else 13 | return find(arr, key, p, c - 1); 14 | } 15 | 16 | int main(){ 17 | int n, m; 18 | cin >> n >> m; 19 | int * a = new int[n]; 20 | int * b = new int[m]; 21 | 22 | for(int i = 0; i < n; i++) 23 | cin >> a[i]; 24 | for(int i = 0; i < m; i++) 25 | cin >> b[i]; 26 | 27 | for(int i = 0; i < m; i++) 28 | if(b[i] <= a[n - 1]) 29 | cout << find(a, b[i], 0, n - 1) << ' '; 30 | else 31 | cout << n << ' '; 32 | 33 | delete[] a; 34 | delete[] b; 35 | } 36 | -------------------------------------------------------------------------------- /1sem/task1/4_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | template 7 | class Queue{ 8 | public: 9 | Queue(); 10 | 11 | ~Queue(); 12 | 13 | void enqueue(T val); 14 | void print(); 15 | 16 | T dequeue(); 17 | 18 | int size(); 19 | 20 | private: 21 | void grow(); 22 | 23 | T * buffer_; 24 | 25 | int bufferSize_; 26 | int size_; 27 | int beg_; 28 | int end_; 29 | }; 30 | 31 | /****************************MAIN**********************************************/ 32 | 33 | int main(){ 34 | int n; 35 | bool success = true; 36 | cin >> n; 37 | Queue queue; 38 | for(int i = 0; i < n; i++) { 39 | int a, b; 40 | cin >> a >> b; 41 | if (a == 2) { 42 | if (b != ((queue.size() == 0) ? (-1) : (queue.dequeue()))) 43 | success = false; 44 | } 45 | else 46 | queue.enqueue(b); 47 | } 48 | if(success) 49 | cout << "YES"; 50 | else 51 | cout << "NO"; 52 | } 53 | 54 | /****************************QUEUE*********************************************/ 55 | 56 | // Public: 57 | 58 | template 59 | Queue::Queue(): 60 | bufferSize_(8), 61 | size_(0), 62 | beg_(0), 63 | end_(0) 64 | { 65 | buffer_ = new T[bufferSize_]; 66 | } 67 | 68 | 69 | 70 | template 71 | Queue::~Queue(){ 72 | delete[] buffer_; 73 | } 74 | 75 | 76 | 77 | template 78 | void Queue::enqueue(T val){ 79 | if(size_ != 0) 80 | end_ = (end_ + 1) % bufferSize_; 81 | buffer_[end_] = val; 82 | size_++; 83 | if(size_ == bufferSize_) 84 | grow(); 85 | } 86 | 87 | 88 | 89 | template 90 | void Queue::print(){ 91 | for(int i = 0; i < bufferSize_; i++) 92 | std::cout << buffer_[i] << ' '; 93 | std::cout << '\n'; 94 | } 95 | 96 | 97 | 98 | template 99 | T Queue::dequeue(){ 100 | T val = buffer_[beg_]; 101 | if(size_ != 1) 102 | beg_ = (beg_ + 1) % bufferSize_; 103 | size_--; 104 | return val; 105 | } 106 | 107 | 108 | 109 | template 110 | int Queue::size(){ 111 | return size_; 112 | } 113 | 114 | // Private: 115 | 116 | template 117 | void Queue::grow(){ 118 | T * tmp = buffer_; 119 | bufferSize_ *= 2; 120 | buffer_ = new T[bufferSize_]; 121 | for(int i = beg_; i < size_; i++) 122 | buffer_[i - beg_] = tmp[i]; 123 | if(beg_ != 0) 124 | for(int i = 0; i < end_ + 1; i++) 125 | buffer_[i + size_ - beg_] = tmp[i]; 126 | beg_ = 0; 127 | end_ = size_ - 1; 128 | delete[] tmp; 129 | } 130 | -------------------------------------------------------------------------------- /1sem/task1/5_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::string; 4 | using std::cin; 5 | using std::cout; 6 | 7 | //Stack v0.3.2 8 | template 9 | class Stack{ 10 | public: 11 | Stack(); 12 | ~Stack(); 13 | void push(T val); 14 | T pop(); 15 | T min(); 16 | T max(); 17 | int size(); 18 | T back(); 19 | void clear(); 20 | 21 | template 22 | friend void popPush (Stack & popFrom, Stack & pushTo); 23 | 24 | private: 25 | struct Node{ 26 | T val; 27 | T min; 28 | T max; 29 | Node * next; 30 | }; 31 | 32 | Node * top_; 33 | int size_; 34 | }; 35 | 36 | //============================================================================= 37 | 38 | bool matches(char L, char R); 39 | 40 | bool isOpening(char val); 41 | 42 | char getMatching(char val); 43 | 44 | //============================================================================= 45 | 46 | int main(){ 47 | Stack stack1, stack2; 48 | string str; 49 | 50 | cin >> str; 51 | int len = str.length(); 52 | for(int i = 0; i < len; i++){ 53 | if(str[i] == '\n') 54 | break; 55 | if(stack1.size() > 0 && matches(stack1.back(), str[i])) 56 | stack1.pop(); 57 | else 58 | stack1.push(str[i]); 59 | } 60 | 61 | string beg; 62 | string end; 63 | 64 | while(stack1.size() > 0 && isOpening(stack1.back())) 65 | end.push_back(getMatching(stack1.pop())); 66 | 67 | while(stack1.size() > 0) 68 | popPush(stack1, stack2); 69 | 70 | while(stack2.size() > 0 && !isOpening(stack2.back())) 71 | beg.push_back(getMatching(stack2.pop())); 72 | 73 | if(stack2.size() == 0){ 74 | len = beg.length(); 75 | 76 | for (int i = 0; i < len; i++) 77 | cout << beg[len - 1 - i]; 78 | cout << str; 79 | cout << end; 80 | } 81 | else{ 82 | cout << "IMPOSSIBLE\n"; 83 | } 84 | 85 | return 0; 86 | } 87 | 88 | //============================================================================= 89 | 90 | bool matches(char R, char L){ 91 | if(R == '(') 92 | return L == ')'; 93 | else 94 | return R + 2 == L; 95 | } 96 | 97 | 98 | 99 | bool isOpening(char val){ 100 | return val == '(' || val == '[' || val == '{'; 101 | } 102 | 103 | 104 | 105 | char getMatching(char val){ 106 | if(val == '(') 107 | return ')'; 108 | if(val == ')') 109 | return '('; 110 | if(val == '{') 111 | return '}'; 112 | if(val == '}') 113 | return '{'; 114 | if(val == '[') 115 | return ']'; 116 | return '['; 117 | } 118 | 119 | //===========================STACK============================================= 120 | 121 | template 122 | Stack::Stack(){ 123 | top_ = NULL; 124 | size_ = 0; 125 | } 126 | 127 | template 128 | Stack::~Stack(){ 129 | clear(); 130 | } 131 | 132 | template 133 | void Stack::push(T val){ 134 | Node * tmp = new Node; 135 | tmp->val = val; 136 | tmp->next = top_; 137 | top_ = tmp; 138 | size_++; 139 | if(size_ <= 1){ 140 | top_->min = val; 141 | top_->max = val; 142 | } 143 | else{ 144 | top_->min = (top_->next->min > val)?val:top_->next->min; 145 | top_->max = (top_->next->max < val)?val:top_->next->max; 146 | } 147 | } 148 | 149 | template 150 | T Stack::pop(){ 151 | if(size_ == 0){ 152 | std::cerr << "Stack::pop() : Empty stack\n"; 153 | } 154 | Node * tmp = top_; 155 | top_ = top_->next; 156 | size_--; 157 | T val = tmp->val; 158 | delete tmp; 159 | return val; 160 | } 161 | 162 | template 163 | T Stack::min(){ 164 | if(size_ == 0) 165 | std::cerr << "Stack::min() : Empty stack\n"; 166 | return top_->min; 167 | } 168 | 169 | template 170 | T Stack::max(){ 171 | if(size_ == 0) 172 | std::cerr << "Stack::max() : Empty stack\n"; 173 | return top_->max; 174 | } 175 | 176 | template 177 | int Stack::size(){ 178 | return size_; 179 | } 180 | 181 | template 182 | T Stack::back(){ 183 | if(size_ == 0){ 184 | std::cerr << "Stack::back() : Empty stack\n"; 185 | } 186 | return top_->val; 187 | } 188 | 189 | template 190 | void Stack::clear(){ 191 | while(size_ != 0){ 192 | Node * tmp = top_; 193 | top_ = top_->next; 194 | delete tmp; 195 | size_--; 196 | } 197 | top_ = NULL; 198 | } 199 | 200 | template 201 | void popPush(Stack & popFrom, Stack & pushTo){ 202 | if(popFrom.size_ == 0){ 203 | std::cerr << "popPush() : Empty stack\n"; 204 | } 205 | typename Stack::Node * tmp = popFrom.top_; 206 | popFrom.top_ = popFrom.top_->next; 207 | popFrom.size_--; 208 | 209 | tmp->next = pushTo.top_; 210 | pushTo.top_ = tmp; 211 | pushTo.size_++; 212 | if(pushTo.size_ <= 1){ 213 | pushTo.top_->min = pushTo.top_->val; 214 | pushTo.top_->max = pushTo.top_->val; 215 | } 216 | else{ 217 | pushTo.top_->min = (pushTo.top_->next->min > pushTo.top_->val)?pushTo.top_->val:pushTo.top_->next->min; 218 | pushTo.top_->max = (pushTo.top_->next->max < pushTo.top_->val)?pushTo.top_->val:pushTo.top_->next->max; 219 | } 220 | } 221 | -------------------------------------------------------------------------------- /1sem/task1/6_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | //Heap v1.0.1 7 | template 8 | class Heap{ 9 | public: 10 | Heap(); 11 | ~Heap(); 12 | void insert(T val); 13 | int size(); 14 | void clear(); 15 | // void print(); 16 | void append(T val); 17 | 18 | protected: 19 | virtual void siftUp(int index) = 0; 20 | virtual void siftDown(int index) = 0; 21 | 22 | T extract_top(); 23 | T get_top(); 24 | 25 | T * buffer_; 26 | int defaultSize_; 27 | int bufferSize_; 28 | int size_; 29 | }; 30 | 31 | //============================================================================= 32 | 33 | //Heap v1 Required 34 | 35 | //MaxHeap v0.0.1 36 | template 37 | class MaxHeap: public Heap{ 38 | private: 39 | void siftUp(int index); 40 | void siftDown(int index); 41 | 42 | public: 43 | T extract_max(); 44 | T get_max(); 45 | }; 46 | 47 | //============================================================================= 48 | 49 | int main(){ 50 | MaxHeap maxHeap; 51 | MaxHeap container; 52 | int n, k; 53 | cin >> n; 54 | for(int i = 0; i < n; i++){ 55 | int x; 56 | cin >> x; 57 | maxHeap.append(x); 58 | } 59 | cin >> k; 60 | int counter = 0; 61 | while(maxHeap.size() > 0){ 62 | int currMass = 0; 63 | while(maxHeap.size() > 0 && currMass + maxHeap.get_max() <= k) { 64 | currMass += maxHeap.get_max(); 65 | container.append(maxHeap.extract_max() / 2); 66 | } 67 | while(container.size() > 0){ 68 | int val = container.extract_max(); 69 | if(val != 0) 70 | maxHeap.append(val); 71 | } 72 | counter++; 73 | } 74 | 75 | cout << counter; 76 | } 77 | 78 | //===========================HEAP============================================== 79 | 80 | template 81 | Heap::Heap(): 82 | defaultSize_(16), 83 | bufferSize_(defaultSize_), 84 | size_(0) 85 | { 86 | buffer_ = new T[bufferSize_]; 87 | } 88 | 89 | template 90 | Heap::~Heap(){ 91 | delete[] buffer_; 92 | } 93 | 94 | template 95 | void Heap::insert(T val){ 96 | if(size_ + 1 > bufferSize_){ 97 | T * tmp = new T[bufferSize_*2]; 98 | for(int i = 0; i < bufferSize_; i++) 99 | tmp[i] = buffer_[i]; 100 | delete[] buffer_; 101 | buffer_ = tmp; 102 | bufferSize_ *= 2; 103 | } 104 | buffer_[size_] = val; 105 | size_++; 106 | siftUp(size_ - 1); 107 | } 108 | 109 | template 110 | T Heap::extract_top(){ 111 | if(!size_) 112 | std::cerr << "Heap::extract_top : Empty heap\n"; 113 | T min = buffer_[0]; 114 | buffer_[0] = buffer_[size_ - 1]; 115 | size_--; 116 | if(size_) 117 | siftDown(0); 118 | return min; 119 | } 120 | 121 | template 122 | T Heap::get_top(){ 123 | if(!size_) 124 | std::cerr << "Heap::get_top : Empty heap\n"; 125 | return buffer_[0]; 126 | } 127 | 128 | template 129 | int Heap::size(){ 130 | return size_; 131 | } 132 | 133 | template 134 | void Heap::clear(){ 135 | delete[] buffer_; 136 | buffer_ = new T[defaultSize_]; 137 | bufferSize_ = defaultSize_; 138 | size_ = 0; 139 | } 140 | 141 | /*template 142 | void Heap::print(){ 143 | for(int i = 0; i < size_; i++) 144 | printf("%d ", buffer_[i]); 145 | printf("\n"); 146 | }*/ 147 | 148 | template 149 | void Heap::append(T val){ 150 | if(size_ + 1 > bufferSize_){ 151 | T * tmp = new T[bufferSize_*2]; 152 | for(int i = 0; i < bufferSize_; i++) 153 | tmp[i] = buffer_[i]; 154 | delete[] buffer_; 155 | buffer_ = tmp; 156 | bufferSize_ *= 2; 157 | } 158 | buffer_[size_] = val; 159 | size_++; 160 | siftUp(size_ - 1); 161 | } 162 | 163 | //===========================MAXHEAP=========================================== 164 | 165 | template 166 | void MaxHeap::siftUp(int index){ 167 | if(index >= this->size_) 168 | std::cerr << "Heap::siftUp : Wrong index\n"; 169 | while(index && this->buffer_[index] > this->buffer_[(index - 1)/2]){ 170 | T tmp = this->buffer_[index]; 171 | this->buffer_[index] = this->buffer_[(index - 1)/2]; 172 | this->buffer_[(index - 1)/2] = tmp; 173 | index = (index - 1)/2; 174 | } 175 | } 176 | 177 | template 178 | void MaxHeap::siftDown(int index){ 179 | if(index >= this->size_) 180 | std::cerr << "Heap::siftDown : Wrong index\n"; 181 | int max = index; 182 | if(index*2 + 1 < this->size_ && this->buffer_[index*2 + 1] > this->buffer_[max]) 183 | max = index*2 + 1; 184 | if(index*2 + 2 < this->size_ && this->buffer_[index*2 + 2] > this->buffer_[max]) 185 | max = index*2 + 2; 186 | if(max != index){ 187 | T tmp = this->buffer_[index]; 188 | this->buffer_[index] = this->buffer_[max]; 189 | this->buffer_[max] = tmp; 190 | siftDown(max); 191 | } 192 | } 193 | 194 | template 195 | T MaxHeap::extract_max(){ 196 | return this->extract_top(); 197 | } 198 | 199 | template 200 | T MaxHeap::get_max(){ 201 | return this->get_top(); 202 | } 203 | -------------------------------------------------------------------------------- /1sem/task2/1_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | bool fit(double* first, double* second){ 6 | if(first[1] < second[1] && first[2] < second[2] && first[3] < second[3] || 7 | first[1] < second[2] && first[2] < second[3] && first[3] < second[1] || 8 | first[1] < second[3] && first[2] < second[1] && first[3] < second[2] || 9 | first[1] < second[1] && first[2] < second[3] && first[3] < second[2] || 10 | first[1] < second[2] && first[2] < second[1] && first[3] < second[3] || 11 | first[1] < second[3] && first[2] < second[2] && first[3] < second[1]){ 12 | return true; 13 | } 14 | return false; 15 | } 16 | 17 | int main() { 18 | int n; 19 | cin >> n; 20 | double** a = new double*[n]; 21 | for(int i = 0; i < n; i++){ 22 | a[i] = new double[4]; 23 | } 24 | 25 | for(int i = 0; i < n; i++){ 26 | a[i][0] = i; 27 | cin >> a[i][1] >> a[i][2] >> a[i][3]; 28 | } 29 | 30 | for(int i = 1; i < n; i++){ 31 | double* x = a[i]; 32 | int j = i -1; 33 | while(j >= 0 && fit(x, a[j])){ 34 | a[j+1] = a[j]; 35 | j--; 36 | } 37 | a[j+1] = x; 38 | } 39 | 40 | for(int i = 0; i < n; i++){ 41 | cout << a[i][0] << ' '; 42 | } 43 | 44 | for(int i = 0; i < n; i++){ 45 | delete[] a[i]; 46 | } 47 | delete[] a; 48 | } 49 | -------------------------------------------------------------------------------- /1sem/task2/2_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | template 7 | struct Heap{ 8 | Heap(); 9 | 10 | ~Heap(); 11 | 12 | void siftUp(int index); 13 | void siftDown(int index); 14 | void insert(T val); 15 | void clear(); 16 | void print(); 17 | void append(T val); 18 | void sort(); 19 | 20 | T extract_max(); 21 | T get_max(); 22 | 23 | int size(); 24 | 25 | T * buffer; 26 | 27 | int defaultSize; 28 | int bufferSize; 29 | int size_; 30 | }; 31 | 32 | struct Customer{ 33 | int beg; 34 | int end; 35 | int ads; 36 | 37 | Customer(); 38 | Customer(int beg, int end); 39 | 40 | friend bool operator > (const Customer & L, const Customer & R); 41 | }; 42 | 43 | //============================================================================= 44 | 45 | void increase(Customer * arr, int n, int start, int adTime){ 46 | for(int i = start; i < n; i++){ 47 | if(arr[i].beg <= adTime) 48 | arr[i].ads++; 49 | else 50 | break; 51 | } 52 | } 53 | 54 | //============================================================================= 55 | 56 | int main(){ 57 | int n; 58 | cin >> n; 59 | Heap heap; 60 | for(int i = 0; i < n; i++){ 61 | int beg, end; 62 | cin >> beg >> end; 63 | Customer customer(beg, end); 64 | heap.append(customer); 65 | } 66 | heap.sort(); 67 | Customer * arr = heap.buffer; 68 | int ads = 0; 69 | for(int i = 0; i < n; i++){ 70 | if(arr[i].ads == 0){ 71 | increase(arr, n, i, arr[i].end - 1); 72 | ads++; 73 | } 74 | if(arr[i].ads == 1){ 75 | increase(arr, n, i, arr[i].end); 76 | ads++; 77 | } 78 | } 79 | 80 | cout << ads; 81 | } 82 | 83 | //===========================CUSTOMER========================================== 84 | 85 | Customer::Customer(int beg, int end): 86 | beg(beg), 87 | end(end), 88 | ads(0) 89 | {} 90 | 91 | Customer::Customer(){} 92 | 93 | bool operator > (const Customer & L, const Customer & R){ 94 | if(L.end > R.end) 95 | return true; 96 | if(L.end == R.end) 97 | return L.beg < R.beg; 98 | return false; 99 | } 100 | 101 | //===========================HEAP============================================== 102 | 103 | template 104 | Heap::Heap(): 105 | defaultSize(16), 106 | bufferSize(defaultSize), 107 | size_(0) 108 | { 109 | buffer = new T[bufferSize]; 110 | } 111 | 112 | template 113 | Heap::~Heap(){ 114 | delete[] buffer; 115 | } 116 | 117 | template 118 | void Heap::siftUp(int index){ 119 | if(index >= this->size_) 120 | std::cerr << "Heap::siftUp : Wrong index\n"; 121 | while(index && this->buffer[index] > this->buffer[(index - 1)/2]){ 122 | T tmp = this->buffer[index]; 123 | this->buffer[index] = this->buffer[(index - 1)/2]; 124 | this->buffer[(index - 1)/2] = tmp; 125 | index = (index - 1)/2; 126 | } 127 | } 128 | 129 | template 130 | void Heap::siftDown(int index){ 131 | if(index >= this->size_) 132 | std::cerr << "Heap::siftDown : Wrong index\n"; 133 | int max = index; 134 | if(index*2 + 1 < this->size_ && this->buffer[index*2 + 1] > this->buffer[max]) 135 | max = index*2 + 1; 136 | if(index*2 + 2 < this->size_ && this->buffer[index*2 + 2] > this->buffer[max]) 137 | max = index*2 + 2; 138 | if(max != index){ 139 | T tmp = this->buffer[index]; 140 | this->buffer[index] = this->buffer[max]; 141 | this->buffer[max] = tmp; 142 | siftDown(max); 143 | } 144 | } 145 | 146 | template 147 | void Heap::insert(T val){ 148 | if(size_ + 1 > bufferSize){ 149 | T * tmp = new T[bufferSize*2]; 150 | for(int i = 0; i < bufferSize; i++) 151 | tmp[i] = buffer[i]; 152 | delete[] buffer; 153 | buffer = tmp; 154 | bufferSize *= 2; 155 | } 156 | buffer[size_] = val; 157 | size_++; 158 | siftUp(size_ - 1); 159 | } 160 | 161 | template 162 | T Heap::extract_max(){ 163 | if(!size_) 164 | std::cerr << "Heap::extract_top : Empty heap\n"; 165 | T min = buffer[0]; 166 | buffer[0] = buffer[size_ - 1]; 167 | size_--; 168 | if(size_) 169 | siftDown(0); 170 | return min; 171 | } 172 | 173 | template 174 | T Heap::get_max(){ 175 | if(!size_) 176 | std::cerr << "Heap::get_top : Empty heap\n"; 177 | return buffer[0]; 178 | } 179 | 180 | template 181 | int Heap::size(){ 182 | return size_; 183 | } 184 | 185 | template 186 | void Heap::clear(){ 187 | delete[] buffer; 188 | buffer = new T[defaultSize]; 189 | bufferSize = defaultSize; 190 | size_ = 0; 191 | } 192 | 193 | template 194 | void Heap::print(){ 195 | for(int i = 0; i < size_; i++) 196 | printf("%d ", buffer[i]); 197 | printf("\n"); 198 | } 199 | 200 | template 201 | void Heap::append(T val){ 202 | if(size_ + 1 > bufferSize){ 203 | T * tmp = new T[bufferSize*2]; 204 | for(int i = 0; i < bufferSize; i++) 205 | tmp[i] = buffer[i]; 206 | delete[] buffer; 207 | buffer = tmp; 208 | bufferSize *= 2; 209 | } 210 | buffer[size_] = val; 211 | size_++; 212 | siftUp(size_ - 1); 213 | } 214 | 215 | template 216 | void Heap::sort(){ 217 | int oldSize = size_; 218 | for(int i = size_ - 1; i >= 0; i--){ 219 | T tmp = extract_max(); 220 | buffer[i] = tmp; 221 | } 222 | size_ = oldSize; 223 | } 224 | -------------------------------------------------------------------------------- /1sem/task2/3_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::swap; 4 | using std::cin; 5 | using std::cout; 6 | 7 | int partition(int * array, int p, int r); 8 | 9 | int kStat(int * array, int n, int k); 10 | 11 | int median(int * a, int p, int r); 12 | 13 | /******************************************************************************/ 14 | 15 | int main(){ 16 | int n, k; 17 | cin >> n >> k; 18 | int * array = new int[n]; 19 | for(int i = 0; i < n; i++) 20 | cin >> array[i]; 21 | cout << kStat(array, n, k); 22 | delete[] array; 23 | return 0; 24 | } 25 | 26 | /******************************************************************************/ 27 | 28 | int median(int * a, int p, int r){ 29 | int mid = (p + r) / 2; 30 | 31 | if (a[p] > a[r]) 32 | if (a[r] > a[mid]) 33 | return r; 34 | else 35 | return mid; 36 | else if (a[p] > a[mid]) 37 | return p; 38 | else 39 | return mid; 40 | } 41 | 42 | 43 | 44 | int partition(int * array, int p, int r){ 45 | swap(array[r], array[median(array, p, r)]); 46 | int j = p; 47 | for(int i = p; i < r; i++) 48 | if(array[i] < array[r]){ 49 | swap(array[i], array[j]); 50 | j++; 51 | } 52 | swap(array[j], array[r]); 53 | return j; 54 | } 55 | 56 | 57 | 58 | int kStat(int * array, int n, int k){ 59 | int p = 0; 60 | int r = n - 1; 61 | int q = partition(array, p, r); 62 | while(q != k){ 63 | if(k < q) 64 | r = q - 1; 65 | else 66 | p = q + 1; 67 | q = partition(array, p, r); 68 | } 69 | return array[q]; 70 | } 71 | -------------------------------------------------------------------------------- /1sem/task2/4_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | //Heap v1.0.1 7 | template 8 | class Heap{ 9 | public: 10 | Heap(); 11 | ~Heap(); 12 | void insert(T val); 13 | int size(); 14 | void clear(); 15 | void print(); 16 | void append(T val); 17 | 18 | protected: 19 | virtual void siftUp(int index) = 0; 20 | virtual void siftDown(int index) = 0; 21 | 22 | T extract_top(); 23 | T get_top(); 24 | 25 | T * buffer_; 26 | int defaultSize_; 27 | int bufferSize_; 28 | int size_; 29 | }; 30 | 31 | //============================================================================= 32 | 33 | //Heap v1 Required 34 | 35 | //MaxHeap v0.0.1 36 | template 37 | class MaxHeap: public Heap{ 38 | private: 39 | void siftUp(int index); 40 | void siftDown(int index); 41 | 42 | public: 43 | T extract_max(); 44 | T get_max(); 45 | }; 46 | 47 | //============================================================================= 48 | 49 | int main(){ 50 | long n, k; 51 | cin >> n >> k; 52 | MaxHeap heap; 53 | 54 | for(long i = 0; i < k; i++){ 55 | int x; 56 | cin >> x; 57 | heap.append(x); 58 | } 59 | for(long i = k; i < n; i++){ 60 | int x; 61 | cin >> x; 62 | if(heap.get_max() > x){ 63 | heap.extract_max(); 64 | heap.append(x); 65 | } 66 | } 67 | 68 | int * result = new int[k]; 69 | for(long i = k - 1; i >= 0; i--) 70 | result[i] = heap.extract_max(); 71 | 72 | for(int i = 0; i < k; i++) 73 | cout << result[i] << ' '; 74 | 75 | delete[] result; 76 | return 0; 77 | } 78 | 79 | //===========================MAXHEAP=========================================== 80 | 81 | template 82 | void MaxHeap::siftUp(int index){ 83 | if(index >= this->size_) 84 | std::cerr << "Heap::siftUp : Wrong index\n"; 85 | while(index && this->buffer_[index] > this->buffer_[(index - 1)/2]){ 86 | T tmp = this->buffer_[index]; 87 | this->buffer_[index] = this->buffer_[(index - 1)/2]; 88 | this->buffer_[(index - 1)/2] = tmp; 89 | index = (index - 1)/2; 90 | } 91 | } 92 | 93 | template 94 | void MaxHeap::siftDown(int index){ 95 | if(index >= this->size_) 96 | std::cerr << "Heap::siftDown : Wrong index\n"; 97 | int max = index; 98 | if(index*2 + 1 < this->size_ && this->buffer_[index*2 + 1] > this->buffer_[max]) 99 | max = index*2 + 1; 100 | if(index*2 + 2 < this->size_ && this->buffer_[index*2 + 2] > this->buffer_[max]) 101 | max = index*2 + 2; 102 | if(max != index){ 103 | T tmp = this->buffer_[index]; 104 | this->buffer_[index] = this->buffer_[max]; 105 | this->buffer_[max] = tmp; 106 | siftDown(max); 107 | } 108 | } 109 | 110 | template 111 | T MaxHeap::extract_max(){ 112 | return this->extract_top(); 113 | } 114 | 115 | template 116 | T MaxHeap::get_max(){ 117 | return this->get_top(); 118 | } 119 | 120 | //===========================HEAP============================================== 121 | 122 | template 123 | Heap::Heap(): 124 | defaultSize_(16), 125 | bufferSize_(defaultSize_), 126 | size_(0) 127 | { 128 | buffer_ = new T[bufferSize_]; 129 | } 130 | 131 | template 132 | Heap::~Heap(){ 133 | delete[] buffer_; 134 | } 135 | 136 | template 137 | void Heap::insert(T val){ 138 | if(size_ + 1 > bufferSize_){ 139 | T * tmp = new T[bufferSize_*2]; 140 | for(int i = 0; i < bufferSize_; i++) 141 | tmp[i] = buffer_[i]; 142 | delete[] buffer_; 143 | buffer_ = tmp; 144 | bufferSize_ *= 2; 145 | } 146 | buffer_[size_] = val; 147 | size_++; 148 | siftUp(size_ - 1); 149 | } 150 | 151 | template 152 | T Heap::extract_top(){ 153 | if(!size_) 154 | std::cerr << "Heap::extract_top : Empty heap\n"; 155 | T min = buffer_[0]; 156 | buffer_[0] = buffer_[size_ - 1]; 157 | size_--; 158 | if(size_) 159 | siftDown(0); 160 | return min; 161 | } 162 | 163 | template 164 | T Heap::get_top(){ 165 | if(!size_) 166 | std::cerr << "Heap::get_top : Empty heap\n"; 167 | return buffer_[0]; 168 | } 169 | 170 | template 171 | int Heap::size(){ 172 | return size_; 173 | } 174 | 175 | template 176 | void Heap::clear(){ 177 | delete[] buffer_; 178 | buffer_ = new T[defaultSize_]; 179 | bufferSize_ = defaultSize_; 180 | size_ = 0; 181 | } 182 | 183 | template 184 | void Heap::print(){ 185 | for(int i = 0; i < size_; i++) 186 | printf("%d ", buffer_[i]); 187 | printf("\n"); 188 | } 189 | 190 | template 191 | void Heap::append(T val){ 192 | if(size_ + 1 > bufferSize_){ 193 | T * tmp = new T[bufferSize_*2]; 194 | for(int i = 0; i < bufferSize_; i++) 195 | tmp[i] = buffer_[i]; 196 | delete[] buffer_; 197 | buffer_ = tmp; 198 | bufferSize_ *= 2; 199 | } 200 | size_++; 201 | buffer_[size_ - 1] = val; 202 | siftUp(size_ - 1); 203 | } 204 | -------------------------------------------------------------------------------- /1sem/task2/5_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::string; 4 | using std::cin; 5 | using std::cout; 6 | 7 | const int k = 256; 8 | 9 | void countingSort(string * a, int n, int * c, int byte); 10 | 11 | void MSDSort(string * a, int n, int byte); 12 | 13 | /******************************************************************************/ 14 | 15 | int main(){ 16 | int n = 0; 17 | string * a = new string[100001]; 18 | 19 | while(!cin.eof()){ 20 | cin >> a[n++]; 21 | if(a[n - 1].empty()){ 22 | n--; 23 | break; 24 | } 25 | } 26 | 27 | MSDSort(a, n, 0); 28 | 29 | for(int i = 0; i < n; i++) 30 | cout << a[i] << '\n'; 31 | 32 | delete[] a; 33 | } 34 | 35 | /******************************************************************************/ 36 | 37 | void countingSort(string * a, int n, int * c, int byte){ 38 | for(int i = 0; i < k; i++) 39 | c[i] = 0; 40 | for(int i = 0; i < n; i++) 41 | c[a[i][byte]]++; 42 | 43 | int sum = 0; 44 | for(int i = 0; i < k; i++){ 45 | int tmp = c[i]; 46 | c[i] = sum; 47 | sum += tmp; 48 | } 49 | 50 | string * b = new string[n]; 51 | for(int i = 0; i < n; i++){ 52 | b[c[a[i][byte]]++] = a[i]; 53 | } 54 | for(int i = 0; i < n; i++) 55 | a[i] = b[i]; 56 | 57 | delete[] b; 58 | } 59 | 60 | 61 | 62 | void MSDSort(string * a, int n, int byte){ 63 | if(n <= 1) 64 | return; 65 | 66 | int * c = new int[k + 1]; 67 | c[k] = n - 1; 68 | 69 | countingSort(a, n, c, byte); 70 | 71 | for(int i = 1; i < k; i++) 72 | MSDSort(a + c[i], c[i + 1] - c[i], byte + 1); 73 | 74 | delete[] c; 75 | } 76 | -------------------------------------------------------------------------------- /1sem/task3/1_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cout; 4 | using std::cin; 5 | 6 | //BST v0.1.2 7 | template 8 | class BST{ 9 | public: 10 | BST(); 11 | ~BST(); 12 | 13 | void insert(T val); 14 | void clear(); 15 | void print(); 16 | 17 | bool deleteByKey(T key); 18 | bool find(T key); 19 | 20 | T findMin(); 21 | T findMax(); 22 | 23 | private: 24 | struct Node{ 25 | Node * left; 26 | Node * right; 27 | T val; 28 | }; 29 | 30 | Node * root_; 31 | 32 | void clearRec(Node *node); 33 | void printRec(Node * node, int depth); 34 | void deleteNode(Node * & node); 35 | 36 | Node * findNode(T key); 37 | }; 38 | 39 | /****************************MAIN*********************************************/ 40 | 41 | int main(){ 42 | BST bst; 43 | int n; 44 | cin >> n; 45 | for(int i = 0; i < n; i++){ 46 | int x; 47 | cin >> x; 48 | bst.insert(x); 49 | } 50 | bst.print(); 51 | } 52 | 53 | /****************************BST**********************************************/ 54 | 55 | // Public: 56 | 57 | template 58 | BST::BST(): 59 | root_(NULL) 60 | {} 61 | 62 | 63 | 64 | template 65 | BST::~BST(){ 66 | clear(); 67 | } 68 | 69 | 70 | 71 | template 72 | void BST::insert(T val){ 73 | Node * tmp = new Node; 74 | tmp->left = NULL; 75 | tmp->right = NULL; 76 | tmp->val = val; 77 | 78 | if(root_ == NULL){ 79 | root_ = tmp; 80 | return; 81 | } 82 | 83 | Node * node = root_; 84 | while(val < node->val && node->left != NULL 85 | || val > node->val && node->right != NULL){ 86 | node = (val < node->val)?(node->left):(node->right); 87 | } 88 | if(val < node->val) 89 | node->left = tmp; 90 | else 91 | node->right = tmp; 92 | } 93 | 94 | 95 | 96 | template 97 | void BST::clear(){ 98 | clearRec(root_); 99 | root_ = NULL; 100 | } 101 | 102 | 103 | 104 | template 105 | void BST::print(){ 106 | printRec(root_, 0); 107 | } 108 | 109 | 110 | 111 | template 112 | bool BST::deleteByKey(T key){ 113 | Node * node = root_; 114 | Node * parent = NULL; 115 | while(key != node->val 116 | && (key < node->val && node->left != NULL 117 | || key > node->val && node->right != NULL)){ 118 | parent = node; 119 | node = (key <= node->val)?(node->left):(node->right); 120 | } 121 | if(node->val != key) 122 | return false; 123 | if(node != root_) 124 | deleteNode((key <= parent->val)?(parent->left):(parent->right)); 125 | else 126 | deleteNode(root_); 127 | return true; 128 | } 129 | 130 | 131 | 132 | template 133 | bool BST::find(T key){ 134 | return (findNode(key) != NULL); 135 | } 136 | 137 | 138 | 139 | template 140 | T BST::findMax(){ 141 | Node * node = root_; 142 | while(node->right != NULL) 143 | node = node->right; 144 | return node->val; 145 | } 146 | 147 | 148 | 149 | template 150 | T BST::findMin(){ 151 | Node * node = root_; 152 | while(node->left != NULL) 153 | node = node->left; 154 | return node->val; 155 | }; 156 | 157 | // Private: 158 | 159 | template 160 | void BST::printRec(Node * node, int depth){ 161 | if(node == NULL) 162 | return; 163 | printRec(node->left, depth + 1); 164 | cout << node->val << ' '; 165 | printRec(node->right, depth + 1); 166 | } 167 | 168 | 169 | 170 | template 171 | void BST::clearRec(Node * node){ 172 | if(node == NULL) 173 | return; 174 | clearRec(node->left); 175 | clearRec(node->right); 176 | delete node; 177 | } 178 | 179 | 180 | 181 | template 182 | void BST::deleteNode(Node * & node){ 183 | if(node->right == NULL){ 184 | Node * tmp = node->left; 185 | delete node; 186 | node = tmp; 187 | } 188 | else if(node->left == NULL){ 189 | Node * tmp = node->right; 190 | delete node; 191 | node = tmp; 192 | } 193 | else{ 194 | Node * minParent = node; 195 | Node * min = node->right; 196 | while(min->left != NULL){ 197 | minParent = min; 198 | min = min->left; 199 | } 200 | if(min == node->right) 201 | minParent->right = min->right; 202 | else 203 | minParent->left = min->right; 204 | min->left = node->left; 205 | min->right = node->right; 206 | delete node; 207 | node = min; 208 | } 209 | } 210 | 211 | 212 | 213 | template 214 | typename BST::Node * BST::findNode(T key){ 215 | Node * node = root_; 216 | while(node != NULL && node->val != key){ 217 | node = (key <= node->val)?(node->left):(node->right); 218 | } 219 | return node; 220 | } 221 | -------------------------------------------------------------------------------- /1sem/task3/4/Huffman.h: -------------------------------------------------------------------------------- 1 | #ifndef HUFFMAN_HUFFMAN_H 2 | #define HUFFMAN_HUFFMAN_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | /******************************************************************************/ 11 | 12 | typedef char byte; 13 | typedef bool bit; 14 | 15 | /******************************************************************************/ 16 | 17 | using std::map; 18 | using std::list; 19 | using std::string; 20 | using std::ifstream; 21 | using std::ofstream; 22 | using std::cout; 23 | 24 | /******************************************************************************/ 25 | 26 | class IInputStream { 27 | public: 28 | IInputStream(ifstream & fin): 29 | fin_(fin) 30 | {} 31 | // Возвращает false, если поток закончился 32 | bool Read(byte& value){ 33 | if(fin_.eof()) 34 | return false; 35 | fin_.get(value); 36 | return true; 37 | } 38 | 39 | private: 40 | ifstream & fin_; 41 | }; 42 | 43 | class IOutputStream { 44 | public: 45 | IOutputStream(ofstream & fout): 46 | fout_(fout) 47 | {} 48 | void Write(byte value){ 49 | fout_ << value; 50 | } 51 | 52 | private: 53 | ofstream & fout_; 54 | }; 55 | 56 | 57 | /******************************************************************************/ 58 | 59 | class bitostream{ 60 | public: 61 | // Constructor, gets input stream 62 | bitostream(IOutputStream & stream); 63 | 64 | 65 | // Writes a bit. Returns true, when byte is written 66 | bool write(bit value); 67 | 68 | private: 69 | // Stores stream 70 | IOutputStream & stream_; 71 | 72 | // Stores byte to be written 73 | byte currentByte_; 74 | 75 | // Stores number of bits in current byte 76 | char bitsWritten_; 77 | 78 | }; 79 | 80 | 81 | 82 | class bitistream{ 83 | public: 84 | // Constructor, gets output stream 85 | bitistream(IInputStream & stream); 86 | 87 | 88 | // Reads a bit. Returns false if stream is over 89 | bool read(bit & value); 90 | 91 | private: 92 | // Stores stream 93 | IInputStream & stream_; 94 | 95 | // Stores reflected byte to be read 96 | byte currentByte_; 97 | 98 | // Stores number of bits read 99 | char bitsRead_; 100 | 101 | }; 102 | 103 | /******************************************************************************/ 104 | 105 | class Node{ 106 | public: 107 | 108 | Node(); 109 | 110 | Node(byte value, long weight, Node * left, Node * right); 111 | 112 | 113 | byte value; 114 | 115 | long weight; 116 | 117 | 118 | Node * left; 119 | 120 | Node * right; 121 | 122 | }; 123 | 124 | 125 | bool nodeComparator(Node * & L, Node * R); 126 | 127 | 128 | // Builds Huffman tree 129 | Node * buildTree(map freq); 130 | 131 | // Initializes symbol codes 132 | void getCodes(Node * node, long code, map & codes); 133 | 134 | // Prints Huffman tree 135 | void printTree(Node * node, int depth, const map & codes); 136 | 137 | // Deletes Huffman tree 138 | void deleteTree(Node * node); 139 | 140 | // Counts length for each code 141 | void countCodeLengths(const map & codes, 142 | map & codeLengths); 143 | 144 | // Deleting extra nodes in decoded tree 145 | void fixTree(Node * node); 146 | 147 | // Encodes file 148 | void Encode(IInputStream & original, IOutputStream & compressed); 149 | 150 | // Decodes file 151 | void Decode(IInputStream & compressed, IOutputStream & decoded); 152 | 153 | 154 | #endif //HUFFMAN_HUFFMAN_H 155 | -------------------------------------------------------------------------------- /1sem/task4/1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | using std::string; 6 | 7 | 8 | // HashTable v0.0.2 9 | class HashTable{ 10 | public: 11 | // Default constructor 12 | HashTable(); 13 | 14 | // Destructor 15 | ~HashTable(); 16 | 17 | // Inserts string. Returns true on success and false otherwise 18 | bool insert(string key); 19 | 20 | // Removes string. Returns true on success and false otherwise 21 | bool remove(string key); 22 | 23 | 24 | // Returns true if table contains string and false otherwise 25 | bool contains(string key) const; 26 | 27 | // Prints table 28 | void print() const; 29 | 30 | private: 31 | struct Node{ 32 | // Constructs node with data = key 33 | Node(string key); 34 | 35 | 36 | string data; 37 | 38 | bool deleted; 39 | }; 40 | 41 | // Rehashes table 42 | void rehash(); 43 | 44 | // Returns hash for key 45 | int hash(string key) const; 46 | 47 | 48 | int bufferSize_; 49 | 50 | int size_; 51 | 52 | Node ** nodes_; 53 | }; 54 | 55 | /******************************************************************************/ 56 | 57 | int main(){ 58 | HashTable hashTable; 59 | 60 | while (!cin.eof()) { 61 | char command; 62 | string str; 63 | 64 | cin >> command; 65 | cin >> str; 66 | 67 | if (str.empty()) break; 68 | 69 | switch(command){ 70 | case '+': 71 | if(hashTable.insert(str)) 72 | cout << "OK\n"; 73 | else 74 | cout << "FAIL\n"; 75 | break; 76 | case '-': 77 | if(hashTable.remove(str)) 78 | cout << "OK\n"; 79 | else 80 | cout << "FAIL\n"; 81 | break; 82 | case '?': 83 | if(hashTable.contains(str)) 84 | cout << "OK\n"; 85 | else 86 | cout << "FAIL\n"; 87 | break; 88 | default: 89 | break; 90 | } 91 | } 92 | return 0; 93 | } 94 | 95 | /****************************HASHTABLE*****************************************/ 96 | 97 | // Public: 98 | 99 | HashTable::HashTable(): 100 | bufferSize_(8), 101 | size_(0) 102 | { 103 | nodes_ = new Node*[bufferSize_]; 104 | for(size_t i = 0; i < bufferSize_; i++) 105 | nodes_[i] = nullptr; 106 | } 107 | 108 | 109 | 110 | HashTable::~HashTable(){ 111 | for (int i = 0; i < bufferSize_; ++i) 112 | if (nodes_[i] != nullptr) 113 | delete nodes_[i]; 114 | delete[] nodes_; 115 | } 116 | 117 | 118 | 119 | bool HashTable::insert(string key){ 120 | if(contains(key)) 121 | return false; 122 | 123 | if(3*bufferSize_ <= 4*(size_ + 1)) 124 | rehash(); 125 | 126 | int hashed = hash(key); 127 | int i = 0; 128 | 129 | while(i < bufferSize_){ 130 | if(nodes_[hashed] == nullptr){ 131 | nodes_[hashed] = new Node(key); 132 | size_++; 133 | return true; 134 | } 135 | else if(nodes_[hashed]->deleted){ 136 | nodes_[hashed]->data = key; 137 | nodes_[hashed]->deleted = false; 138 | size_++; 139 | return true; 140 | } 141 | i++; 142 | hashed = (hashed + i) % bufferSize_; 143 | } 144 | return false; 145 | } 146 | 147 | 148 | 149 | bool HashTable::contains(string key) const{ 150 | int hashed = hash(key); 151 | int i = 0; 152 | while(nodes_[hashed] != nullptr && i < bufferSize_){ 153 | if(!nodes_[hashed]->deleted && nodes_[hashed]->data.compare(key) == 0) 154 | return true; 155 | i++; 156 | hashed = (hashed + i) % bufferSize_; 157 | } 158 | return false; 159 | } 160 | 161 | 162 | 163 | bool HashTable::remove(string key){ 164 | if(!contains(key)) 165 | return false; 166 | 167 | int hashed = hash(key); 168 | int i = 0; 169 | 170 | while(i < bufferSize_){ 171 | if(!nodes_[hashed]->deleted && nodes_[hashed]->data.compare(key) == 0){ 172 | nodes_[hashed]->deleted = true; 173 | size_--; 174 | return true; 175 | } 176 | i++; 177 | hashed = (hashed + i) % bufferSize_; 178 | } 179 | return false; 180 | } 181 | 182 | 183 | 184 | 185 | void HashTable::print() const{ 186 | cout << "Alfa: " << (double) size_ / bufferSize_ 187 | << "; Size: " << size_ 188 | << "; BufferSize: " << bufferSize_ << '\n'; 189 | for(int i = 0; i < bufferSize_; i++) 190 | if(nodes_[i] == nullptr) 191 | cout << "NULL \n"; 192 | else 193 | cout << "KEY: " << nodes_[i]->data 194 | << "; DELETED: " << nodes_[i]->deleted 195 | << "; ADDR: " << nodes_[i] << '\n'; 196 | } 197 | 198 | // Private: 199 | 200 | void HashTable::rehash(){ 201 | Node ** tmp = nodes_; 202 | bufferSize_ *= 2; 203 | size_ = 0; 204 | nodes_ = new Node*[bufferSize_]; 205 | 206 | for(int i = 0; i < bufferSize_; i++) 207 | nodes_[i] = nullptr; 208 | 209 | for(int i = 0; i < bufferSize_ / 2; i++) 210 | if(tmp[i] != nullptr){ 211 | if(!tmp[i]->deleted) 212 | insert(tmp[i]->data); 213 | delete tmp[i]; 214 | } 215 | 216 | delete[] tmp; 217 | } 218 | 219 | 220 | 221 | int HashTable::hash(string key) const{ 222 | int hashed = 0; 223 | for (size_t i = 0; i < key.length(); i++) { 224 | hashed = (hashed + 127 * key[i]) % bufferSize_; 225 | } 226 | return hashed; 227 | } 228 | 229 | /****************************HASHTABLE::NODE***********************************/ 230 | 231 | HashTable::Node::Node(string key) : 232 | data(key), 233 | deleted(false) 234 | {} 235 | -------------------------------------------------------------------------------- /1sem/task4/2_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | using std::swap; 6 | using std::min; 7 | 8 | template 9 | int partition(T * array, int p, int r); 10 | 11 | template 12 | void quickSort(T * array, int p, int r); 13 | 14 | struct Man{ 15 | int weight; 16 | int strength; 17 | 18 | friend bool operator < (const Man & L, const Man & R); 19 | friend bool operator > (const Man & L, const Man & R); 20 | }; 21 | 22 | /****************************MAIN**********************************************/ 23 | 24 | int main(){ 25 | Man * men = new Man[100000]; 26 | int n = 0; 27 | while(!cin.eof()){ 28 | cin >> men[n].weight; 29 | cin >> men[n].strength; 30 | n++; 31 | // cout << "W:" << men[n - 1].weight << '\n'; 32 | // if(cin.eof()) 33 | // cout << "EOF\n"; 34 | } 35 | 36 | n--; 37 | //cout << n << '\n'; 38 | 39 | quickSort(men, 0, n - 1); 40 | 41 | int maxWeight = men[0].strength; 42 | int k = 1; 43 | for(int i = 1; i < n; i++){ 44 | if(men[i].weight <= maxWeight){ 45 | maxWeight = min(maxWeight - men[i].weight, men[i].strength); 46 | k++; 47 | } 48 | } 49 | 50 | cout << k << '\n'; 51 | 52 | // for(int i = 0; i < n; i++) 53 | // cout << men[i].weight << ' ' << men[i].strength << '\n'; 54 | 55 | return 0; 56 | } 57 | 58 | /****************************MAN***********************************************/ 59 | 60 | bool operator < (const Man & L, const Man & R){ 61 | if(L.strength < R.strength) 62 | return true; 63 | else if(L.strength == R.strength) 64 | return L.weight > R.weight; 65 | return false; 66 | } 67 | 68 | 69 | 70 | bool operator > (const Man & L, const Man & R){ 71 | if(L.strength > R.strength) 72 | return true; 73 | else if(L.strength == R.strength) 74 | return L.weight < R.weight; 75 | return false; 76 | } 77 | 78 | /****************************QSORT*********************************************/ 79 | 80 | template 81 | int partition(T * array, int p, int r){ 82 | int pivot; 83 | if(array[p] > array[(r + p)/ 2] && array[(r + p)/ 2] < array[r]) 84 | pivot = (r + p) / 2; 85 | else if(array[r] < array[p] && array[p] < array[(r + p)/ 2]) 86 | pivot = p; 87 | else 88 | pivot = r; 89 | 90 | T tmp = array[pivot]; 91 | array[pivot] = array[r]; 92 | array[r] = tmp; 93 | 94 | int j = p; 95 | for(int i = p; i < r; i++) 96 | if(array[i] > array[r]){ 97 | tmp = array[j]; 98 | array[j] = array[i]; 99 | array[i] = tmp; 100 | j++; 101 | } 102 | 103 | tmp = array[j]; 104 | array[j] = array[r]; 105 | array[r] = tmp; 106 | return j; 107 | } 108 | 109 | template 110 | void quickSort(T * array, int p, int r){ 111 | if(r <= p) 112 | return; 113 | int q = partition(array, p, r); 114 | quickSort(array, p, q - 1); 115 | quickSort(array, q + 1, r); 116 | } 117 | -------------------------------------------------------------------------------- /1sem/task4/3_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | 6 | int main(){ 7 | int num; 8 | cin >> num; 9 | 10 | long ** dp = new long * [num + 1]; 11 | for(int i = 0; i <= num; i++) 12 | dp[i] = new long[num + 1]; 13 | 14 | for(int i = 0; i <= num; i++) 15 | dp[1][i] = 1; 16 | 17 | for(int i = 2; i <= num; i++) 18 | for(int j = 0; j <= num; j++) 19 | dp[i][j] = dp[i - 1][j] + ((j - i + 1 > 0)?(dp[i][j - i]):0); 20 | 21 | cout << dp[num][num]; 22 | 23 | for(int i = 0; i <= num; i++) 24 | delete[] dp[i]; 25 | delete[] dp; 26 | } 27 | -------------------------------------------------------------------------------- /1sem/task4/4_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /******************************************************************************/ 5 | 6 | using std::vector; 7 | using std::cin; 8 | using std::cout; 9 | using std::max; 10 | using std::min; 11 | 12 | /******************************************************************************/ 13 | 14 | class Tree{ 15 | public: 16 | 17 | Tree(int n); 18 | 19 | 20 | void distance(vector & out); 21 | 22 | void insert(int x, int y); 23 | 24 | private: 25 | 26 | struct Node{ 27 | 28 | vector children_; 29 | 30 | int i_; 31 | 32 | int depth_; 33 | }; 34 | 35 | int maxChildrenDepth(Node * node, int except); 36 | 37 | 38 | void fixDepth(Node * node); 39 | 40 | void findDistance(Node * node, int maxDepth, vector & out); 41 | 42 | 43 | vector nodes_; 44 | }; 45 | 46 | /******************************************************************************/ 47 | 48 | int main(){ 49 | int n; 50 | cin >> n; 51 | Tree tree(n); 52 | for(int i = 0; i < n - 1; i++){ 53 | int x, y; 54 | cin >> x >> y; 55 | tree.insert(x, y); 56 | } 57 | vector out(n); 58 | tree.distance(out); 59 | for(int i = 0; i < n; i++) 60 | cout << out[i] << '\n'; 61 | } 62 | 63 | /****************************TREE**********************************************/ 64 | 65 | // Public: 66 | 67 | Tree::Tree(int n): 68 | nodes_(n) 69 | { 70 | for(int i = 0; i < n; i++) 71 | nodes_[i].i_ = i; 72 | } 73 | 74 | 75 | 76 | void Tree::distance(vector & out){ 77 | fixDepth(&nodes_[0]); 78 | findDistance(&nodes_[0], 0, out); 79 | } 80 | 81 | 82 | 83 | void Tree::insert(int x, int y){ 84 | nodes_[min(x, y)].children_.push_back(&nodes_[max(x, y)]); 85 | } 86 | 87 | // Private: 88 | 89 | int Tree::maxChildrenDepth(Node * node, int except){ 90 | int maxDepth = 0; 91 | for(int i = 0; i < node->children_.size(); i++) 92 | if(node->children_[i]->i_ != except 93 | && node->children_[i]->depth_ > maxDepth){ 94 | maxDepth = node->children_[i]->depth_; 95 | } 96 | return maxDepth; 97 | } 98 | 99 | 100 | 101 | void Tree::fixDepth(Node * node){ 102 | if(node == nullptr) 103 | return; 104 | 105 | for(int i = 0; i < node->children_.size(); i++) 106 | fixDepth(node->children_[i]); 107 | 108 | node->depth_ = maxChildrenDepth(node, - 1) + 1; 109 | } 110 | 111 | 112 | 113 | void Tree::findDistance(Node * node, int maxDepth, vector & out){ 114 | if(node == nullptr) 115 | return; 116 | 117 | for(int i = 0; i < node->children_.size(); i++) 118 | findDistance(node->children_[i], max(maxChildrenDepth(node, node->children_[i]->i_), maxDepth) + 1, out); 119 | 120 | out[node->i_] = max(maxChildrenDepth(node, -1), maxDepth); 121 | } 122 | -------------------------------------------------------------------------------- /2sem/task1/1/include/CArcGraph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #ifndef TASK1_CARCGRAPH_H 6 | #define TASK1_CARCGRAPH_H 7 | 8 | #include "IGraph.h" 9 | 10 | class CArcGraph : public IGraph{ 11 | public: 12 | 13 | CArcGraph(unsigned int verticesNumber); 14 | 15 | CArcGraph(const IGraph * graph); 16 | 17 | 18 | virtual void AddEdge(int from, int to) override; 19 | 20 | 21 | virtual int VerticesCount() const override; 22 | 23 | 24 | virtual void GetNextVertices(int vertex, 25 | vector & vertices) const override; 26 | 27 | virtual void GetPrevVertices(int vertex, 28 | vector & vertices) const override; 29 | 30 | private: 31 | 32 | struct Edge{ 33 | 34 | Edge(int from, int to); 35 | 36 | int from; 37 | 38 | int to; 39 | 40 | }; 41 | 42 | 43 | unsigned int verticesNumber_; 44 | 45 | vector edges_; 46 | 47 | }; 48 | 49 | #endif //TASK1_CARCGRAPH_H -------------------------------------------------------------------------------- /2sem/task1/1/include/CListGraph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #ifndef TASK1_CLISTGRAPH_H 6 | #define TASK1_CLISTGRAPH_H 7 | 8 | #include "IGraph.h" 9 | #include 10 | 11 | using std::list; 12 | 13 | class CListGraph : public IGraph{ 14 | public: 15 | 16 | CListGraph(unsigned int verticesNumber); 17 | 18 | CListGraph(const IGraph * graph); 19 | 20 | 21 | virtual void AddEdge(int from, int to) override; 22 | 23 | 24 | virtual int VerticesCount() const override; 25 | 26 | 27 | virtual void GetNextVertices(int vertex, 28 | vector & vertices) const override; 29 | 30 | virtual void GetPrevVertices(int vertex, 31 | vector & vertices) const override; 32 | 33 | private: 34 | 35 | unsigned int verticesNumber_; 36 | 37 | vector> in_; 38 | 39 | vector> out_; 40 | 41 | }; 42 | 43 | #endif //TASK1_CLISTGRAPH_H 44 | -------------------------------------------------------------------------------- /2sem/task1/1/include/CMatrixGraph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #ifndef TASK1_CMATRIXGRAPH_H 6 | #define TASK1_CMATRIXGRAPH_H 7 | 8 | #include "IGraph.h" 9 | 10 | class CMatrixGraph : public IGraph{ 11 | public: 12 | 13 | CMatrixGraph(unsigned int verticesNumber); 14 | 15 | CMatrixGraph(const IGraph * graph); 16 | 17 | 18 | virtual void AddEdge(int from, int to) override; 19 | 20 | 21 | virtual int VerticesCount() const override; 22 | 23 | 24 | virtual void GetNextVertices(int vertex, 25 | vector & vertices) const override; 26 | 27 | virtual void GetPrevVertices(int vertex, 28 | vector & vertices) const override; 29 | 30 | private: 31 | 32 | unsigned int verticesNumber_; 33 | 34 | vector> edges_; 35 | 36 | }; 37 | 38 | #endif //TASK1_CMATRIXGRAPH_H 39 | -------------------------------------------------------------------------------- /2sem/task1/1/include/CSetGraph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #ifndef TASK1_CSETGRAPH_H 6 | #define TASK1_CSETGRAPH_H 7 | 8 | #include 9 | #include "IGraph.h" 10 | 11 | using std::unordered_set; 12 | 13 | class CSetGraph : public IGraph{ 14 | public: 15 | 16 | CSetGraph(unsigned int verticesNumber); 17 | 18 | CSetGraph(const IGraph * graph); 19 | 20 | 21 | virtual void AddEdge(int from, int to) override; 22 | 23 | 24 | virtual int VerticesCount() const override; 25 | 26 | 27 | virtual void GetNextVertices(int vertex, 28 | vector & vertices) const override; 29 | 30 | virtual void GetPrevVertices(int vertex, 31 | vector & vertices) const override; 32 | 33 | private: 34 | 35 | unsigned int verticesNumber_; 36 | 37 | vector> out_; 38 | 39 | vector> in_; 40 | 41 | }; 42 | 43 | #endif //TASK1_CSETGRAPH_H 44 | -------------------------------------------------------------------------------- /2sem/task1/1/include/IGraph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #ifndef TASK1_IGRAPH_H 6 | #define TASK1_IGRAPH_H 7 | 8 | #include 9 | 10 | using std::vector; 11 | 12 | class IGraph { 13 | public: 14 | 15 | virtual ~IGraph() {} 16 | 17 | 18 | virtual void AddEdge(int from, int to) = 0; 19 | 20 | 21 | virtual int VerticesCount() const = 0; 22 | 23 | 24 | virtual void GetNextVertices(int vertex, 25 | vector & vertices) const = 0; 26 | 27 | virtual void GetPrevVertices(int vertex, 28 | vector & vertices) const = 0; 29 | 30 | }; 31 | 32 | #endif //TASK1_IGRAPH_H 33 | -------------------------------------------------------------------------------- /2sem/task1/1/src/CArcGraph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #include "../include/CArcGraph.h" 6 | 7 | CArcGraph::CArcGraph(unsigned int verticesNumber): 8 | verticesNumber_(verticesNumber) 9 | {} 10 | 11 | 12 | 13 | CArcGraph::CArcGraph(const IGraph * graph): 14 | verticesNumber_(graph->VerticesCount()) 15 | { 16 | for(int i = 0; i < verticesNumber_; i++){ 17 | vector vertices; 18 | graph->GetNextVertices(i, vertices); 19 | for(int j : vertices) 20 | AddEdge(i, j); 21 | } 22 | } 23 | 24 | 25 | 26 | void CArcGraph::AddEdge(int from, int to){ 27 | // Checking if edge already exists 28 | for(const Edge & i : edges_) 29 | if(i.from == from && i.to == to) 30 | return; 31 | 32 | Edge edge(from, to); 33 | edges_.push_back(edge); 34 | } 35 | 36 | 37 | 38 | int CArcGraph::VerticesCount() const{ 39 | return verticesNumber_; 40 | } 41 | 42 | 43 | 44 | void CArcGraph::GetNextVertices(int vertex, vector & vertices) const{ 45 | for(const Edge & i : edges_) 46 | if(i.from == vertex) 47 | vertices.push_back(i.to); 48 | } 49 | 50 | 51 | 52 | void CArcGraph::GetPrevVertices(int vertex, vector & vertices) const{ 53 | for(const Edge & i : edges_) 54 | if(i.to == vertex) 55 | vertices.push_back(i.from); 56 | } 57 | 58 | 59 | 60 | CArcGraph::Edge::Edge(int from, int to): 61 | from(from), 62 | to(to) 63 | {} -------------------------------------------------------------------------------- /2sem/task1/1/src/CListgraph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #include "../include/CListGraph.h" 6 | 7 | CListGraph::CListGraph(unsigned int verticesNumber): 8 | verticesNumber_(verticesNumber), 9 | in_(verticesNumber_), 10 | out_(verticesNumber_) 11 | {} 12 | 13 | 14 | 15 | CListGraph::CListGraph(const IGraph * graph): 16 | verticesNumber_(graph->VerticesCount()), 17 | in_(verticesNumber_), 18 | out_(verticesNumber_) 19 | { 20 | for(int i = 0; i < verticesNumber_; i++){ 21 | vector vertices; 22 | graph->GetNextVertices(i, vertices); 23 | for(int j : vertices) 24 | AddEdge(i, j); 25 | } 26 | } 27 | 28 | 29 | 30 | void CListGraph::AddEdge(int from, int to){ 31 | // Checking if edge already exists 32 | if(in_.size() < out_.size()){ 33 | for(int i : in_[to]) 34 | if(i == from) 35 | return; 36 | } 37 | else{ 38 | for(int i : out_[from]) 39 | if(i == to) 40 | return; 41 | } 42 | 43 | in_[to].push_back(from); 44 | out_[from].push_back(to); 45 | } 46 | 47 | 48 | 49 | int CListGraph::VerticesCount() const{ 50 | return verticesNumber_; 51 | } 52 | 53 | 54 | 55 | void CListGraph::GetNextVertices(int vertex, vector & vertices) const{ 56 | for(int i : out_[vertex]) 57 | vertices.push_back(i); 58 | } 59 | 60 | 61 | 62 | void CListGraph::GetPrevVertices(int vertex, vector & vertices) const{ 63 | for(int i : in_[vertex]) 64 | vertices.push_back(i); 65 | } -------------------------------------------------------------------------------- /2sem/task1/1/src/CMatrixGraph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #include 6 | #include "../include/CMatrixGraph.h" 7 | 8 | CMatrixGraph::CMatrixGraph(unsigned int verticesNumber): 9 | verticesNumber_(verticesNumber), 10 | edges_(verticesNumber_) 11 | { 12 | for(vector & i : edges_) 13 | i.assign(verticesNumber_, false); 14 | } 15 | 16 | 17 | 18 | CMatrixGraph::CMatrixGraph(const IGraph * graph): 19 | verticesNumber_(graph->VerticesCount()), 20 | edges_(verticesNumber_) 21 | { 22 | for(vector & i : edges_) 23 | i.assign(verticesNumber_, false); 24 | 25 | for(int i = 0; i < verticesNumber_; i++){ 26 | vector vertices; 27 | graph->GetNextVertices(i, vertices); 28 | for(int j : vertices) 29 | AddEdge(i, j); 30 | } 31 | } 32 | 33 | 34 | 35 | void CMatrixGraph::AddEdge(int from, int to){ 36 | edges_[from][to] = true; 37 | } 38 | 39 | 40 | 41 | int CMatrixGraph::VerticesCount() const{ 42 | return verticesNumber_; 43 | } 44 | 45 | 46 | 47 | void CMatrixGraph::GetNextVertices(int vertex, vector & vertices) const{ 48 | vertices.clear(); 49 | for(int i = 0; i < verticesNumber_; i++) 50 | if(edges_[vertex][i]) 51 | vertices.push_back(i); 52 | } 53 | 54 | 55 | 56 | void CMatrixGraph::GetPrevVertices(int vertex, vector & vertices) const{ 57 | vertices.clear(); 58 | for(int i = 0; i < verticesNumber_; i++) 59 | if(edges_[i][vertex]) 60 | vertices.push_back(i); 61 | } -------------------------------------------------------------------------------- /2sem/task1/1/src/CSetGraph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 16.02.17. 3 | // 4 | 5 | #include "../include/CSetGraph.h" 6 | 7 | CSetGraph::CSetGraph(unsigned int verticesNumber): 8 | verticesNumber_(verticesNumber), 9 | out_(verticesNumber_), 10 | in_(verticesNumber_) 11 | {} 12 | 13 | 14 | 15 | CSetGraph::CSetGraph(const IGraph * graph): 16 | verticesNumber_(graph->VerticesCount()), 17 | out_(verticesNumber_), 18 | in_(verticesNumber_) 19 | { 20 | for(int i = 0; i < verticesNumber_; i++){ 21 | vector vertices; 22 | graph->GetNextVertices(i, vertices); 23 | for(int j : vertices) 24 | AddEdge(i, j); 25 | } 26 | } 27 | 28 | 29 | 30 | void CSetGraph::AddEdge(int from, int to) 31 | { 32 | out_[from].insert(to); 33 | in_[to].insert(from); 34 | } 35 | 36 | 37 | 38 | int CSetGraph::VerticesCount() const 39 | { 40 | return verticesNumber_; 41 | } 42 | 43 | 44 | 45 | void CSetGraph::GetNextVertices(int vertex, vector & vertices) const 46 | { 47 | vertices.clear(); 48 | for(int i : out_[vertex]) 49 | vertices.push_back(i); 50 | } 51 | 52 | 53 | 54 | void CSetGraph::GetPrevVertices(int vertex, vector & vertices) const 55 | { 56 | vertices.clear(); 57 | for(int i : in_[vertex]) 58 | vertices.push_back(i); 59 | } -------------------------------------------------------------------------------- /2sem/task1/1/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "../include/CListGraph.h" 3 | #include "../include/CMatrixGraph.h" 4 | #include "../include/CSetGraph.h" 5 | #include "../include/CArcGraph.h" 6 | 7 | /******************************************************************************/ 8 | 9 | using std::cin; 10 | using std::cout; 11 | 12 | /******************************************************************************/ 13 | 14 | int main(){ 15 | unsigned int n; 16 | cin >> n; 17 | CListGraph graph(n); 18 | bool finish = false; 19 | while(!finish){ 20 | char c; 21 | cin >> c; 22 | if(c == '+'){ 23 | int a, b; 24 | cin >> a >> b; 25 | graph.AddEdge(a, b); 26 | } 27 | else 28 | finish = true; 29 | } 30 | 31 | finish = false; 32 | CListGraph listGraph(&graph); 33 | CMatrixGraph matrixGraph(&graph); 34 | CSetGraph setGraph(&graph); 35 | CArcGraph arcGraph(&graph); 36 | while(!finish){ 37 | char c; 38 | int a, b; 39 | cin >> c; 40 | vector vertices1; 41 | vector vertices2; 42 | vector vertices3; 43 | vector vertices4; 44 | switch(c){ 45 | case '+': 46 | cin >> a >> b; 47 | listGraph.AddEdge(a, b); 48 | matrixGraph.AddEdge(a, b); 49 | setGraph.AddEdge(a, b); 50 | arcGraph.AddEdge(a, b); 51 | break; 52 | case '?': 53 | cout << "List: " << listGraph.VerticesCount() 54 | << "\nMatrix: " << matrixGraph.VerticesCount() 55 | << "\nSet: " << setGraph.VerticesCount() 56 | << "\nArc: " << arcGraph.VerticesCount() 57 | << '\n'; 58 | break; 59 | case '>': 60 | cin >> a; 61 | listGraph.GetNextVertices(a, vertices1); 62 | matrixGraph.GetNextVertices(a, vertices2); 63 | setGraph.GetNextVertices(a, vertices3); 64 | arcGraph.GetNextVertices(a, vertices4); 65 | cout << "List: "; 66 | for(int i : vertices1) 67 | cout << i << ' '; 68 | cout << "\nMatrix: "; 69 | for(int i : vertices2) 70 | cout << i << ' '; 71 | cout << "\nSet: "; 72 | for(int i : vertices3) 73 | cout << i << ' '; 74 | cout << "\nArc: "; 75 | for(int i : vertices4) 76 | cout << i << ' '; 77 | cout << '\n'; 78 | break; 79 | case '<': 80 | cin >> a; 81 | listGraph.GetPrevVertices(a, vertices1); 82 | matrixGraph.GetPrevVertices(a, vertices2); 83 | setGraph.GetPrevVertices(a, vertices3); 84 | arcGraph.GetPrevVertices(a, vertices4); 85 | cout << "List: "; 86 | for(int i : vertices1) 87 | cout << i << ' '; 88 | cout << "\nMatrix: "; 89 | for(int i : vertices2) 90 | cout << i << ' '; 91 | cout << "\nSet: "; 92 | for(int i : vertices3) 93 | cout << i << ' '; 94 | cout << "\nArc: "; 95 | for(int i : vertices4) 96 | cout << i << ' '; 97 | cout << '\n'; 98 | break; 99 | default: 100 | finish = true; 101 | } 102 | } 103 | return 0; 104 | } -------------------------------------------------------------------------------- /2sem/task1/2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /******************************************************************************/ 6 | 7 | using std::unordered_set; 8 | using std::vector; 9 | using std::queue; 10 | 11 | /******************************************************************************/ 12 | 13 | class Graph{ 14 | public: 15 | 16 | Graph(unsigned int verticesNumber); 17 | 18 | 19 | void addEdge(int from, int to); 20 | 21 | 22 | int verticesCount() const; 23 | 24 | 25 | void getNextVertices(int vertex, 26 | vector & vertices) const; 27 | 28 | 29 | int findMinCycle(); 30 | 31 | private: 32 | 33 | struct Pair{ 34 | 35 | Pair(); 36 | 37 | 38 | int depth; 39 | 40 | int father; 41 | 42 | bool visited; 43 | 44 | }; 45 | 46 | 47 | int BFS(int vertex); 48 | 49 | 50 | unsigned int verticesNumber_; 51 | 52 | vector> out_; 53 | 54 | }; 55 | 56 | /****************************GRAPH*********************************************/ 57 | 58 | int main() 59 | { 60 | unsigned int n = 0; 61 | scanf("%d", &n); 62 | Graph graph(n); 63 | 64 | int k; 65 | scanf("%d", &k); 66 | for(int i = 0; i < k; i++){ 67 | int a, b; 68 | scanf("%d%d", &a, &b); 69 | graph.addEdge(a, b); 70 | } 71 | int minCycle = graph.findMinCycle(); 72 | if(minCycle == graph.verticesCount() + 1) 73 | minCycle = -1; 74 | printf("%d", minCycle); 75 | } 76 | 77 | 78 | 79 | Graph::Graph(unsigned int verticesNumber): 80 | verticesNumber_(verticesNumber), 81 | out_(verticesNumber_) 82 | {} 83 | 84 | 85 | 86 | void Graph::addEdge(int from, int to) 87 | { 88 | out_[from].insert(to); 89 | out_[to].insert(from); 90 | } 91 | 92 | 93 | 94 | int Graph::verticesCount() const 95 | { 96 | return verticesNumber_; 97 | } 98 | 99 | 100 | 101 | void Graph::getNextVertices(int vertex, vector & vertices) const 102 | { 103 | for(int i : out_[vertex]) 104 | vertices.push_back(i); 105 | } 106 | 107 | 108 | 109 | int Graph::BFS(int vertex) 110 | { 111 | vector verticesStates(verticesNumber_); 112 | queue verticesQueue; 113 | verticesQueue.push(vertex); 114 | verticesStates[vertex].visited = true; 115 | 116 | while(!verticesQueue.empty()){ 117 | vector nextVertices; 118 | int currentVertex = verticesQueue.front(); 119 | verticesQueue.pop(); 120 | getNextVertices(currentVertex, nextVertices); 121 | 122 | for(int i : nextVertices){ 123 | if(!verticesStates[i].visited){ 124 | verticesQueue.push(i); 125 | verticesStates[i].visited = true; 126 | verticesStates[i].depth = verticesStates[currentVertex].depth + 1; 127 | verticesStates[i].father = currentVertex; 128 | } 129 | else if(i != verticesStates[currentVertex].father){ 130 | return verticesStates[currentVertex].depth + verticesStates[i].depth + 1; 131 | } 132 | } 133 | } 134 | return verticesNumber_ + 1; 135 | } 136 | 137 | 138 | 139 | int Graph::findMinCycle() 140 | { 141 | int minCycle = verticesNumber_ + 1; 142 | for(int i = 0; i < verticesNumber_; i++){ 143 | int cycle = BFS(i); 144 | if(cycle < minCycle) 145 | minCycle = cycle; 146 | } 147 | return minCycle; 148 | } 149 | 150 | /****************************GRAPH::PAIR***************************************/ 151 | 152 | Graph::Pair::Pair(): 153 | depth(0), 154 | visited(false) 155 | {} -------------------------------------------------------------------------------- /2sem/task1/3/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/2sem/task1/3/a.out -------------------------------------------------------------------------------- /2sem/task1/3/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | /******************************************************************************/ 8 | 9 | using std::unordered_set; 10 | using std::vector; 11 | using std::queue; 12 | using std::list; 13 | using std::cin; 14 | using std::cout; 15 | 16 | /******************************************************************************/ 17 | 18 | class Graph{ 19 | public: 20 | Graph(unsigned int verticesNumber); 21 | 22 | void addEdge(int from, int to); 23 | 24 | int verticesCount() const; 25 | 26 | void getNextVertices(int vertex, vector & vertices) const; 27 | 28 | // Counts paths between vertices 29 | int countPaths(int from, int to); 30 | 31 | private: 32 | // Stores info about visited vertex. Needed for countPaths() 33 | struct Vertex{ 34 | Vertex(); 35 | 36 | // Vertex' depth in BFS 37 | int depth; 38 | // Number of paths from first vertex 39 | int paths; 40 | }; 41 | 42 | unsigned int verticesNumber_; 43 | 44 | // Outgoing vertices 45 | vector> out_; 46 | }; 47 | 48 | /****************************GRAPH*********************************************/ 49 | 50 | int main() 51 | { 52 | unsigned int n = 0; 53 | cin >> n; 54 | Graph graph(n); 55 | 56 | // Building graph 57 | int k; 58 | cin >> k; 59 | for(int i = 0; i < k; i++){ 60 | int a, b; 61 | cin >> a >> b; 62 | graph.addEdge(a, b); 63 | } 64 | 65 | int from = 0; 66 | int to = 0; 67 | cin >> from >> to; 68 | 69 | cout << graph.countPaths(from, to); 70 | } 71 | 72 | 73 | 74 | Graph::Graph(unsigned int verticesNumber): 75 | verticesNumber_(verticesNumber), 76 | out_(verticesNumber_) 77 | {} 78 | 79 | 80 | 81 | void Graph::addEdge(int from, int to) 82 | { 83 | // Checking if edge already exists 84 | for(int i : out_[from]) 85 | if(i == to) 86 | return; 87 | 88 | out_[to].push_back(from); 89 | out_[from].push_back(to); 90 | } 91 | 92 | 93 | 94 | int Graph::verticesCount() const 95 | { 96 | return verticesNumber_; 97 | } 98 | 99 | 100 | 101 | void Graph::getNextVertices(int vertex, vector & vertices) const 102 | { 103 | for(int i : out_[vertex]) 104 | vertices.push_back(i); 105 | } 106 | 107 | 108 | 109 | int Graph::countPaths(int from, int to) 110 | { 111 | // Stores info about visited vertex 112 | vector states(verticesNumber_); 113 | // BFS queue 114 | queue q; 115 | q.push(from); 116 | states[from].paths = 1; 117 | 118 | // BFS from first vertex 119 | while(!q.empty()){ 120 | vector nextVertices; 121 | // Current vertex 122 | int v = q.front(); 123 | q.pop(); 124 | getNextVertices(v, nextVertices); 125 | 126 | for(int i : nextVertices){ 127 | if(states[i].paths == 0){ 128 | // If not visited push into queue 129 | q.push(i); 130 | states[i].depth = states[v].depth + 1; 131 | states[i].paths = states[v].paths; 132 | } 133 | else if(states[i].depth == states[v].depth + 1){ 134 | // If visited and has same depth increase path number 135 | states[i].paths += states[v].paths; 136 | } 137 | } 138 | } 139 | return states[to].paths; 140 | } 141 | 142 | /****************************GRAPH::PAIR***************************************/ 143 | 144 | Graph::Vertex::Vertex(): 145 | paths(0), 146 | depth(0) 147 | {} -------------------------------------------------------------------------------- /2sem/task1/4/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using std::vector; 5 | using std::cin; 6 | using std::cout; 7 | 8 | // Returns stok vertex or n, if there is no stok 9 | int findStok(vector> graph) 10 | { 11 | unsigned int n = graph.size(); 12 | 13 | // Stores true if vertex can be stok, false otherwise 14 | vector stok(n, true); 15 | 16 | for(int v = 0; v < n; v++){ 17 | // Skipping vertex if it can't be stok 18 | if(!stok[v]) 19 | continue; 20 | 21 | if(graph[v][v] == 0){ 22 | // Checking line in table 23 | int i = (v + 1) % n; 24 | while(i != v){ 25 | if(graph[v][i] == 0){ 26 | // Vertex k cant't be stok because its column has 0 27 | stok[i] = false; 28 | } 29 | else{ 30 | // Vertex from can't be stok because its line has 1 31 | stok[v] = false; 32 | break; 33 | } 34 | i = (i + 1) % n; 35 | } 36 | 37 | if(i == v){ 38 | // If line has no 1, checking column 39 | for(int m = 0; m < n; m++) 40 | if(graph[m][v] == 0 && m != v){ 41 | // If column has 0 vertex isn't stok, other 42 | // vertices also can't be stok 43 | return n; 44 | } 45 | // If line has no 1 and column has no 0, vertex is stok 46 | return v; 47 | } 48 | } 49 | else{ 50 | // If vertex has outgoing edge, it is not stok 51 | stok[v] = false; 52 | } 53 | } 54 | 55 | // If stok is not found, there is no stock 56 | return n; 57 | } 58 | 59 | int main() 60 | { 61 | unsigned int n = 0; 62 | cin >> n; 63 | 64 | // Reading table 65 | vector> graph(n, vector(n, 0)); 66 | for(int i = 0; i < n; i++) 67 | for(int j = 0; j < n; j++) 68 | cin >> graph[i][j]; 69 | 70 | if(findStok(graph) != n) 71 | cout << "YES"; 72 | else 73 | cout << "NO"; 74 | return 0; 75 | } -------------------------------------------------------------------------------- /2sem/task1/5/temp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /******************************************************************************/ 7 | 8 | using std::unordered_set; 9 | using std::vector; 10 | using std::list; 11 | using std::stack; 12 | 13 | /******************************************************************************/ 14 | 15 | class Graph{ 16 | public: 17 | 18 | Graph(unsigned int verticesNumber); 19 | 20 | void addEdge(int from, int to); 21 | 22 | int verticesCount() const; 23 | 24 | void getNextVertices(int vertex, vector & vertices) const; 25 | 26 | private: 27 | 28 | unsigned int verticesNumber_; 29 | 30 | vector> out_; 31 | 32 | }; 33 | 34 | /******************************************************************************/ 35 | 36 | class LCSGetter{ 37 | public: 38 | 39 | list> operator() (Graph * graph); 40 | 41 | private: 42 | 43 | void DFS(int vertex); 44 | 45 | int time_; 46 | 47 | Graph * graph_; 48 | 49 | stack stack_; 50 | 51 | list> components_; 52 | 53 | vector visited_; 54 | 55 | vector low_; 56 | 57 | }; 58 | 59 | /****************************MAIN**********************************************/ 60 | 61 | int main() 62 | { 63 | unsigned int n = 0; 64 | scanf("%d", &n); 65 | Graph graph(n); 66 | 67 | int k; 68 | scanf("%d", &k); 69 | for(int i = 0; i < k; i++){ 70 | int a, b; 71 | scanf("%d%d", &a, &b); 72 | graph.addEdge(a, b); 73 | } 74 | 75 | LCSGetter lcs; 76 | list> a = lcs(&graph); 77 | for(const list & i : a){ 78 | for(int j : i) 79 | printf("%d ", j); 80 | printf("\n"); 81 | } 82 | } 83 | 84 | /****************************GRAPH*********************************************/ 85 | 86 | Graph::Graph(unsigned int verticesNumber): 87 | verticesNumber_(verticesNumber), 88 | out_(verticesNumber_) 89 | {} 90 | 91 | 92 | 93 | void Graph::addEdge(int from, int to){ 94 | // Checking if edge already exists 95 | for(int i : out_[from]) 96 | if(i == to) 97 | return; 98 | 99 | out_[from].push_back(to); 100 | } 101 | 102 | 103 | 104 | int Graph::verticesCount() const{ 105 | return verticesNumber_; 106 | } 107 | 108 | 109 | 110 | void Graph::getNextVertices(int vertex, vector & vertices) const{ 111 | vertices.clear(); 112 | for(int i : out_[vertex]) 113 | vertices.push_back(i); 114 | } 115 | 116 | /****************************LCSCOUNTER****************************************/ 117 | 118 | list> LCSGetter::operator()(Graph * graph) 119 | { 120 | graph_ = graph; 121 | visited_.assign(graph_->verticesCount(), false); 122 | low_.reserve(graph_->verticesCount()); 123 | time_ = 0; 124 | 125 | for(int i = 0; i < graph->verticesCount(); i++){ 126 | if(!visited_[i]) 127 | DFS(i); 128 | } 129 | 130 | return components_; 131 | } 132 | 133 | 134 | 135 | void LCSGetter::DFS(int vertex) 136 | { 137 | low_[vertex] = time_++; 138 | visited_[vertex] = true; 139 | stack_.push(vertex); 140 | bool isRoot = true; 141 | 142 | vector children; 143 | graph_->getNextVertices(vertex, children); 144 | for(int i : children){ 145 | if(!visited_[i]) 146 | DFS(i); 147 | if(low_[i] < low_[vertex]){ 148 | low_[vertex] = low_[i]; 149 | isRoot = false; 150 | } 151 | } 152 | 153 | if(isRoot){ 154 | list component; 155 | while(true){ 156 | int x = stack_.top(); 157 | stack_.pop(); 158 | component.push_back(x); 159 | low_[x] = graph_->verticesCount() + 1; 160 | if(vertex == x) 161 | break; 162 | } 163 | components_.push_back(component); 164 | } 165 | } 166 | -------------------------------------------------------------------------------- /2sem/task1/6/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | /******************************************************************************/ 9 | 10 | using std::vector; 11 | using std::list; 12 | using std::cin; 13 | using std::cout; 14 | using std::pair; 15 | using std::queue; 16 | 17 | /******************************************************************************/ 18 | 19 | class Graph{ 20 | public: 21 | Graph(unsigned int verticesNumber); 22 | 23 | void addEdge(int from, int to); 24 | 25 | int verticesCount() const; 26 | 27 | int countPaths(int from, int to); 28 | 29 | void getNextVertices(int vertex, vector & vertices) const; 30 | 31 | void getPrevVertices(int vertex, vector & vertices) const; 32 | 33 | private: 34 | struct Vertex{ 35 | Vertex(); 36 | 37 | int depth; 38 | int pathes; 39 | }; 40 | 41 | unsigned int verticesNumber_; 42 | 43 | vector> out_; 44 | 45 | vector> in_; 46 | }; 47 | 48 | /******************************************************************************/ 49 | 50 | // Finds required diameter 51 | double search(int left, int right, int r, vector> cords) 52 | { 53 | double a = 0; 54 | double b = right - left; 55 | int n = cords.size(); 56 | // Binary search 57 | while(b - a > 5e-5){ 58 | double c = (a + b) / 2; 59 | Graph graph(n + 2); 60 | 61 | // Building graph 62 | // Adding edge if table doesn't fit 63 | for(int i = 0; i < n; i++) 64 | for(int j = 0; j < n; j++) 65 | if(sqrt(pow(cords[i].first - cords[j].first, 2) 66 | + pow(cords[i].second - cords[j].second, 2)) - 2 * r < c) 67 | graph.addEdge(i, j); 68 | for(int i = 0; i < n; i++){ 69 | if(cords[i].first - left - r < c) 70 | graph.addEdge(i, n); 71 | if(right - cords[i].first - r < c) 72 | graph.addEdge(i, n + 1); 73 | } 74 | 75 | if(graph.countPaths(n, n + 1) != 0) 76 | b = c; 77 | else 78 | a = c; 79 | } 80 | return a; 81 | } 82 | 83 | /******************************************************************************/ 84 | 85 | int main() 86 | { 87 | int left = 0; 88 | int right = 0; 89 | cin >> left >> right; 90 | int r = 0; 91 | cin >> r; 92 | unsigned n = 0; 93 | cin >> n; 94 | vector> cords(n, pair(0, 0)); 95 | for(int i = 0; i < n; i++) 96 | cin >> cords[i].first >> cords[i].second; 97 | 98 | cout << std::fixed << std::setprecision(3) << search(left, right, r, cords); 99 | } 100 | 101 | /******************************************************************************/ 102 | 103 | Graph::Graph(unsigned int verticesNumber): 104 | verticesNumber_(verticesNumber), 105 | out_(verticesNumber_), 106 | in_(verticesNumber_) 107 | {} 108 | 109 | 110 | 111 | void Graph::addEdge(int from, int to) 112 | { 113 | // Checking if edge already exists 114 | for(int i : out_[from]) 115 | if(i == to) 116 | return; 117 | 118 | out_[from].push_back(to); 119 | in_[to].push_back(from); 120 | out_[to].push_back(from); 121 | in_[from].push_back(to); 122 | } 123 | 124 | 125 | 126 | int Graph::verticesCount() const 127 | { 128 | return verticesNumber_; 129 | } 130 | 131 | 132 | 133 | void Graph::getNextVertices(int vertex, vector & vertices) const 134 | { 135 | vertices.clear(); 136 | for(int i : out_[vertex]) 137 | vertices.push_back(i); 138 | } 139 | 140 | 141 | 142 | void Graph::getPrevVertices(int vertex, vector & vertices) const 143 | { 144 | vertices.clear(); 145 | for(int i : in_[vertex]) 146 | vertices.push_back(i); 147 | } 148 | 149 | 150 | 151 | int Graph::countPaths(int from, int to) 152 | { 153 | vector verticesStates(verticesNumber_); 154 | queue verticesQueue; 155 | verticesQueue.push(from); 156 | verticesStates[from].pathes = 1; 157 | 158 | while(!verticesQueue.empty()){ 159 | vector nextVertices; 160 | int currentVertex = verticesQueue.front(); 161 | verticesQueue.pop(); 162 | getNextVertices(currentVertex, nextVertices); 163 | 164 | for(int i : nextVertices){ 165 | if(!verticesStates[i].pathes){ 166 | verticesQueue.push(i); 167 | verticesStates[i].depth = verticesStates[currentVertex].depth + 1; 168 | verticesStates[i].pathes = verticesStates[currentVertex].pathes; 169 | } 170 | else if(verticesStates[i].depth == verticesStates[currentVertex].depth + 1){ 171 | verticesStates[i].pathes += verticesStates[currentVertex].pathes; 172 | } 173 | } 174 | } 175 | return verticesStates[to].pathes; 176 | } 177 | 178 | /****************************GRAPH::PAIR***************************************/ 179 | 180 | Graph::Vertex::Vertex(): 181 | pathes(0), 182 | depth(0) 183 | {} -------------------------------------------------------------------------------- /2sem/task2/1/int_main: -------------------------------------------------------------------------------- 1 | int main() { 2 | // Initializing graph 3 | unsigned n = 0; 4 | unsigned m = 0; 5 | cin >> n >> m; 6 | Graph graph(n); 7 | for (unsigned i = 0; i < m; i++) { 8 | unsigned s = 0; 9 | unsigned t = 0; 10 | unsigned w = 0; 11 | cin >> s >> t >> w; 12 | graph.addEdge(s, t, w); 13 | } 14 | unsigned from = 0; 15 | unsigned to = 0; 16 | cin >> from >> to; 17 | 18 | vector lens; 19 | dijkstra(graph, from, lens); 20 | 21 | if (lens[to] != INFINITY) 22 | cout << (lens[to]); 23 | else 24 | cout << -1; 25 | 26 | return 0; 27 | } -------------------------------------------------------------------------------- /2sem/task2/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /******************************************************************************/ 7 | 8 | using std::vector; 9 | using std::cin; 10 | using std::cout; 11 | using std::set; 12 | using std::pair; 13 | using std::make_pair; 14 | using std::list; 15 | 16 | const unsigned INFINITY = 4294967295; 17 | 18 | typedef pair pair_uu; 19 | 20 | /******************************************************************************/ 21 | 22 | // Undirected graph. List realization 23 | class Graph { 24 | public: 25 | Graph(unsigned verticesNumber); 26 | 27 | void addEdge(unsigned from, unsigned to, unsigned weight); 28 | 29 | // Vertices - vector of pairs 30 | void getRelated(unsigned vertex, vector &vertices) const; 31 | 32 | unsigned getSize() const; 33 | 34 | private: 35 | unsigned size_; 36 | vector> edges_; 37 | }; 38 | 39 | /******************************************************************************/ 40 | 41 | int dijkstra(Graph const &graph, int from, int to) { 42 | // Stores true is [i] vertex was extracted from the queue 43 | vector used(graph.getSize(), false); 44 | // Stores length of path to [i] vertex 45 | vector path(graph.getSize(), INFINITY); 46 | path[from] = 0; 47 | // Priority queue 48 | set queue; 49 | queue.emplace(make_pair(0, from)); 50 | // Dijkstra algorithm 51 | while (!queue.empty()) { 52 | // Extracting vertex with minimal path 53 | unsigned v = (queue.begin())->second; 54 | queue.erase(queue.begin()); 55 | used[v] = true; 56 | 57 | // Relaxing every related vertex 58 | vector paths; 59 | graph.getRelated(v, paths); 60 | for (pair_uu c : paths) { 61 | if (path[c.first] > path[v] + c.second) { 62 | // Remove old value from queue 63 | if (path[c.first] != INFINITY) 64 | queue.erase(make_pair(path[c.first], c.first)); 65 | // Update path and insert it into queue 66 | path[c.first] = path[v] + c.second; 67 | queue.emplace(pair(path[c.first], c.first)); 68 | } 69 | } 70 | } 71 | 72 | // Return distance to the target vertex or -1 if target is unreachable 73 | return ((path[to] != INFINITY) ? (static_cast(path[to])) : (-1)); 74 | } 75 | 76 | /******************************************************************************/ 77 | 78 | int main() { 79 | std::ios::sync_with_stdio(false); 80 | // Initializing graph 81 | unsigned n = 0; 82 | unsigned m = 0; 83 | cin >> n >> m; 84 | Graph graph(n); 85 | for (unsigned i = 0; i < m; i++) { 86 | unsigned s = 0; 87 | unsigned t = 0; 88 | unsigned w = 0; 89 | cin >> s >> t >> w; 90 | graph.addEdge(s, t, w); 91 | } 92 | unsigned from = 0; 93 | unsigned to = 0; 94 | cin >> from >> to; 95 | 96 | // Printing answer 97 | cout << dijkstra(graph, from, to); 98 | 99 | return 0; 100 | } 101 | 102 | /****************************GRAPH*********************************************/ 103 | 104 | Graph::Graph(unsigned int size) : 105 | size_(size), 106 | edges_(size_, list()) {} 107 | 108 | 109 | void Graph::addEdge(unsigned from, unsigned to, unsigned weight) 110 | { 111 | edges_[from].push_back(make_pair(to, weight)); 112 | edges_[to].push_back(make_pair(from, weight)); 113 | } 114 | 115 | 116 | unsigned Graph::getSize() const 117 | { 118 | return size_; 119 | } 120 | 121 | 122 | void Graph::getRelated(unsigned vertex, vector &vertices) const 123 | { 124 | vertices.clear(); 125 | for (const pair_uu &i : edges_[vertex]) 126 | vertices.push_back(i); 127 | } -------------------------------------------------------------------------------- /2sem/task2/2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /******************************************************************************/ 5 | 6 | using std::vector; 7 | using std::cin; 8 | using std::cout; 9 | 10 | /******************************************************************************/ 11 | 12 | class Graph { 13 | public: 14 | Graph(unsigned verticesNumber); 15 | 16 | void addEdge(int from, int to, double weight); 17 | 18 | unsigned getSize() const; 19 | 20 | void getNext(int vertex, vector &vertices) const; 21 | void getPrev(int vertex, vector &vertices) const; 22 | 23 | double getWeight(int v, int u) const; 24 | 25 | private: 26 | unsigned int size_; 27 | vector> matr_; 28 | }; 29 | 30 | /******************************************************************************/ 31 | 32 | // Returns true if arbitrage exists 33 | // T = O(|E||V|^2) (O(|V|^4) for matrix graph 34 | // Bellman-Ford algorithm finds only negative cycles 35 | // which may be reached from start vertex, 36 | // so it is launched for every vertex in the graph 37 | bool arbitrage(const Graph &graph) { 38 | // Launching B.-F. algorithm for every vertex 39 | for (int k = 0; k < graph.getSize(); k++) { 40 | // Initializing vector storing cost of the [i]s currency 41 | // in initial currency 42 | vector d(graph.getSize(), -1.0); 43 | // Initial currency 44 | d[k] = 1.0; 45 | vector vertices(graph.getSize()); 46 | // Relaxing vertices |V| - 1 time 47 | for (int i = 0; i < graph.getSize() - 1; i++) { 48 | for (int v = 0; v < graph.getSize(); v++) { 49 | graph.getPrev(v, vertices); 50 | for (int u : vertices) 51 | if (d[u] != -1.0 && d[v] < d[u] * graph.getWeight(u, v)) 52 | d[v] = d[u] * graph.getWeight(u, v); 53 | } 54 | } 55 | // Checking for negative cycles 56 | for (int v = 0; v < graph.getSize(); v++) { 57 | graph.getPrev(v, vertices); 58 | for (int u : vertices) 59 | if (d[u] != -1.0 && d[v] < d[u] * graph.getWeight(u, v)) 60 | return true; // Return true if found 61 | } 62 | } 63 | // Return false if cycle was not found 64 | return false; 65 | } 66 | 67 | /******************************************************************************/ 68 | 69 | int main() { 70 | // Initialising graph 71 | unsigned n = 0; 72 | cin >> n; 73 | Graph graph(n); 74 | for (int i = 0; i < n; i++) { 75 | for (int j = 0; j < n; j++) { 76 | if (i == j) 77 | continue; 78 | double x; 79 | cin >> x; 80 | graph.addEdge(i, j, x); 81 | } 82 | } 83 | // Finding arbitrage 84 | cout << ((arbitrage(graph))?"YES":"NO"); 85 | return 0; 86 | } 87 | 88 | /****************************GRAPH*********************************************/ 89 | 90 | Graph::Graph(unsigned int size) : 91 | size_(size), 92 | matr_(size_, vector(size_, -1)) {} 93 | 94 | 95 | void Graph::addEdge(int from, int to, double weight) 96 | { 97 | matr_[from][to] = weight; 98 | } 99 | 100 | 101 | unsigned Graph::getSize() const 102 | { 103 | return size_; 104 | } 105 | 106 | 107 | void Graph::getNext(int vertex, vector &vertices) const 108 | { 109 | vertices.clear(); 110 | for (int i = 0; i < size_; i++) 111 | if (matr_[vertex][i] != -1) 112 | vertices.push_back(i); 113 | } 114 | 115 | 116 | void Graph::getPrev(int vertex, vector &vertices) const 117 | { 118 | vertices.clear(); 119 | for (int i = 0; i < size_; i++) 120 | if (matr_[i][vertex] != -1) 121 | vertices.push_back(i); 122 | } 123 | 124 | 125 | double Graph::getWeight(int v, int u) const 126 | { 127 | return matr_[v][u]; 128 | } -------------------------------------------------------------------------------- /2sem/task2/3/puzzle.in: -------------------------------------------------------------------------------- 1 | 1 2 3 2 | 8 0 4 3 | 7 6 5 -------------------------------------------------------------------------------- /2sem/task2/3/puzzle.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/2sem/task2/3/puzzle.out -------------------------------------------------------------------------------- /2sem/task2/4/input.txt: -------------------------------------------------------------------------------- 1 | 4 3 7 8 2 | 2 13 12 11 3 | 1 6 10 15 4 | 5 9 0 14 -------------------------------------------------------------------------------- /2sem/task2/4/output.txt: -------------------------------------------------------------------------------- 1 | 33 2 | DRDDRUUULDLULDDRDRUULLDDRRRUUULLL -------------------------------------------------------------------------------- /2sem/task2/5/puzzle.in: -------------------------------------------------------------------------------- 1 | 6 3 7 0 2 | 2 1 4 8 3 | 10 5 11 15 4 | 9 13 12 14 5 | 6 | 6 3 7 0 7 | 2 1 4 8 8 | 10 5 11 15 9 | 9 13 12 14 10 | 11 | 31 12 | -------------------------------------------------------------------------------- /2sem/task2/5/puzzle.out: -------------------------------------------------------------------------------- 1 | 15 2 | DRURULDDRULURDD -------------------------------------------------------------------------------- /2sem/task2/6/floyd.in: -------------------------------------------------------------------------------- 1 | 4 2 | 0 5 9 100 3 | 100 0 2 8 4 | 100 100 0 7 5 | 4 100 100 0 -------------------------------------------------------------------------------- /2sem/task2/6/floyd.out: -------------------------------------------------------------------------------- 1 | 0 5 7 13 2 | 12 0 2 8 3 | 11 16 0 7 4 | 4 9 11 0 5 | -------------------------------------------------------------------------------- /2sem/task2/6/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /******************************************************************************/ 5 | 6 | using std::vector; 7 | using std::min; 8 | 9 | /******************************************************************************/ 10 | 11 | // Floyd algorithm 12 | void floyd(vector> & graph){ 13 | for(int k = 0; k < graph.size(); k++) 14 | for(int i = 0; i < graph.size(); i++) 15 | for(int j = 0; j < graph.size(); j++) 16 | graph[i][j] = min(graph[i][j], graph[i][k] + graph[k][j]); 17 | } 18 | 19 | /******************************************************************************/ 20 | 21 | int main() { 22 | std::ifstream fin("floyd.in"); 23 | std::ofstream fout("floyd.out"); 24 | 25 | // Initializing graph 26 | unsigned n = 1; 27 | fin >> n; 28 | vector> graph(n, vector(n, 0)); 29 | for(int i = 0; i < n; i++) 30 | for(int j = 0; j < n; j++){ 31 | double a = 101; 32 | fin >> a; 33 | graph[i][j] = a; 34 | } 35 | 36 | // Starting floyd algorithm 37 | floyd(graph); 38 | 39 | for(int i = 0; i < n; i++){ 40 | for(int j = 0; j < n; j++) 41 | fout << graph[i][j] << ' '; 42 | fout << '\n'; 43 | } 44 | 45 | fin.close(); 46 | fout.close(); 47 | 48 | return 0; 49 | } -------------------------------------------------------------------------------- /2sem/task3/1/kruskal.in: -------------------------------------------------------------------------------- 1 | 4 4 2 | 1 2 1 3 | 2 3 2 4 | 3 4 5 5 | 4 1 4 -------------------------------------------------------------------------------- /2sem/task3/1/kruskal.out: -------------------------------------------------------------------------------- 1 | 7 -------------------------------------------------------------------------------- /2sem/task3/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /******************************************************************************/ 7 | 8 | using std::vector; 9 | using std::list; 10 | using std::ifstream; 11 | using std::ofstream; 12 | using std::pair; 13 | using std::make_pair; 14 | using std::set; 15 | using std::swap; 16 | 17 | const unsigned INFINITY = 4294967295; 18 | 19 | typedef pair pair_uu; 20 | 21 | /******************************************************************************/ 22 | 23 | // Undirected pseudograph. List realization 24 | class Graph { 25 | public: 26 | Graph(unsigned verticesNumber); 27 | 28 | void addEdge(unsigned from, unsigned to, unsigned weight); 29 | 30 | // Vertices - vector of pairs 31 | void getRelated(unsigned vertex, vector &vertices) const; 32 | 33 | unsigned getSize() const; 34 | 35 | private: 36 | unsigned size_; 37 | vector> edges_; 38 | }; 39 | 40 | /******************************************************************************/ 41 | 42 | unsigned MSTWeight(const Graph & graph){ 43 | // Stores weight of minimal edge from used to unused for [i] vertex 44 | vector key(graph.getSize(), INFINITY); 45 | // Stores true if [i] vertex was used in MST 46 | vector used(graph.getSize(), false); 47 | // Priority queue 48 | set queue; 49 | 50 | // Initializing keys 51 | key[0] = 0; 52 | for(int i = 0; i < graph.getSize(); i++) 53 | queue.emplace(make_pair(key[i], i)); 54 | 55 | // Prim's algorithm 56 | while(!queue.empty()){ 57 | // Extracting minimum 58 | unsigned v = queue.begin()->second; 59 | queue.erase(queue.begin()); 60 | used[v] = true; 61 | // Relaxing related vertices 62 | vector related; 63 | graph.getRelated(v, related); 64 | for(const pair_uu & u : related){ 65 | if(!used[u.first] && key[u.first] > u.second){ 66 | // Decreasing key 67 | queue.erase(queue.find(make_pair(key[u.first], u.first))); 68 | key[u.first] = u.second; 69 | queue.emplace(key[u.first], u.first); 70 | } 71 | } 72 | } 73 | 74 | // Recovering answer. Key stores weights of edges in MST 75 | unsigned ans = 0; 76 | for(unsigned w : key){ 77 | ans += w; 78 | } 79 | return ans; 80 | } 81 | 82 | /******************************************************************************/ 83 | 84 | int main() { 85 | ifstream fin("kruskal.in"); 86 | ofstream fout("kruskal.out"); 87 | 88 | // Initializing graph 89 | unsigned n = 0; 90 | unsigned m = 0; 91 | fin >> n >> m; 92 | Graph graph(n); 93 | for(unsigned i = 0; i < m; i++){ 94 | unsigned a = 0; 95 | unsigned b = 0; 96 | unsigned w = 0; 97 | fin >> a >> b >> w; 98 | graph.addEdge(a - 1, b - 1, w); 99 | } 100 | // Printing answer 101 | fout << MSTWeight(graph); 102 | 103 | fin.close(); 104 | fout.close(); 105 | } 106 | 107 | /****************************GRAPH*********************************************/ 108 | 109 | Graph::Graph(unsigned int size) : 110 | size_(size), 111 | edges_(size_, list()) {} 112 | 113 | 114 | void Graph::addEdge(unsigned from, unsigned to, unsigned weight) 115 | { 116 | edges_[from].push_back(make_pair(to, weight)); 117 | edges_[to].push_back(make_pair(from, weight)); 118 | } 119 | 120 | 121 | unsigned Graph::getSize() const 122 | { 123 | return size_; 124 | } 125 | 126 | 127 | void Graph::getRelated(unsigned vertex, 128 | vector &vertices) const 129 | { 130 | vertices.clear(); 131 | for(const pair_uu & i : edges_[vertex]) 132 | vertices.push_back(i); 133 | } -------------------------------------------------------------------------------- /2sem/task3/2/2_Traveling_Salesman_Problem_Valentinov.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/2sem/task3/2/2_Traveling_Salesman_Problem_Valentinov.zip -------------------------------------------------------------------------------- /2sem/task3/2/dots.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | * * 14 | 15 | 16 | * * * ** 17 | * 18 | * * 19 | ** ** * 20 | * * * * 21 | * * * * * 22 | * * ** * ** * 23 | * * * * * 24 | * * * * ** * * * 25 | ** * ** * ** **** * * * 26 | * * * * * ** ** * 27 | * * *** * * * 28 | * * ** **** * *** ** * * 29 | ** * ****** * * ** * * * 30 | * ** * * ****** ** * ** 31 | ** * * * **** ** * * * * 32 | ** *** *** ** ****** ** * 33 | * **** **** ***** * * ** ** * 34 | * ** ******* * *** * * 35 | * ** * * *************** * * * 36 | * * ** *** *** ** ******** ** * * 37 | * * * ***** ****** *** ** *** * 38 | * *** ******** ** **** * * * 39 | * * ** * ***** ** ** * ****** * * * 40 | * *** **** *** ********** * * * * 41 | * * ******************** *** **** * 42 | * * * * ****** * **** ** ** * 43 | * * ******** ******* * ******* * * * 44 | * * ** ** * **** * **** * * * * 45 | * * ****** **** ***** ** * * * 46 | * ** * **** ** *** *** * ** * * 47 | * * ** * * * ****** * ** ** ** 48 | * * *** *** **** *** ******* * * 49 | * * * **** ******* ** ** 50 | * * * *** * **** * *** **** * * * * 51 | * ** * * ** ** * ** 52 | * ** ** * * ** ** * * * 53 | ** * ** * ** *** * * * 54 | * ***** ** *** * 55 | * * * * * * 56 | * * * ** * * 57 | * * * ** ** * 58 | * * * ** * * 59 | * * * **** ** * 60 | * * ** * 61 | *** 62 | * * 63 | * 64 | * 65 | * * 66 | * * * * 67 | 68 | 69 | 70 | * * 71 | 72 | * 73 | 74 | * * 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | -------------------------------------------------------------------------------- /2sem/task3/2/include/MST.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #ifndef INC_2_MST_H 6 | #define INC_2_MST_H 7 | 8 | 9 | #include "graph.h" 10 | #include 11 | #include 12 | 13 | using std::queue; 14 | using std::set; 15 | 16 | // Generates minimum spanning tree in result 17 | void MST(const Graph &graph, Graph & result); 18 | 19 | #endif //INC_2_MST_H 20 | -------------------------------------------------------------------------------- /2sem/task3/2/include/TSP_BF.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/22/17. 3 | // 4 | 5 | #ifndef INC_2_TSP_BF_H 6 | #define INC_2_TSP_BF_H 7 | 8 | #include "graph.h" 9 | 10 | // Function object for Brute Force solution 11 | class MinTourLenBF{ 12 | public: 13 | // Returns length of exact minimal traveling salesman tour 14 | double operator()(const Graph & graph); 15 | 16 | private: 17 | // Recursive function for getting all possible tours 18 | void permutations(unsigned depth); 19 | 20 | // Gets length of tour stored in tour 21 | double getTourLen(); 22 | 23 | // Pointer to original graph 24 | Graph const * graph_; 25 | // Number of dots 26 | unsigned n_; 27 | // Stores tour without 0 vertex 28 | vector tour_; 29 | // Stores length of min tour 30 | double minTour_; 31 | }; 32 | 33 | #endif //INC_2_TSP_BF_H 34 | -------------------------------------------------------------------------------- /2sem/task3/2/include/TSP_MST.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/22/17. 3 | // 4 | 5 | #ifndef INC_2_TSP_MST_H 6 | #define INC_2_TSP_MST_H 7 | 8 | #include "graph.h" 9 | #include "MST.h" 10 | 11 | // Function object for solution using MST 12 | class MinTourLenMST{ 13 | public: 14 | // Returns estimated length of traveling salesman tour 15 | double operator()(const Graph & graph); 16 | 17 | private: 18 | // Function for finding Euler path in graph 19 | void DFS(const Graph & mst, unsigned dot); 20 | 21 | // Stores tour found in DFS 22 | vector tour_; 23 | // Stores used in DFS 24 | vector used_; 25 | // Number of vertices 26 | unsigned n_; 27 | }; 28 | 29 | #endif //INC_2_TSP_MST_H 30 | -------------------------------------------------------------------------------- /2sem/task3/2/include/checker.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/22/17. 3 | // 4 | 5 | #ifndef INC_2_CHECKER_H 6 | #define INC_2_CHECKER_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include "graph.h" 12 | #include "dots.h" 13 | #include "TSP_BF.h" 14 | #include "TSP_MST.h" 15 | 16 | using std::cin; 17 | using std::cout; 18 | using std::fixed; 19 | using std::setw; 20 | using std::setprecision; 21 | using std::move; 22 | 23 | // Container for test results 24 | struct TestResults{ 25 | TestResults(bool success, 26 | time_t time, 27 | double ansBF, 28 | double ansMST, 29 | double error); 30 | 31 | // True if test was passed 32 | bool success; 33 | // Time of testing in seconds 34 | time_t time; 35 | // Brute force answer 36 | double ansBF; 37 | // MST answer 38 | double ansMST; 39 | // Error 40 | double error; 41 | }; 42 | 43 | // Runs test for every seed in seeds and every number of dots in ns 44 | // Criteria is maximal ratio of MST answer to BF answer 45 | TestResults && runTests(const vector & seeds, 46 | const vector & ns, 47 | double criteria); 48 | 49 | // Runs test for every seed in [0..maxSeed] 50 | // and every number of dots im n [2..maxN] 51 | // Criteria is maximal permissible ratio of MST answer to BF answer 52 | TestResults && runTests(unsigned maxSeed = 100, 53 | unsigned maxN = 10, 54 | double criteria = 2); 55 | 56 | TestResults && runTests(const vector & seeds, 57 | unsigned maxN, 58 | double criteria = 2); 59 | 60 | TestResults && runTests(unsigned maxSeed, 61 | const vector & ns, 62 | double criteria = 2); 63 | 64 | // Runs test with specific seed and number of dots (n) 65 | // Criteria is maximal ratio of MST answer to BF answer 66 | TestResults && runTest(unsigned seed, unsigned n, double criteria); 67 | 68 | #endif //INC_2_CHECKER_H 69 | -------------------------------------------------------------------------------- /2sem/task3/2/include/dots.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #ifndef INC_2_DOTS_H 6 | #define INC_2_DOTS_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include "graph.h" 12 | 13 | using std::pair; 14 | using std::vector; 15 | using std::srand; 16 | using std::rand; 17 | using std::sqrt; 18 | using std::log; 19 | using std::move; 20 | 21 | typedef pair dot; 22 | 23 | // graph is connected graph where vertices are dots with integral coordinates 24 | // generated with Gaussian distribution (dispersion 100, expected value (0,0)) 25 | // and edges are distances between this dots 26 | void generateDots(unsigned seed, Graph & graph); 27 | 28 | #endif //INC_2_DOTS_H 29 | -------------------------------------------------------------------------------- /2sem/task3/2/include/graph.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #ifndef INC_2_GRAPH_H 6 | #define INC_2_GRAPH_H 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | using std::vector; 14 | using std::pair; 15 | using std::make_pair; 16 | using std::min; 17 | 18 | typedef pair pair_ud; 19 | typedef pair pair_du; 20 | 21 | class Graph { 22 | public: 23 | Graph(unsigned verticesNumber); 24 | 25 | void addEdge(unsigned from, unsigned to, double weight); 26 | 27 | // Vertices - vector of pairs 28 | void getRelated(unsigned vertex, vector &vertices) const; 29 | 30 | unsigned getSize() const; 31 | 32 | double getWeight(unsigned from, unsigned to) const; 33 | 34 | void print(); 35 | 36 | private: 37 | unsigned size_; 38 | vector> matrix_; 39 | }; 40 | 41 | 42 | #endif //INC_2_GRAPH_H 43 | -------------------------------------------------------------------------------- /2sem/task3/2/src/MST.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #include "../include/MST.h" 6 | 7 | void MST(const Graph &graph, Graph & result) 8 | { 9 | const unsigned INFINITY = 2147483647; 10 | // Stores pair for every edge 11 | vector key(graph.getSize(), pair_ud(INFINITY, -1)); 12 | // Stores true if [i] vertex was used in MST 13 | vector used(graph.getSize(), false); 14 | // Priority queue 15 | set queue; 16 | 17 | // Initializing keys 18 | key[0].second = 0; 19 | for(int i = 0; i < graph.getSize(); i++) 20 | queue.emplace(pair_du(key[i].second, i)); 21 | 22 | // Prim's algorithm 23 | while(!queue.empty()){ 24 | // Extracting minimum 25 | unsigned v = queue.begin()->second; 26 | queue.erase(queue.begin()); 27 | used[v] = true; 28 | // Relaxing related vertices 29 | vector related; 30 | graph.getRelated(v, related); 31 | for(const pair_ud & u : related){ 32 | if(!used[u.first] && key[u.first].second > u.second 33 | || key[u.first].second + 1 < 0.000001){ 34 | // Decreasing key 35 | queue.erase(pair_du(key[u.first].second, u.first)); 36 | key[u.first].first = v; 37 | key[u.first].second = u.second; 38 | queue.emplace(key[u.first].second , u.first); 39 | } 40 | } 41 | } 42 | 43 | for(unsigned i = 1; i < graph.getSize(); i++) 44 | result.addEdge(i, key[i].first, key[i].second); 45 | } -------------------------------------------------------------------------------- /2sem/task3/2/src/TSP_BF.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/22/17. 3 | // 4 | 5 | #include "../include/TSP_BF.h" 6 | 7 | double MinTourLenBF::operator()(const Graph & graph) 8 | { 9 | graph_ = &graph; 10 | n_ = graph_->getSize(); 11 | 12 | if(n_ <= 1) 13 | return 0; 14 | 15 | // Initializing minTour_ with trivial permutation 16 | tour_.clear(); 17 | for(unsigned i = 1; i < n_; i++) 18 | tour_.push_back(i); 19 | minTour_ = getTourLen(); 20 | 21 | // Checking all permutations 22 | permutations(1); 23 | 24 | return minTour_; 25 | } 26 | 27 | 28 | 29 | void MinTourLenBF::permutations(unsigned depth) 30 | { 31 | // If every vertex is used in tour, check it an return 32 | if(depth == tour_.size()){ 33 | double tour = getTourLen(); 34 | if(tour < minTour_) 35 | minTour_ = tour; 36 | return; 37 | } 38 | 39 | // Recursively getting permutations 40 | for(int i = 0; i <= depth; i++){ 41 | // Swap 42 | unsigned tmp = tour_[i]; 43 | tour_[i] = tour_[depth]; 44 | tour_[depth] = tmp; 45 | 46 | permutations(depth + 1); 47 | 48 | // Swap 49 | tmp = tour_[i]; 50 | tour_[i] = tour_[depth]; 51 | tour_[depth] = tmp; 52 | } 53 | } 54 | 55 | 56 | 57 | double MinTourLenBF::getTourLen() 58 | { 59 | double tour = graph_->getWeight(tour_[n_ - 2], 0) 60 | + graph_->getWeight(0, tour_[0]); 61 | for(unsigned i = 1; i < n_ - 1; i++) 62 | tour += graph_->getWeight(tour_[i - 1], tour_[i]); 63 | return tour; 64 | } -------------------------------------------------------------------------------- /2sem/task3/2/src/TSP_MST.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/23/17. 3 | // 4 | 5 | #include "../include/TSP_MST.h" 6 | 7 | double MinTourLenMST::operator()(const Graph & graph) 8 | { 9 | n_ = graph.getSize(); 10 | 11 | //Finding MST 12 | Graph mst(n_); 13 | MST(graph, mst); 14 | 15 | // Finding tour 16 | used_.assign(n_, false); 17 | used_[0] = true; 18 | DFS(mst, 0); 19 | 20 | // Finding tour length 21 | double tour = graph.getWeight(tour_[n_ - 2], 0) 22 | + graph.getWeight(0, tour_[0]); 23 | for(unsigned i = 1; i < n_ - 1; i++) 24 | tour += graph.getWeight(tour_[i - 1], tour_[i]); 25 | 26 | return tour; 27 | } 28 | 29 | 30 | 31 | void MinTourLenMST::DFS(const Graph & mst, unsigned dot) 32 | { 33 | // Pre-order DFS 34 | vector related; 35 | mst.getRelated(dot, related); 36 | for(const pair_ud & ud : related){ 37 | if(!used_[ud.first]){ 38 | tour_.push_back(ud.first); 39 | used_[ud.first] = true; 40 | DFS(mst, ud.first); 41 | } 42 | } 43 | } -------------------------------------------------------------------------------- /2sem/task3/2/src/checker.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/23/17. 3 | // 4 | 5 | #include "../include/checker.h" 6 | 7 | TestResults::TestResults(bool success, 8 | time_t time, 9 | double ansBF, 10 | double ansMST, 11 | double error): 12 | success(success), 13 | time(time), 14 | ansBF(ansBF), 15 | ansMST(ansMST), 16 | error(error) {} 17 | 18 | 19 | 20 | TestResults && runTests(const vector & seeds, 21 | const vector & ns, 22 | double criteria) 23 | { 24 | // Number of successful tests 25 | unsigned s = 0; 26 | // Number of failed tests 27 | unsigned f = 0; 28 | // Total time 29 | time_t timer = 0; 30 | // Avg MST answer 31 | double avgMST = 0; 32 | // Avg BF answer 33 | double avgBF = 0; 34 | // Standard deviation 35 | double stDeviation = 0; 36 | // Running test for every seed and number of dots 37 | for(unsigned seed : seeds){ 38 | for(unsigned n : ns) { 39 | TestResults results = runTest(seed, n, criteria); 40 | if(results.success) 41 | s++; 42 | else 43 | f++; 44 | timer += results.time; 45 | avgMST += results.ansMST; 46 | avgBF += results.ansBF; 47 | stDeviation += results.error; 48 | } 49 | } 50 | avgMST /= f + s; 51 | avgBF /= f + s; 52 | stDeviation = sqrt(stDeviation) / (f + s); 53 | // Printing summary 54 | cout << setw(42) <<"============Testing summary============\n= " 55 | << setw(8) << s << setw(32) << " tests passed =\n= " 56 | << setw(8) << f << setw(32) << " tests failed =\n= " 57 | << setw(8) << s + f << setw(32) << " tests total =\n= " 58 | << setw(8) << timer + 1 << setw(32) << " ttl time =\n= " 59 | << setw(8) << std::fixed << setprecision(3) 60 | << (float)(timer + 1) / (s + f) << setw(32) << " avg time =\n= " 61 | << setw(8) << avgBF << setw(32) << " AVG BF answer =\n= " 62 | << setw(8) << avgMST << setw(32) << " AVG MST answer =\n= " 63 | << setw(8) << stDeviation << setw(32) << " Standard deviation =\n= " 64 | << setw(8) << stDeviation / 100 << setw(30) << "Normalized st. deviation =\n"; 65 | 66 | if (f == 0) 67 | cout << setw(40) << "----------Testing successful----------\n"; 68 | else 69 | cout << setw(40) << "------------Testing failed------------\n"; 70 | 71 | return move(TestResults(f == 0, timer, avgBF, avgMST, stDeviation)); 72 | } 73 | 74 | 75 | 76 | TestResults && runTests(unsigned maxSeed, 77 | unsigned maxN, 78 | double criteria) 79 | { 80 | vector seeds; 81 | for(unsigned i = 0; i <= maxSeed; i++) 82 | seeds.push_back(i); 83 | vector ns; 84 | for(unsigned i = 2; i <= maxN; i++) 85 | ns.push_back(i); 86 | return runTests(seeds, ns, criteria); 87 | } 88 | 89 | 90 | 91 | TestResults && runTests(const vector & seeds, 92 | unsigned maxN, 93 | double criteria) 94 | { 95 | vector ns; 96 | for(unsigned i = 2; i <= maxN; i++) 97 | ns.push_back(i); 98 | return runTests(seeds, ns, criteria); 99 | } 100 | 101 | 102 | 103 | TestResults && runTests(unsigned maxSeed, 104 | const vector & ns, 105 | double criteria) 106 | { 107 | vector seeds; 108 | for(unsigned i = 0; i <= maxSeed; i++) 109 | seeds.push_back(i); 110 | return runTests(seeds, ns, criteria); 111 | } 112 | 113 | 114 | 115 | 116 | TestResults && runTest(unsigned seed, unsigned n, double criteria) 117 | { 118 | // Initializing graph 119 | Graph graph(n); 120 | generateDots(seed, graph); 121 | 122 | // Running test 123 | time_t timer = -time(NULL); 124 | MinTourLenBF minTourLenBF; 125 | MinTourLenMST minTourLenMST; 126 | double bf = minTourLenBF(graph); 127 | double mst = minTourLenMST(graph); 128 | timer += time(NULL); 129 | 130 | // Printing test results 131 | if(1 <= mst / bf && mst / bf <= criteria) 132 | cout << "[SUCCESS]"; 133 | else 134 | cout << "[FAILURE]"; 135 | double err = fabs(mst - bf)/bf * 100; 136 | cout << std::fixed << setprecision(2) 137 | << " BF Answer: " << bf << " <-> MST Answer: " << mst 138 | << "\n[ " << (int)((100 - err >= 0)?(100 - err):(0)) << "% ]" 139 | << "TIME: " << timer 140 | << ", ERR: " << fabs(mst - bf) 141 | << " // SEED: " << seed 142 | << ", N: " << n << "\n\n"; 143 | 144 | return move(TestResults(1 <= mst / bf && mst / bf <= criteria, 145 | timer, bf, mst, fabs(mst - bf))); 146 | } 147 | -------------------------------------------------------------------------------- /2sem/task3/2/src/dots.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #include "../include/dots.h" 6 | 7 | void generateDots(unsigned seed, Graph & graph) 8 | { 9 | // Stores coordinates 10 | vector dots; 11 | srand(seed); 12 | for(unsigned i = 0; i < graph.getSize(); i++){ 13 | // Box muller method 14 | double u = rand()%2001/1000.0 - 1.0; 15 | double v = sqrt(1 - u*u)*(rand()%2001/1000.0 - 1.0); 16 | double s = u*u + v*v; 17 | double p = sqrt(-2*log(s)/s); 18 | // Making double precision value null if it's too small, 19 | // because in this case p is NaN 20 | if(fabs(s - 1) < 0.00001) 21 | p = 0; 22 | double x = 100*u*p; 23 | double y = 100*v*p; 24 | dots.push_back(dot(x, y)); 25 | // Counting edges 26 | for(unsigned j = 0; j < i; j++){ 27 | graph.addEdge(i, j, sqrt(pow(x - dots[j].first, 2.0) 28 | + pow(y - dots[j].second, 2.0))); 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /2sem/task3/2/src/graph.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by valentiay on 4/21/17. 3 | // 4 | 5 | #include "../include/graph.h" 6 | 7 | Graph::Graph(unsigned int size) : 8 | size_(size), 9 | matrix_(size_, vector(size_, 0.0)) {} 10 | 11 | 12 | 13 | void Graph::addEdge(unsigned from, unsigned to, double weight) 14 | { 15 | matrix_[from][to] = weight; 16 | matrix_[to][from] = weight; 17 | } 18 | 19 | 20 | 21 | unsigned Graph::getSize() const 22 | { 23 | return size_; 24 | } 25 | 26 | 27 | 28 | void Graph::getRelated(unsigned vertex, vector &vertices) const 29 | { 30 | vertices.clear(); 31 | for(unsigned i = 0; i < size_; i++){ 32 | if(matrix_[vertex][i] != 0) 33 | vertices.push_back(make_pair(i, matrix_[vertex][i])); 34 | } 35 | } 36 | 37 | 38 | 39 | double Graph::getWeight(unsigned from, unsigned to) const 40 | { 41 | return matrix_[from][to]; 42 | } 43 | 44 | 45 | 46 | void Graph::print() 47 | { 48 | for(int i = 0; i < size_; i++){ 49 | for(int j = 0; j < size_; j++){ 50 | std::cout << std::setw(7) << matrix_[i][j] << ' '; 51 | } 52 | std::cout << '\n'; 53 | } 54 | } -------------------------------------------------------------------------------- /2sem/task3/2/src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "../include/checker.h" 2 | 3 | /* quantity | approximate time 4 | * 2..10 | 0 s 5 | * 11 | 1 s 6 | * 12 | 15 s 7 | * 13 | 3 min 8 | * 14 | 40 min 9 | * 15 | 9 hours 10 | */ 11 | 12 | 13 | int main() { 14 | // !!! Dots coordinates are integral, dispersion is 100 !!! 15 | vector seeds{42}; 16 | vector quantities{10}; 17 | cout << "Results for 10 points, 10 seeds:\n"; 18 | runTests(9, quantities); 19 | cout << "\nResults for 2..12 points, 1 seed:\n"; 20 | runTests(seeds, 12); 21 | } -------------------------------------------------------------------------------- /2sem/task3/3/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | /******************************************************************************/ 8 | 9 | using std::ifstream; 10 | using std::ofstream; 11 | using std::vector; 12 | using std::pair; 13 | using std::make_pair; 14 | using std::min; 15 | using std::queue; 16 | 17 | typedef pair pair_uu; 18 | 19 | const unsigned INFINITY = 2147483647; 20 | 21 | /******************************************************************************/ 22 | 23 | class Graph { 24 | public: 25 | Graph(unsigned verticesNumber); 26 | 27 | void increaseEdge(unsigned from, unsigned to, int weight); 28 | 29 | // Vertices - vector of pairs 30 | void getRelated(unsigned vertex, vector &vertices) const; 31 | 32 | unsigned getSize() const; 33 | 34 | private: 35 | unsigned size_; 36 | vector> matrix_; 37 | }; 38 | 39 | /******************************************************************************/ 40 | 41 | // Function object for counting maximal flow in network 42 | class MaxFlow{ 43 | public: 44 | MaxFlow(): 45 | net_(0){} 46 | 47 | // Returns maxiamal flow 48 | unsigned operator()(const Graph & graph, unsigned s, unsigned t){ 49 | // Edmonds-Karp algorithm 50 | // Residual network 51 | net_ = graph; 52 | // Target vertex 53 | t_ = t; 54 | // Delta in flow in current iteration 55 | unsigned delta = 0; 56 | // Final flow 57 | unsigned flow = 0; 58 | 59 | // Increasing flow iteratively 60 | do{ 61 | delta = IncreaseFlow(s); 62 | flow += delta; 63 | }while(delta != 0); 64 | 65 | return flow; 66 | } 67 | 68 | private: 69 | // Finds path and decreases throughput in residual network 70 | unsigned IncreaseFlow(unsigned s){ 71 | // Stores pair 72 | vector parents(net_.getSize()); 73 | for(unsigned i = 0; i < net_.getSize(); i++){ 74 | parents[i].first = INFINITY; 75 | parents[i].second = INFINITY; 76 | } 77 | parents[s].first = s; 78 | parents[s].second = 0; 79 | 80 | // Finding path with BFS 81 | queue q; 82 | q.emplace(s); 83 | while(!q.empty()){ 84 | unsigned v = q.front(); 85 | q.pop(); 86 | if(v == t_) 87 | break; 88 | vector related; 89 | net_.getRelated(v, related); 90 | for(pair_uu & edge : related){ 91 | if(parents[edge.first].first == INFINITY){ 92 | parents[edge.first].first = v; 93 | parents[edge.first].second = edge.second; 94 | q.push(edge.first); 95 | } 96 | } 97 | } 98 | 99 | // If target vertex isn't reachable delta is 0 100 | if(parents[t_].first == INFINITY) 101 | return 0; 102 | 103 | // Finding minimal edge throughput 104 | unsigned delta = INFINITY; 105 | unsigned u = t_; 106 | while(u != s){ 107 | if(parents[u].second < delta) 108 | delta = parents[u].second; 109 | u = parents[u].first; 110 | } 111 | 112 | // Decreasing throughputs in residual network 113 | u = t_; 114 | while(u != s){ 115 | net_.increaseEdge(parents[u].first, u, -delta); 116 | net_.increaseEdge(u, parents[u].first, delta); 117 | u = parents[u].first; 118 | } 119 | 120 | return delta; 121 | } 122 | 123 | unsigned t_; 124 | Graph net_; 125 | }; 126 | 127 | /******************************************************************************/ 128 | 129 | int main() { 130 | ifstream fin("maxflow.in"); 131 | ofstream fout("maxflow.out"); 132 | 133 | // Initializing graph 134 | unsigned n = 0; 135 | unsigned m = 0; 136 | fin >> n >> m; 137 | Graph graph(n); 138 | for(int i = 0; i < m; i++){ 139 | unsigned v = 0; 140 | unsigned u = 0; 141 | unsigned w = 0; 142 | fin >> v >> u >> w; 143 | graph.increaseEdge(v - 1, u - 1, w); 144 | } 145 | 146 | // Counting maximal flow 147 | MaxFlow maxFlow; 148 | fout << maxFlow(graph, 0, n - 1) << '\n'; 149 | 150 | fin.close(); 151 | fout.close(); 152 | } 153 | 154 | /****************************GRAPH*********************************************/ 155 | 156 | Graph::Graph(unsigned int size) : 157 | size_(size), 158 | matrix_(size_, vector(size_, 0)) {} 159 | 160 | 161 | 162 | void Graph::increaseEdge(unsigned from, unsigned to, int weight) 163 | { 164 | assert(static_cast(matrix_[from][to]) + weight >= 0); 165 | matrix_[from][to] += weight; 166 | } 167 | 168 | 169 | 170 | unsigned Graph::getSize() const 171 | { 172 | return size_; 173 | } 174 | 175 | 176 | 177 | void Graph::getRelated(unsigned vertex, vector &vertices) const 178 | { 179 | vertices.clear(); 180 | for(unsigned i = 0; i < size_; i++){ 181 | if(matrix_[vertex][i] != 0) 182 | vertices.push_back(make_pair(i, matrix_[vertex][i])); 183 | } 184 | } -------------------------------------------------------------------------------- /2sem/task3/3/maxflow.in: -------------------------------------------------------------------------------- 1 | 4 5 2 | 1 2 1 3 | 1 3 2 4 | 3 2 1 5 | 2 4 2 6 | 3 4 1 -------------------------------------------------------------------------------- /2sem/task3/3/maxflow.out: -------------------------------------------------------------------------------- 1 | 3 2 | -------------------------------------------------------------------------------- /2sem/task3/4/input.txt: -------------------------------------------------------------------------------- 1 | 10?01?0 2 | 1???11 -------------------------------------------------------------------------------- /2sem/task3/4/output.txt: -------------------------------------------------------------------------------- 1 | 3 2 | 1000110 3 | 100011 -------------------------------------------------------------------------------- /2sem/task4/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | /**************************************************************************************************/ 8 | 9 | // Function object for finding 2nd statistic on a segment 10 | class R2Q { 11 | public: 12 | // Takes sequence of int and performs pre-processing 13 | R2Q(const std::vector & sequence) 14 | : _sequence(sequence) 15 | , _n(sequence.size()) 16 | , _sparseTable((size_t)(ceil(log2(_n))), 17 | std::vector>(_n, std::pair(0, 0))) 18 | { 19 | // Pre-counting binary logarithms for every index in sequence 20 | for (size_t i = 0; i < _n + 1; i++) 21 | _log2.push_back((size_t)ceil(log2(i))); 22 | 23 | // Initializing 1st row of table with sequence elements 24 | for (size_t i = 0; i < _n; i++) { 25 | _sparseTable[0][i].first = &_sequence[i]; 26 | _sparseTable[0][i].second = &_sequence[i]; 27 | } 28 | 29 | // Initializing other rows of table with first two least elements of segment 30 | for (size_t i = 1; i < _sparseTable.size(); i++) { 31 | for (size_t j = 0; j < _n - (1 << i) + 1; j++) { 32 | std::pair mp = getMinPair(_sparseTable[i - 1][j], 33 | _sparseTable[i - 1][j + (1 << (i - 1))]); 34 | _sparseTable[i][j].first = mp.first; 35 | _sparseTable[i][j].second = mp.second; 36 | } 37 | } 38 | } 39 | 40 | // Returns 2nd statistic on segment [a, b] 41 | int operator()(size_t a, size_t b) 42 | { 43 | // Size of required sparse table segment 44 | size_t k = _log2[b - a + 1] - 1; 45 | // Finding second least element of two segments 46 | return *getMinPair(_sparseTable[k][a], _sparseTable[k][b - (1 << k) + 1]).second; 47 | } 48 | 49 | private: 50 | // Returns pair of two least unique elements for two pairs, where 51 | // a.first <= a.second and b.first <= b.second 52 | std::pair getMinPair(std::pair a, std::pair b) 53 | { 54 | std::pair ans; 55 | // Initializing and sorting vector of elements 56 | std::vector order{a.first, a.second, b.first, b.second}; 57 | std::sort(order.begin(), order.end(), [](int* l, int* r){return *l < *r;}); 58 | 59 | // Taking first element and distinct min element from the rest ones 60 | ans.first = order[0]; 61 | for (short i = 1; i < 4; i++) 62 | if (order[i] != order[0]) { 63 | ans.second = order[i]; 64 | break; 65 | } 66 | return ans; 67 | } 68 | 69 | private: 70 | // Stores sequence of ints 71 | std::vector _sequence; 72 | // Stores size of the sequence 73 | size_t _n; 74 | // Stores binary logarithms 75 | std::vector _log2; 76 | // Stores sparse table 77 | std::vector>> _sparseTable; 78 | }; 79 | 80 | /**************************************************************************************************/ 81 | 82 | int main() { 83 | // Reading sizes 84 | size_t n = 0; 85 | size_t m = 0; 86 | std::cin >> n >> m; 87 | 88 | // Reading sequence of ints 89 | std::vector sequence(n); 90 | for (size_t i = 0; i < n; i++) { 91 | int x = 0; 92 | std::cin >> x; 93 | sequence[i] = x; 94 | } 95 | 96 | // Initializing 2nd statistic finder 97 | R2Q r2q(sequence); 98 | 99 | // Answering for requests 100 | for (size_t i = 0; i < m; i++) { 101 | size_t a = 0; 102 | size_t b = 0; 103 | std::cin >> a >> b; 104 | std::cout << r2q(a - 1, b - 1) << '\n'; 105 | } 106 | 107 | return 0; 108 | } -------------------------------------------------------------------------------- /2sem/task4/2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | /******************************************************************************/ 7 | 8 | // Segment tree with operations of taking maximum and increasing a segment 9 | class SegmentTree{ 10 | public: 11 | // Constructs the tree 12 | SegmentTree(const std::vector& sequence); 13 | 14 | // Returns max on the segment [a, b] 15 | unsigned getSegmentMax(size_t a, size_t b); 16 | // Increases segment [a, b] by delta 17 | void increaseSegment(size_t a, size_t b, unsigned delta); 18 | 19 | private: 20 | // Recursive function for taking max on a segment 21 | // node - root of current subtree, 22 | // left - left bound of current subtree in sequence, 23 | // right - right bound of current subtree 24 | // a - left bound of segment to increase in current subtree 25 | // b - right bound of segment to increase in current subtree 26 | unsigned getSegmentMax(size_t node, size_t left, size_t right, size_t a, size_t b); 27 | // Recursive function for increasing segment by delta 28 | // Arguments same as for max 29 | void increaseSegment(size_t node, size_t left, size_t right, size_t a, size_t b, unsigned delta); 30 | 31 | private: 32 | // Buffer storing the tree like a heap 33 | // Tree is stored as a binary tree with full lower level. All unused leafs are initialized with 0 34 | std::vector> _tree; 35 | // Number of tree leafs 36 | const size_t _n; 37 | }; 38 | 39 | /******************************************************************************/ 40 | 41 | int main() { 42 | // Initializing ticket array 43 | size_t n = 0; 44 | std::cin >> n; 45 | std::vector tickets(n - 1); 46 | for (int i = 0; i < n - 1; i++) { 47 | std::cin >> tickets[i]; 48 | } 49 | 50 | // Building tree 51 | SegmentTree segmentTree(tickets); 52 | 53 | // Getting train capacity 54 | unsigned capacity = 0; 55 | std::cin >> capacity; 56 | 57 | // Processing requests 58 | size_t m = 0; 59 | std::cin >> m; 60 | for (size_t i = 0; i < m; i++) { 61 | size_t a = 0; 62 | size_t b = 0; 63 | unsigned num = 0; 64 | std::cin >> a >> b >> num; 65 | // If number of tickets is more than train capacity request is impossible 66 | // Increasing number of tickets otherwise 67 | if (segmentTree.getSegmentMax(a, b - 1) + num > capacity) 68 | std::cout << i << ' '; 69 | else 70 | segmentTree.increaseSegment(a, b - 1, num); 71 | } 72 | return 0; 73 | } 74 | 75 | /******************************************************************************/ 76 | 77 | SegmentTree::SegmentTree(const std::vector& sequence) 78 | : _n(1ull << (size_t)ceil(log2(sequence.size()))) 79 | { 80 | // Reserving memory for storing tree 81 | // _tree[i].first - current minimum in relevant segment 82 | // _tree[i].second - number to increase relevant segment 83 | _tree.assign(2 * _n - 1, std::pair(0, 0)); 84 | // Initialising leafs with sequence members 85 | for (size_t i = 0; i < sequence.size(); i++) 86 | _tree[_tree.size() / 2 + i].first = sequence[i]; 87 | // Counting min for every other node 88 | for (long i = _tree.size() / 2 - 1; i >= 0; i--) 89 | _tree[i].first = std::max(_tree[2*i + 1].first, _tree[2*i + 2].first); 90 | } 91 | 92 | 93 | 94 | unsigned SegmentTree::getSegmentMax(size_t a, size_t b) 95 | { 96 | return getSegmentMax(0, 0, _n - 1, a, b); 97 | } 98 | 99 | 100 | 101 | unsigned SegmentTree::getSegmentMax(size_t node, size_t left, size_t right, size_t a, size_t b) 102 | { 103 | // If DFS is in obviously wrong place, stop searching 104 | if (a > b || left > right) 105 | return 0; 106 | // If relevant segment is included in segment to find max, return current max 107 | if (a == left && b == right) 108 | return _tree[node].first + _tree[node].second; 109 | 110 | // Visit child nodes 111 | size_t med = (left + right) / 2; 112 | unsigned leftMax = getSegmentMax(2 * node + 1, left, med, a, std::min(b, med)); 113 | unsigned rightMax = getSegmentMax(2 * node + 2, med + 1, right, std::max(a, med + 1), b); 114 | // Return max increased by subtree delta 115 | return std::max(rightMax, leftMax) + _tree[node].second; 116 | } 117 | 118 | 119 | 120 | void SegmentTree::increaseSegment(size_t a, size_t b, unsigned delta) 121 | { 122 | increaseSegment(0, 0, _n - 1, a, b, delta); 123 | } 124 | 125 | 126 | 127 | void SegmentTree::increaseSegment(size_t node, 128 | size_t left, 129 | size_t right, 130 | size_t a, 131 | size_t b, 132 | unsigned delta) 133 | { 134 | // If DFS is in obviously wrong place, stop searching 135 | if (a > b || left > right) 136 | return; 137 | // If relevant segment is included in segment to increase, increase 138 | if (a == left && b == right) { 139 | _tree[node].second += delta; 140 | return; 141 | } 142 | 143 | // Visit child nodes 144 | size_t med = (left + right) / 2; 145 | increaseSegment(2 * node + 1, left, med, a, std::min(b, med), delta); 146 | increaseSegment(2 * node + 2, med + 1, right, std::max(a, med + 1), b, delta); 147 | // Fix max 148 | _tree[node].first = std::max(_tree[2*node + 1].first + _tree[2*node + 1].second, 149 | _tree[2*node + 2].first + _tree[2*node + 2].second); 150 | } -------------------------------------------------------------------------------- /2sem/task4/3/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | /******************************************************************************/ 6 | 7 | // Function object for solving LCA problem 8 | class LCA{ 9 | public: 10 | // Builds and pre-processes tree using vector where i-th index stores father of i-th node 11 | LCA(std::vector>& parents); 12 | 13 | // Returns LCA 14 | unsigned operator()(unsigned a, unsigned b); 15 | unsigned operator()(std::pair query); 16 | 17 | private: 18 | // DFS filling sparse table during pre-processing 19 | void DFS(unsigned node, unsigned parent); 20 | 21 | // Checks if a is ancestor of b 22 | bool isAncestor(unsigned a, unsigned b); 23 | 24 | // Timer used in DFS 25 | unsigned _timer; 26 | // Number of nodes 27 | size_t _n; 28 | // Size of ancestors table 29 | unsigned _l; 30 | 31 | // Stores children for i-th node 32 | std::vector>& _tree; 33 | // Time of visiting i-th node 34 | std::vector _tin; 35 | // Time of leaving i-th node 36 | std::vector _tout; 37 | // Sparse table of ancestors 38 | std::vector> _ancestors; 39 | }; 40 | 41 | /******************************************************************************/ 42 | 43 | // Function object for generating next query 44 | class NextQuery{ 45 | public: 46 | NextQuery(unsigned a0, 47 | unsigned b0, 48 | unsigned long x, 49 | unsigned long y, 50 | unsigned long z, 51 | unsigned n); 52 | 53 | std::pair operator()(unsigned result); 54 | 55 | private: 56 | unsigned _a; 57 | unsigned _b; 58 | unsigned long _x; 59 | unsigned long _y; 60 | unsigned long _z; 61 | unsigned _n; 62 | }; 63 | 64 | /******************************************************************************/ 65 | 66 | int main() { 67 | // Initializing vector of parents 68 | unsigned n = 0; 69 | unsigned m = 0; 70 | std::cin >> n >> m; 71 | std::vector> parents(n); 72 | for (unsigned i = 1; i < n; i++) { 73 | unsigned x; 74 | std::cin >> x; 75 | parents[x].push_back(i); 76 | } 77 | 78 | // Initializing queries 79 | unsigned a0 = 0; 80 | unsigned b0 = 0; 81 | std::cin >> a0 >> b0; 82 | unsigned long x = 0; 83 | unsigned long y = 0; 84 | unsigned long z = 0; 85 | std::cin >> x >> y >> z; 86 | NextQuery nextQuery(a0, b0, x, y, z, n); 87 | 88 | // Generating LCA object 89 | LCA lca(parents); 90 | unsigned long ans = 0; 91 | unsigned result = 0; 92 | for (unsigned i = 0; i < m; i++) { 93 | result = lca(nextQuery(result)); 94 | ans += result; 95 | } 96 | std::cout << ans; 97 | 98 | return 0; 99 | } 100 | 101 | /**************************************************************************************************/ 102 | 103 | LCA::LCA(std::vector>& parents) 104 | : _tree(parents) 105 | , _n(parents.size()) 106 | , _l(static_cast(ceil(log2(_n)))) 107 | , _tin(_n) 108 | , _tout(_n) 109 | , _ancestors(_n, std::vector(_l + 1)) 110 | , _timer(0) 111 | { 112 | DFS(0, 0); 113 | } 114 | 115 | 116 | 117 | unsigned LCA::operator()(unsigned a, unsigned b) 118 | { 119 | if (isAncestor(a, b)) 120 | return a; 121 | if (isAncestor(b, a)) 122 | return b; 123 | // Rising up the tree 124 | for (int i = _l; i >= 0; --i) 125 | if (!isAncestor(_ancestors[a][i], b)) 126 | a = _ancestors[a][i]; 127 | return _ancestors[a][0]; 128 | } 129 | 130 | 131 | 132 | unsigned LCA::operator()(std::pair query) 133 | { 134 | return LCA::operator()(query.first, query.second); 135 | } 136 | 137 | 138 | 139 | void LCA::DFS(unsigned node, unsigned parent) 140 | { 141 | _tin[node] = _timer++; 142 | _ancestors[node][0] = parent; 143 | for (int i = 1; i <= _l; i++) 144 | _ancestors[node][i] = _ancestors[_ancestors[node][i - 1]][i - 1]; 145 | for (size_t i = 0; i < _tree[node].size(); ++i) { 146 | unsigned to = _tree[node][i]; 147 | if (to != parent) 148 | DFS(to, node); 149 | } 150 | _tout[node] = _timer++; 151 | } 152 | 153 | 154 | 155 | bool LCA::isAncestor(unsigned a, unsigned b) 156 | { 157 | return _tin[a] <= _tin[b] && _tout[b] <= _tout[a]; 158 | } 159 | 160 | /**************************************************************************************************/ 161 | 162 | NextQuery::NextQuery(unsigned a0, 163 | unsigned b0, 164 | unsigned long x, 165 | unsigned long y, 166 | unsigned long z, 167 | unsigned n) 168 | : _a(a0) 169 | , _b(b0) 170 | , _x(x) 171 | , _y(y) 172 | , _z(z) 173 | , _n(n) 174 | {} 175 | 176 | 177 | 178 | std::pair NextQuery::operator()(unsigned result) 179 | { 180 | std::pair ans((_a + result) % _n, _b); 181 | _a = (_a * _x + _b * _y + _z) % _n; 182 | _b = (_b * _x + _a * _y + _z) % _n; 183 | return ans; 184 | } -------------------------------------------------------------------------------- /2sem/task4/4/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | // Treap with implicit key 5 | class ImplicitTreap{ 6 | public: 7 | ImplicitTreap(); 8 | ~ImplicitTreap(); 9 | 10 | // Inserts string into position 11 | void insert(size_t position, const std::string& value); 12 | // Removes string by position 13 | void remove(size_t position); 14 | // Clears tree 15 | void clear(); 16 | // Returns string by position 17 | std::string get(size_t position) const; 18 | 19 | private: 20 | // Structure implementing node 21 | struct Node{ 22 | Node(const std::string& value); 23 | 24 | // Fixes treeSize 25 | void fix(); 26 | 27 | // Stores size of subtree 28 | size_t treeSize; 29 | // Priority of current node 30 | int priority; 31 | // Value to store 32 | std::string value; 33 | 34 | // Pointers tp left and right children 35 | Node* left; 36 | Node* right; 37 | }; 38 | 39 | private: 40 | // Splits tree by position, returns two result trees 41 | std::pair split(Node* node, size_t position); 42 | // Merges two trees, returns result tree 43 | Node* merge(Node* node1, Node* node2); 44 | // Recursive function for clearing the tree 45 | void clear(Node* node); 46 | 47 | private: 48 | // Pointer to root 49 | Node* _root; 50 | }; 51 | 52 | /******************************************************************************/ 53 | 54 | int main() { 55 | size_t n = 0; 56 | std::cin >> n; 57 | ImplicitTreap stringArray; 58 | for (size_t i = 0; i < n; i++) { 59 | char cmd; 60 | std::cin >> cmd; 61 | switch(cmd){ 62 | case '+': { 63 | size_t position = 0; 64 | std::string val = ""; 65 | std::cin >> position >> val; 66 | stringArray.insert(position, val); 67 | break; 68 | } 69 | case '?': { 70 | size_t position = 0; 71 | std::cin >> position; 72 | std::cout << stringArray.get(position) << '\n'; 73 | break; 74 | } 75 | default: { 76 | size_t position = 0; 77 | std::cin >> position; 78 | stringArray.remove(position); 79 | break; 80 | } 81 | } 82 | } 83 | return 0; 84 | } 85 | 86 | /******************************************************************************/ 87 | 88 | ImplicitTreap::ImplicitTreap() 89 | : _root(nullptr) 90 | {} 91 | 92 | 93 | 94 | ImplicitTreap::~ImplicitTreap() 95 | { 96 | clear(); 97 | } 98 | 99 | 100 | 101 | void ImplicitTreap::clear() 102 | { 103 | clear(_root); 104 | _root = nullptr; 105 | } 106 | 107 | 108 | 109 | void ImplicitTreap::clear(Node* node) 110 | { 111 | if (node == nullptr) 112 | return; 113 | clear(node->left); 114 | clear(node->right); 115 | delete node; 116 | } 117 | 118 | 119 | 120 | void ImplicitTreap::insert(size_t position, const std::string& value) 121 | { 122 | Node* current = new Node(value); 123 | // Split tree by position and merge new node with right tree then merge result with left tree 124 | std::pair ans = split(_root, position); 125 | Node* right = merge(current, ans.second); 126 | _root = merge(ans.first, right); 127 | } 128 | 129 | 130 | 131 | void ImplicitTreap::remove(size_t position) 132 | { 133 | // Split required node from both sides and merge two other trees 134 | std::pair ans1 = split(_root, position); 135 | std::pair ans2 = split(ans1.second, 1); 136 | delete ans2.first; 137 | _root = merge(ans1.first, ans2.second); 138 | } 139 | 140 | 141 | 142 | std::string ImplicitTreap::get(size_t position) const 143 | { 144 | // Going down the tree 145 | size_t l; 146 | Node* node = _root; 147 | do { 148 | l = (node->left != nullptr)?(node->left->treeSize):0; 149 | if (l == position) 150 | break; 151 | if (position < l) { 152 | node = node->left; 153 | } 154 | else { 155 | position -= l + 1; 156 | node = node->right; 157 | } 158 | } while (true); 159 | return node->value; 160 | } 161 | 162 | 163 | 164 | std::pair ImplicitTreap::split(Node* node, size_t position) 165 | { 166 | if (node == nullptr) 167 | return std::pair(nullptr, nullptr); 168 | size_t l = (node->left != nullptr)?(node->left->treeSize) : 0; 169 | if (l >= position) { 170 | std::pair ans = split(node->left, position); 171 | node->left = ans.second; 172 | node->fix(); 173 | return std::make_pair(ans.first, node); 174 | } 175 | else { 176 | std::pair ans = split(node->right, position - l - 1); 177 | node->right = ans.first; 178 | node->fix(); 179 | return std::make_pair(node, ans.second); 180 | } 181 | } 182 | 183 | 184 | 185 | ImplicitTreap::Node* ImplicitTreap::merge(Node* node1, Node* node2) 186 | { 187 | if (node2 == nullptr) 188 | return node1; 189 | if (node1 == nullptr) 190 | return node2; 191 | if (node1->priority > node2->priority) { 192 | node1->right = merge(node1->right, node2); 193 | node1->fix(); 194 | return node1; 195 | } 196 | else { 197 | node2->left = merge(node1, node2->left); 198 | node2->fix(); 199 | return node2; 200 | } 201 | } 202 | 203 | /******************************************************************************/ 204 | 205 | ImplicitTreap::Node::Node(const std::string& value) 206 | : value(value) 207 | , priority(rand()) 208 | , left(nullptr) 209 | , right(nullptr) 210 | , treeSize(1) 211 | {} 212 | 213 | 214 | 215 | void ImplicitTreap::Node::fix() 216 | { 217 | treeSize = 1; 218 | if (left != nullptr) 219 | treeSize += left->treeSize; 220 | if (right != nullptr) 221 | treeSize += right->treeSize; 222 | } -------------------------------------------------------------------------------- /3sem/task1/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /** 5 | * Находит все вхождения шаблона в текст 6 | * 7 | * @param patt шаблон 8 | * @param str текст 9 | * @return индексы вхождений шаблона в текст 10 | */ 11 | std::vector findEntries(const std::string & patt, const std::string & str) { 12 | std::vector pi(patt.length()); 13 | pi[0] = 0; 14 | 15 | // Считаем префикс-функцию для шаблона 16 | for (int i = 1; i < patt.length(); i++) { 17 | size_t j = pi[i - 1]; 18 | while (j > 0 && patt[i] != patt[j]) { 19 | j = pi[j - 1]; 20 | } 21 | if (patt[i] == patt[j]) { 22 | pi[i] = j + 1; 23 | } else { 24 | pi[i] = 0; 25 | } 26 | } 27 | 28 | std::vector entries; 29 | size_t prev_pi = 0; 30 | // Считаем префикс-функцию для каждого символа в тексте. Если она равна длине шаблона, 31 | // то мы нашли вхождение. Т.к. префикс функция не больше длины шаблона, нам не нужно 32 | // запоминать значения ПФ на тексте. 33 | for (size_t i = 0; i < str.size(); i++) { 34 | size_t j = prev_pi; 35 | while (j > 0 && str[i] != patt[j]) { 36 | j = pi[j - 1]; 37 | } 38 | 39 | if (str[i] == patt[j]) { 40 | j++; 41 | } else { 42 | j = 0; 43 | } 44 | 45 | if (j == patt.length()) { 46 | entries.push_back(1 + i - patt.length()); 47 | } 48 | prev_pi = j; 49 | } 50 | return entries; 51 | } 52 | 53 | 54 | int main() { 55 | std::string patt, str; 56 | std::cin >> patt; 57 | std::cin >> str; 58 | 59 | std::vector entries = findEntries(patt, str); 60 | for (size_t i : entries) { 61 | std::cout << i << " "; 62 | } 63 | return 0; 64 | } -------------------------------------------------------------------------------- /3sem/task1/2/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/3sem/task1/2/a.out -------------------------------------------------------------------------------- /3sem/task1/2/input.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/3sem/task1/2/input.txt -------------------------------------------------------------------------------- /3sem/task1/2/output.txt: -------------------------------------------------------------------------------- 1 | abcadaeabca -------------------------------------------------------------------------------- /3sem/task1/3/input.txt: -------------------------------------------------------------------------------- 1 | 5 3 2 1 0 -------------------------------------------------------------------------------- /3sem/task1/3/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /** 5 | * Строит лексикографически минимальную z-функцию. Значение z-функции на первом символе должно быть 6 | * равно нулю. 7 | * 8 | * Z-блок - это непустая подстрока [ i, i + z[i] ). 9 | * 10 | * @param z вектор, к котором хранится z-функция. 11 | * @return лексикографически минимальная строка, построенная по z-функции. 12 | */ 13 | std::string buildStrByZ(const std::vector & z) { 14 | // Хранит строку-ответ. Первый символ этой строки "a", иначе 15 | // строка не будет лексикографически минимальной 16 | std::string result = "a"; 17 | // Хранит индексы символов, которые не могут быть дописаны после z-блока 18 | // (Иначе значение z-функции для этого блока увеличится) 19 | std::vector used_indices; 20 | // true, если последний записанный символ был частью z-блока 21 | bool append_after_block = true; 22 | 23 | // Пробегаемся по z-функции 24 | size_t str_index = 1; 25 | while (str_index < z.size()) { 26 | // Если значение z-функции не ноль, копируем префикс в z-блок, 27 | // иначе дописываем в строку первую допустимую букву 28 | if (z[str_index] != 0) { 29 | used_indices.clear(); 30 | size_t prefix_index = 0; 31 | size_t remaining_block_len = z[str_index]; 32 | 33 | while (remaining_block_len > 0) { 34 | // Если попался z-блок с бОльшей правой границей, чем тот, который мы копируем, 35 | // начинаем копировать этот z-блок 36 | if (z[str_index] > remaining_block_len) { 37 | remaining_block_len = z[str_index]; 38 | used_indices.push_back(z[str_index]); 39 | prefix_index = 0; 40 | } 41 | 42 | // Если какой-то z-блок заканчивается на той же позиции, что и тот, который мы 43 | // копируем, записываем индекс символа, следующего за концом префикса, который 44 | // соответствует этому z-блоку 45 | if (z[str_index] == remaining_block_len) { 46 | used_indices.push_back(z[str_index]); 47 | } 48 | 49 | result += result[prefix_index]; 50 | 51 | prefix_index++; 52 | str_index++; 53 | remaining_block_len--; 54 | } 55 | 56 | append_after_block = true; 57 | } else { 58 | // Если мы записываем символ после z-блока, дописываем строку первым символом, 59 | // индекса которого нет в used_indices, иначе записываем "b", т.к. "a" сделает значение 60 | // z-функции единицей 61 | if (append_after_block) { 62 | std::vector used_chars(26, false); 63 | for (size_t n : used_indices) { 64 | used_chars[result[n] - 'a'] = true; 65 | } 66 | 67 | char c = 'b'; 68 | while (used_chars[c - 'a']) { 69 | c++; 70 | } 71 | result += c; 72 | 73 | append_after_block = false; 74 | } else { 75 | result += 'b'; 76 | } 77 | 78 | str_index++; 79 | } 80 | } 81 | 82 | return result; 83 | } 84 | 85 | int main() { 86 | freopen("input.txt", "r", stdin); 87 | 88 | // Чтение z-функции 89 | size_t x; 90 | std::vector z; 91 | while(std::cin >> x) { 92 | z.push_back(x); 93 | } 94 | 95 | // Поиск строки 96 | z[0] = 0; 97 | std::cout << buildStrByZ(z); 98 | 99 | return 0; 100 | } -------------------------------------------------------------------------------- /3sem/task2/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const size_t alphabetSize = 256; 6 | 7 | /** 8 | * Возвращает количество различных подстрок строки. 9 | * 10 | * @param s строка. 11 | * @return количество различных подстрок. 12 | */ 13 | size_t distinctSubstrings(std::string s) { 14 | s.push_back('\0'); 15 | // Вектор, хранящий перестановки циклических строк 16 | std::vector permutations(s.length()); 17 | 18 | // Сортируем подстроки из одного элемента подсчетом 19 | std::vector count(alphabetSize, 0); 20 | for (char i : s) { 21 | count[i]++; 22 | } 23 | // Cчитаем начала групп 24 | for (size_t i = 1; i < alphabetSize; i++) { 25 | count[i] += count[i - 1]; 26 | } 27 | // Расставляем строки в нужном порядке 28 | for (size_t i = 0; i < s.length(); i++) { 29 | permutations[--count[s[i]]] = i; 30 | } 31 | 32 | // Считаем количество классов эквивалентности для строк из двух символов. 33 | 34 | // Вектор, хранящий класс номер класса эквивалентности для циклической строки на i-й операции. 35 | // Порядок номеров соответсвует порядку строк 36 | std::vector> classes(1, std::vector(s.length())); 37 | classes[0][permutations[0]] = 0; 38 | size_t classes_num = 1; 39 | for (size_t i = 1; i < s.length(); i++) { 40 | if (s[permutations[i]] != s[permutations[i - 1]]) ++classes_num; 41 | classes[0][permutations[i]] = classes_num - 1; 42 | } 43 | 44 | std::vector new_permutations(s.length()); 45 | // Повторяем алгоритм, пока длина подстрок ( 2^(j + 1) ) не превышает длины строки 46 | int j; 47 | for (j = 0; (1 << j) < s.length(); j++) { 48 | // Увеличиваем размер подстрок, при необходимости циклически переносим начало подстроки 49 | for (size_t i = 0; i < s.length(); i++) { 50 | new_permutations[i] = permutations[i] - (1 << j); 51 | if (new_permutations[i] < 0) { 52 | new_permutations[i] += s.length(); 53 | } 54 | } 55 | // Зная пару (classes[i], classes[i + 2^j]), мы можем расположить строки в лексикографическом порядке. 56 | // Для этого используем LSD. Т.к. младший разряд отсортирован, сортируем по старшему 57 | count.assign(classes_num, 0); 58 | for (size_t i = 0; i < s.length(); i++) { 59 | count[classes[j][new_permutations[i]]]++; 60 | } 61 | for (size_t i = 1; i < classes_num; i++) { 62 | count[i] += count[i - 1]; 63 | } 64 | for (long i = s.length() - 1; i >= 0; i--) { 65 | permutations[--count[classes[j][new_permutations[i]]]] = new_permutations[i]; 66 | } 67 | 68 | // Считаем новые классы эквивалентности 69 | classes.emplace_back(s.length()); 70 | classes[j + 1][permutations[0]] = 0; 71 | classes_num = 1; 72 | for (size_t i = 1; i < s.length(); i++) { 73 | size_t mid1 = (permutations[i] + (1 << j)) % s.length(); 74 | size_t mid2 = (permutations[i - 1] + (1 << j)) % s.length(); 75 | if (classes[j][permutations[i]] != classes[j][permutations[i - 1]] || classes[j][mid1] != classes[j][mid2]) { 76 | classes_num++; 77 | } 78 | classes[j + 1][permutations[i]] = classes_num - 1; 79 | } 80 | } 81 | 82 | std::vector lcp(s.length() - 2, 0); 83 | for (size_t i = 1; i < s.length() - 1; i++) { 84 | size_t x = permutations[i]; 85 | size_t y = permutations[i + 1]; 86 | for (int k = j - 1; k >= 0; --k) 87 | if (classes[k][x] == classes[k][y]) { 88 | lcp[i - 1] += 1 << k; 89 | x += 1 << k; 90 | y += 1 << k; 91 | } 92 | } 93 | 94 | // Считаем количество различных подстрок 95 | size_t ans = 0; 96 | for (int i = 1; i < s.length(); i++) { 97 | ans += (s.length() - 1) - permutations[i]; 98 | } 99 | for (int i = 0; i < s.length() - 2; i++) { 100 | ans -= lcp[i]; 101 | } 102 | return ans; 103 | } 104 | 105 | int main() { 106 | std::string str; 107 | std::cin >> str; 108 | std::cout << distinctSubstrings(str); 109 | return 0; 110 | } -------------------------------------------------------------------------------- /3sem/task3/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | const double E = 0.00000001; 6 | 7 | /*====== Vector3 ======*/ 8 | 9 | struct Vector3 { 10 | Vector3(double x, double y, double z); 11 | 12 | Vector3 operator-(); 13 | 14 | friend Vector3 operator*(double c, const Vector3 & v); 15 | friend Vector3 operator+(const Vector3 & v1, const Vector3 & v2); 16 | friend Vector3 operator-(const Vector3 & v1, const Vector3 & v2); 17 | 18 | double norm(); 19 | 20 | friend double dot(const Vector3 & v1, const Vector3 & v2); 21 | 22 | friend std::ostream & operator<<(std::ostream & os, const Vector3 & vector); 23 | 24 | double x; 25 | double y; 26 | double z; 27 | }; 28 | 29 | /*====== Segment3 ======*/ 30 | 31 | struct Segment3 { 32 | Vector3 from; 33 | Vector3 to; 34 | 35 | Segment3(const Vector3 & from, const Vector3 & to); 36 | }; 37 | 38 | /*============*/ 39 | 40 | double dabs(double n) { 41 | return (n > 0 ? n: -n); 42 | } 43 | 44 | double segmentToSegmentDist(Segment3 S1, Segment3 S2) { 45 | Vector3 u = S1.to - S1.from; 46 | Vector3 v = S2.to - S2.from; 47 | Vector3 w = S1.from - S2.from; 48 | double uu = dot(u, u); 49 | double uv = dot(u, v); 50 | double vv = dot(v, v); 51 | double uw = dot(u, w); 52 | double vw = dot(v, w); 53 | double D = uu*vv - uv*uv; 54 | double s, sN, sD = D; 55 | double t, tN, tD = D; 56 | 57 | if (D <= E) { 58 | sN = 0.0; 59 | sD = 1.0; 60 | tN = vw; 61 | tD = vv; 62 | } else { 63 | sN = (uv*vw - vv*uw); 64 | tN = (uu*vw - uv*uw); 65 | if (sN <= 0.0) { 66 | sN = 0.0; 67 | tN = vw; 68 | tD = vv; 69 | } else if (sN >= sD) { 70 | sN = sD; 71 | tN = vw + uv; 72 | tD = vv; 73 | } 74 | } 75 | 76 | if (tN <= 0.0) { 77 | tN = 0.0; 78 | if (-uw <= 0.0) { 79 | sN = 0.0; 80 | } else if (-uw >= uu) { 81 | sN = sD; 82 | } else { 83 | sN = -uw; 84 | sD = uu; 85 | } 86 | } else if (tN >= tD) { 87 | tN = tD; 88 | if ((-uw + uv) <= 0.0) { 89 | sN = 0; 90 | } else if ((-uw + uv) >= uu) { 91 | sN = sD; 92 | } else { 93 | sN = (-uw + uv); 94 | sD = uu; 95 | } 96 | } 97 | s = (dabs(sN) <= E ? 0.0 : sN / sD); 98 | t = (dabs(tN) <= E ? 0.0 : tN / tD); 99 | 100 | Vector3 dP = w + (s * u) - (t * v); 101 | 102 | return dP.norm(); 103 | } 104 | 105 | /*====== ======*/ 106 | 107 | int main() { 108 | double x1, y1, z1, x2, y2, z2; 109 | double x3, y3, z3, x4, y4, z4; 110 | std::cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2; 111 | std::cin >> x3 >> y3 >> z3 >> x4 >> y4 >> z4; 112 | 113 | printf("%.7f", segmentToSegmentDist(Segment3(Vector3(x1, y1, z1), Vector3(x2, y2, z2)), 114 | Segment3(Vector3(x3, y3, z3), Vector3(x4, y4, z4)))); 115 | } 116 | 117 | 118 | /*====== Vector3 ======*/ 119 | 120 | Vector3::Vector3(double x, double y, double z) 121 | : x(x) 122 | , y(y) 123 | , z(z){} 124 | 125 | 126 | 127 | Vector3 Vector3::operator-() { 128 | return Vector3(-x, -y, -z); 129 | } 130 | 131 | 132 | 133 | Vector3 operator+(const Vector3 & v1, const Vector3 & v2) { 134 | return Vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); 135 | } 136 | 137 | 138 | 139 | Vector3 operator-(const Vector3 & v1, const Vector3 & v2) { 140 | return Vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); 141 | } 142 | 143 | 144 | 145 | double Vector3::norm() { 146 | return sqrt(dot(*this, *this)); 147 | } 148 | 149 | 150 | 151 | double dot(const Vector3 & v1, const Vector3 & v2) { 152 | return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; 153 | } 154 | 155 | 156 | 157 | std::ostream & operator<<(std::ostream & os, const Vector3 & vector) { 158 | os << std::setprecision(5) << "Vector3(" << vector.x << ", " << vector.y << ", " << vector.z << ") "; 159 | return os ; 160 | } 161 | 162 | Vector3 operator*(double c, const Vector3 & v) { 163 | return Vector3(c * v.x, c * v.y, c * v.z); 164 | } 165 | 166 | Vector3 operator/(double c, const Vector3 & v) { 167 | return Vector3(c * v.x, c * v.y, c * v.z); 168 | } 169 | 170 | 171 | /*====== Segment3 ======*/ 172 | 173 | Segment3::Segment3(const Vector3 & from, const Vector3 & to) 174 | : from(from) 175 | , to(to) {} 176 | -------------------------------------------------------------------------------- /3sem/task3/2/a.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/valentiay/study/64b07e718fd84229d590eea115a2275332bfee83/3sem/task3/2/a.out -------------------------------------------------------------------------------- /3sem/task3/2/input.txt: -------------------------------------------------------------------------------- 1 | 5 2 | -1 0 -1 3 | 1 0 -1 4 | 0 0 0 5 | 0 1 1 6 | 0 -1 1 7 | -------------------------------------------------------------------------------- /3sem/task3/4/input.txt: -------------------------------------------------------------------------------- 1 | 0 0 2 | 3 -3 3 | 4 1 4 | 2 -1 -------------------------------------------------------------------------------- /3sem/task4/1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "biginteger.h" 3 | 4 | int main() { 5 | BigInteger b1 = 10; 6 | BigInteger b2 = 4; 7 | std::cout << b1 + b2 << "\n"; 8 | std::cout << b1 - b2 << "\n"; 9 | std::cout << b1 * b2 << "\n"; 10 | std::cout << b1 / b2 << "\n"; 11 | std::cout << b1 % 7 << "\n"; 12 | if (!b1) { 13 | std::cout << "yes"; 14 | } 15 | } -------------------------------------------------------------------------------- /algorithms_and_structures/algotithms/Huffman/Huffman.h: -------------------------------------------------------------------------------- 1 | #ifndef HUFFMAN_HUFFMAN_H 2 | #define HUFFMAN_HUFFMAN_H 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | /******************************************************************************/ 11 | 12 | typedef char byte; 13 | typedef bool bit; 14 | 15 | /******************************************************************************/ 16 | 17 | using std::map; 18 | using std::list; 19 | using std::string; 20 | using std::ifstream; 21 | using std::ofstream; 22 | using std::cout; 23 | 24 | /******************************************************************************/ 25 | 26 | class IInputStream { 27 | public: 28 | IInputStream(ifstream & fin): 29 | fin_(fin) 30 | {} 31 | // Возвращает false, если поток закончился 32 | bool Read(byte& value){ 33 | if(fin_.eof()) 34 | return false; 35 | fin_.get(value); 36 | return true; 37 | } 38 | 39 | private: 40 | ifstream & fin_; 41 | }; 42 | 43 | class IOutputStream { 44 | public: 45 | IOutputStream(ofstream & fout): 46 | fout_(fout) 47 | {} 48 | void Write(byte value){ 49 | fout_ << value; 50 | } 51 | 52 | private: 53 | ofstream & fout_; 54 | }; 55 | 56 | 57 | /******************************************************************************/ 58 | 59 | class bitostream{ 60 | public: 61 | // Constructor, gets input stream 62 | bitostream(IOutputStream & stream); 63 | 64 | 65 | // Writes a bit. Returns true, when byte is written 66 | bool write(bit value); 67 | 68 | private: 69 | // Stores stream 70 | IOutputStream & stream_; 71 | 72 | // Stores byte to be written 73 | byte currentByte_; 74 | 75 | // Stores number of bits in current byte 76 | char bitsWritten_; 77 | 78 | }; 79 | 80 | 81 | 82 | class bitistream{ 83 | public: 84 | // Constructor, gets output stream 85 | bitistream(IInputStream & stream); 86 | 87 | 88 | // Reads a bit. Returns false if stream is over 89 | bool read(bit & value); 90 | 91 | private: 92 | // Stores stream 93 | IInputStream & stream_; 94 | 95 | // Stores reflected byte to be read 96 | byte currentByte_; 97 | 98 | // Stores number of bits read 99 | char bitsRead_; 100 | 101 | }; 102 | 103 | /******************************************************************************/ 104 | 105 | class Node{ 106 | public: 107 | 108 | Node(); 109 | 110 | Node(byte value, long weight, Node * left, Node * right); 111 | 112 | 113 | byte value; 114 | 115 | long weight; 116 | 117 | 118 | Node * left; 119 | 120 | Node * right; 121 | 122 | }; 123 | 124 | 125 | bool nodeComparator(Node * & L, Node * R); 126 | 127 | 128 | // Builds Huffman tree 129 | Node * buildTree(map freq); 130 | 131 | // Initializes symbol codes 132 | void getCodes(Node * node, long code, map & codes); 133 | 134 | // Prints Huffman tree 135 | void printTree(Node * node, int depth, const map & codes); 136 | 137 | // Deletes Huffman tree 138 | void deleteTree(Node * node); 139 | 140 | // Counts length for each code 141 | void countCodeLengths(const map & codes, 142 | map & codeLengths); 143 | 144 | // Deleting extra nodes in decoded tree 145 | void fixTree(Node * node); 146 | 147 | // Encodes file 148 | void Encode(IInputStream & original, IOutputStream & compressed); 149 | 150 | // Decodes file 151 | void Decode(IInputStream & compressed, IOutputStream & decoded); 152 | 153 | 154 | #endif //HUFFMAN_HUFFMAN_H 155 | -------------------------------------------------------------------------------- /algorithms_and_structures/algotithms/Huffman/main.cpp: -------------------------------------------------------------------------------- 1 | #include "Huffman.h" 2 | 3 | /******************************************************************************/ 4 | 5 | int main(){ 6 | ifstream original("original.txt"); 7 | ofstream compressed1("encoded.txt"); 8 | IInputStream originalI(original); 9 | IOutputStream compressed1I(compressed1); 10 | Encode(originalI, compressed1I); 11 | compressed1.close(); 12 | original.close(); 13 | 14 | ifstream compressed2("encoded.txt"); 15 | ofstream decoded("decoded.txt"); 16 | IInputStream compressed2I(compressed2); 17 | IOutputStream decodedI(decoded); 18 | Decode(compressed2I, decodedI); 19 | compressed2.close(); 20 | decoded.close(); 21 | 22 | original.open("original.txt"); 23 | compressed2.open("decoded.txt"); 24 | while(!original.eof()){ 25 | byte a, b; 26 | original.get(a); 27 | compressed2.get(b); 28 | if(a != b) 29 | std::cerr << "Doesn't match \n"; 30 | } 31 | cout << "Ready \n"; 32 | } -------------------------------------------------------------------------------- /algorithms_and_structures/algotithms/kStat.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int partition(int * array, int p, int r); 4 | 5 | int kStat(int * array, int n, int k); 6 | 7 | int median(int * a, int p, int r); 8 | 9 | /******************************************************************************/ 10 | 11 | /******************************************************************************/ 12 | 13 | int median(int * a, int p, int r){ 14 | int mid = (p + r) / 2; 15 | 16 | if (a[p] > a[r]) 17 | if (a[r] > a[mid]) 18 | return r; 19 | else 20 | return mid; 21 | else if (a[p] > a[mid]) 22 | return p; 23 | else 24 | return mid; 25 | } 26 | 27 | 28 | 29 | int partition(int * array, int p, int r){ 30 | std::swap(array[r], array[median(array, p, r)]); 31 | int j = p; 32 | for(int i = p; i < r; i++) 33 | if(array[i] < array[r]){ 34 | std::swap(array[i], array[j]); 35 | j++; 36 | } 37 | std::swap(array[j], array[r]); 38 | return j; 39 | } 40 | 41 | 42 | 43 | int kStat(int * array, int n, int k){ 44 | int p = 0; 45 | int r = n - 1; 46 | int q = partition(array, p, r); 47 | while(q != k){ 48 | if(k < q) 49 | r = q - 1; 50 | else 51 | p = q + 1; 52 | q = partition(array, p, r); 53 | } 54 | return array[q]; 55 | } 56 | -------------------------------------------------------------------------------- /algorithms_and_structures/other/Tim.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main(){ 6 | int n, k; 7 | cin >> n >> k; 8 | k--; 9 | double * a = new double[k*(n - 1) + 1]; 10 | for(int i = 0; i < n; i++) 11 | cin >> a[i*k]; 12 | for(int i = 0; i < n - 1; i++) 13 | for(int j = 1; j < k; j++) 14 | a[i*k + j] = a[i*k] + j*(a[(i + 1)*k] - a[i*k]) / k; 15 | for(int i = 0; i < k*(n - 1) + 1; i++) 16 | cout << a[i] << ' '; 17 | delete[] a; 18 | } 19 | -------------------------------------------------------------------------------- /algorithms_and_structures/other/treeTests: -------------------------------------------------------------------------------- 1 | int main(){ 2 | BST a; 3 | while(1){ 4 | char c; 5 | int x; 6 | cin >> c; 7 | switch(c){ 8 | case '+': 9 | cin >> x; 10 | a.insert(x); 11 | break; 12 | case '-': 13 | cin >> x; 14 | a.deleteByKey(x); 15 | break; 16 | case '?': 17 | cin >> x; 18 | cout << a.find(x) << '\n'; 19 | break; 20 | case 'x': 21 | goto m; 22 | } 23 | a.print(); 24 | } 25 | m:; 26 | } 27 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/BST.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cout; 4 | 5 | //BST v1.0.0 6 | template 7 | class BST{ 8 | public: 9 | BST(); 10 | 11 | ~BST(); 12 | 13 | 14 | void insert(T key); 15 | 16 | bool remove(T key); 17 | 18 | void clear(); 19 | 20 | 21 | bool contains(T key) const; 22 | 23 | T findMin() const; 24 | 25 | T findMax() const; 26 | 27 | 28 | void print() const; 29 | 30 | private: 31 | struct Node{ 32 | Node * left; 33 | 34 | Node * right; 35 | 36 | T key; 37 | }; 38 | 39 | 40 | void clearRec(Node *node); 41 | 42 | void deleteNode(Node * & node); 43 | 44 | Node * findNode(T key); 45 | 46 | 47 | void printRec(Node * node, int depth) const; 48 | 49 | 50 | Node * root_; 51 | }; 52 | 53 | /******************************************************************************/ 54 | 55 | /****************************BST***********************************************/ 56 | 57 | // Public: 58 | 59 | template 60 | BST::BST(): 61 | root_(nullptr) 62 | {} 63 | 64 | 65 | 66 | template 67 | BST::~BST(){ 68 | clear(); 69 | } 70 | 71 | 72 | 73 | template 74 | void BST::insert(T key){ 75 | Node * tmp = new Node; 76 | tmp->left = nullptr; 77 | tmp->right = nullptr; 78 | tmp->key = key; 79 | 80 | if(root_ == nullptr){ 81 | root_ = tmp; 82 | return; 83 | } 84 | 85 | Node * node = root_; 86 | while(key <= node->key && node->left != nullptr 87 | || key > node->key && node->right != nullptr){ 88 | node = (key <= node->key)?(node->left):(node->right); 89 | } 90 | if(key <= node->key) 91 | node->left = tmp; 92 | else 93 | node->right = tmp; 94 | } 95 | 96 | 97 | 98 | template 99 | void BST::clear(){ 100 | clearRec(root_); 101 | root_ = nullptr; 102 | } 103 | 104 | 105 | 106 | template 107 | void BST::print() const{ 108 | printRec(root_, 0); 109 | } 110 | 111 | 112 | 113 | template 114 | bool BST::remove(T key){ 115 | Node * node = root_; 116 | Node * parent = nullptr; 117 | while(key != node->key 118 | && (key < node->key && node->left != nullptr 119 | || key > node->key && node->right != nullptr)){ 120 | parent = node; 121 | node = (key <= node->key)?(node->left):(node->right); 122 | } 123 | if(node->key != key) 124 | return false; 125 | if(node != root_) 126 | deleteNode((key <= parent->key)?(parent->left):(parent->right)); 127 | else 128 | deleteNode(root_); 129 | return true; 130 | } 131 | 132 | 133 | 134 | template 135 | bool BST::contains(T key) const{ 136 | return (findNode(key) != nullptr); 137 | } 138 | 139 | 140 | 141 | template 142 | T BST::findMax() const{ 143 | Node * node = root_; 144 | while(node->right != nullptr) 145 | node = node->right; 146 | return node->key; 147 | } 148 | 149 | 150 | 151 | template 152 | T BST::findMin() const{ 153 | Node * node = root_; 154 | while(node->left != nullptr) 155 | node = node->left; 156 | return node->key; 157 | }; 158 | 159 | // Private: 160 | 161 | template 162 | void BST::printRec(Node * node, int depth) const{ 163 | if(node == nullptr) 164 | return; 165 | printRec(node->right, depth + 1); 166 | for(int i = 0; i < depth*3; i++) 167 | cout << ' '; 168 | cout << node->key << '\n'; 169 | printRec(node->left, depth + 1); 170 | } 171 | 172 | 173 | 174 | template 175 | void BST::clearRec(Node * node){ 176 | if(node == nullptr) 177 | return; 178 | clearRec(node->left); 179 | clearRec(node->right); 180 | delete node; 181 | } 182 | 183 | 184 | 185 | template 186 | void BST::deleteNode(Node * & node){ 187 | if(node->right == nullptr){ 188 | Node * tmp = node->left; 189 | delete node; 190 | node = tmp; 191 | } 192 | else if(node->left == nullptr){ 193 | Node * tmp = node->right; 194 | delete node; 195 | node = tmp; 196 | } 197 | else{ 198 | Node * minParent = node; 199 | Node * min = node->right; 200 | while(min->left != nullptr){ 201 | minParent = min; 202 | min = min->left; 203 | } 204 | if(min == node->right) 205 | minParent->right = min->right; 206 | else 207 | minParent->left = min->right; 208 | min->left = node->left; 209 | min->right = node->right; 210 | delete node; 211 | node = min; 212 | } 213 | } 214 | 215 | 216 | 217 | template 218 | typename BST::Node * BST::findNode(T key){ 219 | Node * node = root_; 220 | while(node != nullptr && node->key != key){ 221 | node = (key <= node->key)?(node->left):(node->right); 222 | } 223 | return node; 224 | } 225 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/Deque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | // Deque v0.0.3 5 | template 6 | class Deque{ 7 | public: 8 | Deque(); 9 | 10 | ~Deque(); 11 | 12 | 13 | void push_front(T val); 14 | 15 | void push_back(T val); 16 | 17 | T pop_front(); 18 | 19 | T pop_back(); 20 | 21 | void clear(); 22 | 23 | 24 | T front()const; 25 | 26 | T back() const; 27 | 28 | int size() const; 29 | 30 | private: 31 | struct Node{ 32 | T val; 33 | 34 | Node * next; 35 | 36 | Node * prev; 37 | }; 38 | 39 | Node * head_; 40 | 41 | Node * tail_; 42 | 43 | int size_; 44 | }; 45 | 46 | /******************************************************************************/ 47 | 48 | /****************************DEQUE*********************************************/ 49 | 50 | template 51 | Deque::Deque(){ 52 | head_ = nullptr; 53 | tail_ = nullptr; 54 | size_ = 0; 55 | } 56 | 57 | 58 | 59 | template 60 | Deque::~Deque(){ 61 | clear(); 62 | } 63 | 64 | 65 | 66 | template 67 | void Deque::push_front(T val){ 68 | Node * tmp = new Node; 69 | tmp -> val = val; 70 | tmp -> next = nullptr; 71 | if(!size_){ 72 | tail_ = tmp; 73 | tmp -> prev = nullptr; 74 | } 75 | else{ 76 | head_ -> next = tmp; 77 | tmp -> prev = head_; 78 | } 79 | head_ = tmp; 80 | size_++; 81 | } 82 | 83 | 84 | 85 | template 86 | void Deque::push_back(T val){ 87 | Node * tmp = new Node; 88 | tmp -> val = val; 89 | tmp -> prev = nullptr; 90 | if(!size_){ 91 | head_ = tmp; 92 | tmp -> next = nullptr; 93 | } 94 | else{ 95 | tail_ -> prev = tmp; 96 | tmp -> next = tail_; 97 | } 98 | tail_ = tmp; 99 | size_++; 100 | } 101 | 102 | 103 | 104 | template 105 | T Deque::pop_front(){ 106 | if(!size_){ 107 | std::cerr << "Deque::pop_front : Empty deque\n"; 108 | } 109 | Node * tmp = head_; 110 | if(size_ == 1) 111 | tail_ = nullptr; 112 | else 113 | head_ -> prev -> next = nullptr; 114 | head_ = tmp -> prev; 115 | size_--; 116 | T val = tmp -> val; 117 | delete tmp; 118 | return val; 119 | } 120 | 121 | 122 | 123 | template 124 | T Deque::pop_back(){ 125 | if(!size_){ 126 | std::cerr << "Deque::pop_back : Empty deque\n"; 127 | } 128 | Node * tmp = tail_; 129 | if(size_ == 1) 130 | head_ = nullptr; 131 | else 132 | tail_ -> next -> prev = nullptr; 133 | tail_ = tmp -> next; 134 | size_--; 135 | T val = tmp -> val; 136 | delete tmp; 137 | return val; 138 | } 139 | 140 | 141 | 142 | template 143 | T Deque::front() const{ 144 | if(!size_){ 145 | std::cerr << "Deque::front : Empty deque\n"; 146 | } 147 | return head_ -> val; 148 | } 149 | 150 | 151 | 152 | template 153 | T Deque::back() const{ 154 | if(!size_){ 155 | std::cerr << "Deque::back : Empty deque\n"; 156 | } 157 | return tail_ -> val; 158 | } 159 | 160 | 161 | 162 | template 163 | int Deque::size() const{ 164 | return size_; 165 | } 166 | 167 | 168 | 169 | template 170 | void Deque::clear(){ 171 | while(size_){ 172 | Node * tmp = tail_; 173 | tail_ = tail_ -> next; 174 | size_--; 175 | delete tmp; 176 | } 177 | } 178 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/HashTable.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cin; 4 | using std::cout; 5 | using std::string; 6 | 7 | 8 | // HashTable v0.0.2 9 | class HashTable{ 10 | public: 11 | // Default constructor 12 | HashTable(); 13 | 14 | // Destructor 15 | ~HashTable(); 16 | 17 | // Inserts string. Returns true on success and false otherwise 18 | bool insert(string key); 19 | 20 | // Removes string. Returns true on success and false otherwise 21 | bool remove(string key); 22 | 23 | 24 | // Returns true if table contains string and false otherwise 25 | bool contains(string key) const; 26 | 27 | // Prints table 28 | void print() const; 29 | 30 | private: 31 | struct Node{ 32 | // Constructs node with data = key 33 | Node(string key); 34 | 35 | 36 | string data; 37 | 38 | bool deleted; 39 | }; 40 | 41 | // Rehashes table 42 | void rehash(); 43 | 44 | // Returns hash for key 45 | int hash(string key) const; 46 | 47 | 48 | int bufferSize_; 49 | 50 | int size_; 51 | 52 | Node ** nodes_; 53 | }; 54 | 55 | /******************************************************************************/ 56 | 57 | /****************************HASHTABLE*****************************************/ 58 | 59 | // Public: 60 | 61 | HashTable::HashTable(): 62 | bufferSize_(8), 63 | size_(0) 64 | { 65 | nodes_ = new Node*[bufferSize_]; 66 | for(size_t i = 0; i < bufferSize_; i++) 67 | nodes_[i] = nullptr; 68 | } 69 | 70 | 71 | 72 | HashTable::~HashTable(){ 73 | for (int i = 0; i < bufferSize_; ++i) 74 | if (nodes_[i] != nullptr) 75 | delete nodes_[i]; 76 | delete[] nodes_; 77 | } 78 | 79 | 80 | 81 | bool HashTable::insert(string key){ 82 | if(contains(key)) 83 | return false; 84 | 85 | if(3*bufferSize_ <= 4*(size_ + 1)) 86 | rehash(); 87 | 88 | int hashed = hash(key); 89 | int i = 0; 90 | 91 | while(i < bufferSize_){ 92 | if(nodes_[hashed] == nullptr){ 93 | nodes_[hashed] = new Node(key); 94 | size_++; 95 | return true; 96 | } 97 | else if(nodes_[hashed]->deleted){ 98 | nodes_[hashed]->data = key; 99 | nodes_[hashed]->deleted = false; 100 | size_++; 101 | return true; 102 | } 103 | i++; 104 | hashed = (hashed + i) % bufferSize_; 105 | } 106 | return false; 107 | } 108 | 109 | 110 | 111 | bool HashTable::contains(string key) const{ 112 | int hashed = hash(key); 113 | int i = 0; 114 | while(nodes_[hashed] != nullptr && i < bufferSize_){ 115 | if(!nodes_[hashed]->deleted && nodes_[hashed]->data.compare(key) == 0) 116 | return true; 117 | i++; 118 | hashed = (hashed + i) % bufferSize_; 119 | } 120 | return false; 121 | } 122 | 123 | 124 | 125 | bool HashTable::remove(string key){ 126 | if(!contains(key)) 127 | return false; 128 | 129 | int hashed = hash(key); 130 | int i = 0; 131 | 132 | while(i < bufferSize_){ 133 | if(!nodes_[hashed]->deleted && nodes_[hashed]->data.compare(key) == 0){ 134 | nodes_[hashed]->deleted = true; 135 | size_--; 136 | return true; 137 | } 138 | i++; 139 | hashed = (hashed + i) % bufferSize_; 140 | } 141 | return false; 142 | } 143 | 144 | 145 | 146 | 147 | void HashTable::print() const{ 148 | cout << "Alfa: " << (double) size_ / bufferSize_ 149 | << "; Size: " << size_ 150 | << "; BufferSize: " << bufferSize_ << '\n'; 151 | for(int i = 0; i < bufferSize_; i++) 152 | if(nodes_[i] == nullptr) 153 | cout << "NULL \n"; 154 | else 155 | cout << "KEY: " << nodes_[i]->data 156 | << "; DELETED: " << nodes_[i]->deleted 157 | << "; ADDR: " << nodes_[i] << '\n'; 158 | } 159 | 160 | // Private: 161 | 162 | void HashTable::rehash(){ 163 | Node ** tmp = nodes_; 164 | bufferSize_ *= 2; 165 | size_ = 0; 166 | nodes_ = new Node*[bufferSize_]; 167 | 168 | for(int i = 0; i < bufferSize_; i++) 169 | nodes_[i] = nullptr; 170 | 171 | for(int i = 0; i < bufferSize_ / 2; i++) 172 | if(tmp[i] != nullptr){ 173 | if(!tmp[i]->deleted) 174 | insert(tmp[i]->data); 175 | delete tmp[i]; 176 | } 177 | 178 | delete[] tmp; 179 | } 180 | 181 | 182 | 183 | int HashTable::hash(string key) const{ 184 | int hashed = 0; 185 | for (size_t i = 0; i < key.length(); i++) { 186 | hashed = (hashed + 127 * key[i]) % bufferSize_; 187 | } 188 | return hashed; 189 | } 190 | 191 | /****************************HASHTABLE::NODE***********************************/ 192 | 193 | HashTable::Node::Node(string key) : 194 | data(key), 195 | deleted(false) 196 | {} 197 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/Heap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Heap v1.1.1 4 | template 5 | class Heap{ 6 | public: 7 | 8 | Heap(); 9 | 10 | ~Heap(); 11 | 12 | 13 | void insert(T val); 14 | 15 | void clear(); 16 | 17 | 18 | 19 | int size() const; 20 | 21 | void print() const; 22 | 23 | protected: 24 | virtual void siftUp(int index) = 0; 25 | 26 | virtual void siftDown(int index) = 0; 27 | 28 | 29 | T extract_top(); 30 | 31 | T get_top() const; 32 | 33 | 34 | T * buffer_; 35 | 36 | int defaultSize_; 37 | 38 | int bufferSize_; 39 | 40 | int size_; 41 | }; 42 | 43 | /******************************************************************************/ 44 | 45 | /****************************HEAP**********************************************/ 46 | 47 | template 48 | Heap::Heap(): 49 | defaultSize_(16), 50 | bufferSize_(defaultSize_), 51 | size_(0) 52 | { 53 | buffer_ = new T[bufferSize_]; 54 | } 55 | 56 | 57 | 58 | template 59 | Heap::~Heap(){ 60 | delete[] buffer_; 61 | } 62 | 63 | 64 | 65 | template 66 | void Heap::insert(T val){ 67 | if(size_ + 1 > bufferSize_){ 68 | T * tmp = new T[bufferSize_*2]; 69 | for(int i = 0; i < bufferSize_; i++) 70 | tmp[i] = buffer_[i]; 71 | delete[] buffer_; 72 | buffer_ = tmp; 73 | bufferSize_ *= 2; 74 | } 75 | buffer_[size_] = val; 76 | size_++; 77 | siftUp(size_ - 1); 78 | } 79 | 80 | 81 | 82 | template 83 | T Heap::extract_top(){ 84 | if(!size_) 85 | std::cerr << "Heap::extract_top : Empty heap\n"; 86 | T min = buffer_[0]; 87 | buffer_[0] = buffer_[size_ - 1]; 88 | size_--; 89 | if(size_) 90 | siftDown(0); 91 | return min; 92 | } 93 | 94 | 95 | 96 | template 97 | T Heap::get_top() const{ 98 | if(!size_) 99 | std::cerr << "Heap::get_top : Empty heap\n"; 100 | return buffer_[0]; 101 | } 102 | 103 | 104 | 105 | template 106 | int Heap::size() const{ 107 | return size_; 108 | } 109 | 110 | 111 | 112 | template 113 | void Heap::clear(){ 114 | delete[] buffer_; 115 | buffer_ = new T[defaultSize_]; 116 | bufferSize_ = defaultSize_; 117 | size_ = 0; 118 | } 119 | 120 | 121 | 122 | template 123 | void Heap::print() const{ 124 | for(int i = 0; i < size_; i++) 125 | printf("%d ", buffer_[i]); 126 | printf("\n"); 127 | } 128 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/MaxHeap.cpp: -------------------------------------------------------------------------------- 1 | // Heap v1 Required 2 | 3 | // MaxHeap v0.0.2 4 | template 5 | class MaxHeap: public Heap{ 6 | private: 7 | 8 | void siftUp(int index); 9 | 10 | void siftDown(int index); 11 | 12 | public: 13 | 14 | T extract_max(); 15 | 16 | T get_max() const; 17 | }; 18 | 19 | /******************************************************************************/ 20 | 21 | /****************************MAXHEAP*******************************************/ 22 | 23 | template 24 | void MaxHeap::siftUp(int index){ 25 | if(index >= this->size_) 26 | std::cerr << "Heap::siftUp : Wrong index\n"; 27 | while(index && this->buffer_[index] > this->buffer_[(index - 1)/2]){ 28 | T tmp = this->buffer_[index]; 29 | this->buffer_[index] = this->buffer_[(index - 1)/2]; 30 | this->buffer_[(index - 1)/2] = tmp; 31 | index = (index - 1)/2; 32 | } 33 | } 34 | 35 | 36 | 37 | template 38 | void MaxHeap::siftDown(int index){ 39 | if(index >= this->size_) 40 | std::cerr << "Heap::siftDown : Wrong index\n"; 41 | int max = index; 42 | if(index*2 + 1 < this->size_ 43 | && this->buffer_[index*2 + 1] > this->buffer_[max]) 44 | max = index*2 + 1; 45 | if(index*2 + 2 < this->size_ 46 | && this->buffer_[index*2 + 2] > this->buffer_[max]) 47 | max = index*2 + 2; 48 | if(max != index){ 49 | T tmp = this->buffer_[index]; 50 | this->buffer_[index] = this->buffer_[max]; 51 | this->buffer_[max] = tmp; 52 | siftDown(max); 53 | } 54 | } 55 | 56 | 57 | 58 | template 59 | T MaxHeap::extract_max(){ 60 | return this->extract_top(); 61 | } 62 | 63 | 64 | 65 | template 66 | T MaxHeap::get_max() const{ 67 | return this->get_top(); 68 | } 69 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/MinHeap.cpp: -------------------------------------------------------------------------------- 1 | // Heap v1 Required 2 | 3 | // MinHeap v0.0.2 4 | template 5 | class MinHeap: public Heap{ 6 | private: 7 | 8 | void siftUp(int index); 9 | 10 | void siftDown(int index); 11 | 12 | public: 13 | 14 | T extract_min(); 15 | 16 | T get_min() const; 17 | }; 18 | 19 | /******************************************************************************/ 20 | 21 | /****************************MINHEAP*******************************************/ 22 | 23 | template 24 | void MinHeap::siftUp(int index){ 25 | if(index >= this->size_) 26 | std::cerr << "Heap::siftUp : Wrong index\n"; 27 | while(index && this->buffer_[index] < this->buffer_[(index - 1)/2]){ 28 | T tmp = this->buffer_[index]; 29 | this->buffer_[index] = this->buffer_[(index - 1)/2]; 30 | this->buffer_[(index - 1)/2] = tmp; 31 | index = (index - 1)/2; 32 | } 33 | } 34 | 35 | 36 | 37 | template 38 | void MinHeap::siftDown(int index){ 39 | if(index >= this->size_) 40 | std::cerr << "Heap::siftDown : Wrong index\n"; 41 | int min = index; 42 | if(index*2 + 1 < this->size_ 43 | && this->buffer_[index*2 + 1] < this->buffer_[min]) 44 | min = index*2 + 1; 45 | if(index*2 + 2 < this->size_ 46 | && this->buffer_[index*2 + 2] < this->buffer_[min]) 47 | min = index*2 + 2; 48 | if(min != index){ 49 | T tmp = this->buffer_[index]; 50 | this->buffer_[index] = this->buffer_[min]; 51 | this->buffer_[min] = tmp; 52 | siftDown(min); 53 | } 54 | } 55 | 56 | 57 | 58 | template 59 | T MinHeap::extract_min(){ 60 | return this->extract_top(); 61 | } 62 | 63 | 64 | 65 | template 66 | T MinHeap::get_min() const{ 67 | return this->get_top(); 68 | } 69 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/Queue.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Queue v0.0.3 4 | template 5 | class Queue{ 6 | public: 7 | 8 | Queue(); 9 | 10 | ~Queue(); 11 | 12 | 13 | void enqueue(T val); 14 | 15 | T dequeue(); 16 | 17 | void clear(); 18 | 19 | 20 | T front() const; 21 | 22 | int size() const; 23 | 24 | private: 25 | 26 | struct Node{ 27 | 28 | T val; 29 | 30 | Node * prev; 31 | 32 | Node * next; 33 | }; 34 | 35 | 36 | Node * head_; 37 | 38 | Node * tail_; 39 | 40 | int size_; 41 | }; 42 | 43 | /******************************************************************************/ 44 | 45 | /****************************QUEUE*********************************************/ 46 | 47 | template 48 | Queue::Queue(){ 49 | head_ = nullptr; 50 | tail_ = nullptr; 51 | size_ = 0; 52 | } 53 | 54 | 55 | 56 | template 57 | Queue::~Queue(){ 58 | clear(); 59 | } 60 | 61 | 62 | 63 | template 64 | void Queue::enqueue(T val){ 65 | Node * tmp = new Node; 66 | tmp->val = val; 67 | tmp->prev = nullptr; 68 | tmp->next = nullptr; 69 | if(size_ == 0) 70 | head_ = tmp; 71 | else 72 | tail_->next = tmp; 73 | tmp->prev = tail_; 74 | tail_ = tmp; 75 | size_++; 76 | } 77 | 78 | 79 | 80 | template 81 | T Queue::dequeue(){ 82 | if(size_ == 0){ 83 | std::cerr << "Queue::dequeue : empty queue \n"; 84 | } 85 | Node * tmp = head_; 86 | if(size_ != 1){ 87 | head_ = head_->next; 88 | head_->prev = nullptr; 89 | } 90 | else{ 91 | head_ = nullptr; 92 | tail_ = nullptr; 93 | } 94 | T val = tmp->val; 95 | size_--; 96 | delete tmp; 97 | return val; 98 | } 99 | 100 | 101 | 102 | template 103 | T Queue::front() const{ 104 | if(size_ == 0){ 105 | std::cerr << "Queue::front : empty queue \n"; 106 | } 107 | return head_->val; 108 | } 109 | 110 | 111 | 112 | template 113 | int Queue::size() const{ 114 | return size_; 115 | } 116 | 117 | 118 | 119 | template 120 | void Queue::clear(){ 121 | while(size_ != 0){ 122 | Node * tmp = tail_; 123 | tail_ = tail_->prev; 124 | delete tmp; 125 | size_--; 126 | } 127 | head_ = nullptr; 128 | tail_ = nullptr; 129 | } 130 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/Stack.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Stack v0.3.3 4 | template 5 | class Stack{ 6 | public: 7 | 8 | Stack(); 9 | 10 | ~Stack(); 11 | 12 | 13 | void push(T val); 14 | 15 | T pop(); 16 | 17 | void clear(); 18 | 19 | 20 | T back() const; 21 | 22 | T min() const; 23 | 24 | T max() const; 25 | 26 | 27 | int size() const; 28 | 29 | 30 | template 31 | friend void popPush (Stack & popFrom, Stack & pushTo); 32 | 33 | private: 34 | 35 | struct Node{ 36 | 37 | T val; 38 | 39 | T min; 40 | 41 | T max; 42 | 43 | Node * next; 44 | }; 45 | 46 | Node * top_; 47 | 48 | int size_; 49 | 50 | }; 51 | 52 | /******************************************************************************/ 53 | 54 | /****************************STACK*********************************************/ 55 | 56 | template 57 | Stack::Stack(){ 58 | top_ = nullptr; 59 | size_ = 0; 60 | } 61 | 62 | 63 | 64 | template 65 | Stack::~Stack(){ 66 | clear(); 67 | } 68 | 69 | 70 | 71 | template 72 | void Stack::push(T val){ 73 | Node * tmp = new Node; 74 | tmp->val = val; 75 | tmp->next = top_; 76 | top_ = tmp; 77 | size_++; 78 | if(size_ <= 1){ 79 | top_->min = val; 80 | top_->max = val; 81 | } 82 | else{ 83 | top_->min = (top_->next->min > val)?val:top_->next->min; 84 | top_->max = (top_->next->max < val)?val:top_->next->max; 85 | } 86 | } 87 | 88 | 89 | 90 | template 91 | T Stack::pop(){ 92 | if(size_ == 0){ 93 | std::cerr << "Stack::pop() : Empty stack\n"; 94 | } 95 | Node * tmp = top_; 96 | top_ = top_->next; 97 | size_--; 98 | T val = tmp->val; 99 | delete tmp; 100 | return val; 101 | } 102 | 103 | 104 | 105 | template 106 | T Stack::min() const{ 107 | if(size_ == 0) 108 | std::cerr << "Stack::min() : Empty stack\n"; 109 | return top_->min; 110 | } 111 | 112 | 113 | 114 | template 115 | T Stack::max() const{ 116 | if(size_ == 0) 117 | std::cerr << "Stack::max() : Empty stack\n"; 118 | return top_->max; 119 | } 120 | 121 | 122 | 123 | template 124 | int Stack::size() const{ 125 | return size_; 126 | } 127 | 128 | 129 | 130 | template 131 | T Stack::back() const{ 132 | if(size_ == 0){ 133 | std::cerr << "Stack::back() : Empty stack\n"; 134 | } 135 | return top_->val; 136 | } 137 | 138 | 139 | 140 | template 141 | void Stack::clear(){ 142 | while(size_ != 0){ 143 | Node * tmp = top_; 144 | top_ = top_->next; 145 | delete tmp; 146 | size_--; 147 | } 148 | top_ = nullptr; 149 | } 150 | 151 | 152 | 153 | template 154 | void popPush(Stack & popFrom, Stack & pushTo){ 155 | if(popFrom.size_ == 0){ 156 | std::cerr << "popPush() : Empty stack\n"; 157 | } 158 | typename Stack::Node * tmp = popFrom.top_; 159 | popFrom.top_ = popFrom.top_->next; 160 | popFrom.size_--; 161 | 162 | tmp->next = pushTo.top_; 163 | pushTo.top_ = tmp; 164 | pushTo.size_++; 165 | if(pushTo.size_ <= 1){ 166 | pushTo.top_->min = pushTo.top_->val; 167 | pushTo.top_->max = pushTo.top_->val; 168 | } 169 | else{ 170 | pushTo.top_->min = (pushTo.top_->next->min > pushTo.top_->val) 171 | ?pushTo.top_->val:pushTo.top_->next->min; 172 | pushTo.top_->max = (pushTo.top_->next->max < pushTo.top_->val) 173 | ?pushTo.top_->val:pushTo.top_->next->max; 174 | } 175 | } 176 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/StackQueue.cpp: -------------------------------------------------------------------------------- 1 | // Stack v0.3 required 2 | 3 | // StackQueue v0.4.0 4 | template 5 | class StackQueue{ 6 | public: 7 | 8 | StackQueue(); 9 | 10 | ~StackQueue(); 11 | 12 | 13 | void enqueue(T val); 14 | 15 | T dequeue(); 16 | 17 | void clear(); 18 | 19 | 20 | T front() const; 21 | 22 | T min() const; 23 | 24 | T max() const; 25 | 26 | 27 | int size() const; 28 | 29 | 30 | private: 31 | 32 | void shift(); 33 | 34 | 35 | Stack stack1_; 36 | 37 | Stack stack2_; 38 | 39 | int size_; 40 | }; 41 | 42 | /******************************************************************************/ 43 | 44 | /****************************STACKQUEUE****************************************/ 45 | 46 | template 47 | StackQueue::StackQueue(){ 48 | size_ = 0; 49 | } 50 | 51 | 52 | 53 | template 54 | StackQueue::~StackQueue(){ 55 | clear(); 56 | } 57 | 58 | 59 | 60 | template 61 | void StackQueue::enqueue(T val){ 62 | stack1_.push(val); 63 | size_++; 64 | } 65 | 66 | 67 | 68 | template 69 | void StackQueue::shift(){ 70 | while(stack1_.size()){ 71 | popPush(stack1_, stack2_); 72 | } 73 | } 74 | 75 | 76 | 77 | template 78 | T StackQueue::dequeue(){ 79 | if(size_ == 0){ 80 | std::cerr << "StackQueue::dequeue : empty queue \n"; 81 | } 82 | if(!stack2_.size()) 83 | shift(); 84 | size_--; 85 | return stack2_.pop(); 86 | } 87 | 88 | 89 | 90 | template 91 | T StackQueue::front() const{ 92 | if(size_ == 0){ 93 | std::cerr << "StackQueue::front : empty queue \n"; 94 | } 95 | if(!stack2_.size()) 96 | shift(); 97 | return stack2_.back(); 98 | } 99 | 100 | 101 | 102 | template 103 | int StackQueue::size() const{ 104 | return size_; 105 | } 106 | 107 | 108 | 109 | template 110 | void StackQueue::clear(){ 111 | stack1_.clear(); 112 | stack2_.clear(); 113 | size_ = 0; 114 | } 115 | 116 | 117 | 118 | template 119 | T StackQueue::min()const{ 120 | if(size_ == 0){ 121 | std::cerr << "Queue::min : empty queue \n"; 122 | } 123 | if(stack1_.size() == 0) 124 | return stack2_.min(); 125 | else if(stack2_.size() == 0) 126 | return stack1_.min(); 127 | else 128 | return std::min(stack1_.min(), stack2_.min()); 129 | } 130 | 131 | 132 | 133 | template 134 | T StackQueue::max()const{ 135 | if(size_ == 0){ 136 | std::cerr << "Queue::max : empty queue \n"; 137 | } 138 | if(stack1_.size() == 0) 139 | return stack2_.max(); 140 | else if(stack2_.size() == 0) 141 | return stack1_.max(); 142 | else 143 | return std::max(stack1_.max(), stack2_.max()); 144 | } 145 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/Treap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cout; 4 | 5 | // Treap v1.0.0 6 | template 7 | class Treap{ 8 | public: 9 | 10 | Treap(); 11 | 12 | ~Treap(); 13 | 14 | 15 | void insert(KeyType key, DataType val); 16 | 17 | bool remove(KeyType key); 18 | 19 | DataType * find(KeyType key); 20 | 21 | void clear(); 22 | 23 | 24 | void print(); 25 | 26 | 27 | // Functions for case KeyType == Datatype; 28 | 29 | void insert(DataType key); 30 | 31 | private: 32 | 33 | struct Node{ 34 | 35 | KeyType key; 36 | 37 | int priority; 38 | 39 | DataType val; 40 | 41 | Node * left; 42 | 43 | Node * right; 44 | }; 45 | 46 | 47 | void split(Node * node, KeyType key, Node * & left, Node * & right); 48 | 49 | Node * merge(Node * left, Node * right); 50 | 51 | 52 | void clearRec(Node * node); 53 | 54 | void printRec(Node * node, int depth); 55 | 56 | 57 | Node * root_; 58 | 59 | }; 60 | 61 | /****************************TREAP*********************************************/ 62 | 63 | // Public: 64 | 65 | template 66 | Treap::Treap(): 67 | root_(nullptr) 68 | { 69 | srand(time(NULL)); 70 | } 71 | 72 | 73 | 74 | template 75 | Treap::~Treap(){ 76 | clear(); 77 | } 78 | 79 | 80 | 81 | template 82 | void Treap::insert(KeyType key, DataType val){ 83 | int priority = rand(); 84 | Node * left = nullptr; 85 | Node * right = nullptr; 86 | Node * tmp = new Node; 87 | 88 | Node * node = root_; 89 | Node * nodeFather = nullptr; 90 | while (node != nullptr && node->priority >= priority){ 91 | nodeFather = node; 92 | node = (key <= node->key)?(node->left):(node->right); 93 | } 94 | split(node, key, left, right); 95 | if(nodeFather == nullptr) 96 | root_ = tmp; 97 | else if(key <= nodeFather->key) 98 | nodeFather->left = tmp; 99 | else 100 | nodeFather->right = tmp; 101 | 102 | tmp->val = val; 103 | tmp->priority = priority; 104 | tmp->key = key; 105 | tmp->left = left; 106 | tmp->right = right; 107 | } 108 | 109 | 110 | 111 | template 112 | void Treap::clear(){ 113 | clearRec(root_); 114 | } 115 | 116 | 117 | 118 | template 119 | void Treap::print(){ 120 | printRec(root_, 0); 121 | } 122 | 123 | 124 | 125 | template 126 | bool Treap::remove(KeyType key){ 127 | Node * node = root_; 128 | Node * nodeFather = nullptr; 129 | while (node != nullptr && node->key != key){ 130 | nodeFather = node; 131 | node = (key <= node->key)?(node->left):(node->right); 132 | } 133 | if(node == nullptr) 134 | return false; 135 | Node * tmp = node; 136 | if(nodeFather == nullptr) 137 | root_ = merge(node->left, node->right); 138 | else if(key <= nodeFather->key) 139 | nodeFather->left = merge(node->left, node->right); 140 | else 141 | nodeFather->right = merge(node->left, node->right); 142 | delete tmp; 143 | return true; 144 | } 145 | 146 | 147 | 148 | template 149 | DataType * Treap::find(KeyType key){ 150 | Node * node = root_; 151 | while (node != nullptr && node->key != key) 152 | node = (key <= node->key)?(node->left):(node->right); 153 | if(node == nullptr) 154 | return nullptr; 155 | return &(node->val); 156 | } 157 | 158 | 159 | 160 | template 161 | void Treap::insert(DataType key){ 162 | insert(key, key); 163 | } 164 | 165 | // Private: 166 | 167 | template 168 | void Treap::clearRec(Node * node){ 169 | if(node == nullptr) 170 | return; 171 | clearRec(node->left); 172 | clearRec(node->right); 173 | delete node; 174 | } 175 | 176 | 177 | 178 | template 179 | void Treap::printRec(Node * node, int depth){ 180 | if(node == nullptr) 181 | return; 182 | printRec(node->right, depth + 1); 183 | for(int i = 0; i < depth*3; i++) 184 | cout << ' '; 185 | cout << node->val << "(" << node->key << "; "<< node->priority << ")\n"; 186 | printRec(node->left, depth + 1); 187 | } 188 | 189 | 190 | 191 | template 192 | void Treap::split(Node * node, KeyType key, 193 | Node * & left, Node * & right){ 194 | if(node == nullptr){ 195 | left = nullptr; 196 | right = nullptr; 197 | } 198 | else if(node->key <= key){ 199 | split(node->right, key, node->right, right); 200 | left = node; 201 | } 202 | else{ 203 | split(node->left, key, left, node->left); 204 | right = node; 205 | } 206 | } 207 | 208 | 209 | 210 | template 211 | typename Treap::Node * Treap 212 | ::merge(Node * left, Node * right){ 213 | if(left == nullptr || right == nullptr) 214 | return (left == 0)?(right):(left); 215 | else if(left->priority > right->priority){ 216 | left->right = merge(left->right, right); 217 | return left; 218 | } 219 | right->left = merge(left, right->left); 220 | return right; 221 | } 222 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/bad/BST_Recursive: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using std::cerr; 4 | using std::cout; 5 | 6 | //BST v0.0.1 7 | template 8 | class BST{ 9 | public: 10 | BST(); 11 | ~BST(); 12 | 13 | void insert(T val); 14 | void clear(); 15 | void print(); 16 | 17 | bool deleteByKey(T key); 18 | bool find(T key); 19 | 20 | T findMin(); 21 | T findMax(); 22 | 23 | private: 24 | struct Node{ 25 | Node * left; 26 | Node * right; 27 | T val; 28 | }; 29 | 30 | Node * root_; 31 | 32 | void clearRec(Node *node); 33 | void insertRec(Node * & node, T val); 34 | void printRec(Node * node, int depth); 35 | void deleteNode(Node * & node); 36 | 37 | bool deleteByKeyRec(Node * & node, T key); 38 | 39 | //Node & findRec(Node ); 40 | }; 41 | 42 | /****************************MAIN*********************************************/ 43 | 44 | int main(){ 45 | srand(time(NULL)); 46 | BST bst; 47 | for(int i = 0; i < 20; i++){ 48 | bst.insert(rand() % 100); 49 | } 50 | bst.print(); 51 | if(!bst.deleteByKey(9)) 52 | cerr << "wrong \n"; 53 | cout << '\n'; 54 | bst.print(); 55 | } 56 | 57 | /****************************BST**********************************************/ 58 | 59 | // Public: 60 | 61 | template 62 | BST::BST(): 63 | root_(NULL) 64 | {} 65 | 66 | 67 | 68 | template 69 | BST::~BST(){ 70 | clear(); 71 | } 72 | 73 | 74 | 75 | template 76 | void BST::insert(T val){ 77 | insertRec(root_, val); 78 | } 79 | 80 | 81 | 82 | template 83 | void BST::clear(){ 84 | clearRec(root_); 85 | root_ = NULL; 86 | } 87 | 88 | 89 | 90 | template 91 | void BST::print(){ 92 | printRec(root_, 0); 93 | } 94 | 95 | 96 | 97 | template 98 | bool BST::deleteByKey(T key){ 99 | return deleteByKeyRec(root_, key); 100 | } 101 | 102 | // Private: 103 | 104 | template 105 | void BST::insertRec(Node * & node, T val){ 106 | if(node == NULL){ 107 | node = new Node; 108 | node->val = val; 109 | node->left = NULL; 110 | node->right = NULL; 111 | return; 112 | } 113 | if(val <= node->val) 114 | insertRec(node->left, val); 115 | else 116 | insertRec(node->right, val); 117 | } 118 | 119 | 120 | 121 | template 122 | void BST::printRec(Node *node, int depth){ 123 | if(node == NULL) 124 | return; 125 | printRec(node->right, depth + 1); 126 | for(int i = 0; i < depth*3; i++) 127 | cout << ' '; 128 | cout << node->val << '\n'; 129 | printRec(node->left, depth + 1); 130 | } 131 | 132 | 133 | 134 | template 135 | void BST::clearRec(Node *node){ 136 | if(node == NULL) 137 | return; 138 | clearRec(node->left); 139 | clearRec(node->right); 140 | delete node; 141 | } 142 | 143 | 144 | 145 | template 146 | bool BST::deleteByKeyRec(Node * & node, T key){ 147 | if(node == NULL) 148 | return false; 149 | if(node->val == key){ 150 | deleteNode(node); 151 | return true; 152 | } 153 | return deleteByKeyRec((node->val >= key)?(node->left):(node->right), key); 154 | } 155 | 156 | 157 | 158 | template 159 | void BST::deleteNode(Node * & node){ 160 | if(node->right == NULL){ 161 | Node * tmp = node->left; 162 | delete node; 163 | node = tmp; 164 | } 165 | else if(node->left == NULL){ 166 | Node * tmp = node->right; 167 | delete node; 168 | node = tmp; 169 | } 170 | else{ 171 | Node * minParent = node; 172 | Node * min = node->right; 173 | while(min->left != 0){ 174 | minParent = min; 175 | min = min->left; 176 | } 177 | minParent->left = NULL; 178 | min->left = node->left; 179 | min->right = node->right; 180 | delete node; 181 | node = min; 182 | } 183 | } 184 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/bad/HT: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using std::cin; 5 | using std::cout; 6 | 7 | // HashTable v0.0.1 8 | class HashTable{ 9 | public: 10 | HashTable(); 11 | ~HashTable(); 12 | 13 | bool insert(char * key); 14 | bool contains(char * key); 15 | bool remove(char * key); 16 | 17 | void print(); 18 | 19 | private: 20 | struct Node{ 21 | Node(char * key); 22 | 23 | void changeKey(char * key); 24 | 25 | char * val; 26 | bool deleted; 27 | }; 28 | 29 | void rehash(); 30 | 31 | int hash(char * key); 32 | 33 | int bufferSize_; 34 | int size_; 35 | Node ** nodes_; 36 | }; 37 | 38 | /****************************MAIN**********************************************/ 39 | 40 | int main(){ 41 | HashTable a; 42 | char * buff = new char[100000]; 43 | char c; 44 | while(!cin.eof()){ 45 | cin >> c; 46 | cin >> buff; 47 | 48 | // a.print(); 49 | } 50 | delete[] buff; 51 | } 52 | 53 | /****************************HASHTABLE*****************************************/ 54 | 55 | // Public: 56 | 57 | HashTable::HashTable(): 58 | bufferSize_(8), 59 | size_(0) 60 | { 61 | nodes_ = new Node*[bufferSize_]; 62 | for(int i = 0; i < bufferSize_; i++) 63 | nodes_[i] = NULL; 64 | } 65 | 66 | 67 | 68 | HashTable::~HashTable(){ 69 | for(int i = 0; i < bufferSize_; i++) 70 | if(nodes_[i] != NULL) 71 | delete nodes_[i]; 72 | delete[] nodes_; 73 | } 74 | 75 | 76 | 77 | bool HashTable::insert(char * key){ 78 | if(contains(key)) 79 | return false; 80 | 81 | if(3*bufferSize_ <= 4*(size_ + 1)) 82 | rehash(); 83 | 84 | int hashed = hash(key); 85 | int i = 0; 86 | 87 | while(i < bufferSize_){ 88 | if(nodes_[hashed] == NULL){ 89 | nodes_[hashed] = new Node(key); 90 | size_++; 91 | return true; 92 | } 93 | else if(nodes_[hashed]->deleted){ 94 | nodes_[hashed]->changeKey(key); 95 | nodes_[hashed]->deleted = false; 96 | size_++; 97 | return true; 98 | } 99 | i++; 100 | hashed = (hashed + i) % bufferSize_; 101 | } 102 | return false; 103 | } 104 | 105 | 106 | 107 | bool HashTable::contains(char * key){ 108 | int hashed = hash(key); 109 | int i = 0; 110 | while(nodes_[hashed] != NULL && i < bufferSize_){ 111 | if(!nodes_[hashed]->deleted && strcmp(nodes_[hashed]->val, key) == 0) 112 | return true; 113 | i++; 114 | hashed = (hashed + i) % bufferSize_; 115 | } 116 | return false; 117 | } 118 | 119 | 120 | 121 | bool HashTable::remove(char * key){ 122 | if(!contains(key)) 123 | return false; 124 | 125 | int hashed = hash(key); 126 | int i = 0; 127 | 128 | while(i < bufferSize_){ 129 | if(!nodes_[hashed]->deleted && strcmp(nodes_[hashed]->val, key) == 0){ 130 | nodes_[hashed]->deleted = true; 131 | size_--; 132 | return true; 133 | } 134 | i++; 135 | hashed = (hashed + i) % bufferSize_; 136 | } 137 | return false; 138 | } 139 | 140 | 141 | 142 | void HashTable::print(){ 143 | cout << "Alfa: " << (double) size_ / bufferSize_ 144 | << "; Size: " << size_ 145 | << "; BufferSize: " << bufferSize_ << '\n'; 146 | for(int i = 0; i < bufferSize_; i++) 147 | if(nodes_[i] == NULL) 148 | cout << "NULL \n"; 149 | else 150 | cout << "KEY: " << nodes_[i]->val 151 | << "; DELETED: " << nodes_[i]->deleted 152 | << "; ADDR: " << nodes_[i] << '\n'; 153 | } 154 | 155 | // Private: 156 | 157 | void HashTable::rehash(){ 158 | Node ** tmp = nodes_; 159 | bufferSize_ *= 2; 160 | size_ = 0; 161 | nodes_ = new Node*[bufferSize_]; 162 | 163 | for(int i = 0; i < bufferSize_; i++) 164 | nodes_[i] = NULL; 165 | 166 | for(int i = 0; i < bufferSize_ / 2; i++) 167 | if(tmp[i] != NULL){ 168 | if(!tmp[i]->deleted) 169 | insert(tmp[i]->val); 170 | delete tmp[i]; 171 | } 172 | 173 | delete[] tmp; 174 | } 175 | 176 | 177 | 178 | int HashTable::hash(char * key){ 179 | int hashed = 0; 180 | int i = 0; 181 | while(key[i] != 0){ 182 | hashed = (hashed + 5*key[i]) % bufferSize_; 183 | i++; 184 | } 185 | return hashed; 186 | } 187 | 188 | /****************************HASHTABLE::NODE***********************************/ 189 | 190 | HashTable::Node::Node(char * key): 191 | deleted(false) 192 | { 193 | val = new char[strlen(key) + 1]; 194 | strcpy(val, key); 195 | } 196 | 197 | 198 | 199 | void HashTable::Node::changeKey(char * key){ 200 | delete[] val; 201 | val = new char[strlen(key) + 1]; 202 | strcpy(val, key); 203 | } 204 | -------------------------------------------------------------------------------- /algorithms_and_structures/structures/bad/dinMassive: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class dinMassive{ 5 | private: 6 | int* massive; 7 | int length; 8 | public: 9 | dinMassive(int size){ 10 | length = size; 11 | massive = new int[size]; 12 | for(int i = 0; i < length; i++){ 13 | massive[i] = 0; 14 | } 15 | } 16 | ~dinMassive(){ 17 | delete[] massive; 18 | } 19 | int len(){ 20 | return length; 21 | } 22 | void init(int index, int value){ 23 | if(index < length){ 24 | massive[index] = value; 25 | } 26 | } 27 | int get(int index){ 28 | if(index < length){ 29 | return massive[index]; 30 | } 31 | else{ 32 | std::cerr << "Wrong index"; 33 | return 0; 34 | } 35 | } 36 | void print(){ 37 | for(int i = 0; i < length; i++){ 38 | std::cout << massive[i] << " "; 39 | } 40 | std::cout << std::endl; 41 | } 42 | void insertionSort(){ 43 | for(int i = 1; i < length; i++) { 44 | int x = massive[i]; 45 | int j = i - 1; 46 | while (j >= 0 && x < massive[j]) { 47 | massive[j + 1] = massive[j]; 48 | j--; 49 | } 50 | massive[j + 1] = x; 51 | } 52 | } 53 | }; 54 | --------------------------------------------------------------------------------