topcoder srm 465 div1

problem1 link

以两个点$p,q$为中心的两个正方形的边长和最大为$2dist(p,q)$,即$p,q$距离的两倍。

也就是两个$p,q$的连线垂直穿过两个正方形的一对边且平分两个正方形。

problem2 link

简化一下题意就是每个base和每个plant都有一个代价。要么付出某个base的代价，要么付出其对应的plant的代价。

将base和plant建立网络流。

源点到每个plant的边的流量为其代价

base到汇点的边的流量为其代价

base与其对应plant的边的流量为无穷大。

然后求最小割即可。

割到的plant就说明要付出这个plant的代价，割到的base就说明付出这个base的代价。

problem3 link

令$p=\frac{1}{d},q=\frac{d-1}{d}$

在$[n-d,n-1]$中任意一个格子，其一步到达$n$的概率都是$p$。恰好经过$t$步到达$n$的概率为$pq^{t-1}$

设$p1[i]$表示先手恰好经过$i$步第一次进入$[n-d,n-1]$区间的概率；

设$p2[i]$表示后手恰好经过$i$步第一次进入$[n-d,n-1]$区间的概率；

设$g(i,j)$表示先手、后手分别经过$i,j$步到达$[n-d,n-1]$区间且先手胜利的概率。

$g(i,j)$的计算方法为：

===============================

g(i,j)=0

if(i<j) {

$g(i,j) += p1[i]*p2[j]*(1-q^{j-i})$ //在后手未进入最后区间时取得胜利

}

$g(i,j)+=p1[i]*p2[j] * q^{|i-j|} * \frac{d}{d+d-1}$ //都进入最后区间再经过若干轮角逐后取得胜利

===============================

那么答案为所有的$g(i,j)$之和。

code for problem1

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class TurretPlacement {

public long count(int[] x, int[] y) {
long result = 0;
for (int i = 0; i < x.length; ++ i) {
for (int j = i + 1; j < x.length; ++ j) {
result += cal(x[i], y[i], x[j], y[j]);
}
}
return result;
}
long cal(int x1, int y1, int x2, int y2) {
long d = (long)(Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) * 2);
return d * (d - 1) / 2;
}
}

　　

code for problem2

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

class MaxFlow {
static class node
{
int v,cap,next;
};

List<node> edges = null;
int[] head = null;
int vertexNum;
int[] pre = null;
int[] cur = null;
int[] num = null;
int[] h = null;

public MaxFlow(int vertexNum) {
this.vertexNum = vertexNum;
edges = new ArrayList<>();
head = new int[vertexNum];
Arrays.fill(head, -1);
pre = new int[vertexNum];
cur = new int[vertexNum];
num = new int[vertexNum];
h = new int[vertexNum];
}

private void addEdge(int u, int v, int cap)
{
node p = new node();
p.v = v;
p.cap = cap;
p.next = head[u];
head[u] = edges.size();
edges.add(p);
}

public void add(int u, int v, int cap)
{
addEdge(u, v, cap);
addEdge(v, u,0);
}

public int getMaxflow(int source, int sink)
{
for (int i = 0; i < vertexNum; ++ i) {
cur[i] = head[i];
num[i] = 0;
h[i] = 0;
}
int u = source;
int result = 0;
while (h[u] < vertexNum)
{
if (u == sink)
{
int Min=Integer.MAX_VALUE;
int v = -1;
for (int i = source; i != sink; i = edges.get(cur[i]).v)
{
int k=cur[i];
if(edges.get(k).cap < Min) {
Min = edges.get(k).cap;
v = i;
}
}
result += Min;
u=v;
for (int i = source; i != sink; i = edges.get(cur[i]).v)
{
int k=cur[i];
edges.get(k).cap -= Min;
edges.get(k ^ 1).cap += Min;
}
}
int index = -1;
for (int i = cur[u]; i != -1; i = edges.get(i).next)
{
if (edges.get(i).cap > 0 && h[u] == h[edges.get(i).v] + 1) {
index = i;
break;
}
}
if (index != -1)
{
cur[u] = index;
pre[edges.get(index).v]=u;
u=edges.get(index).v;
}
else
{
if (--num[h[u]] == 0) {
break;
}
int k = vertexNum;
cur[u] = head[u];
for (int i = head[u]; i != -1; i = edges.get(i).next)
{
if(edges.get(i).cap>0 && h[edges.get(i).v] < k)
{
k = h[edges.get(i).v];
}
}
if (k + 1 < vertexNum) {
num[k + 1] += 1;
}
h[u] = k + 1;
if (u != source) u=pre[u];
}
}
return result;
}
}

