Init commit

Author: albogatov

Timus/1067.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <map>
+#include <algorithm>
+#include <vector>
+#include <sstream>
+
+using namespace std;
+
+class Directory {
+    
+    public: 
+    
+    map<string, Directory*> children;
+    
+    Directory() {
+        
+    }
+    
+    Directory* make_dir(string dir_name) {
+        if (children.find(dir_name) == children.end()) {
+            children[dir_name] = new Directory();
+        }
+        return children[dir_name];
+    }
+    
+    void display_hierarchy(string indentation, bool is_root) {
+        if(!is_root)
+            indentation += " ";
+        for (auto& child : children) {
+            cout << indentation << child.first << endl;
+            child.second->display_hierarchy(indentation, false);
+        }
+        
+    }
+    
+};
+
+int main()
+{
+    int n;
+    
+    cin >> n;
+        
+    Directory* root_dir = new Directory();
+    char separator = '\\';
+    Directory* current_dir;
+    
+    for (int i = 0; i < n; i++) {
+        string current;
+        vector<string> parsed_path;
+        
+        current_dir = root_dir;
+        cin >> current;
+        replace(current.begin(), current.end(), separator, ' ');
+        stringstream ss(current);
+        string tmp;
+        while (ss >> tmp)
+            parsed_path.push_back(tmp);
+            
+        for (string parsed_dir : parsed_path) {
+            current_dir = current_dir->make_dir(parsed_dir);
+        }
+    }
+    root_dir->display_hierarchy("", true);
+    delete current_dir;
+    delete root_dir;
+    return 0;
+}

Timus/1207.cpp

@@ -0,0 +1,110 @@
+#include <iostream>
+#include <cmath>
+#include <map>
+#include <algorithm>
+#define PI 3.1415926535897932384626433832795028841971693993751058
+
+using namespace std;
+
+
+void merge(double * a, double * aux, int l, int m, int r) {
+    int i = l;
+    int j = m + 1;
+    // for (int k = l; k <= r; ++k) {
+    //     aux[k] = a[k];
+        
+    // }
+    for (int k = l; k <= r; ++k) {
+        if (i > m) { 
+            a[k] = aux[j++]; 
+            continue; 
+        }
+        if (j > r) { 
+            a[k] = aux[i++];
+            continue; 
+        }
+        if (aux[j] < aux[i]) { 
+            a[k] = aux[j++];
+        }
+        else {
+            a[k] = aux[i++];
+        }
+    }
+}
+
+
+void merge_sort(double * a, double * aux, int l, int r) {
+    if (l < r) {
+        int m = (l + r) / 2;
+        merge_sort(aux, a, l, m);
+        merge_sort(aux, a, m + 1, r);
+        merge(a, aux, l, m, r);
+    }
+}
+
+void _sort(double* a, int N) {
+    double* aux = new double[N];
+    for (int k = 0; k < N; ++k)  {
+        aux[k] = a[k];
+    }
+    merge_sort(a, aux, 0, N-1);
+    delete[] aux;
+}
+
+int main()
+{
+    int n;
+    cin >> n;
+    int dots[n][2];
+    int min_x = 1000001;
+    int min_y = 1000001;
+    int min_dot_idx = -1;
+    int min_dot[1][2];
+    double atans[n];
+    double atans_copy[n];
+
+    for (int i = 0; i< n; i++) {
+        cin >> dots[i][0] >> dots[i][1];
+    }
+    
+    for (int i = 0; i < n; i++) {
+        if (dots[i][1] < min_y || dots[i][1] == min_y && dots[i][0] < min_x) {
+            min_dot_idx = i;
+            min_x = dots[i][0];
+            min_y = dots[i][1];
+        }
+    }
+    
+    min_dot[0][0] = dots[min_dot_idx][0];
+    min_dot[0][1] = dots[min_dot_idx][1];
+    
+    
+    for (int i = 0; i < n; i++) {
+        double current_atan;
+        if (dots[i][0] == min_dot[0][0]) 
+            current_atan = PI / 2; 
+        else if (dots[i][1] == min_dot[0][1]) 
+            current_atan = 0;
+
+        else current_atan = atan((double) (dots[i][1] - min_dot[0][1]) / (double) (dots[i][0] - min_dot[0][0]));
+        if (current_atan < 0) current_atan += 2 * PI;
+        atans[i] = current_atan;
+        atans_copy[i]=current_atan;
+    }
+    
+    swap(atans[n-1], atans[min_dot_idx]);
+
+    
+    _sort(atans, n-1);
+
+
+    cout << min_dot_idx + 1 << " ";
+    for(int i = 0; i < n; i++) {
+        if (atans_copy[i] == atans[(n-1)/2]) {
+            cout << i+1 << endl;
+            break;
+        }
+    }
+    
+    return 0;
+}

