Solved alot of problems :3

Author: AliOsm

CodeForces Gyms/2013 USP Try-outs/B. Spy Duel.cpp

@@ -1,3 +1,18 @@
+/*
+  Idea:
+    - Precalculate the probability of getting damage `d`
+      from each attack, this can be done by calculating
+      the probability using brute force.
+    - Then using dynamic programming we can calculate the
+      probability of `A` to win.
+    - dp[rema][remb][p] represents:
+      - rema: the remaining health of `A`
+      - remb: the remaining health of `B`
+      - p: the current player
+    - In each turn in the dp we try all attacks using
+      all possible damages.
+*/
+
 #include <bits/stdc++.h>
 
 using namespace std;

CodeForces Gyms/2016-2017 ACM-ICPC, South Pacific Regional Contest (SPPC 16)/D. Dendroctonus.cpp

@@ -0,0 +1,150 @@
+/*
+  Idea:
+    - If there is less than two `I` points the answer is
+      `No`.
+    - Otherwise, for each two points check if the answer
+      can be created from them, if the answer does not exist
+      using only two points, add third point two the two points
+      and check if the answer exist.
+    - The center of the circle created from two points
+      is the mid point between them.
+    - The center of the circle created from three points
+      is the circumcentre of them.
+*/
+
+#include <bits/stdc++.h>
+
+using namespace std;
+
+struct point {
+  double x, y;
+  bool t;
+  point() {}
+  point(double x, double y, char c) : x(x), y(y) {
+    if(c == 'I')
+      t = 0;
+    else
+      t = 1;
+  }
+};
+
+int const N = 1e2 + 1;
+int n;
+point p[N];
+
+double dist(point a, point b) {
+  return sqrt(pow(a.x - b.x, 2) + pow(a.y - b.y, 2));
+}
+
+void lineFromPoints(point P, point Q, double &a,
+                        double &b, double &c) {
+    a = Q.y - P.y;
+    b = P.x - Q.x;
+    c = a*(P.x)+ b*(P.y);
+}
+
+void perpendicularBisectorFromLine(point P, point Q,
+                 double &a, double &b, double &c) {
+  point mid_point = point((P.x + Q.x)/2,
+                          (P.y + Q.y)/2, 'I');
+
+  c = -b*(mid_point.x) + a*(mid_point.y);
+
+  double temp = a;
+  a = -b;
+  b = temp;
+} 
+
+point lineLineIntersection(double a1, double b1, double c1, 
+                         double a2, double b2, double c2) {
+  double determinant = a1*b2 - a2*b1;
+  if(determinant == 0)
+      return point(FLT_MAX, FLT_MAX, 'I');
+  else {
+    double x = (b2*c1 - b1*c2)/determinant;
+    double y = (a1*c2 - a2*c1)/determinant;
+    return point(x, y, 'I');
+  }
+}
+
+point findCircumCenter(point P, point Q, point R) {
+  double a, b, c;
+  lineFromPoints(P, Q, a, b, c);
+  
+  double e, f, g;
+  lineFromPoints(Q, R, e, f, g);
+  
+  perpendicularBisectorFromLine(P, Q, a, b, c);
+  perpendicularBisectorFromLine(Q, R, e, f, g);
+  
+  point circumcenter = lineLineIntersection(a, b, c, e, f, g);
+  
+  return circumcenter;
+}
+
+bool solve(point c, double r) {
+  bool ok = true;
+  for(int k = 0; k < n; ++k) {
+    if(p[k].t == 0 && dist(c, p[k]) - 1e-9 > r) {
+      ok = false;
+      break;
+    }
+
+    if(p[k].t == 1 && dist(c, p[k]) + 1e-9 <= r) {
+      ok = false;
+      break;
+    }
+  }
+
+  return ok;
+}
+
+int main() {
+#ifndef ONLINE_JUDGE
+  freopen("in", "r", stdin);
+#endif
+
+  scanf("%d", &n);
+  int I, N;
+  I = N = 0;
+  for(int i = 0, x, y; i < n; ++i) {
+    char c;
+    scanf("%d %d %c", &x, &y, &c);
+    p[i] = point(x, y, c);
+    I += c == 'I';
+    N += c == 'N';
+  }
+
+  if(I <= 1) {
+    puts("No");
+    return 0;
+  }
+
+  for(int i = 0; i < n; ++i) {
+    for(int j = i + 1; j < n; ++j) {
+      point c;
+      c.x = (p[i].x + p[j].x) / 2.0;
+      c.y = (p[i].y + p[j].y) / 2.0;
+      double r = dist(p[i], c);
+
+      if(solve(c, r)) {
+        puts("No");
+        return 0;
+      }
+
+      for(int k = j + 1; k < n; ++k) {
+        point c = findCircumCenter(p[i], p[j], p[k]);
+        double r = dist(p[i], c);
+
+        if(solve(c, r)) {
+          puts("No");
+          return 0;
+        }
+      }
+    }
+  }
+
+  puts("Yes");
+
+  return 0;
+}

CodeForces/1043A. Elections.cpp

@@ -0,0 +1,27 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 101;
+int n, a[N];
+
+int main() {
+  int mx = -1, t = 0;
+  scanf("%d", &n);
+  for(int i = 0; i < n; ++i)
+    scanf("%d", a + i), t += a[i], mx = max(mx, a[i]);
+
+  for(int i = mx; i < 10000; ++i) {
+    int cur = 0;
+    for(int j = 0; j < n; ++j) {
+      cur += i - a[j];
+    }
+
+    if(cur > t) {
+      printf("%d\n", i);
+      return 0;
+    }
+  }
+
+  return 0;
+}

