2015-2016 ACM ICPC Baltic Selection Contest ［解题报告］

新地址链接

A题：AHB 水题，直接上代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long Long;
const int maxn = 1e5 + 10;
const int maxm = 256;

int main()
{
char s1[20], s2[20];

while (scanf("%s%s", s1, s2) != EOF)
{
int l1 = (int) strlen(s1), l2 = (int) strlen(s2);
bool flag = false;
for (int i = 0; i < l1; i++)
{
int v1 = s1[i]-'0', v2 = s2[i]-'0';
int v = max(v1,v2)-min(v1,v2);
if (v == 0 && !flag)
{
continue;
}
flag = true;
printf("%d", v);
}
if (!flag) printf("0");
puts("");
}

return 0;

B题：Wet Boxes 这个题据说是线段树，暂时没做出来

C题： Minimax Tree

题意：

给出一棵n个节点的树，叶节点都有一个value值，其余节点每个节点可以

放上一个max开关或者一个min开关, 如果u是max开关，那么val[u] =

max(val[v]), v是u的子节点，其中min开关和max开关的个数都是给定的，

并且max开关+min开关 = n-叶子节点数，让你安排每个中间节点是max还是min,

输出根节点的最大值和最小值

题解：

因为求最大值和最小值都是一样的方法，所以我们以求最大值来分析，

首先，我们先考虑把最大的叶子节点u传上去，因为u最大，所以，我们

在往上的路径分叉处只能用max开关，为了能让u传上去，肯定应该让不是该路径上的

其他分叉都尽量用min开关以节省max开关，现在我们考虑u的兄弟节点v，如果要把u的兄弟节点

v传上去，因为u比v大，所以我们在u和v的父节点f上肯定用min开关最划算，那么现在我们就把

问题转化成了把f上的节点传到根节点去(即min(u,v))。

所以说：如果当前考虑的节点u够大，那么我们就直接让接下来的路程都用max开关，否则就让他

用min开关传到父节点去。

代码：

#include <cmath>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

#define vsz(u) ((int) G[u].size())
typedef long long Long;
typedef vector<int>::iterator vIte;
const int maxn = 1e5 + 10;
const int inf = 1e9;
const double eps = 1e-8;

vector<int> G[maxn];
int val[maxn], minv[maxn], maxv[maxn];
int ansmn, ansmx, mn, mx, lev;

void dfs(int u, int judge)
{
minv[u] = inf; maxv[u] = 0;
if (vsz(u) == 0)
{
minv[u] = maxv[u] = val[u];
}
for (vIte it = G[u].begin(); it != G[u].end(); ++it)
{
dfs(*it, judge+(vsz(u)!=1));
minv[u] = min(minv[u], minv[*it]);
maxv[u] = max(maxv[u], maxv[*it]);
}
if (judge <= mx) ansmx = max(ansmx, minv[u]);
if (judge <= mn) ansmn = min(ansmn, maxv[u]);
}
int main()
{
int n, k;

while (scanf("%d%d",&n, &k) != EOF)
{
for (int i = 0; i < maxn; i++)
{
G[i].clear();
}
for (int i = 2; i <= n; i++)
{
int p; scanf("%d", &p);
G[p].push_back(i);
}
int zero = 0;
for (int i = 1; i <= n; i++)
{
scanf("%d", &val[i]);
zero += !val[i];
}
mn = k, mx = zero-k, lev = n-zero;
ansmn = inf; ansmx = 0;
dfs(1, 0);
printf("%d %d\n", ansmn, ansmx);
}

return 0;
}

D题：Journey

给一个n*m的矩阵，由.和#组成，要从左上角走到右下角的花费，其中

奇数步的花费为a,偶数步的花费为b, 直接先求从左上角到右下角的最短路step

然后答案就是step/2*(a+b) + (step&1)，因为第一步是奇数步。

代码：

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;

const int maxn = 507;
int n, m;
int dire[][2] = { {-1,0},{1,0},{0,-1},{0,1} };
char mapp[maxn][maxn];
bool vis[maxn][maxn];
struct Data
{
int x, y, step;
Data() {}
Data(int x1, int y1, int step1) {x = x1, y = y1, step = step1;}
}cur;
queue<Data> que;
bool safe(int x, int y) {
if (0 <= x && x < n && 0 <= y && y < m) return true;
return false;
}
int bfs() {
memset(vis, false, sizeof(vis));
while (!que.empty()) que.pop();
que.push(Data(0,0,0));
vis[0][0] = true;
while (!que.empty()) {
cur = que.front();
que.pop();
if (cur.x == n-1 && cur.y == m-1) return cur.step;
for (int i = 0; i < 4; i++) {
int x = cur.x + dire[i][0], y = cur.y + dire[i][1];
if (safe(x, y)) {
if (mapp[x][y] != '#' && !vis[x][y]) {
que.push(Data(x,y,cur.step+1));
vis[x][y] = true;
}
}
}
}
return -1;
}
int main() {
while (scanf("%d%d", &m, &n) != EOF) {
int a, b;
scanf("%d%d", &a, &b);
for (int i = 0; i < n; i++) {
scanf("%s", mapp[i]);
}
int ans = bfs();
if (ans == -1) printf("IMPOSSIBLE\n");
else {
int cost;
cost = (ans / 2) * (a + b);
if (ans & 1) cost += b;
printf("%d\n", cost);
}
}
return 0;
}

E题：Permutation Polygon

给一个n个点，点是1-n顺时针的，n条边的图，问有多少个交点。

建图的时候建立从小点到大点建有向图，然后从小到大扫描每个点，用

树状数组维护即可。

#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
#define pb push_back
const int maxn = 1e5 + 10;
typedef long long Long;
typedef vector<int>::iterator vIte;
Long C[maxn];
int n;
vector<int> G[maxn];

inline int lowbit(int x)
{
return x&(-x);
}
void add(int x, int v)
{
while (x <= n)
{
C[x] += v;
x += lowbit(x);
}
}
Long sum(int p)
{
Long ret = 0;
while (p > 0)
{
ret += C[p];
p -= lowbit(p);
}
return ret;
}
int main()
{
scanf("%d", &n);

for (int i = 1; i <= n; i++)
{
int v; scanf("%d", &v);
G[min(i,v)].pb(max(i,v));
}
Long ans = 0;
for (int i = 1; i <= n; i++)
{
add(i,-sum(i));
for (vIte it = G[i].begin(); it != G[i].end(); ++it)
{
ans += sum((*it)-1);
}
for (vIte it = G[i].begin(); it != G[i].end(); ++it)
{
add(*it,1);
}
}
printf("%I64d\n", ans);

return 0;
}

F题：Unusual Sum

水题：直接化简一下就ok了：

代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long Long;
const int maxn = 1e5 + 10;
const int maxm = 256;

int main()
{
int t; scanf("%d", &t);

while (t--)
{
double x, y; scanf("%lf%lf", &x, &y);
printf("%.10f\n", (y+1-x)/(x*(y+1)));
}

return 0;
}

G题：Robot Walk

水模拟：

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 100005

char str[maxn];
char op[maxn];
char ans[maxn];
int acnt = 0;
int main()
{
int n, m, x;
scanf("%d%d", &n, &x);
scanf("%s", str);
scanf("%d", &m);
scanf("%s", op);
x--;
ans[acnt++] = str[x];
for (int i = 0; op[i] != '\0'; i++)
{
if (op[i] == 'L') x--;
else x++;
ans[acnt++] = str[x];
}
ans[acnt] = '\0';
puts(ans);
return 0;
}

H题：Game of Corners

水题有点多：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

int main()
{
int n, m;
scanf("%d%d", &n, &m);
if (n > m) swap(n, m);
printf("%I64d\n", (long long)n*(m+1));
return 0;
}

I题：Shell Game

用前视图看，题目就转化为在一个梯形里面放圆，然后直接二分圆的半径，

看是否能放进去就行了。

#include <cmath>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long Long;
const int maxn = 5e2 + 10;
const double eps = 1e-8;

bool ok(double m, double r, double R, double h)
{
r*=2; R*=2;
double seta = atan(h/((R-r)/2.0));
double afa = atan(m/(R/2.0));
double bata = seta - afa;
double edge = sqrt(m*m+(R/2.0)*(R/2.0));
double ans = edge*sin(bata);
return ans >= m;
}
int main()
{
double r, R, h;

while (scanf("%lf%lf%lf", &r, &R, &h) != EOF)
{
double low = 0, high = h/2.0;

while (high-low >= eps)
{
double mid = (low+high) / 2.0;
if (ok(mid,r,R,h))
{
low = mid;
}
else high = mid;
}
printf("%.7f\n", low);
}

return 0;
}

J题：Narrow Bus

给一个空队列，有n个操作，（1<=n<=1e5), 一是F:从队首进入一个数，

