2022牛客寒假算法基础集训营2

最新推荐文章于 2023-02-03 22:34:51 发布
最新推荐文章于 2023-02-03 22:34:51 发布
阅读量315 收藏
点赞数
文章标签： 算法 贪心算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60896526/article/details/126062980
版权

A小沙的炉石

题意：

给定 n n n张法术攻击牌（造成一点基础攻击）和 m m m张法术回复牌（回复一点法力）。有一个随从，每使用一张法术牌就会增加法术攻击力1点。每次使用攻击牌造成的攻击是基础攻击加法术攻击，初始有一点法力，法术攻击力为0点。给定 k k k个询问，是否可以恰好杀死血量为 x x x的怪物。

分析：

首先可以最多攻击的次数cnt = min(m + 1, n),我们考虑最小的攻击伤害 m n mn mn和最大的攻击伤害 m x mx mx。那么我们很容易贪心算出每使用一张攻击牌再使用一张回复牌是最优的， m n = c n t 2 mn=cnt^2 mn=cnt2，先把所有回复牌用完再使用攻击牌所造成 的伤害是最大的， m x = c n t ∗ ( c n t + 2 m + 1 ) / 2 mx =cnt*(cnt+2m+1)/2 mx=cnt∗(cnt+2m+1)/2。那么我们对一些相邻的牌交换顺序后可以发现，该区间内的所有伤害都可以取到，那么我们二分判断即可。

code:

void solve() {
    int n, m;
    in(n), in(m);
    int cnt = min(m + 1, n);
    LL mx = 1LL * cnt * (cnt + 2 * m + 1) / 2;
    int k; in(k);
    while(k--) {
        LL x;
        in(x);
        if(x > mx) {
            puts("NO");
        } else {
            LL l = 1, r = cnt;
            while(l < r) {
                LL mid = l + r >> 1;
                LL now = mid * 1LL * (mid + 2 * m + 1) / 2;
                if(now >= x) r = mid;
                else l = mid + 1;
            }
            if(l * l <= x) puts("YES");
            else puts("NO");
        }
    }
}

C小沙的杀球

题意：

给定一串01序列，0代表是小球，1代表高远球，只有高远球可选择进行杀球操作。初始体力x，每次杀球消耗a点，不杀球回复b点，问最多能杀多少个。

code：

模拟即可。

int main() {
	ll x, a, b;
	cin >> x >> a >> b;
	string s; cin >> s;
	ll res = 0;
	for (char c : s) {
		if (c == '0' || x < a)x += b;
		else {
			res++;
			x -= a;
		}
	}
	cout << res;
	return 0;
}

E小沙的长路

题意：

给定一个n个点的完全图，可以给每条边选择方向且每条边最多走一次，求最长路的最大值和最小值。

思路：

对于最小值：首先如果图中有一个环，那么我们肯定走环，这样会更长，所以我们要少构造有环的边，没有环的话，每个点只能走一次，即 m i n = n − 1 min=n-1 min=n−1。
对于最大值：那么我们肯定想每一条边都走一遍，就是构造一个欧拉通路：度数为奇数的点只能有0个或2个。那么我们就要尽可能少的删去一些边。如果n是奇数，那么我们每个点的度数都是偶数，一条边都不用删即可；否则，我们要删去 ( n − 2 ) / 2 (n-2)/2 (n−2)/2条边，使得 n − 2 n-2 n−2个点的度数变为偶数。

code:

void solve() {
    int n;
    in(n);
    cout << n - 1 << ' ';
    if(n & 1) cout << 1LL * n * (n - 1) / 2 << '\n';
    else {
        cout << 1LL * n * (n - 1) / 2 - (n - 2) / 2 << '\n';
    }
}

F小沙的算数

题意：

给定一个算术式，只包含 ∗ 和 + *和+ ∗和+运算符， q q q次询问，每次询问会修改某个数字的值，并输出修改后式子的答案。（修改是永久性修改）

思路：

首先乘法肯定是优先计算的，那么就启发我们先把乘法运算的数合并起来，看作一个连通块，之后每次修改的时候修改一下连通块的值然后更改答案即可。

code:

