第 45 届国际大学生程序设计竞赛（ICPC）亚洲网上区域赛模拟赛题解（除了C、G之后补）

繁凡さん 2020-10-31 17:58:22

2637

分类专栏： ACM - ICPC 真题

最后发布:2020-10-31 17:58:22首次发布:2020-10-31 17:58:22

本文链接：https://blog.csdn.net/weixin_45697774/article/details/109405903

版权

整理的算法模板合集： ACM模板

这次比赛好多原题呀…（就是那种稍微拓展了一点的原题）

A、Easy Equation

在这里插入图片描述
题目大意：求 $x + y + z = k$ 的方案数，输入为四个数可取的范围。

前缀和差分。

首先一看数据范围是1e6就不可能 $O(n^2)$ 做，只能 $O (n)$ 。

之前做过一道简化版的题，是求 $x + y = z$ 的方案数，用的好像是什么前缀和映射思想，我忘了，是CF上面的一次比赛题，但是我找不到了…这里是三个，所以把那个方法拓展一下即可。

实际上用前缀和来解决思路特别简单，大致是一个前缀和+递推DP的思想。

因为有三个数相加的方案数

我们用 f[i] 表示i能够被多少个前两个范围的数（x+y）加起来的方案数，我们直接循环x，那么所有从 x 到 x+b的数都能被这个数递推过去，方案数+1，我们可以直接用前缀和来维护一个区间+1的操作，这样求得 f 数组，然后我们用同样的思路求g数组，其中g[i]表示的是i能够被多少个x+y+z的方案数，同样的我们维护一个前缀和差分，再求一次前缀和就是所有能通过x+y+z得到这个数的方案数，我们直接枚举所有d的范围，求和既是答案。

一个小插曲

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>

using namespace std;

const int N = 1e8 + 7, M = 5000007, INF = 0x3f3f3f3f;

long long a, b, c, d;
long long f[N];
long long g[N];

int main()
{

    scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
    for(int i = 0; i <= a; ++ i){
        f[i] ++ ;
        f[i + b + 1] -- ;
    }
    for(int i = 1; i <= a + b; ++ i)
        f[i] += f[i - 1];
    for(int i = 0; i <= a + b; ++ i){
        g[i] += f[i];
        g[i + c + 1] -= f[i] ;
    }
    for(int i = 1 ;i <= a + b + c; ++ i)
        g[i] += g[i - 1];
    long long ans = 0;
    for(int i = 0; i <= d; ++ i)
        ans += g[i];
    printf("%lld\n", ans);
    return 0;
}

B、XTL’s Chessboard

在这里插入图片描述

题目大意：弹弹弹

SB题，直接输出2就行了，因为所有的点沿着45度角射出反弹最后都会回到起点，x-1和y-1互质的时候一定会经过角，就会直接反弹原路返回。所以只有起点和终点经过奇数次，答案就是2。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>

using namespace std;

const int N = 500007, M = 5000007, INF = 0x3f3f3f3f;

int n, m, t;
int a[N], b[N];
bool vis[N];
int ans;

int main()
{
    int x, y;
    while(scanf("%d%d%d%d", &n, &m, &x, &y) != EOF && n + m){
        printf("2\n");
    }
    return 0;
}

D、Pokemon Ultra Sun

在这里插入图片描述
题目大意：宝可梦们大战，你和对手都有一个血量，每一轮都是你打对手，攻击力为w，每次有p的概率对手掉血，1-p的概率你自己掉血，求比赛轮数的期望。

概率DP板子题…

我们用 f[i][j] 表示我方掉i血敌方掉j血的期望。
然后直接输出即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>

using namespace std;

const int N = 3507, M = 5000007, INF = 0x3f3f3f3f;

int n, m, t;
int hp1, hp2, w;
double f[N][N];
double p;

int main()
{
    scanf("%d", &t);
    while(t -- ){
        scanf("%d%d%d%lf", &hp1, &hp2, &w, &p);
        memset(f, 0, sizeof f);
        for(int i = 1; i <= hp1; ++ i){
            for(int j = 1; j <= hp2; ++ j){
                f[i][j] = f[max(0, i - w)][j] * (1 - p) + f[i][max(0, j - w)] * p + 1.0;
            }
        }
        printf("%.6f\n", f[hp1][hp2]);
    }
    return 0;
}

