Add exam tasks for 2019

2019/max3sum.cpp

+#include <cstdio>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int main() {
+  int N;
+  scanf("%d", &N);
+  vector<int> a(N), b(N), c(N);
+  for (int i = 0; i < N; ++i) scanf("%d", &a[i]);
+  for (int i = 0; i < N; ++i) scanf("%d", &b[i]);
+  for (int i = 0; i < N; ++i) scanf("%d", &c[i]);
+  int best = -1, best_a = -1, best_ab = -1;
+  for (int i = 0; i < N-2; ++i) {
+    best_a = max(best_a, a[i]);
+    best_ab = max(best_ab, best_a + b[i+1]);
+    best = max(best, best_ab + c[i+2]);
+  }
+  printf("%d\n", best);
+}

2019/mulsum.cpp

+#include <cstdio>
+#include <vector>
+#include <algorithm>
+
+using namespace std;
+
+int main() {
+  int N, M;
+  scanf("%d %d", &N, &M);
+  vector<int> r(M);
+  r[0] = 0;
+  for (int i = 1; i < M; ++i) r[i] = -1;
+
+  int sum = 0, best = 0;
+  for (int i = 0; i < N; ++i) {
+    int x;
+    scanf("%d", &x);
+    sum += x;
+    int prv = r[sum % M];
+    if (prv >= 0) best = max(sum-prv, best); else r[sum % M] = sum;
+  }
+  printf("%d\n", best);
+}

2019/parallel.cpp

+#include <cstdio>
+#include <vector>
+#include <algorithm>
+
+#define X first
+#define Y second
+#define mp make_pair
+
+#define MAXN 100100
+
+using namespace std;
+
+typedef pair< int, int > pii;
+
+int dp[MAXN + 1][2];
+pii rect[MAXN + 1];
+
+int main() {
+  int N, u, v;
+  scanf("%d", &N);
+  for(int i = 1; i <= N; i++) {
+    scanf("%d%d", &u, &v);
+    rect[i] = mp(u, v);
+  }
+  dp[1][0] = rect[1].X;
+  dp[1][1] = rect[1].Y;
+  for(int i = 2; i <= N; i++) {
+    dp[i][0] = rect[i].X + max(
+        dp[i - 1][0] + abs(rect[i].Y - rect[i - 1].Y),
+        dp[i - 1][1] + abs(rect[i - 1].X - rect[i].Y)
+    );
+    dp[i][1] = rect[i].Y + max(
+        dp[i - 1][0] + abs(rect[i - 1].Y - rect[i].X),
+        dp[i - 1][1] + abs(rect[i - 1].X - rect[i].X)
+    );
+  }
+  printf("%d\n", max(dp[N][0], dp[N][1]));
+}

2019/rootit.cpp

+#include <cstdio>
+#include <algorithm>
+#include <queue>
+#include <vector>
+
+#define MAXN 100100
+#define LOG 17
+
+using namespace std;
+
+typedef long long ll;
+
+ll sum[MAXN + 1][LOG + 1], par[MAXN + 1][LOG + 1], S[MAXN + 1];
+int depth[MAXN + 1], p[MAXN + 1], root;
+ll label[MAXN + 1];
+vector<int> graph[MAXN + 1];
+
+void dfs(int s, int par, int d, vector<bool> &visited) {
+  depth[s] = d;
+  S[s] = label[s];
+  visited[s] = true;
+  p[s] = par;
+  for (int i = 0; i < graph[s].size(); i++) {
+    int v = graph[s][i];
+    if (!visited[v]) {
+      dfs(v, s, d + 1, visited);
+      S[s] += S[v];
+    }
+  }
+}
+
+void init(int N) {
+  for (int i = 2; i <= N; i++) {
+    par[i][0] = p[i];
+    sum[i][0] = S[p[i]] - S[i];
+    for (int j = 1; 1 << j <= N; j++) {
+      par[i][j] = -1;
+      sum[i][j] = 0;
+    }
+  }
+  par[root][0] = -1;
+  sum[root][0] = 0;
+  for (int j = 1; 1 << j <= N; j++) {
+    for (int i = 1; i <= N; i++) {
+      par[i][j] = par[par[i][j - 1]][j - 1];
+      sum[i][j] = sum[i][j - 1] + sum[par[i][j - 1]][j - 1];
+    }
+  }
+}
+
+ll query(int u) {
+  int lg = 0, R = root;
+  if (R == u) return S[1];
+  ll val = S[R];
+  while (1 << lg <= depth[R]) lg++;
+  lg--;
+  for (int i = lg; i >= 0; i--) {
+    if (depth[R] - (1 << i) > depth[u]) {
+      val += sum[R][i];
+      R = par[R][i];
+    }
+  }
+  if (p[R] != u) return S[u];
+  return S[1] - val;
+}
+
+int main() {
+  int N, Q, s, u, v;
+  scanf("%d%d", &N, &Q);
+  for (int i = 1; i <= N; i++)
+    scanf("%lld", &label[i]);
+  root = 1;
+  p[root] = -1;
+  for (int i = 2; i <= N; i++) {
+    scanf("%d%d", &u, &v);
+    graph[u].push_back(v);
+    graph[v].push_back(u);
+  }
+  vector<bool> visited(N + 1, false);
+  dfs(1, -1, 0, visited);
+  init(N);
+  while (Q--) {
+    scanf("\n");
+    char c;
+    c = getchar();
+    scanf("%d", &s);
+    if (c == 'R') {
+      root = s;
+    } else {
+      printf("%lld\n", query(s));
+    }
+  }
+}

