 # November 3, 2020 2020 TCO Algorithm WildCard Round Editorials

#### PizzaEatingGame

Used as: Division One – Level One:

Hint: dp[l][r]

A typical dynamic programming on range problem. First choose which slice you want to pick at the first turn. The first move leads to an array, instead of a circle.

Let dp[l][r] = the score that the person who has the turn will get if the game is played on range [l, r).

dp[l][r] = max l <= j < r a[j] + (sum[l][j] – dp[l][j]) + (sum[j + 1][r] – dp[j + 1][r]), where sum[i][j] is sum of a[i]’s in range [l, r).

To make the implementation easier, one can make a copy of the array and append to it.

Time complexity is O(N^3).

The code by lyrically nicely describes the solution:

constexpr int INF = 1001001001;

int N;
int A;
int dp;

struct PizzaEatingGame {
int eat(vector <int> olives) {
N = olives.size();
for (int i = 0; i < N * 2; ++i) {
A[i] = olives[i % N];
}

for (int i = 0; i <= N * 2; ++i) {
fill(dp[i], dp[i] + N * 2 + 1, -INF);
dp[i][i] = 0;
}
for (int w = 1; w <= N; ++w) {
for (int i = 0; i + w <= N * 2; ++i) {
const int j = i + w;
for (int k = i; k < j; ++k) {
dp[i][j] = max(dp[i][j], A[k] - dp[i][k] - dp[k + 1][j]);
}
}
}

int mx = -INF;
for (int i = 0; i < N; ++i) {
mx = max(mx, A[i] - dp[i + 1][i + N]);
}
int sum = 0;
for (int i = 0; i < N; ++i) {
sum += A[i];
}
const int ans = (sum + mx) / 2;
return ans;
}
};



#### BiddingWars

Used as: Division One – Level Two:

Hint: dp[n – 1] = 0, dp[n – 2] = inf, calculate dp[n – 3], dp[n – 4], …, dp.

Let’s calculate dp[v] = the largest non-negative real number r such that if Bob starts with strictly less than r dollars, Alice can force a win, when the initial vertex is v.

dp[n – 1] = 0, dp[n – 2] = inf.

Let’s calculate dp[n – 3], dp[n – 4], …, dp. This way, when we want to calculate dp[v], for each u such that v has an edge to u, dp[u] is calculated.

Focus on calculating dp[v]. Let W = max dp[u] where v has an edge to u. Let L = min dp[u] where v has an edge to u.

There is a case that could be handled easily, W = inf. So there exists a vertex like u such that dp[u] = inf. Let’s prove that dp[v] = L + 1. If Alice has 1 dollar and Bob has less than L + 1 dollars, Alice can bid on 1 dollar. If Bob bids on less than 1 dollar, he will lose. Alice moves the token to u. If Bob bids on more than or equal to 1 dollar, at the best case he moves the token to the vertex which it’s dp is equal to l. He’ll lose again. Because after this turn he has less than L dollars.

Let’s handle the general case. Consider she wants to bid on x. It’s easy to show that there is two optimal cases for Alice:

• Win the bid and move the token to vertex which it’s dp is equal to W. So (1 – x) / dp[v] <= 1 / w. It means that the ratio of Alice remaining money (1 – x) to Bob money (dp[v]) should be less than or equal to 1 / w, which is the ratio of the best vertex Alice can move the token to.
• Lose the bid and Bob will move the token to vertex which it’s dp is equal to L. So 1 / (dp[v] – x) <= 1 / L.

Because we want to maximize dp[v], we convert <= to =. Now we have two unknowns (x and dp[v]) and two equations that when solved, leads to: dp[v] = (w + wl) / (w + 1) = l + (w – l) / (w + 1).

Code by Egor:

double findMax(int n, vector<int> f, vector<int> t) {
vector<int> graph(n);
for (int i = 0; i < f.size(); i++)
graph[f[i]].push_back(t[i]);
vector<double> r(n);
r[n - 2] = numeric_limits<double>::infinity();
r[n - 1] = 0;
for (int i  = n - 3; i >= 0; i--) {
double w = 0;
double l = numeric_limits<double>::infinity();
for (auto& to : graph[i]) {
w = max(w, r[to]);
l = min(l, r[to]);
}
if (__builtin_isinf(w)) {
r[i] = l + 1;
continue;
}
double alpha = (w - l) / (w + 1);
r[i] = l + alpha;
}
return __builtin_isinf(r) ? -1 : r;
}



#### OddCycleDetector

Used as: Division One – Level Three:

Hint: Theory problem. Find vertex-biconnected components of the graph and for each of them check if it’s bipartite or not.

Many users got accepted using finding random odd length cycles. But Let’s describe the deterministic solution.

Find vertex-biconnected components of the graph. If a component is bipartite, no vertex in it can be in an odd length cycle.

We prove that all other vertices are in at least one odd length cycle. Consider a graph H which is biconnected and not bipartite. So it has at least one odd length cycle. Let c1 and c2 be two arbitrary selected vertices in the odd cycle.

Let’s prove that for each vertex like v in H, it’s in at least one odd length cycle. Add a virtual vertex x to H and connect it to c1 and c2. The graph is still biconnected. It’s a known fact about biconnected graphs that between each two vertices, there are two vertex disjoint paths between them. So between v and x there are two vertex disjoint paths, p1, p2. Let d1 be the first vertex in p1 which lies in the odd cycle, let d2 be the first vertex in p2 which lies in the odd cycle.

There are two paths lying on the odd cycle between d1 and d2. One of them is odd-length and the other is even-length. Now, depending on the sum of length of distance of v and d1 (on p1) and distance of v and d2 (on p2) we can choose a suitable path between d1 and d2 to make an odd-length cycle containing v.

To find vertex-disjoint paths between v and c1 and also v and c2, we can use max-flow.

Here is the code by misof:

import java.math.*;

class Edge {
int source, destination, capacity, residue;
Edge(int s, int d, int c, int r) { this.source = s; this.destination = d; this.capacity = c; this.residue = r; }
};

class MaxFlow {
int N;
ArrayList<Integer>[] V;
ArrayList<Edge> E;
MaxFlow(int N) {
this.N = N;
this.V = new ArrayList[N];
for (int n=0; n<N; ++n) this.V[n] = new ArrayList<Integer>();
this.E = new ArrayList<Edge>();
}
void add_arc(int s, int d, int c) {
int e = E.size();
}

int[] findEar(int source) {
int flowSize = 0;
int sink = N-2;

while (true) { // use BFS to find augmenting paths
int[] from = new int[N];
for (int n=0; n<N; ++n) from[n] = -1;
int[] Q = new int[N];
int qs=0, qf=0;
Q[qf++] = source;
from[source] = -2;

while (qs < qf) {
int where = Q[qs++];
for (int e : V[where]) {
int dest = E.get(e).destination;  if (from[dest] != -1) continue;
int res  = E.get(e).residue;      if (res == 0) continue;
from[dest] = e;
Q[qf++] = dest;
if (dest == sink) break;
}
if (from[sink] >= 0) break;
}

if (from[sink]==-1) {
if (flowSize != 2) return new int; // SHOULD NOT HAPPEN

int realN = (N / 2) - 1;

for (Edge e : E) if (e.source % 2 == 1 && e.destination % 2 == 0 && e.source != N-1 && e.destination != N-2 && e.residue == 0) {
int x = e.source / 2;
int y = e.destination / 2;
}

int[] degree = new int[realN];
for (int a=0; a<realN; ++a) for (int b=0; b<realN; ++b) if (inAnswer[a][b]) ++degree[a];
int start = 0;
while (degree[start] != 1) ++start;

int[] path = new int[realN];
path = start;
int pc = 1;
while (true) {
for (int n=0; n<N; ++n) if (inAnswer[ path[pc-1] ][n] && (pc == 1 || path[pc-2] != n)) { path[pc++] = n; break; }
if (degree[path[pc-1]] == 1) break;
}

for (int i=0; i<pc; ++i) answer[i] = path[i];
}

// construct a maximum set of augmenting paths in the graph given by from[]
for (int e : V[sink]) {
int where = E.get(e).destination;           if (from[where]==-1) continue; // no path leads here
int res = E.get(e).capacity - E.get(e).residue; if (res == 0) continue; // can't push anything more

// walk the path and determine the delta
int canPush = res;
int curr = where;
while (true) {
if (from[curr] == -2) break;
canPush = Math.min( canPush, E.get( from[curr] ).residue );
curr    = E.get( from[curr] ).source;
}

// walk the path again and update capacities
flowSize       += canPush;
E.get(e  ).residue += canPush;
E.get(e^1).residue -= canPush;
curr = where;
while (true) {
if (from[curr] == -2) break;
E.get( from[curr]   ).residue -= canPush;
E.get( from[curr]^1 ).residue += canPush;
curr = E.get( from[curr] ).source;
}
}
}
}
};