E、Eat Walnuts

在这里插入图片描述
题目大意：一排的核桃，你每次可以从连续的三个中拿走中间的那一个，花费为a[i - 1] * a[i] * a[i + 1]，求拿的只剩下两个核桃的最小花费。

其实就是一道区间DP的板子题，之前有一道最优矩阵链乘的题，几乎一摸一样。只不过计算方法改了一点。主要是这里需要至少三个核桃才能拿走一个，所以我们需要规定长度至少为3，然后初始化的时候应该初始化f[i][i] = 0; f[i][i + 1] = 0;，而最优矩阵链乘中两个数表示两个矩阵，所以初始条件和长度不一样，区间DP需要考虑边界，可转移长度，最后才是转移方程。

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<cstring>

using namespace std;
typedef long long ll;
const int N = 2007, M = 5000007, INF = 0x3f3f3f3f;

int n, m;
int f[N][N];
int a[N];

int main()
{
    while(scanf("%d", &n) != EOF && n){
        memset(f, 0x3f, sizeof f);
        for(int i = 1; i <= n; ++ i){
            scanf("%d", &a[i]);
            f[i][i] = 0;
            f[i][i + 1] = 0;
        }

        for(int len = 2; len <= n; ++ len){
            for(int i = 1; i <= n - len + 1; ++ i){
                int j = i + len - 1;
                for(int k = i + 1; k < j; ++ k)
                    f[i][j] = min(f[i][j], f[i][k] + f[k][j] + (a[i] + a[k] + a[j]) * (a[i] + a[k] + a[j]));
            }
        }
        printf("%d\n", f[1][n]);
    }
    return 0;
}

F、wrestling on road

在这里插入图片描述
题目翻译 ♂：

Banana先生和Kazuya先生是新日暮里的著名哲学家。新日暮里的国王范（Van）无法在没有他们的情况下管理帝国，因此他将左右监护人的头衔赋予他们。

由于政治上的差异，他们处于相反的立场。新日暮里每天都有早会，范需要设计两条路线，以便香蕉先生和和也雅先生可以参加早会。使事情变得难以管理的是，如果一条道路（不包括两个终点）既属于香蕉先生的道路又属于Kazuya的道路，那么它们将相互搏斗。

一般而言，新日暮里由n个城市和m条没有自环的双向道路组成，最多有一条道路连接任何两个城市。Banana先生居住在1号城市，Kazuya先生居住在2号城市。n和n − 1城市有两个豪华轿车，他们应该参加早上的会议。更正式地：

如果道路在香蕉先生的路线上，那么它就不能可以在和Kazuya的路线上，反之亦然。（也就是他们的路线不能有交叉）

如果Banana先生应该在n城市使用豪华轿车，而Kazuya应该在n-1城市使用豪华轿车。（也就是🍌要到点n，Kazuya要到点n-1）

比赛的时候时间比较短因为这道题没人过，我都没看这道题

结果又是原题，还是我两周前刚做过的题，正解是LCA，我之前是用树链剖分过的。

还没A，晚上回来补一下

啊，是我看错了，好像不能用树链剖分，因为这不是树…那没事了

应该用tarjan缩点，或者LCA乱搞

题目大意就是判断是否有两条道路，使得没有重边，可以有重点。

//假的树链剖分代码，过不去，我题看错了，等我有空了就补
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<cstring>

using namespace std;
typedef long long ll;
const int N = 500007, M = 5000007, INF = 0x3f3f3f3f;
const double eps = 1e-6;

int n, m;
int root, mod;
int head[N], ver[M], nex[M], tot;
int a[N], a_after[N];
struct Tree
{
    int l, r;
    int lz;
    int maxv;
}tr[N * 4];
int son[N];
int id[N], fa[N], cnt, deep[N], sizes[N];
int top[N];

void add(int x, int y)
{
    ver[tot] = y;
    nex[tot] = head[x];
    head[x] = tot ++ ;
}

inline void pushup(int p){
    tr[p].maxv = max(tr[p << 1].maxv, tr[p << 1 | 1].maxv);
}

