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

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


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

A、Easy Equation

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


前缀和差分。

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

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

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

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

我们用 f[i] 表示i能够被多少个前两个范围的数(x+y)加起来的方案数,我们直接循环x,那么所有从 xx+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;
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 撸撸猫 设计师:设计师小姐姐 返回首页