public class OddCycleDetector {

public String checkData(String[] G) {
int N = G.length;
if (N < 1 || N > 50) return "N must be between 1 and 50, inclusive.";
for (int n=0; n<N; ++n) if (G[n].length() != N) return "Each element of G must contain N characters.";
for (int a=0; a<N; ++a) {
if (G[a].charAt(a) != 'N') return "For each i, G[i][i] must be 'N'.";
for (int b=0; b<N; ++b) {
if (G[a].charAt(b) != 'Y' && G[a].charAt(b) != 'N') return "Each character in G must be either 'Y' or 'N'.";
if (G[a].charAt(b) != G[b].charAt(a)) return "For each i and j, G[i][j] must be equal to G[j][i].";
}
}
return "";
}

int N;
boolean[][] G;
int[][] bcc; // for each edge its BCC#
int[] bcc_visited, bcc_vstack, bcc_estack;
int bcc_cur, bcc_cur_time, bcc_vsize, bcc_esize;

int search(int v) {
bcc_visited[v] = ++bcc_cur_time;
int result = bcc_visited[v];

for (int n=0; n<N; ++n) {
if (!G[v][n]) continue;
if (bcc[v][n] != -1) continue;
bcc_vstack[bcc_vsize++] = v;
bcc_estack[bcc_esize++] = n;
bcc[n][v] = -2;
int r;
if (bcc_visited[n] == 0) r = search(n); else r = bcc_visited[n];
if (r >= bcc_visited[v]) {
int a, b;
do {
a = bcc_vstack[--bcc_vsize];
b = bcc_estack[--bcc_esize];
bcc[a][b] = bcc_cur;
bcc[b][a] = bcc_cur;
}
while (a!=v || b!=n);
++bcc_cur;
}
result = Math.min(result,r);
}
return result;
}

void compute_bcc(String[] _G) {
N = _G.length;
G = new boolean[N][N];
for (int a=0; a<N; ++a) for (int b=0; b<N; ++b) G[a][b] = (_G[a].charAt(b) == 'Y');

bcc_cur = 0;
bcc_cur_time = 1;
bcc_vstack = new int[2*N*N]; bcc_vsize = 0;
bcc_estack = new int[2*N*N]; bcc_esize = 0;

bcc = new int[N][N];
for (int a=0; a<N; ++a) for (int b=0; b<N; ++b) bcc[a][b] = -1;

bcc_visited = new int[N];
for (int n=0; n<N; ++n) if (bcc_visited[n] == 0) search(n);
System.out.println("N = " + N + " number of BCCs = " + bcc_cur);
}

boolean[] getBCC(int bcc_id) {
int edges = 0;
for (int a=0; a<N; ++a) for (int b=0; b<N; ++b) if (bcc[a][b] == bcc_id) {
++edges;
}
int vertices = 0;
for (boolean x : answer) if (x) ++vertices;
System.out.println("  BCC "+bcc_id+" with "+vertices+" vertices, "+(edges/2)+" edges");
}

boolean[] currentBCC;
int[] color, depth, dfsparent, oddCycle;
boolean terminate;

void dfs(int bcc_id, int where, int parent) {
dfsparent[where] = parent;
for (int n=0; n<N; ++n) {
if (!G[where][n]) continue;
if (bcc[where][n] != bcc_id) continue;
if (color[n] == 1 - color[where]) continue;
if (color[n] == color[where]) {
// found an odd cycle
int cl = depth[where] - depth[n] + 1;
oddCycle = new int[cl];
oddCycle = where;
for (int i=1; i<cl; ++i) oddCycle[i] = dfsparent[ oddCycle[i-1] ];
terminate = true;
return;
}
color[n] = 1 - color[where];
depth[n] = 1 + depth[where];
dfs(bcc_id, n, where);
if (terminate) return;
}
}

void getOneOddCycle(int bcc_id) {
currentBCC = getBCC(bcc_id);
int start = 0;
while (!currentBCC[start]) ++start;

color = new int[N];
for (int n=0; n<N; ++n) color[n] = -1;
color[start] = 0;

dfsparent = new int[N];

depth = new int[N];
depth[start] = 0;

terminate = false;
oddCycle = new int;

dfs(bcc_id, start, -1);
System.out.print("  BCC "+bcc_id+" odd cycle:"); for (int x : oddCycle) System.out.print(" "+x); System.out.println();
}

compute_bcc(_G);

for (int x : contestantsAnswer) if (x < -1 || x >= N) return "Wrong answer: Each element of the return value must be between -1 and N-1, inclusive.";
int separators = 0;
for (int x : contestantsAnswer) if (x == -1) ++separators;
if (separators != N-1) return "Wrong answer: The return value must contain exactly N-1 copies of the value -1.";

int[] indices = new int[N+1];
indices = -1;
for (int j=1, i=0; i<contestantsAnswer.length; ++i) if (contestantsAnswer[i] == -1) indices[j++] = i;

int[][] pieces = new int[N][];
for (int n=0; n<N; ++n) pieces[n] = new int[ indices[n+1] - indices[n] - 1 ];
for (int n=0; n<N; ++n) for (int i=0; i<pieces[n].length; ++i) pieces[n][i] = contestantsAnswer[ indices[n]+1+i ];

boolean[] isOnCycle = new boolean[N];

for (int bcc_id=0; bcc_id < bcc_cur; ++bcc_id) {
getOneOddCycle(bcc_id);
if (oddCycle.length == 0) continue;
for (int n=0; n<N; ++n) if (currentBCC[n]) isOnCycle[n] = true;
}

for (int n=0; n<N; ++n) if (isOnCycle[n] && pieces[n].length == 0) return "Wrong answer: Did not find an existing odd cycle.";

for (int n=0; n<N; ++n) if (pieces[n].length > 0) {
if (pieces[n].length < 3) return "Wrong answer: Returned certificate must have at least three vertices.";
if (pieces[n].length % 2 == 0) return "Wrong answer: Returned certificate must have an odd number of vertices.";
if (pieces[n].length > N) return "Wrong answer: Returned certificate must not have a repeated vertex.";
for (int a=0; a<pieces[n].length; ++a) for (int b=0; b<a; ++b) if (pieces[n][a] == pieces[n][b]) return "Wrong answer: Returned certificate must not have a repeated vertex.";
for (int a=0; a<pieces[n].length; ++a) {
int x = pieces[n][a], y = pieces[n][ (a+1) % pieces[n].length ];
if (!G[x][y]) return "Wrong answer: Returned certificate is not a valid cycle.";
}
boolean contains = false;
for (int x : pieces[n]) if (x == n) contains = true;
if (!contains) return "Wrong answer: Returned certificate for a vertex does not contain that vertex.";
}

return "";
}

