├── 940 - Majority Element ├── js │ ├── input.txt │ └── script.js └── c-plus-plus │ └── main.cpp ├── 318 - Binomial coefficients 1 (not working) ├── input.txt ├── script.js └── main.cpp ├── 10041 - LinkedList Print in reverse order └── main.cpp ├── 9899 - LinkedList Length └── main.cpp ├── 10063 - Tree Find └── main.cpp ├── 9898 - LinkedList Sum └── main.cpp ├── 10042 - LinkedList Cycle └── main.cpp ├── 10046 - LinkedList Reverse (midterm-4) └── main.cpp ├── 2860 - Sum of integers on the interval └── main.cpp ├── 9002 - Chocolate lover └── main.cpp ├── 10380 - LinkedList Middle └── main.cpp ├── 10893 - Calculator └── main.cpp ├── 4764 - Degrees of vertices └── main.cpp ├── 10060 - Tree PostOrder Traversal └── main.cpp ├── 10061 - Tree Minimum element └── main.cpp ├── 10062 - Tree Maximum element └── main.cpp ├── 10114 - Tree Invert(final-1) └── main.cpp ├── 1616 - Prime number? └── main.cpp ├── 5072 - Count number of edges └── main.cpp ├── 10059 - Tree InOrder Traversal └── main.cpp ├── 992 - Cities and roads └── main.cpp ├── 263 - Three ones (quiz3-1) └── main.cpp ├── 10064 - Tree Sum of elements └── main.cpp ├── 2585 - Profit └── main.cpp ├── 9643 - Catalan numbers └── main.cpp ├── 10057 - Tree PreOrder Traversal └── main.cpp ├── 2169 - Permutations └── main.cpp ├── 4730 - Fibonacci └── main.cpp ├── 2103 - Knapsack └── main.cpp ├── 4761 - Loops └── main.cpp ├── 10332 - Grass Planting └── main.cpp ├── 10110 - Tree Maximum depth └── main.cpp ├── 5080 - Number of hanging vertices 1 └── main.cpp ├── 4051 - Grasshopper(final-3) └── main.cpp ├── 5087 - Implement a stack └── main.cpp ├── 1871 - Squirrel and bamboo (midterm-3) └── main.cpp ├── 6198 - Minimal sum └── main.cpp ├── 9628 - Frog └── main.cpp ├── 4211 - Gas stations └── main.cpp ├── 5073 - Multiedges └── main.cpp ├── 10803 - LinkedList Delete first element └── main.cpp ├── 1533 - Anagram generation └── main.cpp ├── 3982 - From adjacency list to adjacency matrix └── main.cpp ├── 5074 - Degrees of vertices by a list of edges └── main.cpp ├── 5076 - Regular graph └── main.cpp ├── 3968 - Square root └── main.cpp ├── 4763 - From list of edges to adjacency matrix └── main.cpp ├── 4746 - Cafe "Proboscis"(final-5) └── main.cpp ├── 10109 - Tree Minimum depth └── main.cpp ├── 10115 - Tree Symmetric └── main.cpp ├── 10169 - Ternary search └── main.cpp ├── 1560 - Decreasing Number └── main.cpp ├── 1704 - Clever Turtle (quiz3-2) └── main.cpp ├── 5328 - Find Minimum └── main.cpp ├── 10748 - LinkedList Remove Cycle └── main.cpp ├── 5327 - Bracket sequence └── main.cpp ├── 7311 - Insert Parentheses (quiz1-1) └── main.cpp ├── 1228 - Add All └── main.cpp ├── 4739 - Sieve of Eratosthenes └── main.cpp ├── 6249 - Planting Trees └── main.cpp ├── 10111 - Tree Sum of left leaves └── main.cpp ├── 8735 - Train Swapping └── main.cpp ├── 922 - Shift the elements to the right └── main.cpp ├── 4000 - Depth Search └── main.cpp ├── 1366 - Stock Exchange └── main.cpp ├── 4831 - Knapsack └── main.cpp ├── 10043 - LinkedList Cycle starting point └── main.cpp ├── 10113 - Tree Sum of leaves └── main.cpp ├── 3969 - Diplomas (quiz2-3) └── main.cpp ├── 8760 - Depth First Search ├── main.cpp └── adjacencyList.cpp ├── 994 - Coloured rain └── main.cpp ├── 1079 - Removing the letters └── main.cpp ├── 609 - Water └── main.cpp ├── 9761 - Bob in Wonderland └── main.cpp ├── 137 - GCD └── main.cpp ├── 901 - Number of operations └── main.cpp ├── 4419 - Dense forest └── main.cpp ├── 10802 - LinkedList Distance to Cycle (quiz1-3) └── main.cpp ├── 4420 - The root of a cubic equation └── main.cpp ├── 7335 - Saucepans and lids └── main.cpp ├── 9593 - Merge the sequences └── stl-merge.cpp ├── 877 - Puzzle multiplication └── main.cpp ├── 3737 - Is it a Heap? └── main.cpp ├── 9016 - Binary search └── main.cpp ├── 10047 - LinkedList Intersection └── main.cpp ├── 7447 - Cut a string └── main.cpp ├── 10112 - Tree Balanced └── main.cpp ├── 8761 - Depth First Search - Timestamps └── main.cpp ├── 625 - Distance between the vertices └── readme.md ├── 10763 - LinkedList Cycle length └── main.cpp ├── 5329 - Party └── main.cpp ├── 10147 - Tree Previous └── main.cpp ├── 3981 - From adjacency matrix to adjacency list └── main.cpp ├── 10328 - Turtle - right top └── main.cpp ├── 2248 - Super minimum └── main.cpp ├── 4786 - Segments └── main.cpp ├── 3987 - From adjacency list to adjacency matrix └── main.cpp ├── 3843 - Primes └── main.cpp ├── 10157 - Transitive closure └── main.cpp ├── 5198 - Modular Exponentiation └── main.cpp ├── 9647 - Optimal Matrix Multiplication └── main.cpp ├── 10142 - Power of time └── main.cpp ├── 1618 - The Longest Common Subsequence └── main.cpp ├── 4018 - Turtle └── main.cpp ├── 1390 - Car race └── main.cpp ├── 312 - ACM └── main.cpp ├── 138 - Cash Mashine └── main.cpp ├── 1506 - Crossed Ladders └── main.cpp ├── 8669 - All divisors └── main.cpp ├── 9025 - K-th element └── main.cpp ├── 10117 - Triangles (Bronze) └── main.cpp ├── 2401 - Breadth First Search └── main.cpp ├── 5338 - Complete graph - 2 └── main.cpp ├── 978 - Get a tree └── main.cpp ├── 974 - Floyd - 1 └── main.cpp ├── 122 - Mountain routes └── main.cpp ├── 2269 - Connected components ├── dsu(depth_first_search).cpp └── main.cpp ├── 66 - The Directors’ Visitors └── main.cpp ├── 3532 - Interesting polygon └── main.cpp ├── 1457 - "Sort" station └── main.cpp ├── 4852 - The shortest distance └── main.cpp ├── 4004 - Is there a cycle? └── main.cpp ├── 10993 - Bmail Computer Network(quiz4-1) └── main.cpp ├── 3004 - Queue └── main.cpp ├── 832 - Increasing subsequence └── main.cpp ├── 10146 - Tree Next └── main.cpp ├── 3161 - Deques on 6 Megabytes └── main.cpp ├── 683 - Partial matrix sum └── main.cpp ├── 8355 - Book shelf └── main.cpp ├── 988 - Subsequence └── main.cpp ├── 977 - Is it a Tree? └── main.cpp ├── 4259 - Minimum in the stack └── main.cpp ├── 9017 - Binary search - 1 └── main.cpp ├── 1591 - Shoemaker Problem └── main.cpp ├── 6122 - Simple Stack └── main.cpp ├── 4001 - Area of the room └── main.cpp ├── 5721 - Find an element └── main.cpp ├── 7329 - Construction └── main.cpp ├── 9594 - ABA └── main.cpp ├── 10044 - LinkedList Merge └── main.cpp ├── 806 - Platforms - 3 └── main.cpp ├── 928 - The sum of the largest and the smallest └── main.cpp ├── 8598 - Wizard and wolves (midterm-2) └── main.cpp ├── 10418 - Lifeguards (Bronze) └── main.cpp ├── 930 - Mobile Phone └── main.cpp ├── 2321 - Sorting └── quickSort.cpp ├── 10082 - Shortest even path └── main.cpp ├── 10379 - Maximum Frequency Stack └── main.cpp ├── 10866 - Ternary search in array └── main.cpp ├── 4819 - Maximum by minimum └── main.cpp ├── 10143 - Throwing cards away └── main.cpp ├── 2479 - Parentheses Balance └── main.cpp ├── 776 - Roads ├── dsu(depth_first_search).cpp └── main.cpp ├── 982 - Connectivity └── main.cpp ├── 10762 - Soldiers Row └── main.cpp ├── 9020 - Split into k sub-arrays └── main.cpp ├── 10223 - The Settlers of Catan └── main.cpp ├── 1105 - Hello, Pie! └── main.cpp ├── 9557 - Bins and balls └── main.cpp ├── 1765 - Three sequences └── main.cpp ├── 6033 - Kastenlauf └── main.cpp ├── 3841 - Dr Who`s Banquet └── main.cpp ├── 5101 - Hodja Nasreddin └── main.cpp ├── 9018 - n-th integer divisible by a or b └── main.cpp ├── 4369 - Arson └── main.cpp ├── 1522 - Optimal Binary Search Tree └── main.cpp ├── 1482 - Matrix multiplication └── main.cpp ├── 1936 - Flights └── main.cpp ├── 5060 - Reverse Polish notation └── main.cpp ├── 1776 - Rails └── main.cpp ├── 5058 - Sequence of brackets └── main.cpp ├── 4260 - LCS-2 └── main.cpp ├── 975 - Floyd └── main.cpp ├── 3986 - Sources and sinks (quiz1-2) └── main.cpp ├── 1948 - Topological Sort ├── kahn_algo.cpp └── main.cpp ├── 3988 - Transitivity of a graph └── main.cpp ├── 8637 - Sort the points └── main.cpp ├── 10651 - The smallest Topological Sort └── main.cpp ├── 5854 - Maximum Sum basic └── main.cpp ├── 9023 - Minimum increments └── main.cpp ├── 6128 - Simple deque └── main.cpp ├── 10811 - Disjoint Sets Union (midterm-5) └── main.cpp ├── 4973 - Mutation └── main.cpp ├── 10242 - Knight route └── main.cpp ├── 5201 - К-th minimum └── main.cpp ├── 2590 - Space Exploration └── main.cpp ├── 2403 - Strong connectivity └── main.cpp ├── 9654 - Depth first search on a disconnected graph └── main.cpp ├── 10056 - Breadth First Search 0-1 └── main.cpp ├── 4853 - The shortest path └── main.cpp ├── 694 - Minimum in the Queue └── main.cpp ├── 981 - Minimum spanning tree └── main.cpp ├── 8236 - Sort evens and odds └── quickSort.cpp ├── 10652 - The unique Topological Sort └── main.cpp ├── 972 - Sorting time └── quickSort.cpp ├── 1521 - Optimal Matrix Multiplication - 2 └── main.cpp ├── 37 - Mail of the sponsor └── main.cpp ├── 3165 - Bicoloring └── main.cpp ├── 7452 - Print Linked List └── main.cpp ├── 1302 - Almost Prime Numbers └── main.cpp ├── 10236 - N Queens - placement └── main.cpp ├── 3937 - Digital root (quiz2-1) └── main.cpp ├── 10235 - Ordering tasks └── main.cpp ├── 1540 - 23 out of 5 └── main.cpp ├── 2967 - Unification Day └── main.cpp ├── 4019 - Turtle restoring └── main.cpp ├── 8304 - Fun function └── main.cpp ├── 1943 - Bridges └── main.cpp ├── 9035 - Class MinStack └── main.cpp └── 10946 - Nature(quiz4-2) └── dfs.cpp /940 - Majority Element/js/input.txt: -------------------------------------------------------------------------------- 1 | 4 2 | 2 3 2 3 3 | 4 | -------------------------------------------------------------------------------- /318 - Binomial coefficients 1 (not working)/input.txt: -------------------------------------------------------------------------------- 1 | 6 2 | 0 0 3 | 1 0 4 | 1 1 5 | 2 0 6 | 2 1 7 | 2 2 8 | 9 | -------------------------------------------------------------------------------- /10041 - LinkedList Print in reverse order/main.cpp: -------------------------------------------------------------------------------- 1 | //void PrintReverse(ListNode *head) { 2 | // if (head == NULL) 3 | // return; 4 | // 5 | // PrintReverse(head->next); 6 | // 7 | // cout << head->data << " "; 8 | //} -------------------------------------------------------------------------------- /9899 - LinkedList Length/main.cpp: -------------------------------------------------------------------------------- 1 | int size() { 2 | int count = 0; 3 | ListNode *temp = head; 4 | 5 | while (temp != NULL) { 6 | count++; 7 | temp = temp->next; 8 | } 9 | 10 | return count; 11 | } -------------------------------------------------------------------------------- /10063 - Tree Find/main.cpp: -------------------------------------------------------------------------------- 1 | TreeNode *Find(TreeNode *tree, int element) { 2 | if (tree == NULL) return NULL; 3 | if (element == tree->val) return tree; 4 | if (element < tree->val) return Find(tree->left, element); 5 | else return Find(tree->right, element); 6 | } -------------------------------------------------------------------------------- /9898 - LinkedList Sum/main.cpp: -------------------------------------------------------------------------------- 1 | int sum(ListNode *head) 2 | { 3 | ListNode *temp = head; 4 | int sum = 0; 5 | 6 | while (temp != NULL) { 7 | sum += temp->val; 8 | temp = temp->next; 9 | } 10 | 11 | return sum; 12 | } 13 | 14 | // Passing code on e-olymp -------------------------------------------------------------------------------- /10042 - LinkedList Cycle/main.cpp: -------------------------------------------------------------------------------- 1 | //int hasCycle(ListNode *head) 2 | //{ 3 | // if (head == NULL) return 0; 4 | // ListNode* p = head; 5 | // ListNode* q = head; 6 | // while (q->next && q->next->next) 7 | // { 8 | // p = p->next; 9 | // q = q->next->next; 10 | // if (p == q) return 1; 11 | // } 12 | // return 0; 13 | //} -------------------------------------------------------------------------------- /10046 - LinkedList Reverse (midterm-4)/main.cpp: -------------------------------------------------------------------------------- 1 | // 10046 - LinkedList Reverse 2 | 3 | ListNode* reverse(ListNode *head) { 4 | ListNode* prev= nullptr; 5 | ListNode* next; 6 | 7 | while(head) 8 | { 9 | next=head->next; 10 | head->next=prev; 11 | prev=head; 12 | head=next; 13 | } 14 | 15 | return prev; 16 | } -------------------------------------------------------------------------------- /2860 - Sum of integers on the interval/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | long num1, num2; 7 | 8 | cin>>num1>>num2; 9 | 10 | long numbersInInterval = num2 - num1 + 1; 11 | long sumOfNumbersInBetween = ( (num1 + num2) * numbersInInterval ) / 2; 12 | 13 | cout << sumOfNumbersInBetween; 14 | 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /9002 - Chocolate lover/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | long long n, a, b, res; 7 | cin >> n >> a >> b; 8 | 9 | if (n % 2 == 0) { 10 | res = (a + b) * (n / 2); 11 | } else { 12 | res = max(a, b); 13 | n-=1; 14 | res += (a + b) * (n / 2); 15 | } 16 | 17 | cout << res; 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /10380 - LinkedList Middle/main.cpp: -------------------------------------------------------------------------------- 1 | ListNode* MiddleElement(ListNode *head) 2 | { 3 | int count = 0; 4 | ListNode *temp = head; 5 | 6 | while (temp != NULL) { 7 | count++; 8 | temp = temp->next; 9 | } 10 | 11 | ListNode *temp1 = head; 12 | 13 | for (int i = 1; i < (count+1)/2 ; ++i) { 14 | temp1 = temp1->next; 15 | } 16 | 17 | return temp1; 18 | } 19 | 20 | -------------------------------------------------------------------------------- /10893 - Calculator/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | long long n; 7 | cin >> n; 8 | 9 | int count = 0; 10 | while (n != 1) { 11 | if (n%3 == 0) { 12 | n/=3; 13 | count++; 14 | } else { 15 | n-=1; 16 | count++; 17 | } 18 | } 19 | 20 | cout << count; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /4764 - Degrees of vertices/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, count = 0, temp; 7 | cin >> n; 8 | 9 | for (int i = 0; i < n; ++i) { 10 | count = 0; 11 | 12 | for (int j = 0; j < n; ++j) { 13 | cin >> temp; 14 | count += temp; 15 | } 16 | 17 | cout << count << endl; 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /10060 - Tree PostOrder Traversal/main.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | 3 | class TreeNode 4 | { 5 | public: 6 | int val; 7 | TreeNode *left; 8 | TreeNode *right; 9 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 10 | }; 11 | 12 | void PostOrder(TreeNode *tree) 13 | { 14 | if (tree != nullptr) { 15 | PostOrder(tree->left); 16 | PostOrder(tree->right); 17 | printf("%d ", tree->val); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /10061 - Tree Minimum element/main.cpp: -------------------------------------------------------------------------------- 1 | class TreeNode { 2 | public: 3 | int val; 4 | TreeNode *left; 5 | TreeNode *right; 6 | 7 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | }; 9 | 10 | TreeNode *Minimum(TreeNode *tree) { 11 | if (tree == NULL) { 12 | return NULL; 13 | } else { 14 | while (tree->left) { 15 | tree = tree->left; 16 | } 17 | return tree; 18 | } 19 | } -------------------------------------------------------------------------------- /10062 - Tree Maximum element/main.cpp: -------------------------------------------------------------------------------- 1 | class TreeNode { 2 | public: 3 | int val; 4 | TreeNode *left; 5 | TreeNode *right; 6 | 7 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | }; 9 | 10 | TreeNode *Maximum(TreeNode *tree) { 11 | if (tree == NULL) { 12 | return NULL; 13 | } else { 14 | while (tree->right) { 15 | tree = tree->right; 16 | } 17 | return tree; 18 | } 19 | } -------------------------------------------------------------------------------- /10114 - Tree Invert(final-1)/main.cpp: -------------------------------------------------------------------------------- 1 | class TreeNode 2 | { 3 | public: 4 | int val; 5 | TreeNode *left; 6 | TreeNode *right; 7 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 8 | }; 9 | 10 | TreeNode* Invert(TreeNode* tree) 11 | { 12 | if(!tree) return nullptr; 13 | TreeNode* t = new TreeNode(tree->val); 14 | t->left = Invert(tree->right); 15 | t->right = Invert(tree->left); 16 | return t; 17 | } 18 | -------------------------------------------------------------------------------- /1616 - Prime number?/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | unsigned int num; 8 | bool flag = false; 9 | 10 | cin >> num; 11 | 12 | for (int i = 2; i < sqrt(num); ++i) { 13 | if (num % i == 0) { 14 | flag = true; 15 | break; 16 | } 17 | } 18 | 19 | cout << (flag ? "No" : "Yes"); 20 | 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /5072 - Count number of edges/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | int temp; 10 | 11 | int count = 0; 12 | 13 | for(int i = 0; i < n; ++i) { 14 | for (int j = 0; j < n; ++j) { 15 | cin>>temp; 16 | 17 | if(temp) 18 | count++; 19 | } 20 | } 21 | 22 | cout<left); 16 | 17 | printf("%d ", tree->val); 18 | 19 | InOrder(tree->right); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /992 - Cities and roads/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | int a[n][n]; 10 | 11 | int count = 0; 12 | 13 | for(int i = 0; i < n; ++i) { 14 | for (int j = 0; j < n; ++j) { 15 | cin>>a[i][j]; 16 | 17 | if(a[i][j] == 1) 18 | count++; 19 | } 20 | } 21 | 22 | cout< 2 | 3 | #define MAX 100000 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | long long modulo = 12345; 9 | long long n; 10 | cin >> n; 11 | 12 | long long dp[MAX]; 13 | 14 | dp[1] = 2; 15 | dp[2] = 4; 16 | dp[3] = 7; 17 | 18 | for (long long i = 4; i <= n; i++) { 19 | dp[i] = (dp[i - 1] + dp[i - 2] + dp[i - 3]) % modulo; 20 | } 21 | 22 | cout << dp[n]; 23 | } -------------------------------------------------------------------------------- /10064 - Tree Sum of elements/main.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | 3 | class TreeNode 4 | { 5 | public: 6 | int val; 7 | TreeNode *left; 8 | TreeNode *right; 9 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 10 | }; 11 | 12 | int Sum(TreeNode *tree) 13 | { 14 | int sum = 0; 15 | 16 | if (tree != nullptr) { 17 | sum += Sum(tree->left); 18 | sum += Sum(tree->right); 19 | sum += tree->val; 20 | } 21 | 22 | return sum; 23 | } 24 | -------------------------------------------------------------------------------- /2585 - Profit/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | 8 | cin >>n; 9 | 10 | long long m = 0; 11 | long long temp, sum = 0; 12 | 13 | for (int i = 0; i < n; ++i) { 14 | cin >> temp; 15 | sum += temp; 16 | if (sum > m) { 17 | m = sum; 18 | } 19 | if (sum < 0) { 20 | sum = 0; 21 | } 22 | } 23 | 24 | cout << m; 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /9643 - Catalan numbers/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | 8 | int main() { 9 | long long n, m, i, j; 10 | 11 | cin >> n >> m; 12 | 13 | vector cat(n+1, 0); 14 | 15 | cat[0] = 1; 16 | for (i = 1; i <= n; i++) 17 | { 18 | for (j = 0; j < i; j++) 19 | cat[i] = (cat[i] + cat[j] * cat[i - j - 1]) % m; 20 | } 21 | 22 | cout << cat[n]; 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /10057 - Tree PreOrder Traversal/main.cpp: -------------------------------------------------------------------------------- 1 | // C++ 2 | #include "iostream" 3 | 4 | using namespace std; 5 | 6 | class TreeNode 7 | { 8 | public: 9 | int val; 10 | TreeNode *left; 11 | TreeNode *right; 12 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 13 | }; 14 | 15 | void PreOrder(TreeNode *tree) 16 | { 17 | if (tree != nullptr) { 18 | printf("%d ", tree->val); 19 | 20 | PreOrder(tree->left); 21 | PreOrder(tree->right); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /2169 - Permutations/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n; 8 | 9 | cin >> n; 10 | 11 | int m[n + 1]; 12 | 13 | for (int i = 1; i <= n; ++i) { 14 | m[i] = i; 15 | } 16 | 17 | do { 18 | for (int i = 1; i <= n; i++) { 19 | cout << m[i] << " "; 20 | } 21 | cout << endl; 22 | } while (next_permutation(m + 1, m + n + 1)); 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /4730 - Fibonacci/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int fibonacci(unsigned short number) { 6 | 7 | if (number == 0 || number == 1) { 8 | return 1; 9 | } 10 | 11 | return fibonacci(number - 1) + fibonacci(number - 2); 12 | } 13 | 14 | 15 | 16 | int main() { 17 | unsigned short required_fibonacci_number; 18 | 19 | cin >> required_fibonacci_number; 20 | 21 | cout << fibonacci(required_fibonacci_number); 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /2103 - Knapsack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int w, n; 8 | cin >> w >> n; 9 | 10 | int a[n]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> a[i]; 14 | } 15 | 16 | sort(a, a + n); 17 | reverse(a, a + n); 18 | 19 | int useful = 0; 20 | 21 | for (int i = 0; i < w && i < n; ++i) { 22 | useful += a[i]; 23 | } 24 | 25 | cout << useful << endl; 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /4761 - Loops/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, temp; 7 | cin >> n; 8 | 9 | for (int i = 0; i < n; ++i) { 10 | for (int j = 0; j < n; ++j) { 11 | cin >> temp; 12 | // Loop can only occur in central diagonal 13 | if (i == j && temp == 1) { 14 | cout << "YES"; 15 | return 0; 16 | } 17 | } 18 | } 19 | 20 | cout << "NO"; 21 | 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /10332 - Grass Planting/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, temp, temp2; 8 | cin >> n; 9 | 10 | vector v(n, 0); 11 | 12 | while(--n) { 13 | cin >> temp >> temp2; 14 | v[temp - 1] += 1; 15 | v[temp2 - 1] += 1; 16 | } 17 | 18 | int max = 0; 19 | 20 | for(auto a: v) { 21 | if (a >= max) { 22 | max = a; 23 | } 24 | } 25 | 26 | cout << max+1; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /10110 - Tree Maximum depth/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class TreeNode 4 | { 5 | public: 6 | int val; 7 | TreeNode *left; 8 | TreeNode *right; 9 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 10 | }; 11 | 12 | int maxDepth(TreeNode *tree) 13 | { 14 | if (tree == nullptr) { 15 | return 0; 16 | } 17 | if (tree->left == nullptr && tree->right == nullptr) { 18 | return 1; 19 | } else { 20 | return max(maxDepth(tree->left), maxDepth(tree->right)) + 1; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /5080 - Number of hanging vertices 1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, temp, count = 0; 8 | cin >> n; 9 | 10 | vector v(n, 0); 11 | 12 | for (int i = 0; i < n; ++i) { 13 | for (int j = 0; j < n; ++j) { 14 | cin >> temp; 15 | v[i] += temp; 16 | } 17 | } 18 | 19 | for (auto a: v) { 20 | if (a == 1) 21 | count++; 22 | } 23 | 24 | cout << count; 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /4051 - Grasshopper(final-3)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long n, k, a[100]; 6 | 7 | long long dp(long long pos) { 8 | if (pos == n) return 1; 9 | if (pos > n) return 0; 10 | if (a[pos] != -1) return a[pos]; 11 | 12 | long long temp = 0; 13 | for (int i = 1; i <= k; i++) 14 | temp += dp(pos + i); 15 | return a[pos] = temp; 16 | } 17 | 18 | int main() { 19 | cin >> n >> k; 20 | 21 | for (int i = 0; i < 100; i++) { 22 | a[i] = -1; 23 | } 24 | 25 | cout << dp(1); 26 | } -------------------------------------------------------------------------------- /5087 - Implement a stack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int tests, operation, number; 8 | stack myStack; 9 | 10 | cin >> tests; 11 | 12 | while (tests--) { 13 | cin >> operation; 14 | 15 | if (operation == 1) { 16 | cin >> number; 17 | myStack.push(number); 18 | } else if (operation == 2) { 19 | cout << myStack.top() << endl; 20 | myStack.pop(); 21 | } 22 | } 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /1871 - Squirrel and bamboo (midterm-3)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | //1871 - Squirrel and bamboo 8 | 9 | int main() { 10 | int n, val; 11 | 12 | cin >> n; 13 | 14 | stack s; 15 | s.push(0); 16 | 17 | while (n--) 18 | { 19 | cin >> val; 20 | if (val > 0) { 21 | s.push(max(val, s.top())); 22 | } 23 | else { 24 | s.pop(); 25 | cout << s.top() << endl; 26 | } 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /6198 - Minimal sum/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int main() { 6 | long long n; 7 | 8 | cin >> n; 9 | 10 | long long a[n], b[n]; 11 | 12 | for (int i = 0; i < n; i++) { 13 | cin >> a[i]; 14 | } 15 | 16 | for (int i = 0; i < n; i++) { 17 | cin >> b[i]; 18 | } 19 | 20 | sort(a, a+n); 21 | sort(b, b+n); 22 | reverse(b, b+n); 23 | 24 | long long sum = 0; 25 | for (int i = 0; i < n; i++) { 26 | sum += a[i] * b[i]; 27 | } 28 | cout << sum; 29 | } -------------------------------------------------------------------------------- /9628 - Frog/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // Week 9: November 17 Dynamic programming 6 | int main() { 7 | int n; 8 | cin >> n; 9 | 10 | int cost[n], dp[n]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> cost[i]; 14 | } 15 | 16 | dp[0] = 0; 17 | dp[1] = abs(cost[1] - cost[0]); 18 | 19 | for (int i = 2; i < n; ++i) { 20 | dp[i] = min( (dp[i-1] + abs(cost[i] - cost[i-1])), (dp[i-2] + abs(cost[i] - cost[i-2])) ); 21 | } 22 | 23 | cout << dp[n-1]; 24 | 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /4211 - Gas stations/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int l, n; 8 | 9 | cin >> l >> n; 10 | 11 | int g[n]; 12 | for (int i = 0; i < n; ++i) { 13 | cin >> g[i]; 14 | } 15 | 16 | sort(g, g + n); 17 | 18 | double max = l - g[n - 1] + g[0]; 19 | 20 | for (int i = 0; i < n - 1; ++i) { 21 | int t = g[i + 1] - g[i]; 22 | if (t > max) { 23 | max = t; 24 | } 25 | } 26 | 27 | printf("%.1lf", (max / 2)); 28 | 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /5073 - Multiedges/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Multiedges (5073) 4 | // 5 | // Created by Emin Alizade on 6/24/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | 10 | 11 | #include 12 | using namespace std; 13 | 14 | int a[101][101]; 15 | int main(int argc, const char * argv[]) { 16 | int n,m,x,y; 17 | 18 | cin>>n>>m; 19 | for(int i=0;i>x>>y; 21 | a[x][y]++; 22 | if(a[x][y]>1){ 23 | cout<<"YES"; 24 | return 0; 25 | } 26 | } 27 | cout<<"NO"; 28 | return 0; 29 | } -------------------------------------------------------------------------------- /10803 - LinkedList Delete first element/main.cpp: -------------------------------------------------------------------------------- 1 | ListNode* DeleteFirstElement(ListNode* head, int element) { 2 | ListNode *p = head; 3 | ListNode *q = head; 4 | 5 | if(p->val == element) { 6 | head = p->next; 7 | return head; 8 | } 9 | 10 | while (p->next) { 11 | q=p; 12 | p=p->next; 13 | 14 | if(p->val == element) { 15 | if(p->next) { 16 | q->next = p->next; 17 | } else { 18 | q->next = nullptr; 19 | } 20 | break; 21 | } 22 | } 23 | 24 | return head; 25 | } 26 | -------------------------------------------------------------------------------- /1533 - Anagram generation/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int lt(char a, char b) { 7 | if (toupper(a) != toupper(b)) { 8 | return (toupper(a) < toupper(b)); 9 | } 10 | 11 | return (a < b); 12 | } 13 | 14 | int main() { 15 | int n; 16 | 17 | cin >> n; 18 | 19 | while (n--) { 20 | string s; 21 | cin >> s; 22 | sort(s.begin(), s.end(), lt); 23 | 24 | do { 25 | cout << s << endl; 26 | } while(next_permutation(s.begin(), s.end(), lt)); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /3982 - From adjacency list to adjacency matrix/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, size, temp; 8 | cin >> n; 9 | 10 | vector> v(n, vector(n, 0)); 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> size; 14 | while (size--) { 15 | cin >> temp; 16 | v[i][temp-1] = 1; 17 | } 18 | } 19 | 20 | for (auto row: v) { 21 | for (int a: row) { 22 | cout << a << " "; 23 | } 24 | cout << endl; 25 | } 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /5074 - Degrees of vertices by a list of edges/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Degrees of vertices by a list of edges(5074) 4 | // 5 | // Created by Emin Alizade on 6/24/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | using namespace std; 11 | int a[101]; 12 | 13 | int main(int argc, const char * argv[]) { 14 | int n,m; 15 | int x,y; 16 | cin>>n>>m; 17 | for(int i=0;i>x>>y; 20 | a[x-1]++; a[y-1]++; 21 | } 22 | for(int i=0;i 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m, temp, temp2; 8 | cin >> n >> m; 9 | 10 | vector v(n, 0); 11 | 12 | for (int i = 0; i < m; ++i) { 13 | cin >> temp >> temp2; 14 | v[temp-1]++; 15 | v[temp2-1]++; 16 | } 17 | 18 | temp = v[0]; 19 | 20 | bool flag = true; 21 | for (auto a: v) { 22 | if (a != temp) { 23 | flag = false; 24 | break; 25 | } 26 | } 27 | 28 | cout << ((flag) ? "YES" : "NO") << endl; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /3968 - Square root/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define EPS 1e-10 5 | 6 | using namespace std; 7 | 8 | double f(double x) { 9 | return x * x + sqrt(x); 10 | } 11 | 12 | int main() { 13 | double c; 14 | cin >> c; 15 | 16 | double left = 0, right = c, middle; 17 | double y; 18 | 19 | while (right - left > EPS) { 20 | middle = (left + right) / 2; 21 | y = f(middle); 22 | if (y > c) { 23 | right = middle; 24 | } 25 | else { 26 | left = middle; 27 | } 28 | } 29 | 30 | printf("%lf\n",left); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /4763 - From list of edges to adjacency matrix/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int ver, edge; 8 | int start, end; 9 | cin >> ver >> edge; 10 | 11 | vector> v (ver, vector(ver, 0)); 12 | 13 | for (int i = 0; i < edge; ++i) { 14 | cin >> start >> end; 15 | v[start - 1][end - 1] = 1; 16 | v[end - 1][start - 1] = 1; 17 | } 18 | 19 | for (const auto& row: v) { 20 | for (int a: row) { 21 | cout << a << " "; 22 | } 23 | cout << endl; 24 | } 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /940 - Majority Element/js/script.js: -------------------------------------------------------------------------------- 1 | const fs = require('fs') 2 | 3 | fs.readFile('input.txt', 'utf8', (err, data) => { 4 | if (err) { 5 | console.error(err) 6 | return 7 | } 8 | 9 | const lines = data.split("\n"); 10 | 11 | const n = lines[0]; 12 | const numbers = lines[1].split(" "); 13 | 14 | const obj = {}; 15 | 16 | numbers.forEach(num => { 17 | obj[num] ? obj[num]++ : obj[num] = 1; 18 | }) 19 | 20 | let res = -1; 21 | Object.keys(obj).forEach(num => { 22 | if (obj[num] > n/2) { 23 | res = num; 24 | } 25 | }) 26 | 27 | console.log(res); 28 | }) -------------------------------------------------------------------------------- /4746 - Cafe "Proboscis"(final-5)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() 8 | { 9 | vector a; 10 | int n, temp, tip = 0; 11 | 12 | cin >> n; 13 | for (int i = 0; i < n; i++) 14 | { 15 | cin >> temp; 16 | a.push_back(temp); 17 | } 18 | 19 | sort(a.begin(), a.end()); 20 | reverse(a.begin(), a.end()); 21 | 22 | for (int i = 0; i < n; i++) { 23 | if (a[i] - i > 0) { 24 | tip += a[i] - i; 25 | } else { 26 | break; 27 | } 28 | } 29 | 30 | cout << tip << endl; 31 | } -------------------------------------------------------------------------------- /10109 - Tree Minimum depth/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | class TreeNode 4 | { 5 | public: 6 | int val; 7 | TreeNode *left; 8 | TreeNode *right; 9 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 10 | }; 11 | 12 | int minDepth(TreeNode *tree) 13 | { 14 | if (tree->left == nullptr && tree->right == nullptr) { 15 | return 1; 16 | } else if (tree->left == nullptr) { 17 | return minDepth(tree->right) + 1; 18 | } else if (tree->right == nullptr) { 19 | return minDepth(tree->left) + 1; 20 | } else { 21 | return min(minDepth(tree->left), minDepth(tree->right)) + 1; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /10115 - Tree Symmetric/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 09.10.21. 3 | // 4 | // C++ 5 | class TreeNode 6 | { 7 | public: 8 | int val; 9 | TreeNode *left; 10 | TreeNode *right; 11 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 12 | }; 13 | 14 | bool compare(TreeNode* left, TreeNode* right){ 15 | if(!left && !right) return true; 16 | if(!left || !right) return false; 17 | if(left->val == right->val) return compare(left->left, right->right) && compare(left->right, right->left); 18 | return false; 19 | } 20 | 21 | bool isSymmetric(TreeNode *tree) 22 | { 23 | return compare(tree->left, tree->right); 24 | } 25 | -------------------------------------------------------------------------------- /10169 - Ternary search/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define EPS 0.0000001 6 | 7 | double a, b; 8 | 9 | double f(double x) { 10 | return x * x + a * x + b; 11 | } 12 | 13 | double ternarySearch(double a, double b) { 14 | double g, h; 15 | while (b - a > EPS) { 16 | g = a + (b - a) / 3; 17 | h = a + 2 * (b - a) / 3; 18 | if (f(g) <= f(h)) { 19 | b = h; 20 | } else { 21 | a = g; 22 | } 23 | } 24 | return (a + b) / 2; 25 | } 26 | 27 | int main() { 28 | cin >> a >> b; 29 | cout << ternarySearch(-100, 100); 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /1560 - Decreasing Number/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Decreasing Number(1560) 4 | // 5 | // Created by Emin Alizade on 6/23/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | using namespace std; 11 | 12 | // Week 9 Noveember 17 Dynamic programming 13 | 14 | int main() { 15 | long long d[1000001]; 16 | int n; 17 | d[1]=0; 18 | for(int i=2;i<=1000000;i++){ 19 | d[i]=d[i-1]+1; 20 | if(i%2==0) d[i]=min(d[i],d[i/2]+1); 21 | if(i%3==0) d[i]=min(d[i],d[i/3]+1); 22 | } 23 | while(cin>>n){ 24 | cout< 2 | using namespace std; 3 | 4 | // Clever Turtle 1704 5 | int main() { 6 | int n,m; 7 | cin>>n>>m; 8 | long long dp[n][m]; 9 | 10 | for(int i=0;i 2 | 3 | using namespace std; 4 | 5 | int findMin(int arr[], int left, int right) { 6 | if (right == left) { 7 | return arr[left]; 8 | } 9 | 10 | int mid = (left + right) / 2; 11 | 12 | int leftMin = findMin(arr, left, mid); 13 | int rightMin = findMin(arr, mid + 1, right); 14 | 15 | return min(leftMin, rightMin); 16 | } 17 | 18 | int main() { 19 | int n, temp; 20 | cin>>n; 21 | 22 | int arr[n]; 23 | 24 | for (int i = 0; i < n; ++i) { 25 | cin >> temp; 26 | arr[i] = temp; 27 | } 28 | 29 | cout << findMin(arr, 0, n-1); 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /10748 - LinkedList Remove Cycle/main.cpp: -------------------------------------------------------------------------------- 1 | ListNode* removeCycle(ListNode* head) 2 | { 3 | ListNode *p = head; 4 | ListNode *q = head; 5 | 6 | if (head == nullptr) return head; 7 | 8 | bool flag = false; 9 | while (q->next && q->next->next) { 10 | q = q->next->next; 11 | p = p->next; 12 | 13 | if (q == p) { 14 | flag = true; 15 | break; 16 | } 17 | } 18 | 19 | if (flag) { 20 | p = head; 21 | 22 | while (p->next != q->next) { 23 | p = p->next; 24 | q = q->next; 25 | } 26 | 27 | q->next = nullptr; 28 | 29 | } 30 | 31 | return head; 32 | } 33 | -------------------------------------------------------------------------------- /5327 - Bracket sequence/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | string s; 8 | stack myStack; 9 | 10 | cin >> s; 11 | 12 | bool flag = true; 13 | for (char c: s) { 14 | if (c == '(') { 15 | myStack.push(1); 16 | } else if (c == ')') { 17 | if (myStack.empty()) { 18 | flag = false; 19 | break; 20 | } 21 | myStack.pop(); 22 | } 23 | } 24 | 25 | if (myStack.empty() && flag) { 26 | cout << "YES"; 27 | } else { 28 | cout << "NO"; 29 | } 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /7311 - Insert Parentheses (quiz1-1)/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | #include 3 | #include "stack" 4 | 5 | using namespace std; 6 | 7 | // 7311 - Insert Parentheses 8 | int main() { 9 | string s; 10 | stack myStack; 11 | 12 | cin >> s; 13 | 14 | int count = 0; 15 | for (char c: s) { 16 | if (c == '(') { 17 | myStack.push(1); 18 | } else if (c == ')') { 19 | if (myStack.empty()) { 20 | count++; 21 | } else { 22 | myStack.pop(); 23 | } 24 | } 25 | } 26 | 27 | count += myStack.size(); 28 | cout << count; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /1228 - Add All/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | long long n, temp; 8 | cin >> n; 9 | // priority queue because it always keeps sorted 10 | priority_queue, greater > q; 11 | 12 | for (long long i = 0; i < n; ++i) { 13 | cin >> temp; 14 | q.push(temp); 15 | } 16 | 17 | long long cost = 0; 18 | 19 | while (q.size() > 1) { 20 | temp = q.top(); 21 | q.pop(); 22 | temp += q.top(); 23 | q.pop(); 24 | q.push(temp); 25 | cost += temp; 26 | } 27 | 28 | cout << cost; 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /4739 - Sieve of Eratosthenes/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int begin, end; 7 | 8 | cin >> begin >> end; 9 | 10 | int arr[end + 1]; 11 | 12 | for (int i = 0; i <= end; ++i) { 13 | arr[i] = 1; 14 | } 15 | 16 | arr[1] = 0; 17 | 18 | for (int i = 2; i * i <= end; ++i) { 19 | if (arr[i] == 1) { 20 | for (int j = i * i; j <= end; j += i) { 21 | arr[j] = 0; 22 | } 23 | } 24 | } 25 | 26 | for (int i = begin; i <= end; ++i) { 27 | if (arr[i] == 1) { 28 | cout << i << " "; 29 | } 30 | } 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /6249 - Planting Trees/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n; 8 | cin >> n; 9 | 10 | int a[n]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> a[i]; 14 | } 15 | 16 | sort(a, a+n); 17 | reverse(a, a+n); 18 | int max = 0; 19 | 20 | for (int i = 0; i < n; ++i) { 21 | // +1 for starting growing the next day after planting 22 | // +1 since days should be started from 1 not 0 23 | int tempMax = i + a[i] + 1 + 1; 24 | if (tempMax > max) { 25 | max = tempMax; 26 | } 27 | } 28 | 29 | cout << max; 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /10111 - Tree Sum of left leaves/main.cpp: -------------------------------------------------------------------------------- 1 | // C++ 2 | class TreeNode { 3 | public: 4 | int val; 5 | TreeNode *left; 6 | TreeNode *right; 7 | 8 | TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | }; 10 | 11 | int sumLeft(TreeNode *tree) { 12 | int sum = 0; 13 | if (tree->left != nullptr) { 14 | if (tree->left->left == nullptr && tree->left->right == nullptr) { 15 | // Vertex is a leaf if both its left and right child are NULL 16 | sum += tree->left->val; 17 | } else { 18 | sum += sumLeft(tree->left); 19 | } 20 | } 21 | 22 | if(tree->right != nullptr) { 23 | sum += sumLeft(tree->right); 24 | } 25 | return sum; 26 | } -------------------------------------------------------------------------------- /8735 - Train Swapping/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | // 3 | //using namespace std; 4 | // 5 | //int main() { 6 | // int tests; 7 | // cin >> tests; 8 | // 9 | // while (tests--) { 10 | // int n; 11 | // cin >> n; 12 | // 13 | // int m[n]; 14 | // 15 | // for (int i = 0; i < n; ++i) { 16 | // cin >> m[i]; 17 | // } 18 | // 19 | // int res = 0; 20 | // for (int i = 0; i < n - 1; i++) { 21 | // for (int j = i + 1; j < n; j++) { 22 | // if (m[i] > m[j]) res++; 23 | // } 24 | // } 25 | // 26 | // cout << "Optimal train swapping takes " << res << " swaps." << endl; 27 | // } 28 | // return 0; 29 | //} 30 | -------------------------------------------------------------------------------- /922 - Shift the elements to the right/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Shift the elements to the right (922) 4 | // 5 | // Created by Emin Alizade on 3/2/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | 11 | using namespace std; 12 | 13 | int main(int argc, const char *argv[]) { 14 | int n; 15 | cin >> n; 16 | int a[n + 1], b[n + 1]; 17 | for (int i = 1; i <= n; i++) { 18 | cin >> a[i]; 19 | b[i] = a[i]; 20 | } 21 | a[1] = b[n]; 22 | for (int i = 1; i < n; i++) { 23 | a[i + 1] = b[i]; 24 | } 25 | for (int i = 1; i <= n; i++) { 26 | cout << a[i] << " "; 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /4000 - Depth Search/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 03.01.22. 3 | // 4 | 5 | #include 6 | #define MAX 101 7 | 8 | using namespace std; 9 | 10 | int n, g[MAX][MAX], used[MAX], s, counter = 0; 11 | 12 | void dfsMatrix(int v) { 13 | used[v] = 1; 14 | counter++; 15 | 16 | for (int i = 1; i <= n; ++i) { 17 | if (used[i] == 0 && g[v][i] == 1) { 18 | dfsMatrix(i); 19 | } 20 | } 21 | } 22 | 23 | int main() { 24 | cin>>n >> s; 25 | 26 | for (int i = 1; i <= n; ++i) { 27 | for (int j = 1; j <= n; ++j) { 28 | cin >> g[i][j]; 29 | } 30 | } 31 | 32 | dfsMatrix(s); 33 | 34 | cout << counter; 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /1366 - Stock Exchange/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | 4 | using namespace std; 5 | 6 | //Week 9: November 19 - Longest Increasing Subsequence (LIS) 7 | int main() { 8 | int n; 9 | while (cin >> n) { 10 | int x[n+1], lis[n+1]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> x[i]; 14 | } 15 | 16 | int len, i; 17 | for (len = i = 0; i < n; i++) { 18 | int pos = lower_bound(lis,lis+len,x[i]) - lis; 19 | 20 | if (pos < len) { 21 | lis[pos] = x[i]; 22 | } else { 23 | lis[len++] = x[i]; 24 | } 25 | } 26 | 27 | cout << len << endl; 28 | } 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /4831 - Knapsack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int main() { 5 | int s, w, i; 6 | 7 | int m[10010]; 8 | 9 | for (int j = 0; j < 10010; ++j) { 10 | m[j] = 0; 11 | } 12 | 13 | m[0] = 1; 14 | 15 | 16 | cin >> s; 17 | 18 | while(scanf("%d",&w) == 1) 19 | { 20 | for(i = s; i >= w; i--) { 21 | // If we can receive this number from any previous active ones 22 | if (m[i - w] == 1) m[i] = 1; 23 | } 24 | } 25 | 26 | int res = 0; 27 | for(i = s; ; i--) { 28 | if (m[i] > 0) { 29 | res = i; 30 | break; 31 | } 32 | } 33 | 34 | cout << res; 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /10043 - LinkedList Cycle starting point/main.cpp: -------------------------------------------------------------------------------- 1 | //ListNode* detectCycle(ListNode *head) 2 | //{ 3 | // ListNode *p = head; 4 | // ListNode *q = head; 5 | // 6 | // if (head == NULL) return NULL; 7 | // 8 | // bool flag = false; 9 | // while (q->next && q->next->next) { 10 | // q = q->next->next; 11 | // p = p->next; 12 | // 13 | // if (q == p) { 14 | // flag = true; 15 | // break; 16 | // } 17 | // } 18 | // 19 | // if (flag) { 20 | // p = head; 21 | // 22 | // while (p != q) { 23 | // p = p->next; 24 | // q = q->next; 25 | // } 26 | // 27 | // return p; 28 | // } else { 29 | // return NULL; 30 | // } 31 | //} -------------------------------------------------------------------------------- /10113 - Tree Sum of leaves/main.cpp: -------------------------------------------------------------------------------- 1 | int SumLeaves(TreeNode *tree) { 2 | int sum = 0; 3 | 4 | if(tree->left == nullptr && tree->right == nullptr && tree != nullptr) { 5 | sum = tree->val; 6 | } 7 | 8 | if (tree->left != nullptr) { 9 | if (tree->left->left == nullptr && tree->left->right == nullptr) { 10 | sum += tree->left->val; 11 | } else { 12 | sum += SumLeaves(tree->left); 13 | } 14 | } 15 | 16 | if(tree->right != nullptr) { 17 | if (tree->right->left == nullptr && tree->right->right == nullptr) { 18 | sum += tree->right->val; 19 | } else { 20 | sum += SumLeaves(tree->right); 21 | } 22 | } 23 | return sum; 24 | } -------------------------------------------------------------------------------- /3969 - Diplomas (quiz2-3)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long w, h ,n; 6 | 7 | // 3969 - Diplomas 8 | 9 | long long f(long long x) { 10 | return (x / w) * (x / h); 11 | } 12 | 13 | long long binarySearch(long long left, long long right) 14 | { 15 | while (left < right) 16 | { 17 | long long mid = (left + right) / 2; 18 | if (f(mid) < n) { 19 | left = mid + 1; 20 | } 21 | else { 22 | right = mid; 23 | } 24 | } 25 | 26 | return left; 27 | } 28 | 29 | int main() { 30 | 31 | cin >> w >> h >> n; 32 | 33 | long long res = binarySearch(0, (min(w,h) * n)); 34 | 35 | cout << res; 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /8760 - Depth First Search/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | //#define MAX 101 3 | // 4 | //using namespace std; 5 | // 6 | //int g[MAX][MAX], used[MAX], n, m; 7 | // 8 | //void dfsMatrix(int v) { 9 | // cout << v << " "; 10 | // used[v] = 1; 11 | // 12 | // for (int i = 1; i <= n; ++i) { 13 | // if (used[i] == 0 && g[v][i] == 1) { 14 | // dfsMatrix(i); 15 | // } 16 | // } 17 | //} 18 | // 19 | //int main() { 20 | // cin >> n >> m; 21 | // 22 | // int a, b, v; 23 | // for (int i = 1; i <= m; ++i) { 24 | // cin >> a >> b; 25 | // 26 | // g[a][b] = 1; 27 | // g[b][a] = 1; 28 | // } 29 | // 30 | // cin >> v; 31 | // 32 | // dfsMatrix(v); 33 | // 34 | // return 0; 35 | //} 36 | -------------------------------------------------------------------------------- /994 - Coloured rain/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | int hills[n+1]; 10 | int roads[n+1][n+1]; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | for (int j = 1; j <= n; ++j) { 14 | cin >> roads[i][j]; 15 | } 16 | } 17 | 18 | for (int i = 1; i <= n; ++i) { 19 | cin >> hills[i]; 20 | } 21 | 22 | int badBridge = 0; 23 | 24 | for (int i = 1; i <= n; ++i) { 25 | for (int j = i; j <= n; ++j) { 26 | if (roads[i][j] && hills[i] != hills[j]){ 27 | badBridge++; 28 | } 29 | } 30 | } 31 | 32 | cout << badBridge; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /1079 - Removing the letters/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | int dp[201][201]; 5 | string a, b; 6 | 7 | int lcs(int i, int j) { 8 | if (i == -1 || j == -1) { 9 | return 0; 10 | } 11 | 12 | if (dp[i][j] != -1) { 13 | return dp[i][j]; 14 | } 15 | 16 | if(a[i] == b[j]) { 17 | return dp[i][j] = 1 + lcs(i-1,j-1); 18 | } else { 19 | return dp[i][j] = max(lcs(i-1,j), lcs(i, j-1)); 20 | } 21 | } 22 | 23 | 24 | //Week 9: November 19 - Longest Common Subsequence (LCS) 25 | int main() { 26 | 27 | while (cin >> a >> b) { 28 | memset(dp, -1, sizeof(dp)); 29 | 30 | cout << lcs(a.size() - 1, b.size() -1) << endl; 31 | } 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /609 - Water/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | long long n, k; 9 | cin >> n >> k; 10 | 11 | deque a(n); 12 | 13 | for (long long i = 0; i < n; ++i) { 14 | cin >> a[i]; 15 | if (a[i] > k) { 16 | cout << "Impossible"; 17 | return 0; 18 | } 19 | } 20 | 21 | sort(a.begin(), a.end()); 22 | 23 | long long count = 0; 24 | while (!a.empty()) { 25 | count++; 26 | 27 | if (a.front() + a.back() <= k && a.size() > 1) { 28 | a.pop_front(); 29 | } 30 | 31 | a.pop_back(); 32 | } 33 | 34 | 35 | cout << count; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /9761 - Bob in Wonderland/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, temp, temp2; 8 | cin >> n; 9 | 10 | vector v(n, 0); 11 | 12 | while(--n) { 13 | cin >> temp >> temp2; 14 | v[temp - 1] += 1; 15 | v[temp2 - 1] += 1; 16 | } 17 | 18 | int sum = 0; 19 | 20 | // Number of operations is equal to the sum of graph vertices that have degree more than two 21 | // Because for the problem solution we need to have vertices with degree = 2, only two vertices can have degree 1 22 | for(auto a: v) { 23 | if (a > 2) { 24 | sum += a-2; 25 | } 26 | } 27 | 28 | cout << sum; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /137 - GCD/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // The Euclidean Algorithm 6 | int gcd(int a, int b) { 7 | if (a == 0) { 8 | return b; 9 | } 10 | 11 | if (b==0) { 12 | return a; 13 | } 14 | 15 | if (a > b) { 16 | return gcd(a%b, b); 17 | } else { 18 | return gcd(a, b%a); 19 | } 20 | } 21 | 22 | int main() { 23 | int n; 24 | 25 | cin >> n; 26 | 27 | int numbers[n]; 28 | 29 | for (int i = 0; i < n; ++i) { 30 | cin >> numbers[i]; 31 | } 32 | 33 | int gcdValue = numbers[0]; 34 | 35 | for (int i = 1; i < n; ++i) { 36 | gcdValue = gcd(gcdValue, numbers[i]); 37 | } 38 | 39 | cout << gcdValue; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /901 - Number of operations/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Number of operations(901) 4 | // 5 | // Created by Emin Alizade on 3/3/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | 11 | using namespace std; 12 | 13 | int main(int argc, const char *argv[]) { 14 | string s; 15 | cin >> s; 16 | int x; 17 | int count = 0; 18 | int length = s.length(); 19 | for (int i = 0; i < length; i++) { 20 | x = s[i]; 21 | if (x == 42 || x == 43 || x == 45) { 22 | count++; 23 | } 24 | } 25 | if (s[0] == 42 || s[0] == 43 || s[0] == 45) { 26 | cout << count - 1; 27 | } else { 28 | cout << count; 29 | } 30 | 31 | return 0; 32 | } -------------------------------------------------------------------------------- /4419 - Dense forest/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define EPS 1e-9 4 | 5 | using namespace std; 6 | 7 | double vp, vf, oy; 8 | 9 | // square function 10 | double s(double x) { 11 | return x * x; 12 | } 13 | 14 | double t(double x) 15 | { 16 | return sqrt(s(x) + s(1 - oy)) / vp + sqrt(s(oy) + s(1 - x)) / vf; 17 | } 18 | 19 | int main() { 20 | cin >> vp >> vf >> oy; 21 | double left = 0, right = 1; 22 | 23 | double f, g; // points for ternary search 24 | 25 | while (right - left >= EPS) { 26 | f = left + (right - left) / 3; 27 | g = right - (right - left) / 3; 28 | if (t(f) < t(g)) right = g; 29 | else left = f; 30 | } 31 | 32 | printf("%.9lf\n", left); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /10802 - LinkedList Distance to Cycle (quiz1-3)/main.cpp: -------------------------------------------------------------------------------- 1 | // 10802 - LinkedList Distance to Cycle 2 | int DistanceToCycle(ListNode *head) { 3 | ListNode *p = head; 4 | ListNode *q = head; 5 | 6 | if (head == NULL) return -1; 7 | 8 | bool flag = false; 9 | while (q->next && q->next->next) { 10 | q = q->next->next; 11 | p = p->next; 12 | 13 | if (q == p) { 14 | flag = true; 15 | break; 16 | } 17 | } 18 | 19 | if (flag) { 20 | int count = 0; 21 | p = head; 22 | 23 | while (p != q) { 24 | p = p->next; 25 | q = q->next; 26 | count++; 27 | } 28 | 29 | return count; 30 | } else { 31 | return -1; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /4420 - The root of a cubic equation/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define EPS 1e-12 3 | using namespace std; 4 | 5 | int a,b,c,d; 6 | 7 | double f(double x) { 8 | return (a * x * x * x) + ( b * x * x ) + (c * x) + d; 9 | } 10 | 11 | int main() { 12 | cin >> a >> b >> c >> d; 13 | 14 | double left, right = 1, middle; 15 | 16 | while ( f(right) * f(-right) >= 0 ) { 17 | right*=2; 18 | } 19 | 20 | left = -right; 21 | 22 | while (right - left > EPS) { 23 | middle = (left + right) / 2; 24 | 25 | if (f(middle) * f(right) > 0) { 26 | right = middle; 27 | } 28 | else { 29 | left = middle; 30 | } 31 | } 32 | 33 | printf("%lf\n", left); 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /7335 - Saucepans and lids/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | long long n, m; 8 | cin >> n >> m; 9 | 10 | long long a[n], b[m]; 11 | 12 | for (long long i = 0; i < n; ++i) { 13 | cin >> a[i]; 14 | } 15 | 16 | for (long long i = 0; i < m; ++i) { 17 | cin >> b[i]; 18 | } 19 | 20 | long long count = 0; 21 | 22 | long long i = 0, j = 0; 23 | 24 | sort(a, a+n); 25 | sort(b, b+m); 26 | 27 | while (i < n && j < m) { 28 | if (a[i] <= b[j]) { 29 | count++; 30 | i++; 31 | j++; 32 | } else { 33 | j++; 34 | } 35 | } 36 | 37 | cout << count; 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /9593 - Merge the sequences/stl-merge.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | void printVector(vector v) { 8 | for (int el: v) { 9 | cout << el << " "; 10 | } 11 | cout << endl; 12 | } 13 | 14 | int main() { 15 | // stl merge function 16 | int n; 17 | cin >> n; 18 | 19 | vector a(n); 20 | for (int i = 0; i < n; ++i) { 21 | cin >> a[i]; 22 | } 23 | 24 | int m; 25 | cin >> m; 26 | 27 | vector b(m); 28 | for (int i = 0; i < m; ++i) { 29 | cin >> b[i]; 30 | } 31 | 32 | vector res (n+m); 33 | merge(a.begin(), a.end(), b.begin(), b.end(), res.begin()); 34 | 35 | printVector(res); 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /877 - Puzzle multiplication/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 110 4 | #define INF 0x3F3F3F3F 5 | 6 | using namespace std; 7 | 8 | int dp[MAX][MAX], cards[MAX]; 9 | 10 | int f(int i, int j) { 11 | if (dp[i][j] == INF) { 12 | for (int k = i + 1; k < j; k++) { 13 | dp[i][j] = min(dp[i][j], f(i, k) + f(k, j) + cards[i] * cards[k] * cards[j]); 14 | } 15 | } 16 | 17 | return dp[i][j]; 18 | } 19 | 20 | //Week 9: November 17 - Dynamic Programming 21 | int main() { 22 | int n; 23 | cin >> n; 24 | 25 | memset(dp, INF, sizeof(dp)); 26 | 27 | 28 | for (int i = 0; i < n; i++) { 29 | cin >> cards[i]; 30 | dp[i][i] = 0; 31 | dp[i][i + 1] = 0; 32 | } 33 | 34 | 35 | cout << f(0, n - 1); 36 | 37 | return 0; 38 | } -------------------------------------------------------------------------------- /3737 - Is it a Heap?/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, temp; 7 | 8 | cin >> n; 9 | 10 | int a[n + 1]; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | cin >> temp; 14 | a[i] = temp; 15 | } 16 | 17 | 18 | bool flag = true; 19 | for (int i = 1; i <= (n/2 + 1); ++i) { 20 | if (2 * i <= n) { 21 | if (a[i] > a[2*i]) { 22 | flag = false; 23 | break; 24 | } 25 | } 26 | 27 | if ((2 * i) + 1 <= n) { 28 | if (a[i] > a[(2 * i) + 1]) { 29 | flag = false; 30 | break; 31 | } 32 | } 33 | } 34 | 35 | cout << (flag ? "YES" : "NO") << endl; 36 | 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /9016 - Binary search/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int binarySearch(int *arr, int left, int right, int x) 7 | { 8 | while (left < right) 9 | { 10 | int mid = (left + right) / 2; 11 | if (x > arr[mid]) { 12 | left = mid + 1; 13 | } 14 | else { 15 | right = mid; 16 | } 17 | } 18 | 19 | return arr[left] == x; 20 | } 21 | 22 | int main() { 23 | int n, q, temp; 24 | cin >> n >> q; 25 | 26 | int a[n]; 27 | for (int i = 0; i < n; ++i) { 28 | cin >> a[i]; 29 | } 30 | 31 | for (int i = 0; i < q; ++i) { 32 | cin >> temp; 33 | cout << (binarySearch(a, 0, n-1, temp) ? "YES" : "NO") << endl; 34 | } 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /10047 - LinkedList Intersection/main.cpp: -------------------------------------------------------------------------------- 1 | int size(ListNode *l) { 2 | int count = 0; 3 | ListNode *temp = l; 4 | 5 | while (temp != NULL) { 6 | count++; 7 | temp = temp->next; 8 | } 9 | 10 | return count; 11 | } 12 | 13 | ListNode *intersection(ListNode *l1, ListNode *l2) 14 | { 15 | int sizeL1 = size(l1); 16 | int sizeL2 = size(l2); 17 | 18 | if (sizeL1 > sizeL2) { 19 | int dif = sizeL1 - sizeL2; 20 | 21 | while (dif--) { 22 | l1 = l1->next; 23 | } 24 | } else { 25 | int dif = sizeL2 - sizeL1; 26 | 27 | while (dif--) { 28 | l2 = l2->next; 29 | } 30 | } 31 | 32 | while (l1 != l2){ 33 | l1 = l1->next; 34 | l2 = l2->next; 35 | } 36 | 37 | return l1; 38 | } 39 | -------------------------------------------------------------------------------- /7447 - Cut a string/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define INF 0x3F3F3F3F 3 | 4 | using namespace std; 5 | 6 | int dp[101][101]; 7 | string s; 8 | 9 | int f(int l, int r) { 10 | if (l > r) { 11 | return 0; 12 | } 13 | if (l == r) { 14 | return 1; 15 | } 16 | 17 | if (dp[l][r] != INF) { 18 | return dp[l][r]; 19 | } 20 | 21 | int &res = dp[l][r]; 22 | if (s[l] == s[r]) { 23 | res = min(res, f(l + 1, r - 1)); 24 | } 25 | 26 | for (int i = l; i < r; i++) { 27 | res = min(res, f(l, i) + f(i + 1, r)); 28 | } 29 | return res; 30 | } 31 | 32 | //Week 9: November 17 - Dynamic programming 33 | int main() { 34 | cin >> s; 35 | memset(dp, INF, sizeof(dp)); 36 | 37 | printf("%d\n", f(0, s.size() - 1)); 38 | return 0; 39 | } -------------------------------------------------------------------------------- /10112 - Tree Balanced/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | class TreeNode 5 | { 6 | public: 7 | int val; 8 | TreeNode *left; 9 | TreeNode *right; 10 | TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} 11 | }; 12 | 13 | int Height(TreeNode *tree) 14 | { 15 | if (tree == nullptr) { 16 | return 0; 17 | } 18 | if (tree->left == nullptr && tree->right == nullptr) { 19 | return 1; 20 | } else { 21 | int left = Height(tree->left); 22 | int right = Height(tree->right); 23 | if (left == -1 || right == -1 || abs(left - right) > 1) { 24 | return -1; 25 | } 26 | 27 | return max(left, right) + 1; 28 | } 29 | } 30 | 31 | bool isBalanced(TreeNode* root) 32 | { 33 | return Height(root) != -1; 34 | } 35 | -------------------------------------------------------------------------------- /8761 - Depth First Search - Timestamps/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 101 3 | 4 | using namespace std; 5 | 6 | int g[MAX][MAX], used[MAX], d[MAX], f[MAX], t = 1, n, m; 7 | 8 | void dfsMatrix(int v) { 9 | d[v] = t++; 10 | used[v] = 1; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | if (used[i] == 0 && g[v][i] == 1) { 14 | dfsMatrix(i); 15 | } 16 | } 17 | f[v] = t++; 18 | } 19 | 20 | int main() { 21 | cin >> n >> m; 22 | 23 | int a, b, v; 24 | for (int i = 1; i <= m; ++i) { 25 | cin >> a >> b; 26 | 27 | g[a][b] = 1; 28 | g[b][a] = 1; 29 | } 30 | 31 | cin >> v; 32 | 33 | dfsMatrix(v); 34 | 35 | for (int i = 1; i <= n; ++i) { 36 | cout << d[i] << " " << f[i] << endl; 37 | } 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /625 - Distance between the vertices/readme.md: -------------------------------------------------------------------------------- 1 | Input 2 | 3 | First line contains positive integers n, m, s and f (n ≤ 5000, m ≤ 105, 1 ≤ s, f ≤ n, s ≠ f) - the number of vertices and edges in the graph and the numbers of vertices between which the length of the minimum path should be found. 4 | 5 | Each of the next m lines contains three positive integers bi, ei и wi - the ends of the i-th edge and its weight (1 ≤ bi, ei ≤ n, 0 ≤ wi ≤ 105). 6 | 7 | Output 8 | 9 | Print in the first line the minimum weight of the path between vertices s and f. In the second line print the vertices on the shortest path from s to f in the bypass order, space separated. If the route from s to f does not exist, print -1. 10 | 11 | 12 | Input example #1 13 | 4 4 1 3 14 | 1 2 1 15 | 2 3 2 16 | 3 4 5 17 | 4 1 4 18 | 19 | Output example #1 20 | 3 21 | 1 2 3 -------------------------------------------------------------------------------- /10763 - LinkedList Cycle length/main.cpp: -------------------------------------------------------------------------------- 1 | int CycleLength(ListNode* head) 2 | { 3 | ListNode *p = head; 4 | ListNode *q = head; 5 | 6 | if (head == nullptr) return -1; 7 | 8 | bool flag = false; 9 | while (q->next && q->next->next) { 10 | q = q->next->next; 11 | p = p->next; 12 | 13 | if (q == p) { 14 | flag = true; 15 | break; 16 | } 17 | } 18 | 19 | if (flag) { 20 | p = head; 21 | 22 | while (p != q) { 23 | p = p->next; 24 | q = q->next; 25 | } 26 | 27 | int count = 1; 28 | p = p->next; 29 | 30 | while (p != q) { 31 | p = p->next; 32 | count++; 33 | } 34 | 35 | return count; 36 | } else { 37 | return -1; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /5329 - Party/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int numberOfStudents, numberOfGettingYogurt; 7 | int mod = 9929; 8 | 9 | cin >> numberOfStudents >> numberOfGettingYogurt; 10 | 11 | int C[501][501]; 12 | 13 | // Here we calculate all cases beforehand 14 | for (int i = 0; i <= 500; i++) { 15 | for (int j = 0; j <= 500; j++) { 16 | // Base cases 17 | if (j == 0 || j == i) { 18 | C[i][j] = 1; 19 | } 20 | else { 21 | // There is a formula to calculate binominal coefficent 22 | C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod; 23 | } 24 | } 25 | } 26 | 27 | 28 | cout << C[numberOfStudents][numberOfGettingYogurt]; 29 | 30 | return 0; 31 | } -------------------------------------------------------------------------------- /10147 - Tree Previous/main.cpp: -------------------------------------------------------------------------------- 1 | // C++ 2 | class TreeNode { 3 | public: 4 | int val; 5 | TreeNode *left, *right, *parent; 6 | 7 | TreeNode(int x, TreeNode *prev = nullptr) : val(x), left(nullptr), right(nullptr), parent(prev) {} 8 | }; 9 | 10 | TreeNode *Maximum(TreeNode *tree) { 11 | if (tree == nullptr) { 12 | return nullptr; 13 | } else { 14 | while (tree->right) { 15 | tree = tree->right; 16 | } 17 | return tree; 18 | } 19 | } 20 | 21 | TreeNode *Prev(TreeNode *tree) { 22 | if (tree->left != nullptr) { 23 | return Maximum(tree->left); 24 | } 25 | 26 | TreeNode *prev = tree->parent; 27 | 28 | while (prev != nullptr && tree == prev->left) { 29 | tree = prev; 30 | prev = prev->parent; 31 | } 32 | 33 | return prev; 34 | } 35 | -------------------------------------------------------------------------------- /3981 - From adjacency matrix to adjacency list/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, temp; 8 | cin >> n; 9 | 10 | vector> v(n, vector(0)); 11 | 12 | for (int i = 0; i < n; ++i) { 13 | for (int j = 0; j < n; ++j) { 14 | cin >> temp; 15 | 16 | if (temp == 1) { 17 | // For each point from matrix that is one we push to vector as connection from i to j 18 | v[i].push_back(j); 19 | } 20 | } 21 | } 22 | 23 | for (auto vertice: v) { 24 | cout << vertice.size() << " "; 25 | 26 | for (int edge: vertice) { 27 | cout << edge + 1 << " "; 28 | } 29 | 30 | cout << endl; 31 | } 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /10328 - Turtle - right top/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m; 7 | cin >> n >> m; 8 | 9 | 10 | int dp[n][m]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | for (int j = 0; j < m; ++j) { 14 | cin >> dp[i][j]; 15 | } 16 | } 17 | 18 | for (int i = 0; i < n; i++) { 19 | for (int j = m - 1; j >= 0; j--) { 20 | if (i == 0 && j == m-1) { 21 | continue; 22 | } else if (i==0) { 23 | dp[i][j] += dp[i][j+1]; 24 | } else if (j == m-1) { 25 | dp[i][j] += dp[i-1][j]; 26 | } else { 27 | dp[i][j] += max(dp[i-1][j], dp[i][j+1]); 28 | } 29 | } 30 | } 31 | 32 | cout << dp[n-1][0]; 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /2248 - Super minimum/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() 6 | { 7 | int n, k; 8 | cin >> n >> k; 9 | 10 | int a[n]; 11 | 12 | int min = INT32_MAX; 13 | int index = 0; 14 | 15 | for (int i = 0; i < n; i++) 16 | { 17 | cin >> a[i]; 18 | 19 | int rangeBegin = i - k + 1; 20 | if (index < rangeBegin) 21 | { 22 | min = a[rangeBegin]; 23 | for (int j = rangeBegin; j <= i; j++) 24 | if (min >= a[j]) { 25 | min = a[j]; 26 | index = j; 27 | } 28 | } 29 | if (min >= a[i]){ 30 | min = a[i]; 31 | index = i; 32 | } 33 | 34 | if (i + 1 >= k) { 35 | cout << min << " "; 36 | } 37 | } 38 | } -------------------------------------------------------------------------------- /4786 - Segments/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | class segment 7 | { 8 | public: 9 | int start, fin; 10 | segment(int start, int fin) : start(start), fin(fin) {} 11 | }; 12 | 13 | vector v; 14 | 15 | int f(segment a, segment b) 16 | { 17 | return a.fin <= b.fin; 18 | } 19 | 20 | 21 | int main() { 22 | int n, s, e; 23 | cin >> n; 24 | 25 | for (int i = 0; i < n; ++i) { 26 | cin >> s >> e; 27 | v.push_back(segment(s, e)); 28 | } 29 | 30 | sort(v.begin(), v.end(), f); 31 | 32 | int cur = 0, res = 1; 33 | 34 | for (int i = 1; i < v.size(); ++i) { 35 | if (v[i].start >= v[cur].fin) { 36 | cur = i; 37 | res++; 38 | } 39 | } 40 | 41 | cout << res; 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /3987 - From adjacency list to adjacency matrix/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, m, temp, temp2; 8 | cin >> n >> m; 9 | 10 | vector> v(n, vector(n, false)); 11 | 12 | for (int i = 0; i < m; ++i) { 13 | cin >> temp >> temp2; 14 | v[temp - 1][temp2 - 1] = true; 15 | v[temp2 - 1][temp - 1] = true; 16 | } 17 | 18 | bool flag = true; 19 | 20 | for (int i = 0; i < n; ++i) { 21 | for (int j = 0; j < n; ++j) { 22 | if (i == j) { 23 | continue; 24 | } 25 | 26 | if (!v[i][j]) { 27 | flag = false; 28 | break; 29 | } 30 | } 31 | } 32 | 33 | cout << ((flag) ? "YES" : "NO") << endl; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /8760 - Depth First Search/adjacencyList.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 02.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | vector > g; 11 | vector used; 12 | int n, m; 13 | 14 | void dfsMatrix(int v) { 15 | cout << v << " "; 16 | used[v] = 1; 17 | 18 | for (int i = 0; i < g[v].size(); ++i) { 19 | int to = g[v][i]; 20 | 21 | if (used[to] == 0) { 22 | dfsMatrix(to); 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | cin >> n >> m; 29 | g.resize(n + 1); 30 | used.resize(n + 1); 31 | 32 | int a, b, v; 33 | for (int i = 1; i <= m; ++i) { 34 | cin >> a >> b; 35 | 36 | g[a].push_back(b); 37 | g[b].push_back(a); 38 | } 39 | 40 | cin >> v; 41 | 42 | dfsMatrix(v); 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /3843 - Primes/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | vector> testCases; 8 | 9 | long long from, to; 10 | long long max = 10000000; 11 | 12 | while (cin >> from >> to) { 13 | testCases.push_back({from, to}); 14 | } 15 | 16 | vector arr(max+1, 1); 17 | 18 | for (int i = 2; i * i <= max; ++i) { 19 | if (arr[i] == 1) { 20 | for (int j = 2 * i; j <= max; j += i) { 21 | arr[j] = 0; 22 | } 23 | } 24 | } 25 | 26 | for (int i = 2; i <= max; i++) { 27 | arr[i] = arr[i] + arr[i - 1]; 28 | } 29 | 30 | for (auto &test: testCases) { 31 | int count = arr[test[1]] - arr[test[0] - 1]; 32 | cout << count << endl << endl; 33 | count = 0; 34 | } 35 | 36 | return 0; 37 | } -------------------------------------------------------------------------------- /10157 - Transitive closure/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 101 4 | 5 | using namespace std; 6 | 7 | int n; 8 | bool g[MAX][MAX]; 9 | 10 | void floyd() { 11 | for (int k = 1; k <= n; k++) { 12 | for (int i = 1; i <= n; i++) { 13 | for (int j = 1; j <= n; j++) { 14 | if (g[i][k] && g[k][j]) { 15 | g[i][j] = true; 16 | } 17 | } 18 | } 19 | } 20 | } 21 | 22 | // Week 10: November 26 - Transitive closure 23 | int main() { 24 | cin >> n; 25 | 26 | int a, b; 27 | 28 | while (cin >> a >> b) { 29 | g[a][b] = true; 30 | } 31 | 32 | 33 | floyd(); 34 | 35 | for (int i = 1; i <= n; i++) { 36 | for (int j = 1; j <= n; j++) { 37 | cout << g[i][j] << " "; 38 | } 39 | cout << endl; 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /5198 - Modular Exponentiation/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int modExpo(long long number, unsigned int power, int mod) 5 | { 6 | int result = 1; 7 | number = number % mod; // Update number if it is more than or 8 | // equal to mod 9 | 10 | if (number == 0) return 0; 11 | 12 | while (power > 0) 13 | { 14 | // If power is odd, multiply number with result 15 | if (power % 2 == 1) { 16 | result = (result*number) % mod; 17 | } 18 | // power must be even now 19 | power = power / 2; 20 | number = (number*number) % mod; 21 | } 22 | return result; 23 | } 24 | 25 | 26 | int main() { 27 | int number, power, mod; 28 | 29 | cin >> number >> power >> mod; 30 | 31 | int result = modExpo(number, power, mod); 32 | 33 | cout << result; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /9647 - Optimal Matrix Multiplication/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define INF 0x3F3F3F3F3F3F3F3FLL 5 | 6 | using namespace std; 7 | 8 | #define MAX 11 9 | 10 | long long m[MAX][MAX], p[MAX]; 11 | 12 | long long Mult(int i, int j) { 13 | if (m[i][j] == INF) { 14 | for (int k = i; k <= j - 1; k++) { 15 | long long temp = Mult(i, k) + Mult(k + 1, j) + p[i - 1] * p[k] * p[j]; 16 | if (temp < m[i][j]) { 17 | m[i][j] = temp; 18 | } 19 | } 20 | } 21 | return m[i][j]; 22 | } 23 | 24 | // Week 10: November 24 - Matrix multiplication 25 | int main() { 26 | int n; 27 | cin >> n; 28 | memset(m, 0x3F, sizeof(m)); 29 | for (int i = 1; i <= n; i++) { 30 | cin >> p[i-1] >> p[i]; 31 | m[i][i] = 0; 32 | } 33 | 34 | cout << Mult(1, n); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /10142 - Power of time/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "deque" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, nCopy, temp, time = 0; 8 | deque given, ideal; 9 | 10 | cin >> n; 11 | 12 | nCopy = n; 13 | while (nCopy--) { 14 | cin >> temp; 15 | 16 | given.push_back(temp); 17 | } 18 | 19 | nCopy = n; 20 | while (nCopy--) { 21 | cin >> temp; 22 | 23 | ideal.push_back(temp); 24 | } 25 | 26 | while (!ideal.empty()) { 27 | if (ideal.front() == given.front()) { 28 | ideal.pop_front(); 29 | given.pop_front(); 30 | time++; 31 | } else { 32 | temp = given.front(); 33 | given.pop_front(); 34 | given.push_back(temp); 35 | time++; 36 | } 37 | } 38 | 39 | cout << time; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /1618 - The Longest Common Subsequence/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | int dp[1001][1001], a[1001], b[1001]; 5 | 6 | int lcs(int i, int j) { 7 | if (i == 0 || j == 0) { 8 | return 0; 9 | } 10 | 11 | if (dp[i][j] != -1) { 12 | return dp[i][j]; 13 | } 14 | 15 | if(a[i] == b[j]) { 16 | return dp[i][j] = 1 + lcs(i-1,j-1); 17 | } else { 18 | return dp[i][j] = max(lcs(i-1,j), lcs(i, j-1)); 19 | } 20 | } 21 | 22 | 23 | //Week 9: November 19 - Longest Common Subsequence (LCS) 24 | int main() { 25 | int n,m; 26 | 27 | memset(dp, -1, sizeof(dp)); 28 | 29 | cin >> n; 30 | for (int i = 1; i <= n; ++i) { 31 | cin >> a[i]; 32 | } 33 | 34 | cin >> m; 35 | for (int i = 1; i <= m; ++i) { 36 | cin >> b[i]; 37 | } 38 | 39 | cout << lcs(n, m); 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /4018 - Turtle/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m; 7 | 8 | cin >> n >> m; 9 | 10 | 11 | int dp[n][m]; 12 | 13 | for (int i = 0; i < n; ++i) { 14 | for (int j = 0; j < m; ++j) { 15 | cin >> dp[i][j]; 16 | } 17 | } 18 | 19 | for (int i = 0; i < n; ++i) { 20 | for (int j = 0; j < m; ++j) { 21 | if (i == 0 && j == 0) { 22 | continue; 23 | } 24 | 25 | if (i == 0) { 26 | dp[i][j] += dp[i][j-1]; 27 | continue; 28 | } 29 | 30 | if (j == 0) { 31 | dp[i][j] += dp[i-1][j]; 32 | continue; 33 | } 34 | 35 | dp[i][j] += min(dp[i][j-1], dp[i-1][j]); 36 | } 37 | } 38 | 39 | cout << dp[n-1][m-1]; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /1390 - Car race/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 1001 3 | 4 | using namespace std; 5 | 6 | int g[MAX][MAX], used[MAX], n, m; 7 | bool flag = false; 8 | 9 | void dfsMatrix(int v, int prev = -1) { 10 | used[v] = 1; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | if (i != prev && g[v][i] == 1) { 14 | if (used[i] == 1) { 15 | flag = true; 16 | } else { 17 | dfsMatrix(i, v); 18 | } 19 | } 20 | } 21 | } 22 | 23 | int main() { 24 | cin >> n >> m; 25 | 26 | int a, b; 27 | for (int i = 1; i <= m; ++i) { 28 | cin >> a >> b; 29 | 30 | g[a][b] = 1; 31 | g[b][a] = 1; 32 | } 33 | 34 | for (int i = 1; i <= n; i++) { 35 | if (used[i] == 0) { 36 | dfsMatrix(i); 37 | } 38 | } 39 | 40 | cout << (flag ? "YES" : "NO"); 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /312 - ACM/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int dp[1010][20][20], n; 4 | 5 | inline int max3(int a, int b, int c) 6 | { 7 | int ret = a; 8 | if (ret < b) ret = b; 9 | if (ret < c) ret = c; 10 | return ret; 11 | } 12 | 13 | inline int max2(int a, int b) 14 | { 15 | return a > b ? a : b; 16 | } 17 | 18 | int main() 19 | { 20 | int white, black, i, j; 21 | while (scanf("%d%d", &white, &black) != EOF) 22 | { 23 | n++; 24 | for (i = 1; i <= 15; i++) 25 | { 26 | dp[n][i][0] = max2(dp[n - 1][i - 1][0] + white, dp[n - 1][i][0]); 27 | dp[n][0][i] = max2(dp[n - 1][0][i - 1] + black, dp[n - 1][0][i]); 28 | for (j = 1; j <= 15; j++) 29 | dp[n][i][j] = max3(dp[n - 1][i - 1][j] + white, dp[n - 1][i][j - 1] + black, dp[n - 1][i][j]); 30 | } 31 | } 32 | printf("%d\n", dp[n][15][15]); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /138 - Cash Mashine/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Cash Machine(138) 4 | // 5 | // Created by Emin Alizade on 5/10/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | using namespace std; 11 | 12 | int main(int argc, const char * argv[]) { 13 | int n,count=0; 14 | cin>>n; 15 | if(n/500>0){ 16 | count+=n/500; 17 | n=n%500; 18 | } 19 | if(n/200>0){ 20 | count+=n/200; 21 | n=n%200; 22 | } 23 | if(n/100>0){ 24 | count+=n/100; 25 | n=n%100; 26 | } 27 | if(n/50>0){ 28 | count+=n/50; 29 | n=n%50; 30 | } 31 | if(n/20>0){ 32 | count+=n/20; 33 | n=n%20; 34 | } 35 | if(n/10>0){ 36 | count+=n/10; 37 | n=n%10; 38 | } 39 | if(n==0){ 40 | cout< 2 | #include 3 | 4 | using namespace std; 5 | 6 | double x, y, c; 7 | 8 | int main() { 9 | double left, right, a, b, c1, d; 10 | 11 | while (cin >> x >> y >> c) { 12 | left = 0; 13 | right = x > y ? y : x; // min of x,y 14 | 15 | d = (left + right) / 2; // AC the value that we look for 16 | 17 | do { 18 | a = sqrt(x*x - d*d); // from triangle ABC 19 | b = sqrt(y*y - d*d); // from triangle ACD 20 | 21 | c1 = (a*b) / (a+b); 22 | 23 | if (c1 < c) { 24 | right = (left + right) / 2; 25 | } else { 26 | left = (left + right) / 2; 27 | } 28 | 29 | d = (left + right) / 2; 30 | 31 | } while (fabs(c1 - c) > 0.00001); 32 | 33 | printf("%.3lf\n",d); 34 | } 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /8669 - All divisors/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | unsigned int num; 9 | 10 | 11 | vector divisors; 12 | 13 | cin >> num; 14 | 15 | for (int i = 1; i <= sqrt(num); ++i) { 16 | if (num % i == 0) { 17 | // Add divisors up to square root 18 | divisors.push_back(i); 19 | } 20 | } 21 | 22 | // Add divisors after square root 23 | for(int i = divisors.size() - 1; i >= 0; i--) 24 | { 25 | if (num/divisors[i] != divisors[i]) { 26 | // To avoid having two times 6 in 36 input sample 27 | divisors.push_back( num/divisors[i] ); 28 | } 29 | } 30 | 31 | for (auto &divisor : divisors) // access by reference to avoid copying 32 | { 33 | cout << divisor << " "; 34 | } 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /9025 - K-th element/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | vector v; 7 | int n, k, i; 8 | 9 | int Partition(int left, int right) 10 | { 11 | int x = v[left], i = left - 1, j = right + 1; 12 | while (1) 13 | { 14 | do j--; while (v[j] > x); 15 | do i++; while (v[i] < x); 16 | if (i < j) swap(v[i], v[j]); else return j; 17 | } 18 | } 19 | 20 | int kth(int k, int left, int right) 21 | { 22 | if (left == right) return v[left]; 23 | int pos = Partition(left, right); 24 | if (k <= pos) return kth(k, left, pos); 25 | else return kth(k, pos + 1, right); 26 | } 27 | 28 | int main(void) 29 | { 30 | scanf("%d %d", &n, &k); 31 | v.resize(n + 1); 32 | for (i = 1; i <= n; i++) { 33 | scanf("%d", &v[i]); 34 | } 35 | 36 | printf("%d\n", kth(k, 1, n)); 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /10117 - Triangles (Bronze)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n; 8 | cin>>n; 9 | 10 | int x[n], y[n]; 11 | for (int i = 0; i < n; ++i) { 12 | cin >> x[i] >> y[i]; 13 | } 14 | 15 | int maxArea = INT32_MIN; 16 | 17 | // Triangle is rectangular 18 | // Imagine 3 points that are vertices of triangle: i,j,k 19 | for (int i = 0; i < n; ++i) { 20 | for (int j = 0; j < n; ++j) { 21 | for (int k = 0; k < n; ++k) { 22 | if (y[i] == y[j] && x[j] == x[k]) { 23 | int area = abs((x[j] - x[i]) * (y[k] - y[j])); 24 | 25 | if (area > maxArea) { 26 | maxArea = area; 27 | } 28 | } 29 | } 30 | } 31 | } 32 | 33 | cout << maxArea; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /2401 - Breadth First Search/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define MAX 101 4 | 5 | using namespace std; 6 | 7 | int n, s, f; 8 | int g[MAX][MAX]; 9 | int dist[MAX]; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for (int i = 1; i <= n; ++i) { 18 | if (g[from][i] && dist[i] == -1) { 19 | dist[i] = dist[from] + 1; 20 | q.push(i); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n >> s >> f; 28 | memset(dist, -1, sizeof(dist)); 29 | 30 | for (int i = 1; i <= n; ++i) { 31 | for (int j = 1; j <= n; ++j) { 32 | cin >> g[i][j]; 33 | } 34 | } 35 | 36 | q.push(s); 37 | dist[s] = 0; 38 | bfs(); 39 | 40 | cout << (dist[f] != -1 ? dist[f] : 0); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /5338 - Complete graph - 2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define MAX 1001 4 | 5 | using namespace std; 6 | 7 | int n, s, f; 8 | int g[MAX][MAX]; 9 | int dist[MAX]; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for (int i = 1; i <= n; ++i) { 18 | if (g[from][i] && dist[i] == -1) { 19 | dist[i] = dist[from] + 1; 20 | q.push(i); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n; 28 | memset(dist, -1, sizeof(dist)); 29 | 30 | for (int i = 1; i <= n; ++i) { 31 | for (int j = 1; j <= n; ++j) { 32 | cin >> g[i][j]; 33 | } 34 | } 35 | 36 | cin >> s >> f; 37 | 38 | q.push(s); 39 | dist[s] = 0; 40 | bfs(); 41 | 42 | cout << dist[f]; 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /978 - Get a tree/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 02.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | vector > g; 11 | vector used; 12 | int n, m; 13 | 14 | void dfsMatrix(int v) { 15 | used[v] = 1; 16 | 17 | for (int i = 0; i < g[v].size(); ++i) { 18 | int to = g[v][i]; 19 | 20 | if (used[to] == 0) { 21 | cout << v << " " << to << endl; 22 | dfsMatrix(to); 23 | } 24 | } 25 | } 26 | 27 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 28 | 29 | int main() { 30 | cin >> n >> m; 31 | g.resize(n + 1); 32 | used.resize(n + 1); 33 | 34 | int a, b; 35 | for (int i = 1; i <= m; ++i) { 36 | cin >> a >> b; 37 | 38 | g[a].push_back(b); 39 | g[b].push_back(a); 40 | } 41 | 42 | dfsMatrix(1); 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /974 - Floyd - 1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 101 4 | 5 | using namespace std; 6 | 7 | int n; 8 | int g[MAX][MAX]; 9 | 10 | void floyd() { 11 | for (int k = 1; k <= n; k++) { 12 | for (int i = 1; i <= n; i++) { 13 | for (int j = 1; j <= n; j++) { 14 | if (g[i][k] + g[k][j] < g[i][j]) { 15 | g[i][j] = g[i][k] + g[k][j]; 16 | } 17 | } 18 | } 19 | } 20 | } 21 | 22 | // Week 10: November 26 - Floyd 23 | int main() { 24 | cin >> n; 25 | 26 | for (int i = 1; i <= n; i++) { 27 | for (int j = 1; j <= n; j++) { 28 | cin >> g[i][j]; 29 | } 30 | } 31 | 32 | 33 | floyd(); 34 | 35 | for (int i = 1; i <= n; i++) { 36 | for (int j = 1; j <= n; j++) { 37 | cout << g[i][j] << " "; 38 | } 39 | cout << endl; 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /122 - Mountain routes/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | #define MAX 51 6 | int g[MAX][MAX], used[MAX]; 7 | 8 | int n, k, a, b, d; 9 | int res; 10 | 11 | void dfs(int v, int depth) { 12 | if (depth > d) { 13 | return; 14 | } 15 | 16 | if (v == b) { 17 | res++; 18 | return; 19 | } 20 | 21 | used[v] = 1; 22 | 23 | for (int i = 1; i <= n; i++) { 24 | if (g[v][i] && !used[i]) { 25 | dfs(i, depth + 1); 26 | } 27 | } 28 | 29 | used[v] = 0; 30 | } 31 | 32 | int main() { 33 | cin >> n >> k >> a >> b >> d; 34 | 35 | memset(g, 0, sizeof(g)); 36 | memset(used, 0, sizeof(used)); 37 | 38 | for (int i = 0; i < k; i++) { 39 | int a1, a2; 40 | cin >> a1 >> a2; 41 | g[a1][a2] = 1; 42 | } 43 | 44 | res = 0; 45 | dfs(a, 0); 46 | 47 | cout << res; 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /2269 - Connected components/dsu(depth_first_search).cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 03.12.21. 3 | // 4 | 5 | #include 6 | #define MAX 101 7 | 8 | using namespace std; 9 | 10 | int n, g[MAX][MAX], used[MAX]; 11 | 12 | void dfsMatrix(int v) { 13 | used[v] = 1; 14 | 15 | for (int i = 1; i <= n; ++i) { 16 | if (used[i] == 0 && g[v][i] == 1) { 17 | dfsMatrix(i); 18 | } 19 | } 20 | } 21 | 22 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 23 | int main() { 24 | cin>>n; 25 | 26 | for (int i = 1; i <= n; ++i) { 27 | for (int j = 1; j <= n; ++j) { 28 | cin >> g[i][j]; 29 | } 30 | } 31 | 32 | int count = 0; 33 | 34 | for (int i = 1; i <= n; ++i) { 35 | if (used[i] == 0) { 36 | count++; 37 | dfsMatrix(i); 38 | } 39 | } 40 | 41 | cout << count; 42 | 43 | return 0; 44 | } -------------------------------------------------------------------------------- /66 - The Directors’ Visitors/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | class segment 7 | { 8 | public: 9 | int start, fin; 10 | segment(int start, int fin) : start(start), fin(fin) {} 11 | }; 12 | 13 | vector v; 14 | 15 | int f(segment a, segment b) 16 | { 17 | return a.fin <= b.fin; 18 | } 19 | 20 | 21 | int main() { 22 | int n, h1, h2, m1, m2; 23 | cin >> n; 24 | 25 | for (int i = 0; i < n; ++i) { 26 | scanf("%d:%d %d:%d", &h1, &m1, &h2, &m2); 27 | v.push_back(segment(h1 * 60 + m1, h2 * 60 + m2)); 28 | } 29 | 30 | sort(v.begin(), v.end(), f); 31 | 32 | int cur = 0, res = 1; 33 | 34 | for (int i = 1; i < v.size(); ++i) { 35 | if (v[i].start >= v[cur].fin) { 36 | cur = i; 37 | res++; 38 | } 39 | } 40 | 41 | cout << res; 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /3532 - Interesting polygon/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define EPS 1e-12 5 | #define PI acos(-1.0) 6 | 7 | 8 | using namespace std; 9 | 10 | int n; 11 | 12 | int main() { 13 | cin >> n; 14 | int i; 15 | double fi; 16 | 17 | double left = n / 2, right = n * n, middle; 18 | 19 | while (right - left > EPS) { 20 | middle = (left + right) / 2; 21 | 22 | for (fi = 0, i = 1; i <= n; i++) { 23 | double angle = (2 * middle * middle - i * i) / (2 * middle * middle); 24 | 25 | if ((angle < -1.0) || (angle > 1.0)) { 26 | fi = 100; 27 | break; 28 | } 29 | fi += acos(angle); 30 | } 31 | 32 | if (fi <= 2 * PI) { 33 | right = middle; 34 | } else { 35 | left = middle; 36 | } 37 | } 38 | 39 | printf("%.8lf\n", left); 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /1457 - "Sort" station/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, maxM; 7 | cin >> n >> maxM; 8 | 9 | int m[n], max[n]; 10 | // We have two arrays one for elements, second for max elemet up to this point 11 | for (int i = 0; i < n; ++i) { 12 | cin >> m[i]; 13 | if (i == 0) { 14 | max[i] = m[i]; 15 | } else { 16 | if (max[i-1] > m[i]) { 17 | max[i] = max[i-1]; 18 | } else { 19 | max[i] = m[i]; 20 | } 21 | } 22 | } 23 | 24 | // We compare from end to the beginning each element is compared with max that was up to thiis point 25 | bool res = true; 26 | for (int i = n-1; i > 0 ; --i) { 27 | if (m[i] < max[i] && (m[i] + max[i] > maxM)) { 28 | res = false; 29 | } 30 | } 31 | 32 | cout << (res ? "Yes" : "No"); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /4852 - The shortest distance/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define MAX 1001 4 | 5 | using namespace std; 6 | 7 | int n, s; 8 | int g[MAX][MAX]; 9 | int dist[MAX]; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for (int i = 1; i <= n; ++i) { 18 | if (g[from][i] && dist[i] == -1) { 19 | dist[i] = dist[from] + 1; 20 | q.push(i); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n >> s; 28 | memset(dist, -1, sizeof(dist)); 29 | 30 | for (int i = 1; i <= n; ++i) { 31 | for (int j = 1; j <= n; ++j) { 32 | cin >> g[i][j]; 33 | } 34 | } 35 | 36 | q.push(s); 37 | dist[s] = 0; 38 | bfs(); 39 | 40 | for (int i = 1; i <= n; ++i) { 41 | cout << dist[i] << " "; 42 | } 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /4004 - Is there a cycle?/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 101 3 | 4 | using namespace std; 5 | 6 | int n, g[MAX][MAX], used[MAX]; 7 | bool flag = false; 8 | 9 | void dfsMatrix(int v) { 10 | used[v] = 1; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | if (g[v][i] == 1) { 14 | if (used[i] == 0) { 15 | dfsMatrix(i); 16 | } else if (used[i] == 1) { 17 | flag = true; 18 | } 19 | } 20 | } 21 | used[v] = 2; 22 | } 23 | 24 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 25 | int main() { 26 | cin>>n; 27 | 28 | for (int i = 1; i <= n; ++i) { 29 | for (int j = 1; j <= n; ++j) { 30 | cin >> g[i][j]; 31 | } 32 | } 33 | 34 | for (int i = 1; i <= n; ++i) { 35 | if (used[i] == 0) { 36 | dfsMatrix(i); 37 | } 38 | } 39 | 40 | cout << (flag ? 1 : 0); 41 | 42 | return 0; 43 | } -------------------------------------------------------------------------------- /10993 - Bmail Computer Network(quiz4-1)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | const int maximumNumber = 1e6 + 5; 6 | 7 | int n, p[maximumNumber]; 8 | vector g[maximumNumber], answer; 9 | 10 | void dfs(int u, int prev) { 11 | if (u == n) { 12 | for (int i = 0; i < answer.size(); i++) { 13 | cout << answer[i] << " "; 14 | } 15 | cout << endl; 16 | return; 17 | } 18 | 19 | for (int i = 0; i < g[u].size(); i++) { 20 | int v = g[u][i]; 21 | if (v == prev) { 22 | continue; 23 | } 24 | answer.push_back(v); 25 | dfs(v, u); 26 | answer.pop_back(); 27 | } 28 | 29 | return; 30 | } 31 | 32 | int main() { 33 | cin >> n; 34 | for (int i = 2; i <= n; i++) { 35 | cin >> p[i]; 36 | g[p[i]].push_back(i); 37 | g[i].push_back(p[i]); 38 | } 39 | 40 | answer.push_back(1); 41 | dfs(1, 0); 42 | } 43 | -------------------------------------------------------------------------------- /3004 - Queue/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | // priority queue by default has the biggest value on top, but this version has smallest value on top 8 | priority_queue, greater<> > pq; 9 | 10 | long long n, k, time, temp; 11 | 12 | cin >> n >> k; 13 | 14 | for (int i = 0; i < n; ++i) { 15 | cin >> time; 16 | 17 | // Serving first K customers 18 | if (pq.size() != k) { 19 | pq.push(time); 20 | } else { 21 | // Adding up the smallest value with the next clients value 22 | temp = pq.top(); 23 | pq.pop(); 24 | pq.push(time + temp); 25 | } 26 | } 27 | 28 | // Popping smallest values from priority queue while the last element will be our answer 29 | while (pq.size() > 1) { 30 | pq.pop(); 31 | } 32 | 33 | cout << pq.top(); 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /832 - Increasing subsequence/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 100001 3 | 4 | 5 | using namespace std; 6 | 7 | int sz, x[MAX], lis[MAX], L[MAX]; 8 | 9 | 10 | void PrintSeq(int pos) 11 | { 12 | if (sz < 0) return; 13 | while (L[pos] != sz) { 14 | pos--; 15 | } 16 | 17 | sz--; 18 | PrintSeq(pos - 1); 19 | printf("%d ", x[pos]); 20 | } 21 | 22 | //Week 9: November 19 - Longest Increasing Subsequence (LIS) 23 | int main() { 24 | int n; 25 | cin >> n; 26 | 27 | 28 | for (int i = 0; i < n; ++i) { 29 | cin >> x[i]; 30 | } 31 | 32 | int len, i; 33 | // create solitare layout 34 | for (len = i = 0; i < n; i++) 35 | { 36 | int pos = lower_bound(lis,lis+len,x[i]) - lis; 37 | lis[pos] = x[i]; 38 | L[i] = pos; 39 | if (pos == len) 40 | len++; 41 | } 42 | 43 | cout << len << endl; 44 | 45 | sz = len - 1; 46 | PrintSeq(n - 1); 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /10146 - Tree Next/main.cpp: -------------------------------------------------------------------------------- 1 | // C++ 2 | class TreeNode { 3 | public: 4 | int val; 5 | TreeNode *left, *right, *parent; 6 | 7 | TreeNode(int x, TreeNode *prev = nullptr) : val(x), left(nullptr), right(nullptr), parent(prev) {} 8 | }; 9 | 10 | TreeNode *Minimum(TreeNode *tree) { 11 | if (tree == nullptr) { 12 | return nullptr; 13 | } else { 14 | while (tree->left) { 15 | tree = tree->left; 16 | } 17 | return tree; 18 | } 19 | } 20 | 21 | TreeNode *Next(TreeNode *tree) { 22 | // If right subtree exists, next element is 23 | // min of right subtree 24 | if (tree->right != nullptr) 25 | return Minimum(tree->right); 26 | // otherwise, we need to move up until 27 | // we do not find a node which is left node of its parent 28 | TreeNode *Prev = tree->parent; 29 | while ((Prev != nullptr) && (tree == Prev->right)) { 30 | tree = Prev; 31 | Prev = Prev->parent; 32 | } 33 | return Prev; 34 | } 35 | -------------------------------------------------------------------------------- /3161 - Deques on 6 Megabytes/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "vector" 3 | #include "deque" 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | vector> vs(150001); 9 | int n, tempA, tempB; 10 | string str; 11 | 12 | cin >> n; 13 | 14 | while (n--) { 15 | cin >> str; 16 | 17 | if (str == "pushfront") { 18 | cin >> tempA >> tempB; 19 | 20 | vs[tempA].push_front(tempB); 21 | } else if (str == "pushback") { 22 | cin >> tempA >> tempB; 23 | 24 | vs[tempA].push_back(tempB); 25 | } else if (str == "popfront") { 26 | cin >> tempA; 27 | 28 | cout << vs[tempA].front() << endl ; 29 | 30 | vs[tempA].pop_front(); 31 | } else if (str == "popback") { 32 | cin >> tempA; 33 | 34 | cout << vs[tempA].back() << endl ; 35 | 36 | vs[tempA].pop_back(); 37 | } 38 | } 39 | 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /683 - Partial matrix sum/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, m; 7 | cin >> n >> m; 8 | 9 | int dp[n][m]; 10 | 11 | for (int i = 0; i < n; ++i) { 12 | for (int j = 0; j < m; ++j) { 13 | cin >> dp[i][j]; 14 | } 15 | } 16 | 17 | for (int i = 0; i < n; ++i) { 18 | for (int j = 0; j < m; ++j) { 19 | if (i == 0 && j == 0) { 20 | continue; 21 | } else if (i == 0) { 22 | dp[i][j] += dp[i][j - 1]; 23 | } else if (j == 0) { 24 | dp[i][j] += dp[i - 1][j]; 25 | } else { 26 | dp[i][j] += (dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1]); 27 | } 28 | } 29 | } 30 | 31 | for (int i = 0; i < n; ++i) { 32 | for (int j = 0; j < m; ++j) { 33 | cout << dp[i][j] << " "; 34 | } 35 | cout << endl; 36 | } 37 | 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /8355 - Book shelf/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "deque" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, op, temp; 8 | deque shelf; 9 | 10 | cin >> n; 11 | 12 | while (n--) { 13 | cin >> op; 14 | 15 | switch (op) { 16 | case 1: { 17 | cin >> temp; 18 | 19 | shelf.push_back(temp); 20 | 21 | break; 22 | } 23 | case 2: { 24 | cin >> temp; 25 | 26 | shelf.push_front(temp); 27 | 28 | break; 29 | } 30 | case 3: { 31 | cout << shelf.back() << endl; 32 | 33 | shelf.pop_back(); 34 | 35 | break; 36 | } 37 | case 4: { 38 | cout << shelf.front() << endl; 39 | 40 | shelf.pop_front(); 41 | 42 | break; 43 | } 44 | } 45 | } 46 | 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /318 - Binomial coefficients 1 (not working)/script.js: -------------------------------------------------------------------------------- 1 | const c = []; 2 | 3 | function binomCoef(n, k) { 4 | if (n === k || k === 0) { 5 | return 1; 6 | } 7 | 8 | const left = c[n - 1]?.[k - 1] ? c[n - 1]?.[k - 1] : binomCoef(n - 1, k - 1); 9 | const right = c[n - 1]?.[k] ? c[n - 1]?.[k] : binomCoef(n - 1, k); 10 | if (!c[n-1]) { 11 | c[n-1] = []; 12 | } 13 | c[n-1][k-1] = left; 14 | c[n-1][k] = right; 15 | 16 | return left + right; 17 | } 18 | 19 | const fs = require('fs') 20 | 21 | fs.readFile('input.txt', 'utf8', (err, data) => { 22 | if (err) { 23 | console.error(err) 24 | return 25 | } 26 | 27 | const lines = data.split("\n"); 28 | 29 | const testNumbers = lines[0]; 30 | const answers = [] 31 | 32 | for (let i = 1; i <= testNumbers; i++) { 33 | const [n,k] = lines[i].split(" "); 34 | 35 | answers.push(binomCoef(parseInt(n), parseInt(k))) 36 | } 37 | 38 | console.log(answers.join("\n")); 39 | }) -------------------------------------------------------------------------------- /988 - Subsequence/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 1001 3 | 4 | int x[MAX], lis[MAX]; 5 | 6 | using namespace std; 7 | 8 | //Week 9: November 19 - Longest Increasing Subsequence (LIS) 9 | int main() { 10 | int n; 11 | cin >> n; 12 | 13 | for (int i = 0; i < n; ++i) { 14 | cin >> x[i]; 15 | } 16 | 17 | int len, i; 18 | for (len = i = 0; i < n; i++) { 19 | int pos = lower_bound(lis,lis+len,x[i]) - lis; 20 | 21 | // prints for understanding of algo 22 | // cout << "x " << x[i] << endl; 23 | // cout << "pos " << pos << endl; 24 | // cout << "len " << len << endl; 25 | 26 | if (pos < len) { 27 | lis[pos] = x[i]; 28 | } else { 29 | lis[len++] = x[i]; 30 | } 31 | 32 | // cout << "list is "; 33 | // for (int j = 0; j < len; ++j) { 34 | // cout << lis[j] << " "; 35 | // } 36 | // cout << endl; 37 | } 38 | 39 | cout << len; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /977 - Is it a Tree?/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 101 3 | 4 | using namespace std; 5 | 6 | int n, g[MAX][MAX], used[MAX], countEdges = 0, countVisited = 0; 7 | 8 | void dfsMatrix(int v) { 9 | used[v] = 1; 10 | countVisited++; 11 | 12 | for (int i = 1; i <= n; ++i) { 13 | if (used[i] == 0 && g[v][i] == 1) { 14 | dfsMatrix(i); 15 | } 16 | } 17 | } 18 | 19 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 20 | int main() { 21 | cin>>n; 22 | 23 | for (int i = 1; i <= n; ++i) { 24 | for (int j = 1; j <= n; ++j) { 25 | cin >> g[i][j]; 26 | if (g[i][j] == 1) { 27 | countEdges++; 28 | } 29 | } 30 | } 31 | 32 | dfsMatrix(1); 33 | 34 | // It's a tree if number of edges is n-1 and we can visit all edges 35 | if (countEdges / 2 == n - 1 && countVisited == n) { 36 | cout << "YES"; 37 | } else { 38 | cout << "NO"; 39 | } 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /4259 - Minimum in the stack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int n, op, temp; 8 | stack min; 9 | 10 | cin >> n; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> op; 14 | 15 | switch (op) { 16 | case 1: { 17 | cin >> temp; 18 | 19 | if (min.empty()) { 20 | min.push(temp); 21 | } else { 22 | if (min.top() > temp) { 23 | min.push(temp); 24 | } else { 25 | min.push(min.top()); 26 | } 27 | } 28 | 29 | break; 30 | } 31 | case 2: { 32 | min.pop(); 33 | break; 34 | } 35 | case 3: { 36 | cout << min.top() << endl ; 37 | break; 38 | } 39 | } 40 | } 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /9017 - Binary search - 1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int lowerBound(int *arr, int left, int right, int x) { 7 | while (left < right) { 8 | int mid = (left + right) / 2; 9 | if (x <= arr[mid]) 10 | right = mid; 11 | else 12 | left = mid + 1; 13 | } 14 | return left; 15 | } 16 | 17 | int upperBound(int *arr, int left, int right, int x) { 18 | while (left < right) { 19 | int mid = (left + right) / 2; 20 | if (x >= arr[mid]) 21 | left = mid + 1; 22 | else 23 | right = mid; 24 | } 25 | return left; 26 | } 27 | 28 | 29 | int main() { 30 | int n, q, temp; 31 | cin >> n >> q; 32 | 33 | int a[n]; 34 | for (int i = 0; i < n; ++i) { 35 | cin >> a[i]; 36 | } 37 | 38 | for (int i = 0; i < q; ++i) { 39 | cin >> temp; 40 | cout << (upperBound(a, 0, n, temp) - lowerBound(a, 0, n, temp)) << endl; 41 | } 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /1591 - Shoemaker Problem/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int i, n, t, fine; 6 | 7 | class Work 8 | { 9 | public: 10 | int time, fine, id; 11 | Work (int time = 0, int fine = 0, int id = 0) : time(time), fine(fine), id(id) {}; 12 | }; 13 | 14 | Work *Jobs; 15 | 16 | int f(Work a, Work b) 17 | { 18 | // a.time b.time 19 | // ------ < ------ 20 | // a.fine b.fine 21 | if (a.time * b.fine == b.time * a.fine) return a.id < b.id; 22 | return a.time * b.fine < b.time * a.fine; 23 | } 24 | 25 | int main(void) 26 | { 27 | while(scanf("%d",&n) == 1) 28 | { 29 | Jobs = new Work[n]; 30 | for(i = 0; i < n; i++) 31 | { 32 | scanf("%d %d",&t, &fine); 33 | Jobs[i] = Work(t,fine,i+1); 34 | } 35 | 36 | sort(Jobs,Jobs+n,f); 37 | 38 | printf("%d",Jobs[0].id); 39 | for(i = 1; i < n; i++)printf(" %d",Jobs[i].id); 40 | printf("\n"); 41 | 42 | delete[] Jobs; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /6122 - Simple Stack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | stack stack1; 8 | string cmd; 9 | 10 | while (cin >> cmd) { 11 | if (cmd == "push") { 12 | int n; 13 | cin >> n; 14 | stack1.push(n); 15 | cout << "ok" << endl; 16 | } 17 | 18 | if (cmd == "pop") { 19 | cout << stack1.top() << endl; 20 | stack1.pop(); 21 | } 22 | 23 | if (cmd == "back") { 24 | cout << stack1.top() << endl; 25 | } 26 | 27 | if (cmd == "size") { 28 | cout << stack1.size() << endl; 29 | } 30 | 31 | if (cmd == "clear") { 32 | while (!stack1.empty()) { 33 | stack1.pop(); 34 | } 35 | cout << "ok" << endl; 36 | } 37 | 38 | if (cmd == "exit") { 39 | cout << "bye" << endl; 40 | break; 41 | } 42 | } 43 | 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /4001 - Area of the room/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int n; 7 | string m[11]; // declare the grid - two-dimensional char array 8 | int area = 0; 9 | 10 | // start depth first search at position (x, y) 11 | void dfs(int i, int j) { 12 | // if we out of bounds of the grid - return 13 | if ((i < 0) || (i >= n) || (j < 0) || (j >= n)) { 14 | return; 15 | } 16 | 17 | if (m[i][j] == '*') { 18 | return; 19 | } 20 | 21 | // mark current position as used (passed) 22 | m[i][j] = '*'; 23 | area++; 24 | 25 | // run depth first search in four neighbouring directions 26 | dfs(i - 1, j); 27 | dfs(i + 1, j); 28 | dfs(i, j - 1); 29 | dfs(i, j + 1); 30 | } 31 | 32 | int main() { 33 | cin >> n; 34 | for (int i = 0; i < n; i++) { 35 | cin >> m[i]; 36 | } 37 | 38 | int x, y; 39 | cin >> x >> y; 40 | 41 | dfs(x - 1, y - 1); 42 | 43 | 44 | 45 | // print the answer 46 | cout << area << endl; 47 | return 0; 48 | } -------------------------------------------------------------------------------- /5721 - Find an element/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | vector v; 7 | int n, k, i; 8 | 9 | int Partition(int left, int right) 10 | { 11 | // key to success is to take x as median 12 | int x = (v[left] + v[right])/2, i = left - 1, j = right + 1; 13 | while (1) 14 | { 15 | do j--; while (v[j] > x); 16 | do i++; while (v[i] < x); 17 | if (i < j) swap(v[i], v[j]); else return j; 18 | } 19 | } 20 | 21 | int kth(int k, int left, int right) 22 | { 23 | if (left == right) return v[left]; 24 | int pos = Partition(left, right); 25 | if (k <= pos) return kth(k, left, pos); 26 | else return kth(k, pos + 1, right); 27 | } 28 | 29 | int main(void) 30 | { 31 | scanf("%d %d", &n, &k); 32 | v.resize(n + 1); 33 | for (i = 1; i <= n; i++) 34 | scanf("%d", &v[i]); 35 | if (k>n || k < 0) { 36 | printf("%d", -1); 37 | } else { 38 | printf("%d\n", kth(n-k + 1, 1, n)); 39 | } 40 | 41 | return 0; 42 | } -------------------------------------------------------------------------------- /940 - Majority Element/c-plus-plus/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n, temp, maj, count = 0; 7 | 8 | cin >> n; 9 | 10 | int arr[n]; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | cin >> temp; 14 | arr[i] = temp; 15 | } 16 | 17 | for (int i = 0; i < n; ++i) { 18 | if (count == 0) { 19 | maj = arr[i]; 20 | count++; 21 | } else { 22 | if (maj == arr[i]) { 23 | count++; 24 | } else { 25 | count--; 26 | } 27 | } 28 | } 29 | 30 | if (count == 0) { 31 | cout << -1 << endl; 32 | } else { 33 | count = 0; 34 | for (int i = 0; i < n; ++i) { 35 | if (maj == arr[i]) { 36 | count++; 37 | } 38 | } 39 | 40 | if (n / 2 < count) { 41 | cout << maj << endl; 42 | } else { 43 | cout << -1 << endl; 44 | } 45 | } 46 | 47 | 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /7329 - Construction/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int n,m; 6 | 7 | int comparator(int *arr, int x) { 8 | int count = 0; 9 | 10 | for (int i = 0; i < n; ++i) { 11 | count += arr[i] / x; 12 | } 13 | 14 | return count >= m; 15 | } 16 | 17 | int binarySearch(int *arr, int left, int right) 18 | { 19 | while (left < right) 20 | { 21 | int mid = (left + right) / 2; 22 | if (comparator(arr, mid)) { 23 | left = mid + 1; 24 | } 25 | else { 26 | right = mid; 27 | } 28 | } 29 | 30 | return left - 1; 31 | } 32 | 33 | int main() { 34 | cin >> n >> m; 35 | 36 | int woods[n]; 37 | long long sum = 0; 38 | 39 | for (int i = 0; i < n; ++i) { 40 | cin >> woods[i]; 41 | sum += woods[i]; 42 | } 43 | 44 | // if it's impossible to get the number 45 | if (sum < m) { 46 | cout << 0; 47 | return 0; 48 | } 49 | 50 | cout << binarySearch(woods, 0, INT32_MAX); 51 | 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /9594 - ABA/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | string a; 7 | cin >> a; 8 | 9 | unsigned long long length = a.size(); 10 | unsigned long long na[length]; // number of a in each position 11 | 12 | for (unsigned long long i = 0; i < length; ++i) { 13 | na[i] = 0; //initially setting to zero 14 | } 15 | 16 | for (unsigned long long i = 0; i < length; ++i) { 17 | na[i] = i == 0 ? 0 : na[i-1]; // each na[i] is equal to previous 18 | 19 | if (a[i] == 'A') { 20 | na[i]++; // if the char is a, the number of a up to this point ++ 21 | } 22 | } 23 | 24 | unsigned long long res = 0; 25 | 26 | for (unsigned long long i = 0; i < length; ++i) { 27 | if (a[i] == 'B') { 28 | // To find out how many ABA strings is there we, look for each B in strng and multiply number of a before that b and after that b 29 | res += na[i] * (na[length - 1] - na[i]); 30 | } 31 | } 32 | 33 | cout << res; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /10044 - LinkedList Merge/main.cpp: -------------------------------------------------------------------------------- 1 | ListNode* merge(ListNode *l1, ListNode *l2) 2 | { 3 | // Declaringtwo variables, res which is going to be returned after everything and temp to operate on 4 | ListNode *temp = new ListNode(0); 5 | ListNode *res = new ListNode(0); 6 | res = temp; 7 | 8 | // Adding to temp from both linked list elements that are smaller 9 | while (l1 && l2) { 10 | if (l1->val > l2->val) { 11 | temp->next = new ListNode(l2->val); 12 | l2 = l2->next; 13 | } else { 14 | temp->next = new ListNode(l1->val); 15 | l1 = l1->next; 16 | } 17 | 18 | temp = temp->next; 19 | } 20 | 21 | // adding the rest of list 1 22 | while (l1) { 23 | temp->next = new ListNode(l1->val); 24 | l1 = l1->next; 25 | temp = temp->next; 26 | } 27 | 28 | // adding the rest of list 2 29 | while (l2) { 30 | temp->next = new ListNode(l2->val); 31 | l2 = l2->next; 32 | temp = temp->next; 33 | } 34 | 35 | return res->next; 36 | } -------------------------------------------------------------------------------- /806 - Platforms - 3/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long myF(long long i, long long j) { 6 | long long t = (i-j) * (i-j); 7 | return t; 8 | } 9 | 10 | //Week 9: November 17 Dynamic programming 11 | int main() { 12 | long long n; 13 | cin >> n; 14 | 15 | long long cost[n], dp[n]; 16 | 17 | for (long long i = 0; i < n; ++i) { 18 | cin >> cost[i]; 19 | } 20 | 21 | dp[0] = 0; 22 | dp[1] = myF(cost[1],cost[0]); 23 | 24 | if (n > 2) { 25 | dp[1] = min(dp[1], 3 * myF(cost[2], cost[0]) + myF(cost[2], cost[1])); 26 | } 27 | 28 | for (long long i = 2; i < n - 1; ++i) { 29 | dp[i] = min((dp[i-1] + myF(cost[i], cost[i-1])), (dp[i-2] + (3 * myF(cost[i], cost[i-2]))) ); 30 | dp[i] = min(dp[i], (dp[i-1] + (3 * myF(cost[i-1], cost[i+1]) + myF(cost[i+1], cost[i])) )); 31 | } 32 | 33 | long long i = n - 1; 34 | dp[i] = min((dp[i-1] + myF(cost[i], cost[i-1])), (dp[i-2] + (3 * myF(cost[i], cost[i-2])))); 35 | 36 | 37 | cout << dp[i]; 38 | 39 | return 0; 40 | } -------------------------------------------------------------------------------- /928 - The sum of the largest and the smallest/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int findMin(int arr[], int left, int right) { 6 | if (right == left) { 7 | return arr[left]; 8 | } 9 | 10 | int mid = (left + right) / 2; 11 | 12 | int leftMin = findMin(arr, left, mid); 13 | int rightMin = findMin(arr, mid + 1, right); 14 | 15 | return min(leftMin, rightMin); 16 | } 17 | 18 | int findMax(int arr[], int left, int right) { 19 | if (right == left) { 20 | return arr[left]; 21 | } 22 | 23 | int mid = (left + right) / 2; 24 | 25 | int leftMin = findMax(arr, left, mid); 26 | int rightMin = findMax(arr, mid + 1, right); 27 | 28 | return max(leftMin, rightMin); 29 | } 30 | 31 | int main() { 32 | // divide and conquer 33 | int n, temp; 34 | cin>>n; 35 | 36 | int arr[n]; 37 | 38 | for (int i = 0; i < n; ++i) { 39 | cin >> temp; 40 | arr[i] = temp; 41 | } 42 | 43 | cout << findMin(arr, 0, n-1) + findMax(arr, 0, n-1); 44 | 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /8598 - Wizard and wolves (midterm-2)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define MAX 100001 5 | long long h[MAX], n, a, b; 6 | 7 | using namespace std; 8 | 9 | // 8598 - Wizard and wolves 10 | 11 | long long canBeKilled(long long x) { 12 | long long res = 0; 13 | 14 | for (long long i = 0; i < n; i++) { 15 | if (h[i] > x * b) { 16 | // casting to double one side of division is important to prevent integer division 17 | res += ceil( (h[i] - x * b) / (double)(a - b) ); 18 | } 19 | } 20 | 21 | return res <= x; 22 | } 23 | 24 | int main() { 25 | cin >> n >> a >> b; 26 | 27 | for (long long i = 0; i < n; ++i) { 28 | cin >> h[i]; 29 | } 30 | 31 | long long left = 0, right = 1000000000, mid; 32 | 33 | while (left < right) 34 | { 35 | mid = (left + right) / 2; 36 | if (canBeKilled(mid)) { 37 | right = mid; 38 | } 39 | else { 40 | left = mid + 1; 41 | } 42 | } 43 | 44 | cout << left; 45 | 46 | return 0; 47 | } -------------------------------------------------------------------------------- /10418 - Lifeguards (Bronze)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int n; 9 | 10 | cin >> n; 11 | 12 | int s[n], e[n]; 13 | 14 | for (int i = 0; i < n; ++i) { 15 | cin >> s[i] >> e[i]; 16 | } 17 | 18 | int maxCover = INT32_MIN; 19 | 20 | vector cover(1001,0); 21 | for (int i = 0; i < n; ++i) { 22 | for (int j = s[i]; j < e[i]; ++j) { 23 | cover[j]++; 24 | } 25 | } 26 | 27 | for (int i = 0; i < n; ++i) { 28 | for (int j = s[i]; j < e[i]; ++j) { 29 | cover[j]--; 30 | } 31 | 32 | int currentCover = 0; 33 | for (int j = 0; j < cover.size(); ++j) { 34 | if (cover[j] > 0) { 35 | currentCover++; 36 | } 37 | } 38 | maxCover = max(maxCover, currentCover); 39 | 40 | for (int j = s[i]; j < e[i]; ++j) { 41 | cover[j]++; 42 | } 43 | } 44 | 45 | cout << maxCover; 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /930 - Mobile Phone/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Mobile Phone (930) 4 | // 5 | // Created by Emin Alizade on 3/2/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | 11 | using namespace std; 12 | 13 | int main() { 14 | string s; 15 | cin >> s; 16 | string ss; 17 | while (cin >> ss) { //24 test case soderjit probel iz za etoqo delaem tak 18 | s += ss; 19 | } 20 | int a[10]; 21 | for (int i = 0; i < 10; i++) { 22 | a[i] = -1; 23 | } 24 | int x; 25 | int length = s.length(); 26 | for (int i = 0; i < length; i++) { 27 | if (s[i] >= 48 && s[i] <= 57) { 28 | x = s[i] - 48; 29 | a[x] = 1; 30 | } 31 | } 32 | int count = 0; 33 | for (int i = 0; i < 10; i++) { 34 | if (a[i] < 0) { 35 | count++; 36 | } 37 | } 38 | cout << count << endl; 39 | for (int i = 0; i < 10; i++) { 40 | if (a[i] < 0) { 41 | cout << i << " "; 42 | } 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /2321 - Sorting/quickSort.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 29.10.21. 3 | // 4 | 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | int i, n; 10 | 11 | vector lst; 12 | 13 | void swap(int &i, int &j) 14 | { 15 | int temp = i; i = j; j = temp; 16 | } 17 | 18 | int Partition(vector &m, int L, int R) 19 | { 20 | int x = m[L]; 21 | int i = L - 1, j = R + 1; 22 | while (1) 23 | { 24 | do j--; while (x > m[j]); 25 | do i++; while (m[i] > x); 26 | if (i < j) swap(m[i], m[j]); else return j; 27 | } 28 | } 29 | 30 | void QuickSort(vector &m, int L, int R) 31 | { 32 | int q; 33 | if (L < R) 34 | { 35 | q = Partition(m, L, R); 36 | QuickSort(m, L, q); QuickSort(m, q + 1, R); 37 | } 38 | } 39 | 40 | int main() 41 | { 42 | scanf("%d", &n); 43 | lst.resize(n); 44 | 45 | for (i = 0; i < n; i++) 46 | scanf("%d", &lst[i]); 47 | 48 | QuickSort(lst, 0, lst.size() - 1); 49 | 50 | for (i = n-1; i >= 0; i--) 51 | printf("%d ", lst[i]); 52 | 53 | return 0; 54 | } -------------------------------------------------------------------------------- /10082 - Shortest even path/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int n, m, s, f; 8 | vector> g; 9 | vector dist; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for(int to: g[from]) { 18 | if (dist[to] == -1) { 19 | dist[to] = dist[from] + 1; 20 | q.push(to); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n >> m >> s >> f; 28 | dist.resize(2*n+1); 29 | fill(dist.begin(), dist.end(), -1); 30 | 31 | g.resize(2*n+1); 32 | 33 | int a, b; 34 | for (int i = 0; i < m; ++i) { 35 | cin >> a >> b; 36 | g[2*a - 1].push_back(2*b); 37 | g[2*b].push_back(2*a - 1); 38 | 39 | g[2*a].push_back(2*b - 1); 40 | g[2*b - 1].push_back(2*a); 41 | } 42 | 43 | q.push(2*s - 1); 44 | dist[2*s - 1] = 0; 45 | bfs(); 46 | 47 | cout << dist[2 * f - 1] << endl; 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /10379 - Maximum Frequency Stack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "map" 3 | #include "stack" 4 | #include "vector" 5 | 6 | using namespace std; 7 | 8 | int main() { 9 | map freq; 10 | 11 | vector> st; 12 | 13 | string str; 14 | int temp; 15 | 16 | while (cin >> str) { 17 | if (str == "push") { 18 | cin >> temp; 19 | 20 | // cout << st.size() << " while try to access" << freq[temp] << endl; 21 | 22 | if (st.size() < freq[temp] + 1) { 23 | stack tempStack; 24 | 25 | st.push_back(tempStack); 26 | } 27 | 28 | st[freq[temp]].push(temp); 29 | 30 | freq[temp]++; 31 | } else if (str == "pop") { 32 | int mostFreq = st[st.size() - 1].top(); 33 | 34 | cout << mostFreq << endl; 35 | st[st.size() - 1].pop(); 36 | 37 | if (st[st.size() - 1].empty()) { 38 | st.erase(st.end() - 1); 39 | } 40 | 41 | freq[mostFreq]--; 42 | } 43 | } 44 | 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /10866 - Ternary search in array/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | long long ternarySearch(long long arr[], long long a, long long b, long long x) { 6 | long long g, h; 7 | while (a < b) { 8 | g = a + (b - a) / 3; 9 | h = b - (b - a) / 3; 10 | 11 | if (arr[g] == x) { 12 | return 1; 13 | } 14 | 15 | if (arr[h] == x) { 16 | return 1; 17 | } 18 | 19 | if (x < arr[g]) { 20 | b = g - 1; 21 | } else if (x > arr[h]) { 22 | a = h + 1; 23 | } else { 24 | a = g+1; 25 | b = h-1; 26 | } 27 | } 28 | 29 | return x == arr[a]; 30 | } 31 | 32 | int main() { 33 | long long n, q; 34 | cin >> n >> q; 35 | 36 | long long a[n]; 37 | 38 | for (long long i = 0; i < n; ++i) { 39 | cin >> a[i]; 40 | } 41 | 42 | for (long long i = 0; i < q; ++i) { 43 | long long temp; 44 | cin >> temp; 45 | 46 | cout << (ternarySearch(a, 0, n-1, temp) ? "YES" : "NO") << endl; 47 | } 48 | return 0; 49 | } -------------------------------------------------------------------------------- /4819 - Maximum by minimum/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int n, m, s; 8 | vector> g; 9 | vector dist; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for(int to: g[from]) { 18 | if (dist[to] == -1) { 19 | dist[to] = dist[from] + 1; 20 | q.push(to); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n >> m >> s; 28 | dist.resize(n+1); 29 | fill(dist.begin(), dist.end(), -1); 30 | g.resize(n+1); 31 | 32 | int a, b; 33 | for (int i = 0; i < m; ++i) { 34 | cin >> a >> b; 35 | // flipping edges 36 | g[b].push_back(a); 37 | } 38 | 39 | q.push(s); 40 | dist[s] = 0; 41 | bfs(); 42 | 43 | int max = -1; 44 | for (int i = 1; i <= n; ++i) { 45 | if (dist[i] > max) { 46 | max = dist[i]; 47 | } 48 | } 49 | 50 | cout << max; 51 | 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /10143 - Throwing cards away/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "deque" 3 | #include "vector" 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int n; 9 | 10 | while (cin >> n) { 11 | if (n == 0) { 12 | break; 13 | } 14 | 15 | deque cards; 16 | vector discarded; 17 | 18 | for (int i = 1; i <= n; ++i) { 19 | cards.push_front(i); 20 | } 21 | 22 | while (cards.size() > 1) { 23 | discarded.push_back(cards.back()); 24 | 25 | cards.pop_back(); 26 | 27 | int temp = cards.back(); 28 | 29 | cards.pop_back(); 30 | 31 | cards.push_front(temp); 32 | } 33 | 34 | cout << "Discarded cards: "; 35 | 36 | for (int i = 0; i < discarded.size(); i++) { 37 | cout << discarded[i]; 38 | 39 | if (i < discarded.size() - 1) { 40 | cout << ", " ; 41 | } 42 | } 43 | 44 | cout << endl; 45 | 46 | cout<< "Remaining card: " << cards.front() << endl; 47 | } 48 | 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /2479 - Parentheses Balance/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | int t; 8 | string str; 9 | 10 | cin >> t; 11 | getline (cin,str); 12 | 13 | while (t--) { 14 | getline (cin,str); 15 | stack myStack; 16 | 17 | if (str.length() == 0) { 18 | cout << "Yes" << endl ; 19 | continue; 20 | } 21 | 22 | bool flag = true; 23 | for (char c: str) { 24 | if (c == '(' || c== '[') { 25 | myStack.push(c); 26 | } else if (c == ')' || c == ']') { 27 | c = c == ')' ? '(' : '['; 28 | if (!myStack.empty() && myStack.top() == c) { 29 | myStack.pop(); 30 | } else { 31 | flag = false; 32 | break; 33 | } 34 | } 35 | } 36 | 37 | if (myStack.empty() && flag) { 38 | cout<< "Yes"< 10 | #include 11 | 12 | using namespace std; 13 | 14 | vector > g; 15 | vector used; 16 | int n, m; 17 | 18 | void dfsEdgeList(int v) { 19 | used[v] = 1; 20 | 21 | for (int i = 0; i < g[v].size(); ++i) { 22 | int to = g[v][i]; 23 | 24 | if (used[to] == 0) { 25 | dfsEdgeList(to); 26 | } 27 | } 28 | } 29 | 30 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 31 | int main() { 32 | cin >> n >> m; 33 | g.resize(n + 1); 34 | used.resize(n + 1); 35 | 36 | int a, b; 37 | for (int i = 1; i <= m; ++i) { 38 | cin >> a >> b; 39 | 40 | g[a].push_back(b); 41 | g[b].push_back(a); 42 | } 43 | 44 | int count = 0; 45 | 46 | for (int i = 1; i <= n; ++i) { 47 | if (used[i] == 0) { 48 | count++; 49 | dfsEdgeList(i); 50 | } 51 | } 52 | 53 | cout << count - 1; 54 | 55 | return 0; 56 | } -------------------------------------------------------------------------------- /982 - Connectivity/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int repr(int dsu[], int i) { 6 | int r = dsu[i]; 7 | while (r != dsu[r]){ 8 | r = dsu[r]; 9 | } 10 | return r; 11 | } 12 | 13 | void make_union(int dsu[], int a, int b) { 14 | a = repr(dsu, a); 15 | b = repr(dsu, b); 16 | 17 | if (a == b) { 18 | return; 19 | } else { 20 | dsu[a] = b; 21 | } 22 | } 23 | 24 | int numberOfSets(int dsu[], int n) { 25 | int count = 0; 26 | for (int i = 1; i <= n; ++i) { 27 | if (i == dsu[i]) { 28 | count++; 29 | } 30 | } 31 | return count; 32 | } 33 | 34 | int main() { 35 | int n, m; 36 | int e1, e2; 37 | cin >> n >> m; 38 | 39 | int dsu[n + 1]; 40 | 41 | for (int i = 1; i <= n; ++i) { 42 | dsu[i] = i; 43 | } 44 | 45 | for (int i = 1; i <= m; ++i) { 46 | cin >> e1 >> e2; 47 | make_union(dsu, e1, e2); 48 | } 49 | 50 | // Graph is connected if it contains only one connected component. 51 | cout << (numberOfSets(dsu, n) == 1 ? "YES" : "NO" ); 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /10762 - Soldiers Row/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack" 3 | #include "map" 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int n, temp; 9 | stack> myStack; 10 | 11 | cin >> n; 12 | 13 | for (int i = 0; i < n; ++i) { 14 | cin >> temp; 15 | 16 | if (myStack.empty()) { 17 | myStack.push(make_pair(temp, i)); 18 | cout << -1 << " " ; 19 | } else { 20 | if ( myStack.top().first > temp ) { 21 | cout << myStack.top().second << " "; 22 | myStack.push(make_pair(temp, i)); 23 | } else { 24 | while (!myStack.empty() && myStack.top().first <= temp) { 25 | myStack.pop(); 26 | } 27 | 28 | if (myStack.empty()) { 29 | myStack.push(make_pair(temp, i)); 30 | cout << -1 << " " ; 31 | } else { 32 | cout << myStack.top().second << " "; 33 | myStack.push(make_pair(temp, i)); 34 | } 35 | } 36 | } 37 | } 38 | 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /9020 - Split into k sub-arrays/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | long long n, k; 8 | vector a; 9 | 10 | long long f(long long x) { 11 | long long count = 1; 12 | long long sum = 0; 13 | for (long long i = 0; i < n; ++i) { 14 | if (a[i] > x) { 15 | count = LLONG_MAX; 16 | break; 17 | } 18 | if (sum + a[i] <= x) { 19 | sum += a[i]; 20 | } else { 21 | count++; 22 | sum = a[i]; 23 | } 24 | } 25 | 26 | return count <= k; 27 | } 28 | 29 | long long binary(long long l, long long r) { 30 | while (l < r) { 31 | long long m = (l + r) / 2; 32 | 33 | if (!f(m)) { 34 | l = m + 1; 35 | } else { 36 | r = m; 37 | } 38 | } 39 | 40 | return l; 41 | } 42 | 43 | int main() { 44 | cin >> n >> k; 45 | a.resize(n); 46 | 47 | long long sum = 0; 48 | for (long long i = 0; i < n; ++i) { 49 | cin >> a[i]; 50 | sum += a[i]; 51 | } 52 | 53 | cout << binary(1, sum); 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /10223 - The Settlers of Catan/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 26 4 | 5 | using namespace std; 6 | 7 | int mas[MAX][MAX]; 8 | int best; 9 | int n, m, i, a, b; 10 | 11 | // TODO analyze the code 12 | 13 | void run(int i, int depth) { 14 | // The variable best maintains the value of the longest path. 15 | if (depth > best) 16 | best = depth; 17 | // Find into which vertex j can we go from i. 18 | for (int j = 0; j < n; j++) 19 | if (mas[i][j]) { 20 | // Delete the edge (i, j) and continue search from the vertex j. 21 | mas[i][j] = mas[j][i] = 0; 22 | run(j, depth + 1); 23 | // Upon return from the function run restore the edge (i, j). 24 | mas[i][j] = mas[j][i] = 1; 25 | } 26 | } 27 | 28 | int main() { 29 | while (scanf("%d %d", &n, &m), n + m) { 30 | memset(mas, 0, sizeof(mas)); 31 | for (i = 0; i < m; i++) { 32 | scanf("%d %d", &a, &b); 33 | mas[a][b] = mas[b][a] = 1; 34 | } 35 | best = 0; 36 | for (i = 0; i < n; i++) 37 | run(i, 0); 38 | printf("%d\n", best); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /1105 - Hello, Pie!/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | #define MAX 21 8 | #define INF 0x3F3F3F3F 9 | 10 | int cnt, best, n, i, j, k; 11 | int m[MAX][MAX], dp[1 << MAX][MAX]; 12 | 13 | int solve(int mask, int last) 14 | { 15 | int &res = dp[mask][last]; 16 | if (res == INF) 17 | { 18 | mask ^= 1 << last; 19 | for (int i = 1; i < n + 1; ++i) 20 | if (mask & 1 << i) res = min(res, solve(mask, i) + m[i][last]); 21 | } 22 | return res; 23 | } 24 | 25 | int main() 26 | { 27 | scanf("%d", &n); 28 | 29 | for (i = 0; i < n + 1; i++) 30 | for (j = 0; j < n + 1; j++) scanf("%d", &m[i][j]); 31 | 32 | for (k = 0; k < n + 1; k++) 33 | for (i = 0; i < n + 1; i++) 34 | for (j = 0; j < n + 1; j++) 35 | if (m[i][k] + m[k][j] < m[i][j]) m[i][j] = m[i][k] + m[k][j]; 36 | 37 | memset(dp, 0x3F, sizeof dp); 38 | dp[1][0] = 0; best = INF; 39 | for (i = 1; i < n + 1; i++) dp[1 | 1 << i][i] = m[0][i]; 40 | for (i = 1; i < n + 1; i++) best = min(best, solve((1 << n + 1) - 1, i) + m[i][0]); 41 | printf("%d\n", best); 42 | return 0; 43 | } -------------------------------------------------------------------------------- /9557 - Bins and balls/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int modExpo(long long number, unsigned int power, int mod) 7 | { 8 | int result = 1; 9 | number = number % mod; // Update number if it is more than or 10 | // equal to mod 11 | 12 | if (number == 0) return 0; 13 | 14 | while (power > 0) 15 | { 16 | // If power is odd, multiply number with result 17 | if (power % 2 == 1) { 18 | result = (result*number) % mod; 19 | } 20 | // power must be even now 21 | power = power / 2; 22 | number = (number*number) % mod; 23 | } 24 | return result; 25 | } 26 | 27 | int main() { 28 | long long numberOfBinsOrBalls; 29 | long long modulo = pow(10,9) + 7; 30 | 31 | cin >> numberOfBinsOrBalls; 32 | 33 | // in order to prevent the case where we call modExpo function with 0 value 34 | if (numberOfBinsOrBalls > 1) { 35 | long long result = ((numberOfBinsOrBalls % modulo) * modExpo(numberOfBinsOrBalls - 1, numberOfBinsOrBalls-1, modulo)) % modulo; 36 | 37 | cout << result; 38 | } else { 39 | cout<<1; 40 | } 41 | 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /1765 - Three sequences/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | int dp[101][101][101], a[101], b[101], c[101]; 5 | 6 | int maxOf3 (int a, int b, int c){ 7 | int val = a; 8 | val = max(val, b); 9 | val = max(val, c); 10 | return val; 11 | } 12 | 13 | int lcs(int i, int j, int z) { 14 | if (i == 0 || j == 0 || z == 0) { 15 | return 0; 16 | } 17 | 18 | if (dp[i][j][z] != -1) { 19 | return dp[i][j][z]; 20 | } 21 | 22 | if(a[i] == b[j] && b[j] == c[z]) { 23 | return dp[i][j][z] = 1 + lcs(i-1,j-1, z-1); 24 | } else { 25 | return dp[i][j][z] = maxOf3(lcs(i - 1, j, z), lcs(i, j - 1, z), lcs(i, j, z-1)); 26 | } 27 | } 28 | 29 | 30 | //Week 9: November 19 - Longest Common Subsequence (LCS) 31 | int main() { 32 | int n,m,k; 33 | 34 | memset(dp, -1, sizeof(dp)); 35 | 36 | cin >> n; 37 | for (int i = 1; i <= n; ++i) { 38 | cin >> a[i]; 39 | } 40 | 41 | cin >> m; 42 | for (int i = 1; i <= m; ++i) { 43 | cin >> b[i]; 44 | } 45 | 46 | cin >> k; 47 | for (int i = 1; i <= k; ++i) { 48 | cin >> c[i]; 49 | } 50 | 51 | cout << lcs(n, m, k); 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /6033 - Kastenlauf/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 103 4 | 5 | using namespace std; 6 | 7 | long long g[MAX][MAX], used[MAX], n; 8 | 9 | void dfsMatrix(long long v) { 10 | used[v] = 1; 11 | 12 | for (long long i = 0; i < n+2; ++i) { 13 | if (used[i] == 0 && g[v][i] == 1) { 14 | dfsMatrix(i); 15 | } 16 | } 17 | } 18 | 19 | // Week 11: November 29 - December 5 - DFS (Depth First Search) 20 | int main() { 21 | long long t; 22 | 23 | cin >> t; 24 | 25 | while (t--) { 26 | cin >> n; 27 | memset(g, 0, sizeof (g)); 28 | memset(used, 0, sizeof (used)); 29 | 30 | long long x[n + 2], y[n + 2]; 31 | 32 | for (long long i = 0; i < n + 2; ++i) { 33 | cin >> x[i] >> y[i]; 34 | } 35 | 36 | for (long long i = 0; i < n + 2; i++) { 37 | for (long long j = i + 1; j < n + 2; j++) { 38 | if (abs(x[i] - x[j]) + abs(y[i] - y[j]) <= 1000) { 39 | g[i][j] = g[j][i] = 1; 40 | } 41 | } 42 | } 43 | 44 | dfsMatrix(0); 45 | 46 | cout << (used[n+1] == 1 ? "happy" : "sad") << endl; 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /3841 - Dr Who`s Banquet/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | bool process(priority_queue &q) 7 | { 8 | while (!q.empty()) { 9 | int desired = q.top(); 10 | q.pop(); 11 | 12 | priority_queue temp; 13 | 14 | while (desired--) { 15 | if (q.empty()) { 16 | return false; 17 | } 18 | 19 | if (q.top() != 1) { 20 | temp.push(q.top() - 1); 21 | } 22 | 23 | q.pop(); 24 | } 25 | 26 | while (!temp.empty()) { 27 | q.push(temp.top()); 28 | temp.pop(); 29 | } 30 | } 31 | 32 | return true; 33 | } 34 | 35 | int main() { 36 | priority_queue pq; 37 | int n; 38 | char c; 39 | 40 | // reading input line by line 41 | while (scanf("%d%c", &n, &c) == 2) 42 | { 43 | pq.push(n); 44 | 45 | if (c == '\n') { 46 | cout<< (process(pq) ? "ok" : "fail") << endl << endl; 47 | 48 | // emptying pq for the next test case 49 | while (!pq.empty()) { 50 | pq.pop(); 51 | } 52 | } 53 | } 54 | return 0; 55 | } -------------------------------------------------------------------------------- /5101 - Hodja Nasreddin/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int main() { 6 | int n; 7 | cin >> n; 8 | 9 | long long sum = 0, a[n][n], b[n][n]; 10 | int mod = 9929; 11 | 12 | for (int i = 0; i < n; ++i) { 13 | for (int j = 0; j < n; ++j) { 14 | if (i == 0 || j == 0) { 15 | a[i][j] = 1; 16 | } else { 17 | a[i][j] = (a[i-1][j] + a[i][j-1]) % mod; 18 | } 19 | } 20 | } 21 | 22 | for (int i = n-1; i >= 0; i--) { 23 | for (int j = n-1; j >= 0; j--) { 24 | if (i == n-1 || j == n-1) { 25 | b[i][j] = 1; 26 | } else { 27 | b[i][j] = (b[i+1][j] + b[i][j+1]) % mod; 28 | } 29 | } 30 | } 31 | 32 | for (int i = 0; i < n; ++i) { 33 | for (int j = 0; j < n; ++j) { 34 | sum = ( sum + ( (a[i][j] * b[i][j]) % mod ) ) % mod; 35 | } 36 | } 37 | 38 | // for (int i = 0; i < n; ++i) { 39 | // for (int j = 0; j < n; ++j) { 40 | // cout << b[i][j] << " "; 41 | // } 42 | // cout << endl; 43 | // } 44 | 45 | cout << sum; 46 | 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /9018 - n-th integer divisible by a or b/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | 6 | int a, b, x; 7 | 8 | // Recursive function to return gcd of a and b 9 | long long gcd(long long int a, long long int b) 10 | { 11 | if (b == 0) 12 | return a; 13 | return gcd(b, a % b); 14 | } 15 | 16 | // Function to return LCM of two numbers 17 | long long lcm(int a, int b) 18 | { 19 | return (a / gcd(a, b)) * b; 20 | } 21 | 22 | // function that determines number of positive integers in the interval [1; n], divisible by either a or b 23 | int f(int n) { 24 | return (n/a) + (n/b) - (n/ lcm(a, b)); 25 | } 26 | 27 | int binarySearch(int left, int right) 28 | { 29 | while (left < right) 30 | { 31 | int mid = (left + right) / 2; 32 | if (f(mid) < x) { 33 | left = mid + 1; 34 | } 35 | else { 36 | right = mid; 37 | } 38 | } 39 | 40 | return left; 41 | } 42 | 43 | 44 | int main() { 45 | // Binary search week 5, october 22 class 46 | cin >> a >> b >> x; 47 | 48 | // binary search according to condition of problem 49 | int res = binarySearch(1, 1000000000); 50 | 51 | cout<< res; 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /4369 - Arson/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int n, m, k; 8 | vector> g; 9 | vector dist; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for(int to: g[from]) { 18 | if (dist[to] == -1) { 19 | dist[to] = dist[from] + 1; 20 | q.push(to); 21 | } 22 | } 23 | } 24 | } 25 | 26 | int main() { 27 | cin >> n >> m; 28 | dist.resize(n+1); 29 | fill(dist.begin(), dist.end(), -1); 30 | 31 | g.resize(n+1); 32 | 33 | int a, b; 34 | for (int i = 0; i < m; ++i) { 35 | cin >> a >> b; 36 | g[a].push_back(b); 37 | g[b].push_back(a); 38 | } 39 | 40 | cin >> k; 41 | 42 | int temp; 43 | while (k--) { 44 | cin >> temp; 45 | q.push(temp); 46 | dist[temp] = 0; 47 | } 48 | 49 | bfs(); 50 | 51 | int v = 1; 52 | for (int i = 1; i <= n; ++i) { 53 | if (dist[i] > dist[v]) { 54 | v = i; 55 | } 56 | } 57 | 58 | cout << dist[v] << endl << v; 59 | 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /1522 - Optimal Binary Search Tree/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 252 3 | 4 | using namespace std; 5 | 6 | 7 | int e[MAX], t[MAX][MAX], sum[MAX]; 8 | 9 | int weight(int i, int j) 10 | { 11 | if (i > j) return 0; 12 | return sum[j] - sum[i-1]; 13 | } 14 | 15 | int f(int i, int j) { 16 | if (i >= j) { 17 | return 0; 18 | } 19 | 20 | if (t[i][j] == INT32_MAX) { 21 | for (int k = i; k <= j; ++k) { 22 | int tempSum = weight(i, k-1) + f(i, k - 1) + weight(k+1, j) + f(k + 1, j); 23 | 24 | if (t[i][j] > tempSum) { 25 | t[i][j] = tempSum; 26 | } 27 | } 28 | } 29 | 30 | return t[i][j]; 31 | } 32 | 33 | // Week 10: November 24 - Optimal Binary Search Tree 34 | int main() { 35 | int n; 36 | while (cin >> n) { 37 | 38 | for (int i = 0; i < MAX; ++i) { 39 | for (int j = 0; j < MAX; ++j) { 40 | t[i][j] = INT32_MAX; 41 | } 42 | } 43 | 44 | sum[0] = 0; 45 | for (int i = 1; i <= n; ++i) { 46 | cin >> e[i]; 47 | sum[i] = sum[i-1] + e[i]; 48 | } 49 | 50 | cout << f(1, n) << endl; 51 | } 52 | return 0; 53 | } 54 | 55 | //6 1 3 5 10 20 30 -------------------------------------------------------------------------------- /2269 - Connected components/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | // 3 | //using namespace std; 4 | // 5 | //int repr(int dsu[], int i) { 6 | // int r = dsu[i]; 7 | // while (r != dsu[r]){ 8 | // r = dsu[r]; 9 | // } 10 | // return r; 11 | //} 12 | // 13 | //void make_union(int dsu[], int a, int b) { 14 | // a = repr(dsu, a); 15 | // b = repr(dsu, b); 16 | // 17 | // if (a == b) { 18 | // return; 19 | // } else { 20 | // dsu[a] = b; 21 | // } 22 | //} 23 | // 24 | //int numberOfSets(int dsu[], int n) { 25 | // int count = 0; 26 | // for (int i = 1; i <= n; ++i) { 27 | // if (i == dsu[i]) { 28 | // count++; 29 | // } 30 | // } 31 | // return count; 32 | //} 33 | // 34 | //int main() { 35 | // int n, temp; 36 | // cin >> n; 37 | // 38 | // int dsu[n + 1]; 39 | // 40 | // for (int i = 1; i <= n; ++i) { 41 | // dsu[i] = i; 42 | // } 43 | // 44 | // for (int i = 0; i < n; ++i) { 45 | // for (int j = 0; j < n; ++j) { 46 | // cin >> temp; 47 | // if (temp == 1) { 48 | // make_union(dsu, i+1, j+1); 49 | // } 50 | // } 51 | // } 52 | // 53 | // cout << numberOfSets(dsu, n); 54 | // return 0; 55 | //} 56 | -------------------------------------------------------------------------------- /1482 - Matrix multiplication/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // Matrix multiplication 6 | int main() { 7 | int na,ma, nb,mb; 8 | 9 | cin >> na >> ma; 10 | 11 | int a[na][ma]; 12 | 13 | for (int i = 0; i < na; ++i) { 14 | for (int j = 0; j < ma; ++j) { 15 | cin >> a[i][j]; 16 | } 17 | } 18 | 19 | cin >> nb >> mb; 20 | 21 | int b[nb][mb]; 22 | 23 | for (int i = 0; i < nb; ++i) { 24 | for (int j = 0; j < mb; ++j) { 25 | cin >> b[i][j]; 26 | } 27 | } 28 | 29 | if (ma != nb) { 30 | cout << -1; 31 | } else { 32 | int c[na][mb]; 33 | 34 | memset(c, 0, sizeof(c)); 35 | 36 | for (int i = 0; i < na; ++i) { 37 | for (int j = 0; j < nb; ++j) { 38 | for (int k = 0; k < mb; ++k) { 39 | c[i][k] += a[i][j] * b[j][k]; 40 | } 41 | } 42 | } 43 | 44 | cout << na << " " << mb << endl; 45 | 46 | for (int i = 0; i < na; ++i) { 47 | for (int j = 0; j < mb; ++j) { 48 | cout << c[i][j] << " "; 49 | } 50 | cout << endl; 51 | } 52 | } 53 | 54 | return 0; 55 | } 56 | -------------------------------------------------------------------------------- /1936 - Flights/main.cpp: -------------------------------------------------------------------------------- 1 | #include "iostream" 2 | 3 | #define MAX 1010 4 | 5 | // TODO review this questin 6 | 7 | int n, i, j, L, R, Mid, flag; 8 | int graph[MAX][MAX], g[MAX][MAX]; 9 | int used[MAX]; 10 | 11 | 12 | void dfs(int v, int type) { 13 | used[v] = 1; 14 | for (int i = 0; i < n; i++) 15 | if ((type ? g[i][v] : g[v][i]) && !used[i]) dfs(i, type); 16 | } 17 | 18 | int AllVisited(void) { 19 | for (int i = 0; i < n; i++) 20 | if (!used[i]) return 0; 21 | return 1; 22 | } 23 | 24 | 25 | int main() { 26 | 27 | scanf("%d", &n); 28 | for (i = 0; i < n; i++) 29 | for (j = 0; j < n; j++) 30 | scanf("%d", &graph[i][j]); 31 | 32 | L = 0; 33 | R = 2000000000; 34 | while (L < R) { 35 | Mid = (L + R) / 2; 36 | 37 | for (i = 0; i < n; i++) 38 | for (j = 0; j < n; j++) 39 | g[i][j] = (graph[i][j] <= Mid); 40 | memset(used, 0, sizeof(used)); 41 | dfs(0, 0); 42 | flag = 0; 43 | if (AllVisited()) { 44 | memset(used, 0, sizeof(used)); 45 | dfs(0, 1); 46 | if (!AllVisited()) flag = 1; 47 | } else flag = 1; 48 | if (!flag) R = Mid; else L = Mid + 1; 49 | } 50 | 51 | printf("%d\n", L); 52 | } -------------------------------------------------------------------------------- /776 - Roads/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | // 3 | //using namespace std; 4 | // 5 | //int repr(int dsu[], int i) { 6 | // int r = dsu[i]; 7 | // while (r != dsu[r]){ 8 | // r = dsu[r]; 9 | // } 10 | // return r; 11 | //} 12 | // 13 | //void make_union(int dsu[], int a, int b) { 14 | // a = repr(dsu, a); 15 | // b = repr(dsu, b); 16 | // 17 | // if (a == b) { 18 | // return; 19 | // } else { 20 | // dsu[a] = b; 21 | // } 22 | //} 23 | // 24 | //int numberOfSets(int dsu[], int n) { 25 | // int count = 0; 26 | // for (int i = 1; i <= n; ++i) { 27 | // if (i == dsu[i]) { 28 | // count++; 29 | // } 30 | // } 31 | // return count; 32 | //} 33 | // 34 | //int main() { 35 | // int n, m; 36 | // int e1, e2; 37 | // cin >> n >> m; 38 | // 39 | // int dsu[n + 1]; 40 | // 41 | // for (int i = 1; i <= n; ++i) { 42 | // dsu[i] = i; 43 | // } 44 | // 45 | // for (int i = 1; i <= m; ++i) { 46 | // cin >> e1 >> e2; 47 | // make_union(dsu, e1, e2); 48 | // } 49 | // 50 | //// Number of new roads that is required to connect all the cities is equal to the number of different components a.k.a. sets - 1 51 | // cout << (numberOfSets(dsu, n) - 1 ); 52 | // return 0; 53 | //} -------------------------------------------------------------------------------- /5060 - Reverse Polish notation/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "stack" 3 | 4 | using namespace std; 5 | 6 | int main() { 7 | string str; 8 | stack myStack; 9 | 10 | int op1, op2; 11 | 12 | 13 | while (cin >> str) { 14 | if (str == "*") { 15 | op2 = myStack.top(); 16 | myStack.pop(); 17 | op1 = myStack.top(); 18 | myStack.pop(); 19 | myStack.push(op1 * op2); 20 | } else if (str == "/") { 21 | op2 = myStack.top(); 22 | myStack.pop(); 23 | op1 = myStack.top(); 24 | myStack.pop(); 25 | myStack.push(op1 / op2); 26 | } else if (str == "+") { 27 | op2 = myStack.top(); 28 | myStack.pop(); 29 | op1 = myStack.top(); 30 | myStack.pop(); 31 | myStack.push(op1 + op2); 32 | } else if (str == "-") { 33 | op2 = myStack.top(); 34 | myStack.pop(); 35 | op1 = myStack.top(); 36 | myStack.pop(); 37 | myStack.push(op1 - op2); 38 | } else { 39 | int temp = stoi(str); 40 | myStack.push(temp); 41 | } 42 | } 43 | 44 | cout << myStack.top(); 45 | 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /1776 - Rails/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | int x, n, cur, ok, i; 7 | stack s; 8 | 9 | int main() { 10 | // Reading first n 11 | while (scanf("%d", &n), n) { 12 | // reading first number of train 13 | while (scanf("%d", &x), x) { 14 | cur = 1; 15 | ok = 1; 16 | 17 | // emptying stack if it has elements 18 | while (!s.empty()){ 19 | s.pop(); 20 | } 21 | 22 | // Will read n-1 times numbers, since we have read first number of train in 13 line 23 | for (i = 1; i < n; i++) { 24 | // After reading first number creating stack up to that number 25 | for (; cur <= x; cur++){ 26 | s.push(cur); 27 | } 28 | 29 | // if at any moment x isn't the number that 30 | if (s.top() != x) 31 | ok = 0; 32 | else 33 | s.pop(); 34 | cin >> x; 35 | } 36 | 37 | if (ok == 1) 38 | cout << "Yes" << endl; 39 | else 40 | cout << "No" << endl; 41 | 42 | } 43 | cout << endl; 44 | } 45 | } -------------------------------------------------------------------------------- /5058 - Sequence of brackets/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Sequence of brackets (5058) 4 | // 5 | // Created by Emin Alizade on 3/2/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | int main(int argc, const char *argv[]) { 15 | stack s; 16 | string a; 17 | cin >> a; 18 | int length = a.length(); 19 | char b; 20 | int x; 21 | int flag = 0; 22 | for (int i = 0; i < length; i++) { 23 | b = a[i]; 24 | x = b; 25 | if (x == 40 || x == 123 || x == 91) { 26 | s.push(x); 27 | } 28 | 29 | if (x == 41 || x == 125 || x == 93) { 30 | if (!s.empty()) { 31 | if ((x - 1) == s.top() || (x - 2) == s.top()) { 32 | s.pop(); 33 | } else { 34 | flag = 1; 35 | break; 36 | } 37 | } else { 38 | flag = 1; 39 | break; 40 | } 41 | } 42 | } 43 | 44 | if (s.empty() && flag == 0) { 45 | cout << "yes"; 46 | } 47 | if (!s.empty() || flag == 1) { 48 | cout << "no"; 49 | } 50 | 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /4260 - LCS-2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | int dp[1001][1001]; 6 | string a, b; 7 | 8 | int lcs(int i, int j) { 9 | if (i == 0 || j == 0) { 10 | return 0; 11 | } 12 | 13 | if (dp[i][j] != -1) { 14 | return dp[i][j]; 15 | } 16 | 17 | if (a[i] == b[j]) { 18 | return dp[i][j] = 1 + lcs(i - 1, j - 1); 19 | } else { 20 | return dp[i][j] = max(lcs(i - 1, j), lcs(i, j - 1)); 21 | } 22 | } 23 | 24 | 25 | //Week 9: November 19 - Longest Common Subsequence (LCS) 26 | int main() { 27 | cin >> a >> b; 28 | a = " " + a; 29 | b = " " + b; 30 | 31 | memset(dp, -1, sizeof(dp)); 32 | 33 | // cout << lcs(a.size() - 1, b.size() - 1) << endl; 34 | lcs(a.size() - 1, b.size() - 1); 35 | 36 | int i = a.size() - 1; int j = b.size() - 1; 37 | string res; 38 | 39 | while (i >= 1 && j >= 1) { 40 | if (a[i] == b[j]) { 41 | res = res + a[i]; 42 | i--; 43 | j--; 44 | } else { 45 | if (dp[i - 1][j] > dp[i][j - 1]) 46 | i--; 47 | else 48 | j--; 49 | } 50 | } 51 | 52 | reverse(res.begin(), res.end()); 53 | cout << res << endl; 54 | 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /975 - Floyd/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 101 4 | 5 | using namespace std; 6 | 7 | int n; 8 | int g[MAX][MAX]; 9 | 10 | // Because if we have 100 vertices that are connected like a train, 11 | // like this 0-0-0-0-0-0 , then the distance between them would be like large 12 | 13 | int maxN = INT32_MAX / 2 - 1; 14 | 15 | void floyd() { 16 | for (int k = 1; k <= n; k++) { 17 | for (int i = 1; i <= n; i++) { 18 | for (int j = 1; j <= n; j++) { 19 | if (g[i][k] + g[k][j] < g[i][j]) { 20 | g[i][j] = g[i][k] + g[k][j]; 21 | } 22 | } 23 | } 24 | } 25 | } 26 | 27 | // Week 10: November 26 - Floyd 28 | int main() { 29 | cin >> n; 30 | 31 | for (int i = 1; i <= n; i++) { 32 | for (int j = 1; j <= n; j++) { 33 | cin >> g[i][j]; 34 | if (g[i][j] == -1) { 35 | g[i][j] = maxN; 36 | } 37 | } 38 | } 39 | 40 | 41 | floyd(); 42 | int res = 0; 43 | 44 | for (int i = 1; i <= n; i++) { 45 | for (int j = 1; j <= n; j++) { 46 | if (g[i][j] > res && g[i][j] != maxN) { 47 | res = g[i][j]; 48 | } 49 | } 50 | } 51 | 52 | cout << res; 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /3986 - Sources and sinks (quiz1-2)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | // 3986 - Sources and sinks 6 | int main() { 7 | int n; 8 | cin >> n; 9 | 10 | int a[n][n]; 11 | 12 | bool source[n]; 13 | bool sink[n]; 14 | int countSink = n; 15 | int countSource = n; 16 | 17 | for (int i = 0; i < n; ++i) { 18 | source[i] = true; 19 | sink[i] = true; 20 | } 21 | 22 | for (int i = 0; i < n; ++i) { 23 | for (int j = 0; j < n; ++j) { 24 | cin >> a[i][j]; 25 | if (a[i][j] == 1) { 26 | 27 | if (sink[i]) { 28 | sink[i] = false; 29 | countSink--; 30 | } 31 | 32 | if (source[j]) { 33 | source[j] = false; 34 | countSource--; 35 | } 36 | 37 | } 38 | } 39 | } 40 | 41 | cout << countSource << " "; 42 | for (int i = 0; i < n; ++i) { 43 | if (source[i]) { 44 | cout << i + 1 << " "; 45 | } 46 | } 47 | 48 | cout << endl; 49 | cout << countSink << " "; 50 | for (int i = 0; i < n; ++i) { 51 | if (sink[i]) { 52 | cout << i + 1 << " "; 53 | } 54 | } 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /1948 - Topological Sort/kahn_algo.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 20.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | vector> g; 12 | vector InDegree, topSort; 13 | queue q; 14 | 15 | int main() { 16 | int n, m; 17 | 18 | cin >> n >> m; 19 | g.resize(n+1); 20 | InDegree.assign(n + 1, 0); 21 | 22 | int a, b; 23 | for (int i = 0; i < m; ++i) { 24 | cin >> a >> b; 25 | g[a].push_back(b); 26 | InDegree[b]++; 27 | } 28 | 29 | for (int i = 1; i < InDegree.size(); i++) { 30 | if (InDegree[i] == 0) { 31 | q.push(i); 32 | } 33 | } 34 | 35 | while (!q.empty()) 36 | { 37 | int v = q.front(); 38 | q.pop(); 39 | topSort.push_back(v); 40 | for (int i = 0; i < g[v].size(); i++) { 41 | int to = g[v][i]; 42 | InDegree[to]--; 43 | if (InDegree[to] == 0) { 44 | q.push(to); 45 | } 46 | } 47 | } 48 | 49 | if (topSort.size() < n) { 50 | cout << -1; 51 | } 52 | else { 53 | for (int i = 0; i < topSort.size(); i++) { 54 | cout << topSort[i] << " "; 55 | } 56 | } 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /3988 - Transitivity of a graph/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 101 4 | 5 | using namespace std; 6 | 7 | int n, m; 8 | bool g[MAX][MAX]; 9 | 10 | bool floyd() { 11 | for (int i = 1; i <= n; i++) { 12 | for (int j = i + 1; j <= n; j++) { 13 | for (int k = 1; k <= n; k++) { 14 | if (k == i || k == j) continue; 15 | 16 | // Here we check transitivity, 17 | // like if there is edge from i to k, 18 | // and from k to j, there has to be direct edge from i to j as well 19 | // otherwise this graph is not transitive 20 | 21 | if (g[i][k] && g[k][j]) { 22 | if(!g[i][j]) { 23 | return false; 24 | } 25 | } 26 | } 27 | } 28 | } 29 | 30 | return true; 31 | } 32 | 33 | // Week 10: November 26 - Transitive closure 34 | int main() { 35 | cin >> n >> m; 36 | 37 | for (int i = 1; i <= n; i++) { 38 | for (int j = 1; j <= n; j++) { 39 | g[i][j] = false; 40 | } 41 | } 42 | 43 | int a, b; 44 | 45 | for (int i = 0; i < m; ++i) { 46 | cin >> a >> b; 47 | g[a][b] = true; 48 | g[b][a] = true; 49 | } 50 | 51 | 52 | cout << (floyd() ? "YES" : "NO"); 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /8637 - Sort the points/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | struct MyPoint { 7 | MyPoint(int a, int b) { 8 | x = a; 9 | y = b; 10 | } 11 | 12 | int x, y; 13 | }; 14 | 15 | int comparator(MyPoint a, MyPoint b) { 16 | int sumA = a.x + a.y; 17 | int sumB = b.x + b.y; 18 | 19 | if (sumA == sumB) { 20 | return a.x < b.x; 21 | } 22 | return sumA < sumB; 23 | } 24 | 25 | int Partition(vector &m, int L, int R) 26 | { 27 | MyPoint x = m[L]; 28 | int i = L - 1, j = R + 1; 29 | while (1) 30 | { 31 | do j--; while (comparator(x,m[j])); 32 | do i++; while (comparator(m[i],x)); 33 | if (i < j) swap(m[i], m[j]); else return j; 34 | } 35 | } 36 | 37 | void quickSort(vector &m, int L, int R) 38 | { 39 | int q; 40 | if (L < R) 41 | { 42 | q = Partition(m, L, R); 43 | quickSort(m, L, q); 44 | quickSort(m, q + 1, R); 45 | } 46 | } 47 | 48 | int main() { 49 | int x,y; 50 | vector a; 51 | 52 | while (cin >> x>>y) { 53 | a.push_back(MyPoint(x, y)); 54 | } 55 | 56 | quickSort(a, 0 , a.size() - 1); 57 | 58 | for (int i = 0; i < a.size(); ++i) { 59 | cout << a[i].x << " " << a[i].y << endl; 60 | } 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /10651 - The smallest Topological Sort/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 20.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | vector> g; 12 | vector InDegree, topSort; 13 | priority_queue , greater> q; 14 | 15 | int main() { 16 | int n, m; 17 | 18 | cin >> n >> m; 19 | g.resize(n+1); 20 | InDegree.assign(n + 1, 0); 21 | 22 | int a, b; 23 | for (int i = 0; i < m; ++i) { 24 | cin >> a >> b; 25 | g[a].push_back(b); 26 | InDegree[b]++; 27 | } 28 | 29 | for (int i = 1; i < InDegree.size(); i++) { 30 | if (InDegree[i] == 0) { 31 | q.push(i); 32 | } 33 | } 34 | 35 | while (!q.empty()) 36 | { 37 | int v = q.top(); 38 | q.pop(); 39 | topSort.push_back(v); 40 | for (int i = 0; i < g[v].size(); i++) { 41 | int to = g[v][i]; 42 | InDegree[to]--; 43 | if (InDegree[to] == 0) { 44 | q.push(to); 45 | } 46 | } 47 | } 48 | 49 | if (topSort.size() < n) { 50 | cout << -1; 51 | } 52 | else { 53 | for (int i = 0; i < topSort.size(); i++) { 54 | cout << topSort[i] << " "; 55 | } 56 | } 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /5854 - Maximum Sum basic/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // main.cpp 3 | // e-olymp Maximum Sum basic(5854) 4 | // 5 | // Created by Emin Alizade on 6/24/19. 6 | // Copyright © 2019 Emin Alizade. All rights reserved. 7 | // 8 | 9 | #include 10 | 11 | using namespace std; 12 | 13 | int main() { 14 | int n, m; 15 | cin >> n >> m; 16 | 17 | int dp[n][m]; 18 | 19 | for (int i = 0; i < n; ++i) { 20 | for (int j = 0; j < m; ++j) { 21 | cin >> dp[i][j]; 22 | } 23 | } 24 | 25 | for (int i = 1; i < n; ++i) { 26 | for (int j = 0; j < m; ++j) { 27 | int maxPrev = INT32_MIN; 28 | maxPrev = max(maxPrev, dp[i-1][j]); 29 | 30 | if (j > 0) { 31 | maxPrev = max(maxPrev, dp[i-1][j-1]); 32 | } 33 | 34 | if (j < m-1) { 35 | maxPrev = max(maxPrev, dp[i-1][j+1]); 36 | } 37 | 38 | dp[i][j] += maxPrev; 39 | } 40 | } 41 | 42 | // for (int i = 0; i < n; ++i) { 43 | // for (int j = 0; j < m; ++j) { 44 | // cout << dp[i][j] << " "; 45 | // } 46 | // cout << endl; 47 | // } 48 | 49 | int maxResult = INT32_MIN; 50 | for (int j = 0; j < m; ++j) { 51 | maxResult = max(maxResult, dp[n - 1][j]); 52 | } 53 | 54 | cout << maxResult; 55 | 56 | return 0; 57 | } -------------------------------------------------------------------------------- /9023 - Minimum increments/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | //Check if the given x is suitable 6 | bool f(long long *arr, long long x, long long n) { 7 | bool flag = true; 8 | for (long long i = 0; i < n; ++i) { 9 | if (x < arr[i]){ 10 | flag = false; 11 | break; 12 | } 13 | x++; 14 | } 15 | return flag; 16 | } 17 | 18 | int main() { 19 | long long n; 20 | cin >> n; 21 | 22 | long long a[n]; 23 | long long max; 24 | 25 | for (long long i = 0; i < n; ++i) { 26 | cin >> a[i]; 27 | if (i==0) { 28 | max = a[i]; 29 | } else { 30 | if (max < a[i]) { 31 | max = a[i]; 32 | } 33 | } 34 | } 35 | 36 | long long left = a[0]; 37 | long long right = max; 38 | 39 | while (left < right) 40 | { 41 | long long mid = (left + right) / 2; 42 | if (f(a, mid, n)) { 43 | right = mid; 44 | } 45 | else { 46 | left = mid + 1; 47 | } 48 | } 49 | 50 | long long count = 0; 51 | 52 | for (long long i = 0; i < n; ++i) { 53 | while (a[i] != left) { 54 | a[i]++; 55 | count++; 56 | } 57 | left++; 58 | } 59 | 60 | cout << count; 61 | 62 | return 0; 63 | } 64 | -------------------------------------------------------------------------------- /1948 - Topological Sort/main.cpp: -------------------------------------------------------------------------------- 1 | //#include 2 | //#include 3 | // 4 | //using namespace std; 5 | // 6 | //vector> g; 7 | //vector used, topSort; 8 | //bool containsCycle = false; 9 | // 10 | //void dfs(int i) { 11 | // used[i] = 1; 12 | // for (int j = 0; j < g[i].size(); j++) 13 | // { 14 | // int to = g[i][j]; 15 | // 16 | // // grey vertex - we have a cycle 17 | // if (used[to] == 1) { 18 | // containsCycle = true; 19 | // } 20 | // 21 | // // if not visited - run dfs 22 | // if (used[to] == 0) { 23 | // dfs(to); 24 | // } 25 | // } 26 | // used[i] = 2; 27 | // topSort.push_back(i); 28 | //} 29 | // 30 | //int main() { 31 | // int n, m; 32 | // 33 | // cin >> n >> m; 34 | // g.resize(n+1); 35 | // used.resize(n+1,0); 36 | // 37 | // int a, b; 38 | // for (int i = 0; i < m; ++i) { 39 | // cin >> a >> b; 40 | // g[a].push_back(b); 41 | // } 42 | // 43 | // for(int i = 1; i <= n; i++) { 44 | // if (!used[i]) { 45 | // dfs(i); 46 | // } 47 | // } 48 | // 49 | // if (containsCycle) { 50 | // printf("-1"); 51 | // } 52 | // else { 53 | // for (int i = n - 1; i >= 0; i--) { 54 | // printf("%d ", topSort[i]); 55 | // } 56 | // } 57 | // 58 | // return 0; 59 | //} 60 | -------------------------------------------------------------------------------- /6128 - Simple deque/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | deque dq; 6 | int a; 7 | string str; 8 | 9 | int main(){ 10 | while(cin>>str) 11 | {if(str=="push_front") 12 | { 13 | cin>>a; 14 | dq.push_front(a); 15 | cout<<"ok"<>a; 19 | dq.push_back(a); 20 | cout<<"ok"< 2 | 3 | using namespace std; 4 | 5 | int repr(int dsu[], int i) { 6 | // Path compression heuristic 7 | if (i == dsu[i]) { 8 | return i; 9 | } 10 | return dsu[i] = repr(dsu, dsu[i]); 11 | } 12 | 13 | void make_union(int dsu[], int depthDsu[], int a, int b) { 14 | a = repr(dsu, a); 15 | b = repr(dsu, b); 16 | 17 | if (a == b) { 18 | return; 19 | } else { 20 | if (depthDsu[a] > depthDsu[b]) { 21 | swap(a, b); 22 | } 23 | dsu[a] = b; 24 | if (depthDsu[a] == depthDsu[b]) { 25 | depthDsu[b]++; 26 | } 27 | } 28 | } 29 | 30 | void setCreate(int dsu[], int depthDsu[], int i) { 31 | dsu[i] = i; 32 | depthDsu[i] = 0; 33 | } 34 | 35 | int main() { 36 | int n, m; 37 | int e1, e2; 38 | string o; 39 | cin >> n >> m; 40 | 41 | int dsu[n + 1]; 42 | int depthDsu[n + 1]; 43 | 44 | for (int i = 1; i <= n; ++i) { 45 | setCreate(dsu, depthDsu, i); 46 | } 47 | 48 | for (int i = 1; i <= m; ++i) { 49 | cin >> o >> e1 >> e2; 50 | if (o == "union") { 51 | make_union(dsu, depthDsu, e1, e2); 52 | } 53 | if (o == "get") { 54 | cout << (repr(dsu, e1) == repr(dsu, e2) ? "YES" : "NO") << endl; 55 | } 56 | } 57 | 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /4973 - Mutation/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | class segment 8 | { 9 | public: 10 | int start, fin; 11 | segment(int start, int fin) : start(start), fin(fin) {} 12 | }; 13 | 14 | 15 | int f(segment a, segment b) 16 | { 17 | return a.fin <= b.fin; 18 | } 19 | 20 | // Week 7 - greedy (activity selection problem) 21 | int main() { 22 | int n; 23 | cin >> n; 24 | 25 | int a[n]; 26 | vector temp(n + 1, segment(-1, -1)), filteredSegments; 27 | 28 | for (int i = 0; i < n; ++i) { 29 | cin >> a[i]; 30 | 31 | if (temp[a[i]].start == -1) { 32 | temp[a[i]].start = i; 33 | temp[a[i]].fin = i; 34 | } else { 35 | temp[a[i]].fin = i; 36 | } 37 | } 38 | 39 | // Filtering out empty segments 40 | for(segment s: temp) { 41 | if (s.start != -1) { 42 | filteredSegments.push_back(s); 43 | } 44 | } 45 | 46 | sort(filteredSegments.begin(), filteredSegments.end(), f); 47 | 48 | int cur = 0, res = 1; 49 | 50 | for (int i = 1; i < filteredSegments.size(); ++i) { 51 | if (filteredSegments[i].start >= filteredSegments[cur].fin) { 52 | cur = i; 53 | res++; 54 | } 55 | } 56 | 57 | cout << filteredSegments.size() - res; 58 | 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /10242 - Knight route/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define MAX 9 4 | 5 | using namespace std; 6 | 7 | int sol[MAX][MAX]; 8 | int n; 9 | 10 | int xMove[8] = {2, 1, -1, -2, -2, -1, 1, 2}; 11 | int yMove[8] = {1, 2, 2, 1, -1, -2, -2, -1}; 12 | 13 | int isSafe(int x, int y) { 14 | return (x >= 0 && x < n && y >= 0 && y < n && sol[x][y] == -1); 15 | } 16 | 17 | void printSolution() { 18 | for (int x = 0; x < n; x++) { 19 | for (int y = 0; y < n; y++) 20 | printf("%2d ", sol[x][y]); 21 | printf("\n"); 22 | } 23 | } 24 | 25 | int solveKTUtil(int x, int y, int movei) { 26 | sol[x][y] = movei; 27 | if (movei == n * n) return 1; 28 | for (int k = 0; k < 8; k++) { 29 | int next_x = x + xMove[k]; 30 | int next_y = y + yMove[k]; 31 | if (isSafe(next_x, next_y)) { 32 | if (solveKTUtil(next_x, next_y, movei + 1) == 1) return 1; 33 | } 34 | } 35 | sol[x][y] = -1; 36 | return 0; 37 | } 38 | 39 | int solve() { 40 | for (int x = 0; x < n; x++) 41 | for (int y = 0; y < n; y++) 42 | sol[x][y] = -1; 43 | 44 | if (solveKTUtil(0, 0, 1) == 0) { 45 | printf("Solution does not exist"); 46 | return 0; 47 | } else { 48 | printSolution(); 49 | } 50 | return 1; 51 | } 52 | 53 | 54 | int main() { 55 | scanf("%d", &n); 56 | solve(); 57 | 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /5201 - К-th minimum/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | vector v; 7 | long long n, k, i; 8 | 9 | long long Partition(long long left, long long right) { 10 | long long x = v[left], i = left - 1, j = right + 1; 11 | while (1) { 12 | do j--; while (v[j] > x); 13 | do i++; while (v[i] < x); 14 | if (i < j) swap(v[i], v[j]); else return j; 15 | } 16 | } 17 | 18 | long long kth(long long k, long long left, long long right) { 19 | if (left == right) return v[left]; 20 | long long pos = Partition(left, right); 21 | if (k <= pos) return kth(k, left, pos); 22 | else return kth(k, pos + 1, right); 23 | } 24 | 25 | long long p(long long x) { 26 | long long mod = 1743; 27 | 28 | long long a1 = (132 * (((((x % mod) * (x % mod)) % mod) * (x % mod)) % mod)) % mod; 29 | long long a2 = (77 * (((x % mod) * (x % mod)) % mod)) % mod; 30 | long long a3 = (1345 * (x % mod)) % mod; 31 | 32 | long long res = ((((a1 + a2) % mod) + a3) % mod + 1577) % mod; 33 | 34 | // cout << a1 << " " << a2 << " " <> n >>k; 42 | 43 | v.push_back(0); 44 | 45 | for (long long j = 1; j <= n; ++j) { 46 | v.push_back(p(j)); 47 | } 48 | 49 | cout << kth(k, 1, n) << endl; 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /318 - Binomial coefficients 1 (not working)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | // 80% passes 7 | 8 | map c; 9 | 10 | unsigned long long binomCoef(unsigned long long n, unsigned long long k) { 11 | if (n == k) return 1; 12 | if (k == 0) return 1; 13 | 14 | string leftStr = to_string(n - 1) + "," + to_string(k - 1); 15 | string rightStr = to_string(n - 1) + "," + to_string(k); 16 | unsigned long long left = 0, right = 0; 17 | 18 | if (c.find(leftStr) != c.end()) { 19 | left = c.at(leftStr); 20 | // cout << "in if" << endl; 21 | // cout << "in if" << c.at(to_string(n) + "," + to_string(k)) << endl; 22 | } else { 23 | left = binomCoef(n - 1, k - 1); 24 | c.insert(make_pair(leftStr, left)); 25 | } 26 | 27 | if (c.find(rightStr) != c.end()) { 28 | right = c.at(rightStr); 29 | // cout << "in if" << c.at(to_string(n) + "," + to_string(k)) << endl; 30 | } else { 31 | right = binomCoef(n - 1, k); 32 | c.insert(make_pair(rightStr, right)); 33 | } 34 | 35 | return left + right; 36 | } 37 | 38 | int main() { 39 | int t; 40 | 41 | cin >> t; 42 | 43 | while (t--) { 44 | unsigned long long n, k; 45 | 46 | cin >> n >> k; 47 | 48 | cout << binomCoef(n, k) << endl; 49 | } 50 | 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /2590 - Space Exploration/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int n; 7 | string m[1001]; // declare the grid - two-dimensional char array 8 | 9 | // start depth first search at position (x, y) 10 | void dfs(int i, int j) { 11 | // if we out of bounds of the grid - return 12 | if ((i < 0) || (i >= n) || (j < 0) || (j >= n)) { 13 | return; 14 | } 15 | 16 | // if we come to empty cell - return 17 | if (m[i][j] == '.') { 18 | return; 19 | } 20 | 21 | // mark current position as used (passed) 22 | m[i][j] = '.'; 23 | 24 | // run depth first search in four neighbouring directions 25 | dfs(i - 1, j); 26 | dfs(i + 1, j); 27 | dfs(i, j - 1); 28 | dfs(i, j + 1); 29 | } 30 | 31 | int main() { 32 | cin >> n; 33 | for (int i = 0; i < n; i++) { 34 | cin >> m[i]; 35 | } 36 | 37 | // count the number of asteroids - number of connected components 38 | int count = 0; 39 | for (int i = 0; i < n; i++) { 40 | for (int j = 0; j < n; j++) { 41 | if (m[i][j] == '*') // if position (i, j) contains a stone, run dfs from it 42 | { 43 | dfs(i, j); 44 | count++; // increase the number of connected components 45 | } 46 | } 47 | } 48 | 49 | // print the answer 50 | cout << count << endl; 51 | return 0; 52 | } 53 | -------------------------------------------------------------------------------- /2403 - Strong connectivity/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | vector > g, gr; // graph and graph reverse 6 | vector used, top; 7 | 8 | void dfs1(int v) 9 | { 10 | used[v] = 1; 11 | for(int i = 0; i < g[v].size(); i++) { 12 | int to = g[v][i]; 13 | if (!used[to]) { 14 | dfs1(to); 15 | } 16 | } 17 | top.push_back(v); 18 | } 19 | 20 | void dfs2(int v) 21 | { 22 | used[v] = 1; 23 | for(int i = 0; i < gr[v].size(); i++) { 24 | int to = gr[v][i]; 25 | if (!used[to]) { 26 | dfs2(to); 27 | } 28 | } 29 | } 30 | 31 | int main() 32 | { 33 | int n,m; 34 | cin >> n >> m; 35 | g.assign(n+1,vector()); 36 | gr.assign(n+1,vector()); 37 | 38 | int a, b; 39 | for(int i = 1; i <= m; i++) { 40 | cin >> a >> b; 41 | g[a].push_back(b); 42 | gr[b].push_back(a); 43 | } 44 | 45 | used.assign(n+1,0); 46 | 47 | for(int i = 1; i <= n; i++) { 48 | if (!used[i]) { 49 | dfs1(i); 50 | } 51 | } 52 | 53 | used.assign(n+1,0); 54 | 55 | int count = 0, v; 56 | for(int i = n - 1; i >= 0; i--) 57 | { 58 | v = top[i]; 59 | if (!used[v]) 60 | { 61 | dfs2(v); 62 | count++; 63 | } 64 | } 65 | 66 | cout << count; 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /9654 - Depth first search on a disconnected graph/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define MAX 101 6 | 7 | using namespace std; 8 | 9 | int g[MAX][MAX], t = 1, n; 10 | 11 | struct Vertex { 12 | int used, d, f, id; 13 | 14 | Vertex(int i) { 15 | id = i; 16 | used = 0; 17 | d = 0; 18 | f = 0; 19 | } 20 | }; 21 | 22 | int comparator(Vertex a, Vertex b) { 23 | return a.d < b.d; 24 | } 25 | 26 | vector vertex; 27 | 28 | void dfsMatrix(int v) { 29 | if (vertex[v].used == 1) { 30 | return; 31 | } 32 | 33 | vertex[v].d = t++; 34 | vertex[v].used = 1; 35 | 36 | for (int i = 1; i <= n; ++i) { 37 | if (vertex[i].used == 0 && g[v][i] == 1) { 38 | dfsMatrix(i); 39 | } 40 | } 41 | vertex[v].f = t++; 42 | } 43 | 44 | int main() { 45 | cin >> n; 46 | 47 | for (int i = 0; i <= n; ++i) { 48 | vertex.push_back(Vertex(i)); 49 | } 50 | 51 | int a, b; 52 | while (cin >> a >> b) { 53 | g[a][b] = 1; 54 | g[b][a] = 1; 55 | } 56 | 57 | for (int i = 1; i <= n; ++i) { 58 | dfsMatrix(i); 59 | } 60 | 61 | sort(vertex.begin(), vertex.end(), comparator); 62 | 63 | for (int i = 1; i <= n; ++i) { 64 | printf("Vertex: %d, Gray %d, Black %d\n", vertex[i].id, vertex[i].d, vertex[i].f); 65 | } 66 | 67 | return 0; 68 | } -------------------------------------------------------------------------------- /10056 - Breadth First Search 0-1/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | struct edge 8 | { 9 | int to, dist; 10 | edge(int to, int dist) : to(to), dist(dist) {} 11 | }; 12 | 13 | int n,m,s,d; 14 | vector> g; 15 | vector dist; 16 | deque q; 17 | 18 | 19 | void bfs() { 20 | while (!q.empty()) { 21 | int from = q.front(); 22 | q.pop_front(); 23 | 24 | for (int i = 0; i < g[from].size(); ++i) { 25 | int to = g[from][i].to; 26 | int w = g[from][i].dist; 27 | 28 | if (dist[to] == -1 || dist[to] > dist[from] + w) { 29 | dist[to] = dist[from] + w; 30 | 31 | if (w == 0) { 32 | q.push_front(to); 33 | } else { 34 | q.push_back(to); 35 | } 36 | } 37 | } 38 | } 39 | } 40 | 41 | //Week 12: December 6 - 12 - BFS 0-1 graph 42 | 43 | int main() { 44 | cin >> n >> m >> s >> d; 45 | dist.resize(n + 1); 46 | fill(dist.begin(), dist.end(), -1); 47 | 48 | g.resize(n+1); 49 | 50 | int a,b,w; 51 | for (int i = 0; i < m; ++i) { 52 | cin >> a >> b >> w; 53 | g[a].push_back(edge(b, w)); 54 | g[b].push_back(edge(a, w)); 55 | } 56 | 57 | q.push_front(s); 58 | dist[s] = 0; 59 | bfs(); 60 | 61 | cout << dist[d]; 62 | return 0; 63 | } -------------------------------------------------------------------------------- /4853 - The shortest path/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int n, m, s, f; 8 | vector> g; 9 | vector dist, par; 10 | queue q; 11 | 12 | void bfs() { 13 | while (!q.empty()) { 14 | int from = q.front(); 15 | q.pop(); 16 | 17 | for(int to: g[from]) { 18 | if (dist[to] == -1) { 19 | dist[to] = dist[from] + 1; 20 | par[to] = from; 21 | q.push(to); 22 | } 23 | } 24 | } 25 | } 26 | 27 | void printPath(int to) { 28 | vector res; 29 | while (to != -1) { 30 | res.push_back(to); 31 | to = par[to]; 32 | } 33 | 34 | for (int i = res.size() - 1; i >= 0; i--) { 35 | cout << res[i] << " "; 36 | } 37 | 38 | cout << endl; 39 | } 40 | 41 | int main() { 42 | cin >> n >> m >> s >> f; 43 | dist.resize(n+1); 44 | fill(dist.begin(), dist.end(), -1); 45 | 46 | par.resize(n+1); 47 | fill(par.begin(), par.end(), -1); 48 | 49 | g.resize(n+1); 50 | 51 | int a, b; 52 | for (int i = 0; i < m; ++i) { 53 | cin >> a >> b; 54 | g[a].push_back(b); 55 | g[b].push_back(a); 56 | } 57 | 58 | q.push(s); 59 | dist[s] = 0; 60 | bfs(); 61 | 62 | cout << dist[f] << endl; 63 | if (dist[f] != -1) { 64 | printPath(f); 65 | } 66 | 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /694 - Minimum in the Queue/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 09.10.21. 3 | // 4 | 5 | #include "iostream" 6 | 7 | using namespace std; 8 | 9 | int main() { 10 | int n, a, b, c, x; 11 | long long res = 0; 12 | 13 | cin >> n >> a >> b >> c >> x; 14 | 15 | int values[n], valuesStart = 0, valuesEnd = 0; 16 | int min[n], minStart = 0, minEnd = 0; 17 | 18 | fill_n(values, n, -1); 19 | fill_n(min, n, -1); 20 | 21 | for (int i = 0; i < n; ++i) { 22 | x = (1L * a * x * x + 1L * b * x + c) / 100 % 1000000L; 23 | 24 | if (x % 5 < 2) { 25 | // Pop value from arrays if there is an element in it 26 | if (valuesStart != valuesEnd) { 27 | if (values[valuesStart] == min[minStart]) { 28 | // If the value that we pop is in min array pop it from there too 29 | minStart++; 30 | } 31 | // In any way we pop value from values array 32 | valuesStart++; 33 | } 34 | } else { 35 | // Push to the arrays 36 | values[valuesEnd++] = x; 37 | while (minStart != minEnd && ( x < min[minEnd - 1] ) ) { 38 | minEnd--; 39 | } 40 | min[minEnd++] = x; 41 | } 42 | 43 | // get Minimum and add to res 44 | res += minStart != minEnd ? min[minStart] : 0; 45 | } 46 | 47 | cout << res; 48 | 49 | return 0; 50 | } -------------------------------------------------------------------------------- /981 - Minimum spanning tree/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #define MAXV 20001 5 | #define MAXE 100001 6 | using namespace std; 7 | 8 | struct Edge 9 | { 10 | int u, v,dist; 11 | } e[MAXE]; 12 | 13 | int repr[MAXV], sizeOfSet[MAXV], res; 14 | 15 | void swap(int &x, int &y) 16 | { 17 | int t = x; x = y; y = t; 18 | } 19 | 20 | int Repr(int n) 21 | { 22 | if (n == repr[n]) return n; 23 | return repr[n] = Repr(repr[n]); 24 | } 25 | 26 | int Union(int x,int y) 27 | { 28 | x = Repr(x); y = Repr(y); 29 | if(x == y) return 0; 30 | 31 | if (sizeOfSet[x] < sizeOfSet[y]) swap(x, y); 32 | repr[y] = x; 33 | sizeOfSet[x] += sizeOfSet[y]; 34 | return 1; 35 | } 36 | 37 | int comp(Edge a, Edge b) 38 | { 39 | return (a.dist < b.dist); 40 | } 41 | // Week 8 - 12 nov (MST) (Union set) 42 | int main() 43 | { 44 | int i, n, m; 45 | scanf("%d %d", &n, &m); 46 | for(i = 1; i <= n; i++) 47 | { 48 | repr[i] = i; 49 | sizeOfSet[i] = 1; 50 | } 51 | 52 | for(i = 0; i < m; i++) { 53 | scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].dist); 54 | } 55 | 56 | sort(e, e + m, comp); 57 | 58 | res = 0; 59 | for(i = 0; i < m; i++) { 60 | // add to res if not in the same set 61 | if (Union(e[i].u, e[i].v)) { 62 | res += e[i].dist; 63 | } 64 | } 65 | 66 | cout << res << endl; 67 | 68 | return 0; 69 | } 70 | -------------------------------------------------------------------------------- /8236 - Sort evens and odds/quickSort.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 30.10.21. 3 | // 4 | 5 | #include 6 | 7 | using namespace std; 8 | 9 | void swap(int &a, int &b) { 10 | int c = a; 11 | a = b; 12 | b = c; 13 | } 14 | 15 | int comparator(int a, int b) { 16 | if (abs(a % 2) != abs(b % 2)) 17 | return abs(a % 2) < abs(b % 2); 18 | if (a % 2 == 0) 19 | return a < b; 20 | if (abs(a % 2) == 1) 21 | return a > b; 22 | } 23 | 24 | int Partition(int m[], int L, int R) 25 | { 26 | int x = m[L]; 27 | int i = L - 1, j = R + 1; 28 | while (1) 29 | { 30 | do j--; while (comparator(m[j], x)); 31 | do i++; while (comparator(x,m[i])); 32 | if (i < j) swap(m[i], m[j]); else return j; 33 | } 34 | } 35 | 36 | void quickSort(int m[], int L, int R) 37 | { 38 | int q; 39 | if (L < R) 40 | { 41 | q = Partition(m, L, R); 42 | quickSort(m, L, q); 43 | quickSort(m, q + 1, R); 44 | } 45 | } 46 | 47 | void printArray(int a[], int n) { 48 | for (int i = 1; i <= n; ++i) { 49 | cout << a[i] << " "; 50 | } 51 | // cout << endl; 52 | } 53 | 54 | int main() { 55 | int n, temp; 56 | 57 | cin >> n; 58 | 59 | int a[n + 1]; 60 | 61 | for (int i = 1; i <= n; ++i) { 62 | cin>>temp; 63 | a[i] = temp; 64 | } 65 | 66 | quickSort(a, 1, n); 67 | 68 | printArray(a, n); 69 | 70 | return 0; 71 | } -------------------------------------------------------------------------------- /10652 - The unique Topological Sort/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 20.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | vector> g; 12 | vector InDegree, topSort; 13 | queue q; 14 | bool uniqueTopSort = true; 15 | 16 | int main() { 17 | int n, m; 18 | 19 | cin >> n >> m; 20 | g.resize(n+1); 21 | InDegree.assign(n + 1, 0); 22 | 23 | int a, b; 24 | for (int i = 0; i < m; ++i) { 25 | cin >> a >> b; 26 | g[a].push_back(b); 27 | InDegree[b]++; 28 | } 29 | 30 | for (int i = 1; i < InDegree.size(); i++) { 31 | if (InDegree[i] == 0) { 32 | q.push(i); 33 | } 34 | } 35 | 36 | while (!q.empty()) 37 | { 38 | if (q.size() > 1) { 39 | uniqueTopSort = false; 40 | } 41 | int v = q.front(); 42 | q.pop(); 43 | topSort.push_back(v); 44 | for (int i = 0; i < g[v].size(); i++) { 45 | int to = g[v][i]; 46 | InDegree[to]--; 47 | if (InDegree[to] == 0) { 48 | q.push(to); 49 | } 50 | } 51 | } 52 | 53 | if (topSort.size() < n) { 54 | cout << -1; 55 | } 56 | else { 57 | if (uniqueTopSort) { 58 | cout << "YES"; 59 | } else { 60 | cout << "NO"; 61 | } 62 | } 63 | 64 | return 0; 65 | } 66 | -------------------------------------------------------------------------------- /972 - Sorting time/quickSort.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 29.10.21. 3 | // 4 | 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | int i, n, h, m, s; 10 | 11 | struct MyTime 12 | { 13 | int hour, min, sec; 14 | }; 15 | 16 | vector lst; 17 | 18 | int f(MyTime a, MyTime b) 19 | { 20 | if ((a.hour == b.hour) && (a.min == b.min)) return a.sec < b.sec; 21 | if (a.hour == b.hour) return a.min < b.min; 22 | return a.hour < b.hour; 23 | } 24 | 25 | void swap(int &i, int &j) 26 | { 27 | int temp = i; i = j; j = temp; 28 | } 29 | 30 | int Partition(vector &m, int L, int R) 31 | { 32 | MyTime x = m[L]; 33 | int i = L - 1, j = R + 1; 34 | while (1) 35 | { 36 | do j--; while (f(x,m[j])); 37 | do i++; while (f(m[i],x)); 38 | if (i < j) swap(m[i], m[j]); else return j; 39 | } 40 | } 41 | 42 | void QuickSort(vector &m, int L, int R) 43 | { 44 | int q; 45 | if (L < R) 46 | { 47 | q = Partition(m, L, R); 48 | QuickSort(m, L, q); QuickSort(m, q + 1, R); 49 | } 50 | } 51 | 52 | int main() 53 | { 54 | scanf("%d", &n); 55 | lst.resize(n); 56 | 57 | for (i = 0; i < n; i++) 58 | scanf("%d %d %d", &lst[i].hour, &lst[i].min, &lst[i].sec); 59 | 60 | QuickSort(lst, 0, lst.size() - 1); 61 | 62 | for (i = 0; i < n; i++) 63 | printf("%d %d %d\n", lst[i].hour, lst[i].min, lst[i].sec); 64 | 65 | return 0; 66 | } -------------------------------------------------------------------------------- /1521 - Optimal Matrix Multiplication - 2/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #define INF 0x3F3F3F3F3F3F3F3FLL 5 | 6 | using namespace std; 7 | 8 | #define MAX 11 9 | 10 | long long m[MAX][MAX], s[MAX][MAX], p[MAX]; 11 | 12 | long long Mult(int i, int j) { 13 | if (m[i][j] == INF) { 14 | for (int k = i; k <= j - 1; k++) { 15 | long long temp = Mult(i, k) + Mult(k + 1, j) + p[i - 1] * p[k] * p[j]; 16 | if (temp < m[i][j]) { 17 | m[i][j] = temp; 18 | s[i][j] = k; 19 | } 20 | } 21 | } 22 | return m[i][j]; 23 | } 24 | 25 | string Print(int i, int j) 26 | { 27 | if (i == j) return "A" + to_string(i); 28 | return "(" + Print(i,s[i][j]) + " x " + Print(s[i][j]+1,j) + ")"; 29 | } 30 | 31 | // Week 10: November 24 - Matrix multiplication 32 | int main() { 33 | int n, counter = 1; 34 | while (true) { 35 | cin >> n; 36 | if (n == 0) { 37 | break; 38 | } 39 | 40 | memset(m, 0x3F, sizeof(m)); 41 | for (int i = 1; i <= n; i++) { 42 | cin >> p[i-1] >> p[i]; 43 | m[i][i] = 0; 44 | } 45 | 46 | Mult(1, n); 47 | 48 | cout << "Case " << counter << ": "; 49 | if (n==1) { 50 | cout << "(A1)"; 51 | } else { 52 | cout << Print(1,n); 53 | } 54 | 55 | cout << endl; 56 | 57 | counter++; 58 | } 59 | return 0; 60 | } -------------------------------------------------------------------------------- /37 - Mail of the sponsor/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int repr(int dsu[], int i) { 6 | // Path compression heuristic 7 | if (i == dsu[i]){ 8 | return i; 9 | } 10 | return dsu[i] = repr(dsu, dsu[i]); 11 | } 12 | 13 | void make_union(int dsu[], int depthDsu[], int a, int b) { 14 | a = repr(dsu, a); 15 | b = repr(dsu, b); 16 | 17 | if (a == b) { 18 | return; 19 | } else { 20 | // Rank heuristic 21 | if (depthDsu[a] > depthDsu[b]) { 22 | swap(a, b); 23 | } 24 | dsu[a] = b; 25 | if (depthDsu[a] == depthDsu[b]) { 26 | depthDsu[b]++; 27 | } 28 | } 29 | } 30 | 31 | int numberOfSets(int dsu[], int n) { 32 | int count = 0; 33 | for (int i = 1; i <= n; ++i) { 34 | if (i == dsu[i]) { 35 | count++; 36 | } 37 | } 38 | return count; 39 | } 40 | 41 | void setCreate(int dsu[], int depthDsu[], int i) { 42 | dsu[i] = i; 43 | depthDsu[i] = 0; 44 | } 45 | 46 | int main() { 47 | int n, s, m; 48 | int e1, e2; 49 | cin >> n >> s >> m; 50 | 51 | int dsu[n + 1]; 52 | int depthDsu[n + 1]; 53 | 54 | for (int i = 1; i <= n; ++i) { 55 | setCreate(dsu, depthDsu, i); 56 | } 57 | 58 | for (int i = 1; i <= m; ++i) { 59 | cin >> e1 >> e2; 60 | make_union(dsu, depthDsu, e1, e2); 61 | } 62 | 63 | cout << (numberOfSets(dsu, n) - 1 ); 64 | return 0; 65 | } -------------------------------------------------------------------------------- /3165 - Bicoloring/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #define MAX 1001 3 | 4 | using namespace std; 5 | 6 | int g[MAX][MAX], used[MAX], n, m; 7 | bool flag = false; 8 | 9 | void dfsMatrix(int v, int color) { 10 | // if graph is not bicolorable, no sence to continue dfs 11 | if (flag) { 12 | return; 13 | } 14 | 15 | // color the vertex v 16 | used[v] = color; 17 | 18 | for (int i = 1; i <= n; ++i) { 19 | if (g[v][i] == 1) { 20 | // if vertex i is not colored (not visited), 21 | // continue dfs from it. Color vertex i with 3 - color 22 | if (used[i] == 0) { 23 | dfsMatrix(i, 3 - color); 24 | } else if (used[v] == used[i]) { 25 | flag = true; 26 | } 27 | } 28 | } 29 | } 30 | 31 | // Week 11: November 29 - December 5 - DFS (Depth First Search) (bicolor) 32 | int main() { 33 | while (true) { 34 | cin >> n; 35 | 36 | if (n == 0) { 37 | break; 38 | } 39 | 40 | cin >> m; 41 | 42 | memset(g, 0, sizeof(g)); 43 | memset(used, 0, sizeof(used)); 44 | 45 | int a, b; 46 | for (int i = 1; i <= m; ++i) { 47 | cin >> a >> b; 48 | 49 | g[a][b] = 1; 50 | g[b][a] = 1; 51 | } 52 | 53 | flag = false; 54 | dfsMatrix(1, 1); 55 | 56 | cout << (flag ? "NOT BICOLOURABLE." : "BICOLOURABLE.") << endl; 57 | } 58 | 59 | return 0; 60 | } -------------------------------------------------------------------------------- /7452 - Print Linked List/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | class Node { 6 | 7 | public: 8 | int data; 9 | Node *next; 10 | Node() : next(NULL) {}; 11 | Node(int data, Node *next = NULL) : data(data), next(next) {}; 12 | }; 13 | 14 | class List { 15 | 16 | public: 17 | 18 | Node *head, *tail; 19 | 20 | List() : head(NULL), tail(NULL) {}; 21 | 22 | void addToTail(int val) { 23 | if (tail != NULL) // list is not empty 24 | { 25 | tail->next = new Node(val); 26 | tail = tail->next; 27 | } 28 | else head = tail = new Node(val); 29 | } 30 | 31 | void Print() { 32 | Node *head = this->head; 33 | while (head != NULL) 34 | { 35 | printf("%d ", head->data); 36 | head = head->next; 37 | } 38 | printf("\n"); 39 | } 40 | 41 | void PrintReverse() { 42 | ReversePrinter(this->head); 43 | } 44 | 45 | void ReversePrinter(Node *head) 46 | { 47 | if (head == NULL) 48 | return; 49 | 50 | ReversePrinter(head->next); 51 | 52 | cout << head->data << " "; 53 | } 54 | 55 | }; 56 | 57 | int main() { 58 | int n, temp; 59 | cin >> n; 60 | 61 | List l = List(); 62 | 63 | for (int i = 0; i < n; ++i) { 64 | cin >> temp; 65 | l.addToTail(temp); 66 | } 67 | 68 | l.Print(); 69 | l.PrintReverse(); 70 | 71 | return 0; 72 | } 73 | -------------------------------------------------------------------------------- /1302 - Almost Prime Numbers/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | //Almost Prime Numbers 9 | int main() { 10 | long long almostMax = 1e12; 11 | long long primesMax = 1e6; 12 | 13 | int primes[primesMax+1]; 14 | vector almost; 15 | 16 | // sieve of eratosthenes for generating primes 17 | for(int i = 0; i < primesMax; i++) { 18 | primes[i] = 1; 19 | } 20 | 21 | for(int i = 2; i < sqrt(primesMax); i++) { 22 | if (primes[i]) { 23 | for (int j = i * i; j <= primesMax; j += i) { 24 | primes[j] = 0; 25 | } 26 | } 27 | } 28 | // end of sieve of eratosthenes 29 | 30 | 31 | // Generating almost primes 32 | for (int i = 2; i <= primesMax; ++i) { 33 | if (primes[i]) { 34 | long long temp = i; 35 | while ((temp *= i) <= almostMax) { 36 | almost.push_back(temp); 37 | } 38 | } 39 | } 40 | 41 | // Sorting it for binary search 42 | sort(almost.begin(), almost.end()); 43 | 44 | 45 | // Main Part read data and output accordingly 46 | 47 | int n; 48 | long long a, b; 49 | cin >> n; 50 | 51 | while (n--) { 52 | cin >> a >> b; 53 | cout << upper_bound(almost.begin(), almost.end(), b) 54 | - upper_bound(almost.begin(), almost.end(), a-1) << endl; 55 | } 56 | 57 | return 0; 58 | } 59 | -------------------------------------------------------------------------------- /10236 - N Queens - placement/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | using namespace std; 4 | 5 | int mat[11][11]; 6 | int n; 7 | 8 | int attacked(int x, int y) { 9 | if (mat[x][y])return 1; 10 | 11 | for (int i = 1; i <= n; i++) { 12 | if (y - i >= 1 && mat[x][y - i]) return 1; 13 | if (y + i <= n && mat[x][y + i]) return 1; 14 | if (x - i >= 1 && mat[x - i][y]) return 1; 15 | if (x + i <= n && mat[x + i][y]) return 1; 16 | if (x - i >= 1 && y - i >= 1 && mat[x - i][y - i]) return 1; 17 | if (x + i <= n && y + i <= n && mat[x + i][y + i]) return 1; 18 | if (x + i <= n && y - i >= 1 && mat[x + i][y - i]) return 1; 19 | if (x - i >= 1 && y + i <= n && mat[x - i][y + i]) return 1; 20 | } 21 | return 0; 22 | } 23 | 24 | void print(void) { 25 | for (int i = 1; i <= n; i++) { 26 | for (int j = 1; j <= n; j++) 27 | printf("%d ", mat[i][j]); 28 | printf("\n"); 29 | } 30 | } 31 | 32 | int solve(int x) { 33 | if (x == 0) { 34 | print(); 35 | return 1; 36 | } 37 | for (int i = 1; i <= n; i++) { 38 | for (int j = 1; j <= n; j++) { 39 | if (attacked(i, j) == 1) continue; 40 | mat[i][j] = 1; 41 | if (solve(x - 1)) return 1; 42 | mat[i][j] = 0; 43 | } 44 | } 45 | return 0; 46 | } 47 | 48 | 49 | int main() { 50 | scanf("%d", &n); 51 | 52 | if (!solve(n)) { 53 | puts("Not possible"); 54 | } 55 | return 0; 56 | } 57 | -------------------------------------------------------------------------------- /3937 - Digital root (quiz2-1)/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | // 3937 - Digital root 6 | 7 | using namespace std; 8 | 9 | long long temp; 10 | vector arr; 11 | 12 | long long sum(long long num) { 13 | if (num < 10) { 14 | return num; 15 | } else { 16 | return sum(num / 10) + num % 10; 17 | } 18 | } 19 | 20 | long long digitalRoot(long long n) { 21 | while (n > 9) n = sum(n); 22 | return n; 23 | } 24 | 25 | long long comparator(long long a, long long b) { 26 | if (digitalRoot(a) == digitalRoot(b)) { 27 | return a < b; 28 | } 29 | 30 | return digitalRoot(a) < digitalRoot(b); 31 | } 32 | 33 | long long Partition(vector &m, long long L, long long R) { 34 | long long x = m[L]; 35 | long long i = L - 1, j = R + 1; 36 | while (true) { 37 | do j--; while (comparator(x, m[j])); 38 | do i++; while (comparator(m[i], x)); 39 | if (i < j) swap(m[i], m[j]); else return j; 40 | } 41 | } 42 | 43 | void QuickSort(vector &m, long long L, long long R) { 44 | if (L < R) { 45 | long long q = Partition(m, L, R); 46 | QuickSort(m, L, q); 47 | QuickSort(m, q + 1, R); 48 | } 49 | } 50 | 51 | int main() { 52 | while (cin >> temp) { 53 | arr.push_back(temp); 54 | } 55 | 56 | QuickSort(arr, 0, arr.size() - 1); 57 | 58 | for (long long i = 0; i < arr.size(); i++) { 59 | cout << arr[i] << " "; 60 | } 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /10235 - Ordering tasks/main.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Emin Alizade on 20.12.21. 3 | // 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | int main() { 12 | int n, m; 13 | 14 | while (cin >> n >> m) { 15 | if (n == 0 && m == 0) { 16 | break; 17 | } 18 | 19 | vector> g (n + 1); 20 | vector InDegree(n + 1, 0), topSort; 21 | queue q; 22 | 23 | int a, b; 24 | for (int i = 0; i < m; ++i) { 25 | cin >> a >> b; 26 | g[a].push_back(b); 27 | InDegree[b]++; 28 | } 29 | 30 | for (int i = 1; i < InDegree.size(); i++) { 31 | if (InDegree[i] == 0) { 32 | q.push(i); 33 | } 34 | } 35 | 36 | while (!q.empty()) 37 | { 38 | int v = q.front(); 39 | q.pop(); 40 | topSort.push_back(v); 41 | for (int i = 0; i < g[v].size(); i++) { 42 | int to = g[v][i]; 43 | InDegree[to]--; 44 | if (InDegree[to] == 0) { 45 | q.push(to); 46 | } 47 | } 48 | } 49 | 50 | if (topSort.size() < n) { 51 | cout << -1; 52 | } 53 | else { 54 | for (int i = 0; i < topSort.size(); i++) { 55 | cout << topSort[i] << " "; 56 | } 57 | } 58 | 59 | cout << endl; 60 | } 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /1540 - 23 out of 5/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | int a[5]; 7 | 8 | // TODO review the code 9 | 10 | 11 | bool RunSum(int Sum, int index) { 12 | if (index == 5) { 13 | if (Sum == 23) { 14 | return true; 15 | } else { 16 | return false; 17 | } 18 | } 19 | 20 | if (RunSum(Sum + a[index], index + 1)) { 21 | return true; 22 | } 23 | 24 | if (RunSum(Sum - a[index], index + 1)) { 25 | return true; 26 | } 27 | 28 | if (RunSum(Sum * a[index], index + 1)) { 29 | return true; 30 | } 31 | return false; 32 | } 33 | 34 | int main() { 35 | 36 | while (true) { 37 | for (int i = 0; i < 5; ++i) { 38 | cin >> a[i]; 39 | } 40 | 41 | bool allZeroes = true; 42 | 43 | for (int i = 0; i < 5; ++i) { 44 | if (a[i] != 0) { 45 | allZeroes = false; 46 | } 47 | } 48 | 49 | if (allZeroes) { 50 | break; 51 | } 52 | 53 | bool flag; 54 | sort(a,a+5); 55 | 56 | do { 57 | flag = RunSum(a[0],1); 58 | 59 | if (flag) { 60 | break; 61 | } 62 | } while(next_permutation(a,a+5)); 63 | 64 | if (flag) { 65 | printf("Possible\n"); 66 | } 67 | else { 68 | printf("Impossible\n"); 69 | } 70 | 71 | memset(a,0,sizeof(a)); 72 | } 73 | return 0; 74 | } 75 | -------------------------------------------------------------------------------- /2967 - Unification Day/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #define MAX 5001 8 | #define INF 0x3F3F3F3F 9 | using namespace std; 10 | 11 | int x[MAX], y[MAX]; 12 | int used[MAX], dist[MAX]; 13 | 14 | int dist2(int i, int j) { 15 | return (x[j] - x[i]) * (x[j] - x[i]) + (y[j] - y[i]) * (y[j] - y[i]); 16 | } 17 | 18 | double Prim(int n) { 19 | memset(dist, 0x3F, sizeof(dist)); 20 | memset(used, 0, sizeof(used)); 21 | 22 | double res = 0; 23 | int cur = 0; 24 | dist[cur] = 0; 25 | used[cur] = 1; 26 | for (int i = 1; i < n; i++) { 27 | 28 | 29 | // Relaxation process 30 | for (int j = 0; j < n; j++) { 31 | if (!used[j] && (dist2(cur, j) < dist[j])) { 32 | dist[j] = dist2(cur, j); 33 | } 34 | } 35 | 36 | // choosing vertex with minimum distance from current 37 | int min = INF; 38 | for (int j = 0; j < n; j++) { 39 | if (!used[j] && (dist[j] < min)) { 40 | min = dist[j]; 41 | cur = j; 42 | } 43 | } 44 | 45 | used[cur] = 1; 46 | res += sqrt(dist[cur]); 47 | } 48 | 49 | return res; 50 | } 51 | 52 | //Week 8 - November 12 (prim algorithm) 53 | int main() { 54 | int n; 55 | cin >> n; 56 | 57 | for (int i = 0; i < n; i++) { 58 | cin >> x[i] >> y[i]; 59 | } 60 | 61 | double res = Prim(n); 62 | 63 | cout << res; 64 | return 0; 65 | } -------------------------------------------------------------------------------- /4019 - Turtle restoring/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | int main() { 8 | int n, m; 9 | vector> path; 10 | 11 | cin >> n >> m; 12 | 13 | 14 | int dp[n+1][m+1]; 15 | 16 | for (int i = 1; i <= n; ++i) { 17 | for (int j = 1; j <= m; ++j) { 18 | cin >> dp[i][j]; 19 | } 20 | } 21 | 22 | for (int i = 1; i <= n; ++i) { 23 | for (int j = 1; j <= m; ++j) { 24 | if (i == 1 && j == 1) { 25 | continue; 26 | } 27 | 28 | if (i == 1) { 29 | dp[i][j] += dp[i][j-1]; 30 | continue; 31 | } 32 | 33 | if (j == 1) { 34 | dp[i][j] += dp[i-1][j]; 35 | continue; 36 | } 37 | 38 | dp[i][j] += min(dp[i][j-1], dp[i-1][j]); 39 | } 40 | } 41 | 42 | cout << dp[n][m] << endl; 43 | 44 | int i = n, j = m; 45 | 46 | while (i >= 1 && j >= 1) { 47 | path.push_back(make_pair(i, j)); 48 | 49 | if (i == 1) { 50 | j--; 51 | } else if (j == 1) { 52 | i--; 53 | } else if (dp[i-1][j] < dp[i][j-1]) { 54 | i--; 55 | } else { 56 | j--; 57 | } 58 | } 59 | 60 | reverse(path.begin(), path.end()); 61 | 62 | for (i = 0; i < path.size(); i++) { 63 | cout << path[i].first << " " << path[i].second << endl; 64 | } 65 | 66 | return 0; 67 | } -------------------------------------------------------------------------------- /8304 - Fun function/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace std; 5 | 6 | map values; 7 | 8 | // Solution here is to cache values that we have found and simplify the right part function 9 | 10 | int funFuction(int x, int y) { 11 | if (x<=0 || y<=0) { 12 | return 0; 13 | } else if (x <= y) { 14 | int leftPart, rightPart; 15 | string left = to_string(x-1) + "," + to_string(y-2); 16 | string right = to_string(x-2) + "," + to_string(y-1); 17 | 18 | if (values.find(left) == values.end()) { 19 | leftPart = funFuction(x - 1, y - 2); 20 | 21 | values.insert(pair(left, leftPart)); 22 | } else { 23 | leftPart = values.find(left)->second; 24 | } 25 | 26 | if (values.find(right) == values.end()) { 27 | rightPart = funFuction(x-2, y-1); 28 | values.insert(pair(right, rightPart)); 29 | } else { 30 | rightPart = values.find(right)->second; 31 | } 32 | 33 | return leftPart + rightPart + 2; 34 | } else { 35 | // x>y contidion; 36 | 37 | // if x > y and function is there to return f(x-2, y-2) it will always stay x>y so we can simplify 38 | if (y % 2 == 0) { 39 | return y/2; 40 | } else { 41 | return y/2 + 1; 42 | } 43 | } 44 | } 45 | 46 | int main() { 47 | int x,y; 48 | 49 | cin >> x >> y; 50 | 51 | cout << funFuction(x, y); 52 | 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /1943 - Bridges/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | vector> > graph; 8 | vector used, d, up; 9 | int i, n, m, a, b, tm; 10 | set Bridges; 11 | set::iterator iter; 12 | 13 | void dfs (int v, int p = -1) // NOLINT(misc-no-recursion) 14 | { 15 | int i, to; 16 | used[v] = 1; 17 | d[v] = up[v] = tm++; 18 | for (i = 0; i < graph[v].size(); i++) 19 | { 20 | to = graph[v][i].first; 21 | if (to == p) continue; 22 | if (used[to]) { 23 | up[v] = min(up[v], d[to]); 24 | } 25 | else 26 | { 27 | dfs (to, v); 28 | up[v] = min (up[v], up[to]); 29 | if (up[to] > d[v]) { 30 | Bridges.insert(graph[v][i].second); 31 | } 32 | } 33 | } 34 | } 35 | 36 | int main() 37 | { 38 | scanf("%d %d",&n,&m); 39 | graph.resize(n+1); used.resize(n+1); 40 | d.resize(n+1); up.resize(n+1); 41 | 42 | for(i = 1; i <= m; i++) 43 | { 44 | scanf("%d %d",&a,&b); 45 | graph[a].push_back(make_pair(b, i)); 46 | graph[b].push_back(make_pair(a, i)); 47 | } 48 | 49 | tm = 1; 50 | for(i = 1; i <= n; i++) { 51 | if (!used[i]) { 52 | dfs(i); 53 | } 54 | } 55 | 56 | printf("%d\n",Bridges.size()); 57 | for(iter = Bridges.begin(); iter != Bridges.end(); iter++) { 58 | printf("%d ", *iter); 59 | } 60 | printf("\n"); 61 | 62 | return 0; 63 | } -------------------------------------------------------------------------------- /9035 - Class MinStack/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | using namespace std; 6 | 7 | int i, n; 8 | string str; 9 | 10 | class MyStack 11 | { 12 | private: 13 | stack s, mn; 14 | public: 15 | void push(int x) 16 | { 17 | s.push(x); 18 | if (mn.empty()) mn.push(x); 19 | else mn.push(min(mn.top(), x)); 20 | } 21 | 22 | int pop(void) 23 | { 24 | int temp = s.top(); 25 | s.pop(); 26 | mn.pop(); 27 | return temp; 28 | } 29 | 30 | int top(void) 31 | { 32 | return s.top(); 33 | } 34 | 35 | int GetMin(void) 36 | { 37 | return mn.top(); 38 | } 39 | 40 | int GetSize(void) 41 | { 42 | return s.size(); 43 | } 44 | }; 45 | 46 | int main(void) 47 | { 48 | MyStack s; 49 | while (cin >> str) 50 | { 51 | if (str == "push") 52 | { 53 | cin >> n; 54 | s.push(n); 55 | } 56 | else 57 | if (str == "pop") 58 | { 59 | cout << s.top() << endl; 60 | s.pop(); 61 | } 62 | else 63 | if (str == "top") 64 | { 65 | cout << s.top() << endl; 66 | } 67 | else 68 | if (str == "size") 69 | { 70 | cout << s.GetSize() << endl; 71 | } 72 | else 73 | if (str == "GetMin") 74 | { 75 | cout << s.GetMin() << endl; 76 | } 77 | } 78 | return 0; 79 | } 80 | -------------------------------------------------------------------------------- /10946 - Nature(quiz4-2)/dfs.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | int n, m; 9 | map creatures; 10 | vector> g; 11 | vector used; 12 | int connectedComponentLength, maxx; 13 | 14 | void dfsEdgeList(int v) { // NOLINT(misc-no-recursion) 15 | used[v] = 1; 16 | connectedComponentLength++; 17 | 18 | for (int i = 0; i < g[v].size(); ++i) { 19 | int to = g[v][i]; 20 | 21 | if (used[to] == 0) { 22 | dfsEdgeList(to); 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | while (scanf("%d %d", &n, &m), n + m){ 29 | g = vector>(n, vector()); 30 | used = vector(n, 0); 31 | 32 | creatures.clear(); 33 | 34 | string t1, t2; 35 | for (int i = 0; i < n; ++i) { 36 | cin >> t1; 37 | creatures[t1] = i; 38 | } 39 | 40 | for (int i = 0; i < m; ++i) { 41 | cin >> t1 >> t2; 42 | int to = creatures[t1]; 43 | int from = creatures[t2]; 44 | 45 | g[from].push_back(to); 46 | g[to].push_back(from); 47 | } 48 | 49 | for (int i = 0; i < n; ++i) { 50 | if (used[i] == 0) { 51 | dfsEdgeList(i); 52 | maxx = max(maxx, connectedComponentLength); 53 | connectedComponentLength = 0; 54 | } 55 | } 56 | 57 | cout << maxx << endl; 58 | maxx = 0; 59 | } 60 | 61 | return 0; 62 | } --------------------------------------------------------------------------------