2019/treecity.cpp

+#include <cstdio>
+#include <algorithm>
+#include <vector>
+
+#define MAXN 501000
+#define INF 123456789012345LL
+
+#define X first
+#define Y second
+#define mp make_pair
+#define pb push_back
+
+using namespace std;
+
+typedef long long ll;
+typedef pair<int, int> pii;
+
+int N, label[MAXN + 1], sub_black[MAXN + 1], black;
+
+vector<pii> T[MAXN + 1];
+
+ll total, ans = INF;
+
+void dfs_precomp(int u, int p, ll dist) {
+  if (label[u]) total += dist;
+  sub_black[u] = label[u];
+  for (auto e : T[u]) {
+    int v = e.X, w = e.Y;
+    if (v == p) continue;
+    dfs_precomp(v, u, dist + (ll) w);
+    sub_black[u] += sub_black[v];
+  }
+}
+
+void dfs_solve(int u, int p, ll cur_dist) {
+  ans = min(ans, cur_dist);
+  for (auto e : T[u]) {
+    int v = e.X;
+    ll w = e.Y;
+    if (v == p) continue;
+    int down_count = sub_black[v], up_count = black - sub_black[v];
+    ll new_dist = cur_dist - (ll) down_count * w + (ll) up_count * w;
+    dfs_solve(v, u, new_dist);
+  }
+}
+
+int main() {
+  scanf("%d", &N);
+  for (int i = 1; i <= N; i++) {
+    scanf("%d", &label[i]);
+    black += label[i];
+  }
+  for (int i = 1; i < N; i++) {
+    int u, v, w;
+    scanf("%d%d%d", &u, &v, &w);
+    T[u].pb(mp(v, w));
+    T[v].pb(mp(u , w));
+  }
+  dfs_precomp(1, -1, 0);
+  dfs_solve(1, -1, total);
+  printf("%lld\n", ans);
+}

2019/vacation.cpp

+#include <cstdio>
+#include <algorithm>
+#include <vector>
+#include <set>
+
+#define MAXN 5100
+#define INF 1234567890
+#define INFLL 12345678901234567LL
+
+#define X first
+#define Y second
+#define mp make_pair
+#define pb push_back
+
+using namespace std;
+
+typedef pair<int, int> pii;
+typedef long long ll;
+
+int N, B, S, R, dist[MAXN + 1][2];
+
+vector<pii> G[MAXN + 1][2];
+
+ll A[MAXN + 1], dp[MAXN + 1][2];
+
+void dijkstra(int s, int id) {
+  set<pii> S;
+  for (int i = 1; i <= N; i++) dist[i][id] = INF;
+  dist[s][id] = 0;
+  S.insert(mp(0, s));
+  while (!S.empty()) {
+    pii A = *S.begin();
+    S.erase(S.begin());
+    int u = A.Y, d = A.X;
+    for (int i = 0; i < G[u][id].size(); i++) {
+      int v = G[u][id][i].Y, w = G[u][id][i].X;
+      if (d + w < dist[v][id]) {
+        dist[v][id] = d + w;
+        S.insert(mp(d + w, v));
+      }
+    }
+  }
+}
+
+
+int main() {
+  int u, v, w;
+  ll sum = 0;
+  scanf("%d%d%d%d", &N, &S, &B, &R);
+  for (int i = 0; i < R; i++) {
+    scanf("%d%d%d", &u, &v, &w);
+    G[u][0].pb(mp(w, v));
+    G[v][1].pb(mp(w, u));
+  }
+  dijkstra(B + 1, 0);
+  dijkstra(B + 1, 1);
+  for (int i = 1; i <= B; i++) A[i] = (ll)(dist[i][0] + dist[i][1]);
+  sort(A + 1, A + B + 1);
+  for (int i = 1; i <= B; i++) {
+    sum += A[i];
+    dp[i][1] = (ll)(i - 1) * sum;
+  }
+  for (int k = 2; k <= S; k++) {
+    for (int i = 1; i <= B; i++) {
+      sum = A[i];
+      dp[i][k % 2] = INFLL;
+      for (int j = i - 1; j >= 0; j--) {
+        if ((i - j) * k > i) break;
+        dp[i][k % 2] = min(dp[i][k % 2],
+                           (ll)(i - j - 1) * sum + dp[j][(k - 1) % 2]);
+        sum += A[j];
+      }
+    }
+  }
+  printf("%lld\n", dp[B][S % 2]);
+}