public class GreenWarfare {

int p2(int x) {
return x * x;
}

public int minimumEnergyCost(int[] canonX, int[] canonY, int[] baseX, int[] baseY,
int[] plantX, int[] plantY, int energySupplyRadius) {
final int n = baseX.length;
final int m = plantX.length;
MaxFlow maxFlow = new MaxFlow(n + m + 2);
for (int j = 0; j < m; ++ j) {
int c = Integer.MAX_VALUE;
for (int i = 0; i < canonX.length; ++ i) {
c = Math.min(c, p2(canonX[i] - plantX[j]) + p2(canonY[i] - plantY[j]));
}
maxFlow.add(0, j + 1, c);
}
for (int j = 0; j < n; ++ j) {
int c = Integer.MAX_VALUE;
for (int i = 0; i < canonX.length; ++ i) {
c = Math.min(c, p2(canonX[i] - baseX[j]) + p2(canonY[i] - baseY[j]));
}
maxFlow.add(m + j + 1, m + n + 1, c);
}
for (int i = 0; i < m; ++ i) {
for (int j = 0; j < n; ++ j) {
int d = p2(baseX[j] - plantX[i]) + p2(baseY[j] - plantY[i]);
if ( d <= p2(energySupplyRadius)) {
maxFlow.add(i + 1, m + j + 1, Integer.MAX_VALUE);
}
}
}
return maxFlow.getMaxflow(0, m + n + 1);
}
}

　　

code for problem3

import java.util.*;
import java.math.*;
import static java.lang.Math.*;

public class BouncingDiceGame {

public double winProbability(int n, int d, int x, int y) {
double[] p1 = cal(n, d, x);
double[] p2 = cal(n, d, y);
double[] p = new double
;
p[0] = 1;
p[1] = (d - 1.0) / d;
for (int i = 2; i < n; ++ i) {
p[i] = p[i - 1] * p[1];
}
double result = 0;
for (int i = 0; i < p1.length; ++ i) {
for (int j = 0; j < p2.length; ++ j) {
if (i < j) {
result += p1[i] * p2[j] * (1 - p[j - i]);
}
result += p1[i] * p2[j] * p[Math.abs(i - j)] * d / (d + d - 1);
}
}
return result;
}
double[] cal(int n, int d, int x) {
if (x >= n - d) {
double[] result = new double[1];
result[0] = 1;
return result;
}
final int m = n - d - x;
double[] result = new double[m + 1];
result[0] = 0;
double[][] f = new double[2]
;
for (int i = x; i <n; ++ i) {
f[0][i] = 1;
}
int pre = 0;
int cur = 1;
for (int i = 1; i <= m; ++ i) {
Arrays.fill(f[cur], 0);
for (int j = x + 1; j < n; ++ j) {
int rr = j - 1 >= n - d? n - d - 1 : j - 1;
int ll = j - d - 1 >= 0? j - d - 1: 0;
if (rr < ll) {
continue;
}
f[cur][j] = (f[pre][rr] - f[pre][ll] ) / d;
}
for (int j = x; j < n; ++ j) {
f[cur][j] += f[cur][j - 1];
}
result[i] = f[cur][n - 1] - f[cur][n - d - 1];
pre ^= 1;
cur ^= 1;
}
return result;
}
}