CodeForces/1043B. Lost Array.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 1001;
+int n, a[N], x[N];
+
+int main() {
+  scanf("%d", &n);
+  for(int i = 1; i <= n; ++i)
+    scanf("%d", a + i);
+
+  vector<int> sol;
+  for(int i = 1; i <= n; ++i) {
+    x[i - 1] = a[i] - a[i - 1];
+    bool ok = true;
+    for(int j = 1, cnt = 0; j <= n; ++j, ++cnt) {
+      if(x[cnt % i] + a[j - 1] != a[j]) {
+        ok = false;
+        break;
+      }
+    }
+    if(ok)
+      sol.push_back(i);
+  }
+
+  printf("%d\n", int(sol.size()));
+  for(int i = 0; i < sol.size(); ++i)
+    printf("%d ", sol[i]);
+
+  return 0;
+}

CodeForces/1043C. Smallest Word.cpp

@@ -0,0 +1,34 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+string s, tmp;
+vector<int> sol;
+
+int main() {
+  cin >> s;
+
+  for(int i = 0; i < s.length(); ++i) {
+    if(i + 1 < s.length() && s[i] == 'b' && s[i + 1] == 'a') {
+      reverse(s.begin(), s.begin() + i);
+      sol.push_back(i);
+      continue;
+    }
+
+    if(i + 1 < s.length() && s[i] == 'a' && s[i + 1] == 'b' ||
+      i == s.length() - 1 && s[i] == 'a') {
+      reverse(s.begin(), s.begin() + i);
+      sol.push_back(i);
+    }
+  }
+
+  for(int i = 0; i < s.length(); ++i) {
+    if(binary_search(sol.begin(), sol.end(), i))
+      printf("1 ");
+    else
+      printf("0 ");
+  }
+  puts("");
+
+  return 0;
+}

CodeForces/1043D. Mysterious Crime.cpp

@@ -0,0 +1,83 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 1e5 + 1, M = 1e9 + 9;
+int n, m, a[N][10], p, idxs[N][10];
+long long hash_value[N][10], p_pow[N], ip_pow[N];
+
+long long fst(long long b, long long p) {
+  if(p == 0)
+    return 1;
+  if(p == 1)
+    return b;
+
+  long long ret = fst(b, p >> 1) % M;
+  ret = ret * ret % M;
+
+  if(p & 1)
+    ret = ret * b % M;
+
+  return ret;
+}
+
+void compute_hash(int idx) {
+  hash_value[1][idx] = (1ll * a[1][idx] * p_pow[1]) % M;
+  for(int i = 2; i <= n; ++i)
+    hash_value[i][idx] = (hash_value[i - 1][idx] + (1ll * a[i][idx] * p_pow[i]) % M) % M;
+}
+
+bool can(int mid, int v) {
+  if(idxs[v][0] + mid - 1 > n)
+    return false;
+  long long cur = (1ll * (((hash_value[idxs[v][0] + mid - 1][0] - hash_value[idxs[v][0] - 1][0]) + M) % M) * ip_pow[idxs[v][0]]) % M;
+  for(int i = 0; i < m; ++i) {
+    if(idxs[v][i] + mid - 1 > n)
+      return false;
+    if((1ll * (((hash_value[idxs[v][i] + mid - 1][i] - hash_value[idxs[v][i] - 1][i]) + M) % M) * ip_pow[idxs[v][i]]) % M != cur)
+      return false;
+  }
+  return true;
+}
+
+int calc(int v) {
+  int ret = 0, l, r, mid, res;
+
+  l = 1, r = N, mid, res = 0;
+  while(l <= r) {
+    mid = (l + r) >> 1;
+    if(can(mid, v))
+      res = mid, l = mid + 1;
+    else
+      r = mid - 1;
+  }
+  ret += res;
+
+  return ret;
+}
+
+int main() {
+  p = 100003;
+  p_pow[1] = ip_pow[1] = 1;
+  for(int i = 2; i < N; ++i) {
+    p_pow[i] = (1ll * p_pow[i - 1] * p) % M;
+    ip_pow[i] = fst(p_pow[i], M - 2);
+  }
+
+  scanf("%d %d", &n, &m);
+  for(int i = 0; i < m; ++i) {
+    for(int j = 1; j <= n; ++j) {
+      scanf("%d", &a[j][i]);
+      idxs[a[j][i]][i] = j;
+    }
+    compute_hash(i);
+  }
+
+  long long res = 0;
+  for(int i = 1; i <= n; ++i)
+    res += calc(i);
+
+  printf("%lld\n", res);
+
+  return 0;
+}

CodeForces/1077A. Frog Jumping.cpp

@@ -0,0 +1,20 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int t, a, b, k;
+
+int main() {
+  scanf("%d", &t);
+  while(t-- != 0) {
+    scanf("%d %d %d", &a, &b, &k);
+
+    int aa = (k + 1) / 2;
+    int bb = k / 2;
+
+    long long res = 1ll * a * aa - 1ll * b * bb;
+    printf("%lld\n", res);
+  }
+
+  return 0;
+}

CodeForces/1077B. Disturbed People.cpp

@@ -0,0 +1,21 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+int const N = 1e2 + 1;
+int n, a[N];
+
+int main() {
+  scanf("%d", &n);
+  for(int i = 0; i < n; ++i)
+    scanf("%d", a + i);
+
+  int res = 0;
+  for(int i = 1; i < n - 1; ++i)
+    if(a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1)
+      a[i + 1] = 0, ++res;
+
+  printf("%d\n", res);
+
+  return 0;
+}