public int[] detect(String[] _G) {
compute_bcc(_G);

ArrayList<Integer>[] certificates = new ArrayList[N];
for (int n=0; n<N; ++n) certificates[n] = new ArrayList<Integer>();

for (int bcc_id=0; bcc_id < bcc_cur; ++bcc_id) {
getOneOddCycle(bcc_id);
if (oddCycle.length == 0) continue;
for (int n=0; n<N; ++n) if (currentBCC[n] && certificates[n].size() == 0) {
// construct certificate for n
boolean onCycle = false;
for (int x : oddCycle) if (x == n) onCycle = true;
if (onCycle) {
for (int x : oddCycle) certificates[n].add(x);
continue;
}
// n lies outside the one cycle, find two paths to it
MaxFlow MF = new MaxFlow(2*N + 2);
for (int i=0; i<N; ++i) MF.add_arc(2*i, 2*i+1, 1); // capacity on vertices
boolean[] onOddCycle = new boolean[N];
for (int x : oddCycle) { onOddCycle[x] = true; MF.add_arc(2*x+1, 2*N, 1); } // cycle -> sink
for (int a=0; a<N; ++a) for (int b=0; b<N; ++b) if (!onOddCycle[a]) if (G[a][b]) if (bcc[a][b] == bcc_id) MF.add_arc(2*a+1, 2*b, 1); // edges not on cycle
int[] ear = MF.findEar(2*N+1);

int prvy = 0; while (oddCycle[prvy] != ear) ++prvy;
int druhy = prvy, dopredu = 0; while (oddCycle[druhy] != ear[ear.length-1]) { ++dopredu; druhy=(druhy+1) % oddCycle.length; }
if ((ear.length + dopredu) % 2 == 0) {
// chceme toto
for (int x : ear) certificates[n].add(x);
for (int i=(druhy+oddCycle.length-1) % oddCycle.length; i!=prvy; i = (i+oddCycle.length-1)%oddCycle.length) certificates[n].add(oddCycle[i]);
} else {
// chceme druhe
for (int x : ear) certificates[n].add(x);
for (int i=(druhy+1) % oddCycle.length; i!=prvy; i=(i+1)%oddCycle.length) certificates[n].add(oddCycle[i]);
}

}
}

for (int n=0; n<N; ++n) {
}

}
}



a.poorakhavan

Guest Blogger

categories & Tags

UNLEASH THE GIG ECONOMY. START A PROJECT OR TALK TO SALES
Close