typedef long long LL;
typedef pair<int, int> pii;
template <typename T> void inline in(T &x) {
    int f = 1; x = 0; char s = getchar();
    while (s < '0' || s > '9') { if (s == '-') f = -1; s = getchar(); }
    while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();
    x *= f;
} 
template <typename T> void inline pr(T x) {
    if (x < 0) { putchar('-'); pr(-x); return ; }
    if (x >= 10) pr(x / 10);
    putchar((x % 10) + '0');
}

const int N = 1e6 + 10, M = N * 2, mod = 1e9 + 7;
inline LL ksm(LL a, LL b){
    LL ans = 1; 
    for(; b; b >>= 1, a = a * a % mod) if(b & 1) ans = ans * a % mod;
    return ans;
}
//----------------------------------------------------------------------------------------//
#define int LL
int n, q, p[N];
int a[N], b[N];

int find(int x) {
    return x == p[x] ? x : p[x] = find(p[x]);
}
void merge(int a, int b) {
    int pa = find(a), pb = find(b);
    if(a != b) p[pa] = pb;
}
void solve() {
    in(n), in(q);
    string s; cin >> s;
    for(int i = 1; i <= n; i++) p[i] = i;
    for(int i = 1; i <= n; i++) in(a[i]), b[i] = a[i];
    for(int i = 2; i <= n; i++) {
        if(s[i - 2] == '*') merge(i - 1, i);
    }
    int ans = 0;
    for(int i = 1; i <= n; i++) {
        if(find(i) != i) {
            int pa = find(i);
            a[pa] = a[pa] * 1LL * a[i] % mod;
        } else ans = (ans + a[i]) % mod;
    }
    // D(ans);
    while(q--) {
        int x, y;
        in(x), in(y);
        int fx = find(x);
        ans = (ans - a[fx] + mod) % mod;
        a[fx] = a[fx] * ksm(b[x], mod - 2) % mod * y % mod;
        ans = (ans + a[fx]) % mod;
        b[x] = y;
        cout << ans << '\n';
    }
}

G小沙的身法

题意：

给定 n n n个木桩，每个木桩离地的高度为 a [ i ] a[i] a[i]， n n n个木桩构成一棵树，边代表着可以从木桩 u u u跳到木桩 v v v，如果 a [ u ] > a [ v ] a[u]>a[v] a[u]>a[v],则不消耗体力，否则消耗 a [ u ] − a [ v ] a[u]-a[v] a[u]−a[v]点体力。 m m m个询问，每次询问从木桩 x x x跳到 y y y的最小体力。

思路：

既然是树上的问题且是无根树，那么我们首先能想到的是先任选一个根节点去操作，操作什么呢？根据题目的要求，我们可以先求出根节点跳到每一个节点的最小体力：g[i] = g[fa] + max(0, a[i] - a[fa])。但是这样是不够的，我们思考：我们是需要 x x x节点先往上跳，跳到根节点，再从根节点往下跳跳到 y y y节点。所以我们还需要求出每一个点向上跳到根节点的最小体力值f[i] = f[fa] + max(0, a[fa] - a[i])，那么对于重复部分，减去它们的 L C A LCA LCA即可。即ans = f[u] - f[lca(x,y)] + g[y] - g[lca(x,y)] + a[x].

code:

typedef long long LL;
typedef pair<int, int> pii;
template <typename T> void inline in(T &x) {
    int f = 1; x = 0; char s = getchar();
    while (s < '0' || s > '9') { if (s == '-') f = -1; s = getchar(); }
    while (s <= '9' && s >= '0') x = x * 10 + (s ^ 48), s = getchar();
    x *= f;
} 
template <typename T> void inline pr(T x) {
    if (x < 0) { putchar('-'); pr(-x); return ; }
    if (x >= 10) pr(x / 10);
    putchar((x % 10) + '0');
}

const int N = 1e6 + 10, M = N * 2, mod = 1e9 + 7;
inline LL ksm(LL a, LL b){
    LL ans = 1; 
    for(; b; b >>= 1, a = a * a % mod) if(b & 1) ans = ans * a % mod;
    return ans;
}
//----------------------------------------------------------------------------------------//

