adding a few problems from winter school

Codeforces/Cards-364.cpp

@@ -0,0 +1,97 @@
+#include <bits/stdc++.h>
+
+template<typename T> T gcd(T a, T b) {
+    if(!b) return a;
+    return gcd(b, a % b);
+}
+template<typename T> T lcm(T a, T b) {
+    return a * b / gcd(a, b);
+}
+
+template<typename T> void chmin(T& a, T b) { a = (a > b) ? b : a; }
+template<typename T> void chmax(T& a, T b) { a = (a < b) ? b : a; }
+int in() { int x; scanf("%d", &x); return x; }
+
+using namespace std;
+
+typedef long long Int;
+typedef unsigned long long uInt;
+typedef unsigned uint;
+
+const int MAXN = 200;
+
+int N;
+int P[MAXN];
+bool used[MAXN];
+vector<int> graph[MAXN];
+vector<pair<int, int> > ans;
+
+bool bpm(int u, bool seen[], int matchR[]) {
+    for (int i = 0; i < (int) graph[u].size(); i++) {
+		int v = graph[u][i];
+
+        if (!seen[v]) {
+            seen[v] = true; 
+
+            if (matchR[v] < 0 || bpm(matchR[v], seen, matchR)) {
+                matchR[v] = u;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+int maxBPM() {
+    int matchR[MAXN];
+
+    memset(matchR, -1, sizeof(matchR));
+
+    int result = 0; 
+    for (int u = 0; u < N; u++) {
+        bool seen[MAXN];
+        memset(seen, 0, sizeof(seen));
+
+        if (bpm(u, seen, matchR)) {
+            result++;
+        }
+    }
+
+    for (int i = 0; i < N; i++) {
+        if (!used[i]) {
+            ans.push_back(make_pair(i + 1, matchR[i] + 1));
+            used[i] = used[matchR[i]] = true;
+        }
+    }
+    return result;
+}
+
+
+int main(void) {
+    cin >> N;
+
+    int all = 0;
+
+    for (int i = 0; i < N; i++) {
+        cin >> P[i];
+        all += P[i];
+    }
+
+    int each = all / (N / 2);
+
+
+    for (int i = 0; i < N; i++) {
+        for (int j = 0 ; j < N; j++) {
+            if (i != j && P[i] + P[j] == each) {
+                graph[i].push_back(j);
+            }
+        }
+    }
+
+    maxBPM();
+
+    for (int i = 0; i < (int) ans.size(); i++) {
+        cout << ans[i].first << " " << ans[i].second << "\n";        
+    }
+    return 0;    
+}

Codeforces/CellsNotUnderAttack.cpp

@@ -0,0 +1,51 @@
+#include <bits/stdc++.h>
+
+template<typename T> T gcd(T a, T b) {
+    if(!b) return a;
+    return gcd(b, a % b);
+}
+template<typename T> T lcm(T a, T b) {
+    return a * b / gcd(a, b);
+}
+
+template<typename T> void chmin(T& a, T b) { a = (a > b) ? b : a; }
+template<typename T> void chmax(T& a, T b) { a = (a < b) ? b : a; }
+int in() { int x; scanf("%d", &x); return x; }
+
+using namespace std;
+
+typedef long long Int;
+typedef unsigned long long uInt;
+typedef unsigned uint;
+
+const int MAXN = 100005;
+
+Int N, M;
+Int R[MAXN], C[MAXN];
+
+int main(void) {
+    cin >> N >> M;
+
+    Int ans = 0;
+    Int AR = 0;
+    Int AC = 0;
+
+    for (int i = 0; i < M; i++) {
+        int A, B;
+        cin >> A >> B;
+
+        if (!R[A]) {
+            ans += (N - AC);
+            AR += 1;
+        }
+        if (!C[B]) {
+            ans += (N - AR);
+            AC += 1;
+        }
+        R[A] = C[B] = 1;
+
+        cout << N * N - ans<< "\n";
+    }
+
+    return 0;
+}

Codeforces/DeliveryBears.cpp

@@ -0,0 +1,147 @@
+#include <bits/stdc++.h>
+
+template<typename T> T gcd(T a, T b) {
+    if(!b) return a;
+    return gcd(b, a % b);
+}
+template<typename T> T lcm(T a, T b) {
+    return a * b / gcd(a, b);
+}
+
+template<typename T> void chmin(T& a, T b) { a = (a > b) ? b : a; }
+template<typename T> void chmax(T& a, T b) { a = (a < b) ? b : a; }
+int in() { int x; scanf("%d", &x); return x; }
+
+using namespace std;
+
+typedef long long Int;
+typedef unsigned long long uInt;
+typedef unsigned uint;
+
+const int MAXN = 510;
+const int INF = 1001;
+
+int N, M, K;
+vector<int> paths;
+int A[MAXN], B[MAXN], C[MAXN];
+
+struct edge {
+    int to,rev;    
+    double cap;
+    edge(int to, Int cap, int rev): to(to), cap(cap), rev(rev) {}
+};
+
+vector<edge> G[MAXN];
+Int level[MAXN];
+int iter[MAXN];
+
+void init(int N) {
+    for (int i = 0; i < N; i++) {
+        G[i].clear();
+    }
+}
+
+void add_edge(int from,int to,Int cap) {
+    G[from].push_back(edge(to, cap, G[to].size()));
+    G[to].push_back(edge(from, 0, G[from].size()-1));
+}
+
+void bfs(int s) {
+    memset(level, -1, sizeof(level));
+    queue<int> que;
+    level[s] = 0;
+    que.push(s);
+
+    while(!que.empty()) {
+        int v = que.front();
+        que.pop();
+        for (int i = 0; i < (int) G[v].size(); i++) {
+            edge& e = G[v][i];
+            if(e.cap > 0 && level[e.to] < 0) {
+                level[e.to] = level[v] + 1;
+                que.push(e.to);
+            }
+        }
+    }
+}
+
+Int dfs(int v, int t, double f) {
+    if(v == t) return f;
+    for(int& i = iter[v]; i < (int) G[v].size(); i++) {
+        edge &e = G[v][i];
+        if(e.cap > 0 && level[v] < level[e.to]) {
+            Int d = dfs(e.to, t, min(f, e.cap));
+            if (d > 0) {
+                e.cap -= d;
+                G[e.to][e.rev].cap += d;
+                return d;
+            }
+        }
+    }
+    return 0;
+}
+
+double max_flow(int s, int t) {
+    double flow = 0;
+    for( ; ; ) {
+        bfs(s);
+        if (level[t] < 0) {
+            return flow;
+        }
+        memset(iter, 0, sizeof(iter));
+        int f;
+        while ((f=dfs(s,t,INF*INF)) > 0) {
+            flow += f;
+        }
+    }
+}
+
+double func(int pos, double carry, int used) {
+    if (pos == (int) paths.size()) {
+        return carry;
+    } else if (used == 0) {
+        return -INF;
+    } else {
+        double ans = -1000;
+
+        for (int i = used; i >= 1; i--) {
+            if (used - i >= (int) paths.size() - pos + 1) {
+                ans = max(ans, func(pos + 1, min(carry, paths[pos] / (double) i), used - i));
+            }
+        }
+
+        return ans;
+    }
+}
+
+int main(void) {
+    cin >> N >> M >> K;
+
+    init(N + 1);
+
+    for (int i = 0; i < M; i++) {
+        cin >> A[i] >> B[i] >> C[i];
+    }
+
+    double l = 0.0, h = 100000000000000.0;
+
+    for (int x = 0; x < 100; x++) {
+        double m = (l + h) / 2;
+
+        init(N + 1);
+
+        for (int i = 0; i < M; i++) {
+            add_edge(A[i], B[i], C[i] / m);
+        }
+
+        if (max_flow(1, N) < K) {
+            h = m;
+        } else {
+            l = m;
+        }
+    }
+
+    cout << fixed << setprecision(12) << l * K << endl;
+
+    return 0;
+}