二是B:从队尾进入一个数，三是第O i: 第i个进入的数选择两边中人少的一边出队，

所有在他前方的依次出队，从队列的另一边依次进入，输出地i个人出队的时候，有多少人

要因此出队。用Splay模拟即可

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 1e8;
struct node
{
int l, r, f, sz, v;
void clear()
{
l = r = f = sz = 0;
}
} nd[maxn];
int rt, tot;
void init()
{
tot = 0;
rt = 0;
}
int newNode()
{
nd[++tot].clear();
return tot;
}
void up(int x)
{
nd[x].sz = 1;
if (nd[x].l) nd[x].sz += nd[nd[x].l].sz;
if (nd[x].r) nd[x].sz += nd[nd[x].r].sz;
}
void r_rorate(int x)
{
int f = nd[x].f, l = nd[x].l;
if (nd[f].l == x) nd[f].l = l;
else nd[f].r = l;
nd[l].f = f;
nd[x].l = nd[l].r; nd[nd[x].l].f = x;
nd[x].f = l; nd[l].r = x;
up(x);
}
void l_rorate(int x)
{
int f = nd[x].f, r = nd[x].r;
if (nd[f].l == x) nd[f].l = r;
else nd[f].r = r;
nd[r].f = f;
nd[x].r = nd[r].l; nd[nd[x].r].f = x;
nd[x].f = r; nd[r].l = x;
up(x);
}
void splay(int x, int rootf)
{
for (; nd[x].f != rootf; )
{
int f = nd[x].f, g = nd[f].f;
if (g == rootf) {
if (nd[f].l == x)
r_rorate(f);
else
l_rorate(f);
}
else {
if (nd[g].l == f)
if (nd[f].l==x) r_rorate(g), r_rorate(f);
else l_rorate(f), r_rorate(g);
else
if (nd[f].r == x) l_rorate(g), l_rorate(f);
else r_rorate(f), l_rorate(g);
}
}
up(x);
if (!rootf) rt = x;
}
int getFirst(int x)
{
for (; nd[x].l; x = nd[x].l) ;
return x;
}
int getLast(int x)
{
for (; nd[x].r; x = nd[x].r) ;
return x;
}
int Gao(int x)
{
splay(x, 0);
int ret = inf;
if (nd[x].l) ret = min(ret, nd[nd[x].l].sz);
else ret = 0;
if (nd[x].r) ret = min(ret, nd[nd[x].r].sz);
else ret = 0;
if (nd[x].r == 0)
{
nd[nd[x].l].f = 0;
rt = nd[x].l;
nd[x].l = 0;
return ret;
}
nd[nd[x].r].f = 0;
int xx = getLast(x);
splay(xx, 0);
nd[xx].r = nd[x].l;
if (nd[x].l) nd[nd[x].l].f = xx;
if (nd[x].l) splay(nd[x].l, 0);
nd[x].r = 0;
return ret;
}
int main()
{
int n;
while (scanf("%d", &n) != EOF)
{
init();
nd[0].clear();
for (int i = 0; i < n; i++)
{
nd[0].l = nd[0].r = 0;
char cmd[3]; scanf("%s", cmd);
if (cmd[0] == 'F')
{
int id = newNode();
int x = getFirst(rt);
splay(x, 0);
if (x) nd[x].l = id;
nd[id].f = x;
splay(id, 0);
}
else if (cmd[0] == 'B')
{
int x = getLast(rt);
int id = newNode();
splay(x, 0);
if (x) nd[x].r = id;
nd[id].f = x;
splay(id, 0);
}
else
{
int id; scanf("%d", &id);
printf("%d\n", Gao(id));
}
}
}
return 0;
}