int n, m;
int h[N], e[M], ne[M], idx;
LL a[N];
int depth[N], fa[N][25];
LL f[N], g[N]; //f[x]向上跳，g[x]向下跳
inline void add(int a, int b) {
    e[idx] = b; ne[idx] = h[a]; h[a] = idx++;
}
void dfs(int u, int FA = 0) {
    depth[u] = depth[FA] + 1;
    fa[u][0] = FA;
    for(int k = 1; k < 20; k++) fa[u][k] = fa[fa[u][k - 1]][k - 1];

    f[u] = f[FA] + max(0LL, a[FA] - a[u]);
    g[u] = g[FA] + max(0LL, a[u] - a[FA]);

    for(int i = h[u]; ~i; i = ne[i]) {
        int j = e[i];
        if(j == FA) continue;
        dfs(j, u);
    }
}
inline int LCA(int a, int b) {
    if(depth[a] < depth[b]) swap(a, b);
    for(int k = 20; k >= 0; k--) {
        if(depth[fa[a][k]] >= depth[b]) 
            a = fa[a][k];
    }
    if(a == b) return a;
    for(int k = 20; k >= 0; k--) {
        if(fa[a][k] != fa[b][k]) {
            a = fa[a][k];
            b = fa[b][k];
        }
    }
    return fa[a][0];
}
void solve() {
    in(n), in(m);
    memset(h, -1, sizeof h);
    for(int i = 1; i <= n; i++) in(a[i]);
    for(int i = 1; i < n; i++) {
        int x, y; in(x), in(y);
        add(x, y); add(y, x);
    }
    dfs(1); 
    while(m--) {
        int x, y;
        in(x), in(y);
        int L = LCA(x, y);
        LL ans = f[x] - f[L] + g[y] - g[L] + a[x];
        cout << ans << '\n';
    }
}

H小沙的数数

题意：

给定 n , m ( n , m < 1 0 18 ) n,m(n,m<10^{18}) n,m(n,m<1018)，构造一个长度为 n n n数列满足的数组的和等于 m m m的情况下 s u m = a [ 1 ] ⊕ a [ 2 ] ⊕ . . . ⊕ a [ n ] sum = a[1]\oplus a[2]\oplus ...\oplus a[n] sum=a[1]⊕a[2]⊕...⊕a[n]的值尽可能的大。求有多少种方案。

分析：

对于异或运算，相当于无进位加法。更严谨的说： a + b = ( a & b ) ∗ 2 + a ⊕ b a+b=(a\&b) * 2 + a\oplus b a+b=(a&b)∗2+a⊕b， 要使 a ⊕ b a\oplus b a⊕b最大，即让 a & b = 0 a\&b=0 a&b=0。
那么我们想让异或和 s u m sum sum尽可能的大，就是让 s u m = m sum=m sum=m，同时所有数的二进制下的每一位最多只有一个1，且该位是由 m m m决定的。同时该位的1可以放在任意一个数的相应位上。

code：

void solve() {
    LL n, m;
    in(n), in(m);
    n %= mod;
    LL res = 1;
    for(; m; m -= lowbit(m)) res = res * n % mod;
    cout << res << '\n';

}

L/M小沙的remake

题意：

有 n n n个物品，每个物品价值为 a [ i ] a[i] a[i],我们可以选择这个物品，也可以不，如果选择它的话，保证在它前面的区间 [ i − b [ i ] , i ) [i-b[i],i) [i−b[i],i)内所有选择过的物品的价值都小于它。问有多少种选择方案。

思路：

既然要保证按价值大小进行选择，那么我们就先按照价值对其进行排序。然后用树状数组优化转移即可。

code：

int a[N], b[N];
pii p[N];
LL tr[N];
int n,seed;

