adding a few stuff

LiveArchive/CatVsDog.cpp

@@ -0,0 +1,162 @@
+#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;
+
+#ifdef ONLINE_JUDGE
+#define debug(args...)
+#else
+#define debug(args...) fprintf(stderr,args)
+#endif
+
+typedef long long Int;
+typedef unsigned long long uInt;
+typedef unsigned uint;
+
+const int MAXN = 1010;
+const int INF = 1011;
+
+int T;
+int C, D, N;
+string P[MAXN], Q[MAXN];
+vector<int> graph[MAXN];
+int color[MAXN];
+
+void dfs(int x, int c) {
+    color[x] = c;
+
+    for (int i = 0; i < (int) graph[x].size(); i++) {
+        if (color[graph[x][i]] == -1) {
+            dfs(graph[x][i], c ^ 1);
+        }
+    }
+}
+
+struct edge {
+    int to,rev;
+    Int 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, Int 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;
+}
+
+int max_flow(int s, int t) {
+    Int 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;
+        }
+    }
+}
+
+int main(void) {
+    cin >> T;
+
+    while (T--) {
+        cin >> C >> D >> N;
+
+        init(N + 2);
+
+        for (int i = 0; i < MAXN; i++) {
+            graph[i].clear();
+            color[i] = -1;
+        }
+
+        for (int i = 1; i <= N; i++) {
+            cin >> P[i] >> Q[i];
+
+            for (int j = 1; j < i; j++) {
+                if (P[i] == Q[j] || Q[i] == P[j]) {
+                    graph[i].push_back(j);
+                    graph[j].push_back(i);
+                }
+            }
+        }
+
+        for (int i = 1; i <= N; i++) {
+            if (color[i] == -1) {
+                dfs(i, 0);
+            }
+        }
+
+        for (int i = 1; i <= N; i++) {
+            if (color[i] == 0) {
+                add_edge(0, i, 1);
+
+                for (int j = 0; j < (int) graph[i].size(); j++) {
+                    add_edge(i, graph[i][j], 1);
+                }
+            } else {
+                add_edge(i, N + 1, 1);
+            }
+        }
+
+        cout << N - max_flow(0, N + 1) << "\n";
+    }
+    return 0;
+}

LiveArchive/i.in

@@ -0,0 +1,9 @@
+2
+1 1 2
+C1 D1
+D1 C1
+1 2 4
+C1 D1
+C1 D1
+C1 D2
+D2 C1

Notebook/src/Maximum Flow.cpp

@@ -1,5 +1,5 @@
 const int MAXN = 101010;
-const int INF = 101011;
+const int INF = 101;
 
 struct edge {
     int to,rev;
@@ -31,7 +31,7 @@ void bfs(int s) {
     while(!que.empty()) {
         int v = que.front();
         que.pop();
-        for (int i = 0; i < G[v].size(); i++) {
+        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;

SPOJPL/Alphacode.cpp

@@ -23,34 +23,34 @@ string S;
 Int dp[MAXN];
 
 Int func(int pos) {
-	if (pos >= S.size()) {
-		return 1LL;
-	} else if (S[pos] == '0') {
-		return 0LL;
-	} else {
-		Int& ans = dp[pos];
-
-		if (ans == -1) {
-			ans = 0;
+    if (pos >= (int) S.size()) {
+        return 1LL;
+    } else if (S[pos] == '0') {
+        return 0LL;
+    } else {
+        Int& ans = dp[pos];
+
+        if (ans == -1) {
+            ans = 0;
 
-			int curr = 0;
-
-			for ( ; pos < S.size(); ) {
-				curr = curr * 10 + (S[pos] - '0');
-				if (curr > 26) break;
-				ans += func(pos + 1);
-				pos++;
-			}
-		}
+            int curr = 0;
+
+            for ( ; pos < S.size(); ) {
+                curr = curr * 10 + (S[pos] - '0');
+                if (curr > 26) break;
+                ans += func(pos + 1);
+                pos++;
+            }
+        }
 
-		return ans;
-	}
+        return ans;
+    }
 }
 
 int main(void) {
-	while (cin >> S && S != "0") {
-		memset(dp, -1LL, sizeof(dp));
-		cout << func(0) << endl;
-	}
+    while (cin >> S && S != "0") {
+        memset(dp, -1LL, sizeof(dp));
+        cout << func(0) << endl;
+    }
     return 0;
 }

SPOJPL/BuyingApples.cpp

@@ -0,0 +1,72 @@
+#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;
+
+#ifdef ONLINE_JUDGE
+#define debug(args...)
+#else
+#define debug(args...) fprintf(stderr,args)
+#endif
+
+typedef long long Int;
+typedef unsigned long long uInt;
+typedef unsigned uint;
+
+const int MAXN = 110;
+const int INF = INT_MAX / 5;
+
+int T, N, K;
+int P[MAXN];
+int dp[MAXN][MAXN];
+
+int main(void) {
+    cin >> T;
+
+    while (T--) {
+        cin >> N >> K;
+
+        for (int i = 0; i < K; i++) {
+            cin >> P[i];
+        }
+
+        for (int i = 0; i < MAXN; i++) {
+            for (int j = 0; j < MAXN; j++) {
+                dp[i][j] = INF;                
+            }
+        }
+
+        int ans = INF;
+
+        dp[0][0] = 0;
+
+        for (int i = 1; i <= K; i++) {
+            for (int k = 0; k <= K; k++) {
+                for (int a = 0; a < K; a++) {
+                    if (k - (a + 1) < 0 || P[a] == -1) continue;
+                    dp[i][k] = min(dp[i][k], dp[i - 1][k - (a + 1)] + P[a]);
+                }
+                if (k == K) {
+                    ans = min(ans, dp[i][K]);
+                }
+            }
+        }
+
+        if (ans == INF) {
+            ans = -1;
+        }
+        cout << ans << "\n";
+    }
+    return 0;
+}

SPOJPL/i.in

@@ -1,6 +1,4 @@
-5
-2 3
-10 2
-0 1
-5 4
-1 10
+25114
+1111111111
+3333333333
+0