inline void pushdown(int p)
{
    auto &root = tr[p], &left = tr[p << 1], &right = tr[p << 1 | 1];
    if(root.lz == 0)return ;
    left.lz += root.lz;
    right.lz += root.lz;
    left.maxv += root.lz;
    right.maxv += root.lz;
    root.lz = 0;
}

void build(int p, int l, int r)
{
    tr[p] = {l, r, 0, 0};
    if(l == r){
        tr[p].maxv = a_after[l];
        return ;
    }
    int mid = l + r >> 1;
    build(p << 1, l, mid);
    build(p << 1 | 1, mid + 1, r);
    pushup(p);
}

int query(int p, int l, int r)
{
    if(tr[p].l >= l && tr[p].r <= r){
        return tr[p].maxv;
    }
    pushdown(p);
    int mid = tr[p].l +tr[p].r >> 1;
    int res = 0;
    if(l <= mid)res = max(res, query(p << 1, l, r));
    if(r > mid)res = max(res, query(p << 1 | 1, l, r));
    return res;
}

void modify(int p, int l, int r, int k)
{
    if(tr[p].l >= l && tr[p].r <= r){
        tr[p].lz += k;
        tr[p].maxv += k;
        return ;
    }
    int mid = tr[p].l + tr[p].r >> 1;
    pushdown(p);
    if(l <= mid)modify(p << 1, l, r, k);
    if(r > mid)modify(p << 1 | 1, l, r, k);
    pushup(p);
    return ;
}

void dfs_son(int x, int father, int deeps)
{
    deep[x] = deeps;
    fa[x] = father;
    sizes[x] = 1;
    int max_son = -1;
    for(int i = head[x]; ~i; i = nex[i]){
        int y = ver[i];
        if(y == father)continue;
        dfs_son(y, x, deeps + 1);
        sizes[x] += sizes[y];
        if(sizes[y] > max_son)son[x] = y, max_son = sizes[y];
    }
}

void dfs_build(int x, int topfa)
{
    id[x] = ++ cnt;
    a_after[cnt] = a[x];
    top[x] = topfa;
    if(!son[x])return ;
    dfs_build(son[x], topfa);
    for(int i = head[x]; ~i; i = nex[i]){
        int y = ver[i];
        if(y == fa[x] || y == son[x])continue;
        dfs_build(y, y);//每个节点都有从他自己开始的一个轻链
    }
}

void update_range(int x, int y, int k)
{
    while(top[x] != top[y]){
        if(deep[top[x]] < deep[top[y]])swap(x, y);
        modify(1, id[top[x]], id[x], k);
        x = fa[top[x]];
    }
    if(deep[x] > deep[y])
        swap(x, y);
        modify(1, id[x], id[y], k);
}

bool solve(int a1, int a2, int b1, int b2){
    update_range(a1, a2, 1);
    update_range(b1, b2, 1);
    if(tr[1].maxv == 2){
        return false;
    }
    update_range(a1, a2, -1);
    update_range(b1, b2, -1);
    return true;
}
int t;
int main()
{
    scanf("%d", &t);
    while(t -- ){
        memset(tr, 0, sizeof tr);
        memset(head, -1, sizeof head);
        tot = 0;
        scanf("%d%d", &n, &m);
        root = 1;
        for(int i = 1; i <= n - 1; ++ i){
            int x, y;
            scanf("%d%d", &x, &y);
            add(x, y);add(y, x);
        }
        dfs_son(root, 0, 1);
        dfs_build(root, root);
        build(1, 1, n);
        //1~n, 1 ~ n - 1//2~n, 2~n - 1
        bool flag = 0;
        if(solve(1, n, 2, n - 1))
            puts("Banana and kazuya won't be angry!"), flag = 1;
        if(!flag && solve(1, n - 1, 2, n))
            puts("Banana and kazuya won't be angry!"), flag = 1;
        if(!flag)puts("Van is in a dilemma!");
    }
    return 0;
}

H、Nuclear launch detected

在这里插入图片描述
DP

#include<cstdio>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<cstring>