Timus/1296.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+ 
+using namespace std;
+ 
+int main()
+{   
+    int n;
+    cin >> n;
+    int sequence[n];
+    int currentSum = 0;
+    int maxSum = currentSum;
+    for (int i = 0; i < n; i++) {
+        cin >> sequence[i];
+    }
+    for (int i = 0; i < n; i++) {
+        currentSum += sequence[i];
+        if (currentSum <= 0)
+            currentSum = 0;
+        else if (currentSum > maxSum) maxSum = currentSum;
+    }
+    cout << maxSum << endl;
+    return 0;
+}

Timus/1450.cpp

@@ -0,0 +1,56 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+
+using namespace std;
+
+int min_dist = -2147483647;
+
+class Wire {
+    public:
+        int from, to, benefit;
+        
+        Wire(int from, int to, int benefit) {
+            this->from = from;
+            this->to = to;
+            this->benefit = benefit;
+        }
+        
+        Wire() {
+            
+        }
+};
+
+int main()
+{
+    int n,m,s,f;
+
+    cin >> n >> m;
+    
+    Wire* wire_array[m];
+    
+    for (int i = 0; i < m; i++) {
+            int a,b,c;
+            cin >> a >> b >> c;
+            wire_array[i] = new Wire(a,b,c);
+    }
+    
+    cin >> s >> f;
+    
+    vector<int> path_dijkstra(n+1, min_dist);
+    
+    path_dijkstra[s] = 0;
+    for (int i = 1; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            if (path_dijkstra[wire_array[j]->from] != min_dist && path_dijkstra[wire_array[j]->to] < wire_array[j]->benefit + path_dijkstra[wire_array[j]->from]) {
+                path_dijkstra[wire_array[j]->to] = path_dijkstra[wire_array[j]->from] + wire_array[j]->benefit;     
+            }
+        }
+    }
+    
+    if (path_dijkstra[f] > min_dist)
+        cout << path_dijkstra[f] << endl;
+    else cout << "No solution";
+    
+    return 0;
+}

Timus/1494.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int main()
+{
+    int n;
+    
+    cin >> n;
+    
+    int pulled[n];
+    
+    vector<int> rolled;
+    
+    for (int i = 0; i < n; i++) {
+        cin >> pulled[i];
+    }
+    
+    int max_pulled = 0;
+    
+    for (int i = 0; i < n; i++) {
+        if (pulled[i] > max_pulled) {
+            for (int j = max_pulled + 1; j < pulled[i]; j++)
+                rolled.push_back(j);
+            max_pulled = pulled[i];
+        } else {
+            if (pulled[i] == rolled.back()) {
+                rolled.pop_back();
+                continue;
+            }
+                
+            else {
+                cout << "Cheater" << endl;
+                return 0;
+            }
+        }
+    }
+
+    cout << "Not a proof" << endl;
+
+    return 0;
+}

Timus/1726.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+#include <cmath>
+#include <algorithm>
+
+using namespace std;
+
+int main()
+{
+    long long n;
+    cin >> n;
+    int x[n];
+    int y[n];
+    long long distance_walked = 0;
+    
+    for (long long  i = 0; i < n; i++) {
+        cin >> x[i] >> y[i];
+    }
+    
+    sort(x, x+n);
+    sort(y, y+n);
+    
+    for (long long  i = 1; i < n; i++) {
+        distance_walked += abs(x[i] - x[i-1] + y[i] - y[i-1]) * i * (n-i);
+    }
+    
+    cout << (distance_walked * 2)/(n*(n-1)) << endl;
+    
+    return 0;
+}