K题： Profact

1e5组数据，输入一个a(1<=a<=1e18),问a是否能用若干个阶乘的乘积得到。

因为20的阶乘就已经超过了1e18,直接把所有的组合情况放进set，然后二分查找即可。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
using namespace std;
#define LL long long
#define INF 1e18
LL num[20];
set<LL> Set;
void solve(LL x, int s)
{
for (int i = s; i<20; i++)
{
if (INF/x < num[i]) return;
Set.insert(x*num[i]);
solve(x*num[i], i);
}
}
void init()
{
num[1] = 1;
for (int i = 2; i<20; i++)
num[i] = num[i-1]*i;
Set.insert(1);
solve(1, 2);
}
int main()
{
init();
int t;
scanf("%d", &t);
while (t--)
{
LL x;
scanf("%I64d", &x);
if (Set.find(x) != Set.end()) puts("YES");
else puts("NO");
}
return 0;
}

L题： Emoticons

水模拟

{% highlight c++ %}
#include <cstdio>
#include <cstring>
using namespace std;
const int maxn = 1e5+7;
char str[maxn];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
scanf("%s", str);
int sm = 0, sa = 0;
for (int i = 0; i < n; i++) {
if (str[i] == ':') {
if (i - 1 >= 0) {
if (str[i-1] == '(') sm++;
if (str[i-1] == ')') sa++;
}
if (i + 1 < n) {
if (str[i+1] == '(') sa++;
if (str[i+1] == ')') sm++;
}
}
}
if (sm > sa) printf("HAPPY\n");
else if (sm < sa) printf("SAD\n");
else printf("BORED\n");
}
return 0;
}