using namespace std;
const int N = 2e5 + 5;
int n, h, l, r, a[N];
int dp[N][205];
int f(int x) { x = (x%h+h)%h; return x>=l&&x<=r; }
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> h >> l >> r;
	for(int i=1; i<=n; i++)
	{
		cin >> a[i];
		a[i] = (a[i] + a[i-1])%h;
		for(int j=0; j<=min(i-1, h-1); j++)
		{
			dp[i][j] = max(dp[i][j], dp[i-1][j] + f(a[i]-j));
			dp[i][(j+1)%h] = max(dp[i][(j+1)%h], dp[i-1][j] + f(a[i]-j-1));
		}
	}
	int ans = 0;
	for(int i=0; i<h; i++) ans = max(ans, dp[n][i]);
	cout << ans << '\n';
	return 0;
}

I 、Character Wheels

在这里插入图片描述
题目大意：给你一个n*n的字符串矩阵，其中n是偶数，我们从外向里编号为1~n，每次输入P表示输出这个矩阵，L、x、t表示第x圈向左（逆时针）转t圈，R同理。

其实就是一个大模拟，会让你转然后输出，我们可以标记一下当前一共需要转多少次，最后输出的时候直接判断一下画图输出即可，因为只有四种情况，毕竟正方形，转四圈就会转回来，然后一直是一个循环节，所以我们只需要考虑%4，分别画图计算出转0，1，2，3次的位置输出即可，不用真的每次都把图转过来，这样写出来代码比较简单。（输入字符还是cin好用，不用担心什么奇怪的换行符，空格符，输出的时候可以用printf快一点）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>

using namespace std;

const int N = 107, M = 5000007, INF = 0x3f3f3f3f;

int n, m;
int a[N];
char g[N][N], op;
int num;
int rota[N];//rota[i]表示第i圈要顺时针转多少圈

int get_num(int x, int y)//得到圈数，画个图就好
{
    int minv = min(x, y);//一侧
    int maxv = n + 1 - max(x, y);//另一侧
    return min(minv, maxv);//最小既是圈数
}

void print()
{
    for(int i = 1; i <= n; ++ i){
        for(int j = 1; j <= n; ++ j){
            num = get_num(i, j);
            int t = rota[num];
            if(t == 1)
                printf("%c", g[n + 1 - j][i]);//自己画图理解
            else if(t == 2)
                printf("%c", g[n + 1 - i][n + 1 - j]);
            else if(t == 3)
                printf("%c", g[j][n + 1 - i]);
            else printf("%c", g[i][j]);
        }
        puts("");
    }
}

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++ i){
        for(int j = 1; j <= n; ++ j){
            cin >> g[i][j];
        }
    }
    scanf("%d", &m);
    while(m -- ){
        cin >> op;
        if(op == 'P'){
            print();
        }
        else if(op == 'L'){
            int x, t;
            scanf("%d%d", &x, &t);
            rota[x] -= t;
            while(rota[x] < 0)//顺时针转3圈等于逆时针转1圈
                rota[x] += 4;
        }
        else {
            int x, t;
            scanf("%d%d", &x, &t);
            rota[x] += t;
            rota[x] %= 4;
        }
    }
    return 0;
}

J、K-th route

在这里插入图片描述
~~图我收了~~

待补。

先放一个大佬的代码：

#include <bits/stdc++.h>
using namespace std;
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
const int N=3e6;
ll f[N],a,b,c,d;
int main()
{
	ios::sync_with_stdio(false);
	int T;
	cin>>T;
	while(T--)
	{
		int x,y,k;
		cin>>x>>y>>k;
		if (k>(x+1)*(y+1)-1||x+y>k||(k-x-y)%2==1)
		{
			cout<<"NO"<<endl;
		} else
		{
			cout<<"YES"<<endl;
			int t=k-x-y;
			int f=t/(2*y);
			int x1=0,y1=0;;
			rep(i,1,f)
			{
				x1+=2;
				rep(j,1,y) cout<<"E";
				cout<<"S";
				rep(j,1,y) cout<<"W";
				cout<<"S";
			}
		    f=(t%(2*y))/2;
		    if (x1<x-1)
		    {
		    	rep(i,1,f) cout<<"E";
		    	cout<<"S";
		    	rep(i,1,f) cout<<"W";
		    	cout<<"S";
		    	x1+=2;
		    } else
		    {
		      rep(i,1,f)
			  {
				y1+=2;
				cout<<"SENE";
		      }
		    }
		    rep(i,x1,x-1) cout<<"S";
			rep(i,y1,y-1) cout<<"E";
			cout<<endl; 
		}
	}
	return 0;
}