inline void add(int x, LL v) {
    while(x <= n) {
        tr[x] = (tr[x] + v) % mod;
        x += lowbit(x);
    }
}
inline LL get(int x) {
    LL sum = 0;
    while(x) {
        sum = (sum + tr[x]) % mod;
        x -= lowbit(x);
    }
    return sum;
}
void solve() {
    scanf("%d %d",&n,&seed);
	srand(seed);
	for(int i = 1; i <= n; i++) {
		a[i]=read(0),b[i]=read(i);
        p[i].fi = a[i];
        p[i].se = i;
	}
    sort(p + 1, p + 1 + n);
    for(int i = 1; i <= n; i++) {
        LL now = (get(p[i].se) - get(p[i].se - b[p[i].se] - 1) + 1 + mod) % mod;
        add(p[i].se, now);
    }
    cout << get(n);
}
Silence_Jy
关注
2022牛客寒假算法基础集训营1
SecretMas的博客
03-07 4036
A 九小时九个人九扇门 题意： 给定n个正整数，分别计算出数字根为1—9的组合数 涉及算法：数字根，线性dp 数字根： 将一正整数的各个位数相加(即横向相加)后，若加完后的值大于等于10的话，则继续将各位数进行横向相加直到其值小于十为止所得到的数，即为数字根。 性质一： 两个正整数相加，原来两个数的数字根之和等于和的数字根。 性质二： 设一个正整数为 x，则其数字根为 (x - 1) % 9 + 1。 由数字根的性质二，数字根求解的核心代码： int f (int x) { return (x - 1
2023牛客寒假算法基础集训营1
m0_51863774的博客
01-17 999
/本人能力有限，以下只附上本人get到的题，其他参考以上链接或其他来源：牛客网众所周知，2022年是四年一度的世界杯年，那么当然要整点足球题。本题需要你模拟一次点球大战。假设对战双方为A和B，则点球大战中双方会按照ABABABABAB方式来罚点球，即两队交替罚点球、各罚五次、A队先罚。点球有罚进和罚不进两种结果，罚中的一方加一分。其判断胜负的规则为得分多者获胜，而若在罚完某一球后（无论是哪队罚的），当前双方比分已经使得无论之后的罚球结果如何都不会影响比赛的结果，则此时比赛结束。
2023牛客寒假算法基础集训营3(A~G)
ygh2437068791的博客
01-20 302
2023牛客寒假算法基础集训营3A~G，这次题目比较好，都比较简洁，做的就很舒服
2023牛客寒假算法基础集训营4 赛时思路+正解
qq_52358098的博客
01-30 1016
也许是qdu acmer写的最后一篇寒假训练营题解。
2023牛客寒假算法基础集训营5(9/12)
eyuhaobanga的博客
02-01 149
2023牛客寒假算法基础集训营5
2021牛客寒假算法基础集训营5 - D石子游戏
weixin_45509601的博客
02-22 1410
前言：哎，这场打的就很nanshou，开局a出俩题，剩下的数学题兴趣就直接无了，结果俩小时直接结束战斗。 结束之后看了一下题解，感觉D题讲的有点麻烦，这边讲一下一种更低效率不过更加直观的做法。如果有看不懂题解的朋友可以尝试一下我的理解。 正文开始# 没看过题目的可以去牛客先看一下。我这里自己出一组数据。 1 5 2 3 3 2 0 2 这里介绍一个算法，差分算法，至于为什么想到的，只能说看到这题就本能的就想到这个算法。 我们对数据进行差分（就是前一个数减后一个数）。得到差分数组cut。 0 1 2 -2 然
2022牛客寒假算法基础集训营3
m0_58178876的博客
01-30 1363
当天去走亲戚了，后来自己vp了一下，只能说逃过一劫，这场真阴间（呜呜呜，被智乃哥哥杀爆了），赛中6赛后8，估算rank在450名左右，打了估计掉分 A：签中签，0 B：背包，6（1） C：dp（补） D：签到，2 E：模拟，175（6） G：数据结构（补） I：尺取，107（5） L：stl+模拟，30 B：智乃买瓜 这题本质就是一个分组背包，每种物品三个操作：选，不选，选一半，其实就是一组里面三个物品，0，整个，半个。至于我为什么wa1，哈哈，忘了取模，棹，前两场每场都因为这个wa过.
2023牛客寒假算法基础集训营5 小沙の不懂(思维)
最新发布
jikelk的博客
02-03 544
每日一题（牛客）
【题解】2023牛客寒假算法基础集训营2
qq_52765554的博客
01-23 2356
贪心的想，总权值最大，可能存在一个点处于v的边界上，再看数据范围，因此我们可以枚举边界（即H），用map存一下分别对应的改变区间，最后，分别枚举不同的H求maxv即可。贪心的想，当一个大的权值点深度越深，则它被求sum的次数就越多，所以我们就往这个方向靠，求出每个点的深度，深度越深，则赋予其越大的权值，最后累加求和即可。我们发现，当前分成k组时，如果某种元素个数k，则该种元素的造成的影响是k-1，累加即可。tag：贪心，dfs，bfs，树形DP。
牛客寒假训练营2-小沙的炉石 （结论或二分题）
weixin_45666296的博客
02-24 252
题意 链接：登录—专业IT笔试面试备考平台_牛客网 来源：牛客网 小沙热衷于玩决斗法，今天他和他的弟弟玩起了炉石，弟弟特别特别的菜，但是为了照顾弟弟的自尊心，所以小沙想要恰好将弟弟斩杀。 恰好斩杀：弟弟的血量恰好变成0。 小沙当前的手上有nnn张法术进攻牌，每张牌都会消耗一点法力，造成一点基础伤害，有mmm张法术回复牌，不需要消耗法力值，每次可以恢复一点法力。小沙一开始有一点法力，法力没有上限。 他们都属于法术。 小沙场上有一个随从。他可以使你施法法术后使你的法术伤害+1。 每张法术进攻牌.
【非官方题解】2022牛客寒假算法基础集训营2
Wmiracle的博客
01-30 863
牛客寒假算法基础集训营2非官方题解，记录自己的学习过程，内容为赛时自己的代码加上赛后参考他人代码的总和
2022牛客寒假算法基础集训营2 A.小沙的炉石&&I.小沙的构造
ZZU_LGY
01-26 531
A.小沙的炉石----推性质+二分 二分代码 #include <iostream> #include <algorithm> using namespace std; #define int long long const int N = 1000010,mod=1000000007; signed main() { int n,m,q; scanf("%lld%lld%lld",&n,&m,&q); int x; wh
【2022寒假基础集训】第二场 -A.小沙的炉石【二分】
lppppppppps的博客
02-18 478
Date：2022.02.17 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 小沙热衷于玩决斗法，今天他和他的弟弟玩起了炉石，弟弟特别特别的菜，但是为了照顾弟弟的自尊心，所以小沙想要恰好将弟弟斩杀。 恰好斩杀：弟弟的血量恰好变成0。 小沙当前的手上有n张法术进攻牌，每张牌都会消耗一点法力，造成一点基础伤害，有mm张法术回复牌，不需要消耗法力值，每次可以恢复一点法力。小沙一开始有一点法力，法力没有上
2022牛客寒假补题记录 2
nttttt の blog
03-31 324
A.小沙的炉石 数学结论/二分 感觉考虑区间合并会更好做一些,不过不好想 考虑在有限次的攻击中能造成伤害的最大和最小值 攻击最大次数 maxn=min(n,m+1)maxn=min(n,m+1)maxn=min(n,m+1); 设攻击 aaa 次,回蓝bbb次,易想到 一次攻击一次回蓝造成的伤害是最低的,伤害序列为 1,3,5,7....1,3,5,7....1,3,5,7....,伤害为 a2a^2a2 先使用完法术牌再使用攻击牌伤害是最高的,伤害序列为1+b,2+b,3+b....1+b,2+b,3+
完全图/欧拉回路
honeistbutter的博客
02-08 2621
链接 完全图： 完全图是一个简单的无向图，其中每对不同的顶点之间都恰连有一条边相连。完全图最多有n*(n-1)/2条边 求最长路径的最小值和最大值： 最小值：首先最长路径不能有环，否则会无限长，所以在无环情况下，每个点经过一次，最长路径的最小值是n−1n-1n−1 最大值：走遍每一条边——欧拉回路，又因为无向图的欧拉回路最多有(n−1)n/2(n-1)n/2(n−1)n/2条边，而欧拉回路要求无向图的奇数度的点最多有2个，分奇偶点情况讨论 奇数点：nnn为奇数，(n−1)(n-1)(n−1)为偶数，所以n
牛客暑期多校集训营五题详解：最小行走距离与传送门策略
2020牛客暑期多校集训营第五场的编程题目是关于带权图的路径规划与优化问题，主要涉及C++编程。题目背景是有一个包含n个节点和m条边的图，初始位置在1号节点，需要按照顺序完成k个任务，每个任务包括从一个特定的a[i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值