2025牛客寒假算法基础集训营6

A. 复制鸡

题意：对于一个字符串，你每次可以选择其中任意一些位置，然后把每个位置上的字符复制一个到这个位置后面。现在给你一个操作过的字符串，求它的所有可能的原串的最小长度。

因为每个位置操作后是在后面添加一个相同的字符，那么我们可以把所有相同的区间当做一个字符。数有多少个这样的区间就行了。

点击查看代码 
void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; ++ i) {
    	std::cin >> a[i];
    }

    int ans = 1;
    for (int i = 1; i < n; ++ i) {
    	ans += a[i] != a[i - 1];
    }

    std::cout << ans << "\n";
}

B. 好伙计猜拳

题意：给你n个二元组(a,b)，你可以花c2代价交换某个二元组的a,b，或者删掉某个二元组。求最终让这个二元组序列的a和b都非递减的最小代价。

比较简单的dp，f[i][0/1]表示第i个位置时没有/有进行交换的最小代价。那么可以枚举上一个没有被删的位置在哪里，然后进行讨论就行。答案取值有点麻烦，可以加一个inf,inf的二元组到最后面，答案就是f[n+1][0]。

点击查看代码 
void solve() {
    int n, c1, c2;
    std::cin >> n >> c1 >> c2;
    std::vector<std::pair<int, int>> a(n + 2);
    for (int i = 1; i <= n; ++ i) {
    	std::cin >> a[i].first >> a[i].second;
    }

    a[n + 1] = {2e9, 2e9};

    const i64 inf = 1e18;
    std::vector f(n + 2, std::array<i64, 2>{inf, inf});
    f[0][0] = 0;
    for (int i = 1; i <= n + 1; ++ i) {
    	for (int j = 0; j < i ; ++ j) {
    		auto & [x, y] = a[i];
    		auto & [c, d] = a[j];
    		if (c <= x && d <= y) {
    			f[i][0] = std::min(f[i][0], f[j][0] + (i64)(i - j - 1) * c1);
    		}

    		if (d <= x && c <= y) {
    			f[i][0] = std::min(f[i][0], f[j][1] + (i64)(i - j - 1) * c1);
    		}

    		if (c <= y && d <= x) {
    			f[i][1] = std::min(f[i][1], f[j][0] + (i64)(i - j - 1) * c1 + c2);
    		}

    		if (c <= x && d <= y) {
    			f[i][1] = std::min(f[i][1], f[j][1] + (i64)(i - j - 1) * c1 + c2);
    		}
    	}
    }

    std::cout << f[n + 1][0] << "\n";
}

C. 数列之和

题意：在一个由偶数组成的无穷序列里，求所有长度大于2的区间和的第k大。

ai=2×i−2，一个区间[i,j]的区间和为(j−i+1)(ai+aj)2，代入得(j−i+1)(2i−2+2j−2)2=(j−i+1)(i+j−2)。可以通过打表发现除了大于2的所有2的幂，其它偶数都会出现。于是二分找到这个数即可。

点击查看代码 
void solve() {
	//(j - i + 1)(i + j - 2)
	i64 k;
	std::cin >> k;

	auto check = [&](i64 x) -> i64 {
		i64 lg = std::__lg(x) - 1;
		return x / 2 - lg;
	};

	i64 l = 2, r = 3e18;
	while (l < r) {
		i64 mid = l + r >> 1ll;
		if (check(mid) >= k) {
			r = mid;
		} else {
			l = mid + 1;
		}
	}

	std::cout << l << "\n";
}

D. Viva La Vida(Fried-Chicken's Version)

题意：有一个n个点的完全图，图里的边是有一个随机生成的n(n−1)2的排列赋值的。现在按照下面的步骤重新选边，从1到n的每个点都选择它连接的所有边里边权最小的边，如果这条边之前被其他点选了就不用操作了。求最后图的联通块个数的期望。

首先，最后的图一定是一个森林，然后森林的联通块的个数就是点数减边数，因为森林可以从一棵树删边变过来，一棵树是n个点n−1条边，是一个联通块，每删去一条边就会多一个联通块，而每次删边点数不变，边数减一，所以森林的联通块的个数就是点数减边数。那么回到这个问题，这个图里什么操作和删边等价？就是两个点选择了同一条边，本来每个点都选一条不一样的边就是n点n边，每有一条边被重复选就少一条边，就相当于删边了。于是我们要求的是每条边被重复选择的概率。一条边连接的两个点总共有2n−3条边，那么这条边是这些边里最小的边的概率是12n−3，总共有n(n−1)2条边，所以答案就是n(n−1)22n−3。

E. 任造化落骰

题意：给你n个在值域里独立均匀生成的数，每次询问有多少区间的max×min≥k。

注意考虑独立均匀生成带来了什么性质。结论是所有区间的(max,min)中不同的对最多有2nlogn个。
那么可以枚举左端点，每次求一段(max,min)相同的区间，可以二分去求，用st表预处理区间最大最小值。然后右端点一段一段条，所有左端点的右端点总共只会跳2nlogn次，所以可以把所有(max,min)对应的区间用map存下来。然后把所有值都存到数组了，搞一个前缀和，查询就可以直接二分。

点击查看代码 
template <class Info> 
struct ST {
    std::vector<std::vector<Info>> st;
    ST(std::vector<Info> a) {
        int n = a.size(), m = std::__lg(n) + 1;
        st.assign(n, std::vector<Info>(m));
        for (int i = 0; i < n; ++ i) {
            st[i][0] = a[i];
        }

        for (int j = 1; j < m; ++ j) {
            for (int i = 0; i + (1 << j - 1) < n; ++ i) {
                st[i][j] = st[i][j - 1] + st[i + (1 << j - 1)][j - 1];
            }
        }
    }

    Info query(int l, int r) {
        int lg = std::__lg(r - l + 1);
        return st[l][lg] + st[r - (1 << lg) + 1][lg];
    }
};

struct Info {
    int max, min;
};

Info operator + (Info a, Info b) {
    return {std::max(a.max, b.max), std::min(a.min, b.min)};
}

bool operator == (const Info a, const Info b)  {
    return a.max == b.max && a.min == b.min;
}

void solve() {
    int n, m, q;
    std::cin >> n >> m >> q;
    std::vector<int> a(n);
    std::vector<Info> info(n);
    for (int i = 0; i < n; ++ i) {
        std::cin >> a[i];
        info[i] = {a[i], a[i]};
    }

    ST<Info> st(info);
    std::map<i64, i64> mp;
    for (int i = 0; i < n; ++ i) {
        int j = i;
        while (j < n) {
            Info info = st.query(i, j);
            int l = j, r = n - 1;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (st.query(i, mid) == info) {
                    l = mid;
                } else {
                    r = mid - 1;
                }
            }

            mp[(i64)info.max * info.min] += l - j + 1;
            j = l + 1;
        }
    }

    std::vector<i64> v;
    for (auto & [x, y] : mp) {
        v.push_back(x);
    }

    int cnt = v.size();
    std::vector<i64> sum(cnt + 1);
    for (int i = 0; i < cnt; ++ i) {
        sum[i + 1] = sum[i] + mp[v[i]];
    }

    while (q -- ) {
        i64 k;
        std::cin >> k;
        int p = std::lower_bound(v.begin(), v.end(), k) - v.begin();
        std::cout << sum[cnt] - sum[p] << "\n";
    }
}

F. 薪得体会

题意：n个二元组(a,b)，你可以将其重新排列，然后按顺序操作，开始工资为a1，如果前面的最大工资大于等于ai，则第i个的值为ai+bi，否则为ai。问最大工资是多少。

发现如果我们选最大的ai，那么其余的aj+bj都可以选，那么只剩下求有没有一种方式可以得到ai+bi，如果a中ai的值有多个，那么就可以取到；如果只有一个，那么问题就变成比a比ai小的二元组里最大能不能是ai。那么这提示我们按a从小到大处理。
按照ai从小到大排序，然后按顺序遍历，如果有多个二元组a的值为ai，则所有aj<=ai的aj+bj都可以取到，否则看前面小于ai能得到的最大值能不能有ai，然后如果我们选ai，则前面的所有aj<ai的aj+bj都可以取到。

点击查看代码 
void solve() {
    int n;
    std::cin >> n;
    std::vector<std::pair<int, int>> a(n + 1);
    for (int i = 1; i <= n; ++ i) {
    	std::cin >> a[i].first >> a[i].second;
    }

    std::sort(a.begin() + 1, a.end(), [&](std::pair<int, int> & a, std::pair<int, int> & b) {
    	return a.first < b.first;
    });

    std::vector<int> pre(n + 1);
    for (int i = 1; i <= n; ++ i) {
    	pre[i] = std::max(pre[i - 1], a[i].first + a[i].second);
    }

    int ans = 0;
    for (int i = 1; i <= n; ++ i) {
    	int j = i;
    	while (j <= n && a[i].first == a[j].first) {
    		++ j;
    	}

    	-- j;
    	if (j - i + 1 > 1) {
    		ans = std::max(ans, pre[j]);
    	} else if (ans >= a[i].first) {
    		ans = std::max(ans, a[i].first + a[i].second);
    	}

    	ans = std::max(ans, pre[i - 1]);
    	i = j;
    }

    ans = std::max(ans, a[n].first);

    std::cout << ans << "\n";
}

G. 目标是【L2】传说高手

题意：有n个卡牌，进行了若干场对局，每场对局中每个卡牌都可以出或者不出。一个卡牌的胜率为出场次数/使用该牌的对局获胜次数，一个卡牌的出场率为出场次数/总局数。选择给你若干给有一位小数的小数，代表每张卡牌的某个概率。求当这个概率代表每个胜率的时候的最少对局数和作为出场率的最少对局数。每个概率在[pi−0.05,pi+0.05)之间浮动。

观察到小数位很少，为了保证精度我们可以给每个概率乘上100，那么pi∈[0,10000]，pi在[pi−5,pi+5)之间浮动。
先看问题二，考虑最多多少场一定满足所有情况，发现1000场就够了，因为只有一个小数位，那么任何一个概率的分母都可以用1000表示。
那么我们可以从小到大枚举总场次x，那么对于每个概率都要满足pi−510000≤yx<pi+510000，其中y也是枚举，最多到x，那么就是x×(pi−5)≤y×10000<x×(pi+5)，可以按概率从小到大排序，那么y就是不断递增的，n个数总共只会执行x次。
再看问题一，首先化为最简分式的形式来看，必如25,34。一个贪心的想法是直接取最大的分母，因为每个卡牌在每一场可以选择出不出，那么总共出分母大小次，在赢的场里面选分子大小的场数就行了。但发现是不行的，因为你总共出了这么多场，要求输几场赢几场，可能使得其他卡牌不能满足，比如举的这个例子，总场数是5，赢两场输三场，发现第二个卡牌需要赢三场，满足不了。因为我们只能满足胜场或者输场的个数，但没法两个都满足。那么考虑至少需要多少胜场，是最大分子的值，最少需要几个败场？则是最大的分母减分子大小个。
那么我们也可以枚举分母，对于每个卡牌找一个满足条件的分母记录胜场和败场的最大值即可。

点击查看代码 
void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; ++ i) {
        std::string s;
        std::cin >> s;
        for (int j = 0; j < s.size(); ++ j) {
            if (s[j] != '.') {
                a[i] = a[i] * 10 + s[j] - '0';
            }
        }

        a[i] *= 10;
        // std::cout << a[i] << " \n"[i == n - 1];
    }

    std::sort(a.begin(), a.end());

    if (a[n - 1] == 0) {
        std::cout << 0 << " " << 0 << "\n";
        return;
    }

    int ans1 = 0, ans2 = 0;
    int max1 = 0, max2 = 0;
    std::vector<int> st(n);
    int cnt = 0;
    for (int i = 1; cnt < n; ++ i) {
        for (int j = 0; j < n; ++ j) {
            if (st[j]) {
                continue;
            }

            if (a[j] == 0) {
                st[j] = 1;
                ++ cnt;
                continue;
            }

            int down = i * (a[j] - 5);
            int up = i * (a[j] + 5);
            if (down % 10000) {
                down /= 10000;
                down += 1;
                down *= 10000;
            }

            if (down < up) {
                ++ cnt;
                st[j] = 1;
                int x = down / 10000;
                max1 = std::max(max1, x);
                max2 = std::max(max2, i - x);
            }
        }
    }

    ans1 = max1 + max2;

    for (int i = 1; i <= 1000; ++ i) {
        int j = 0;
        for (int k = 0; k < n; ++ k) {
            while (j <= i && (j * 10000 < i * (a[k] - 5) || j * 10000 >= i * (a[k] + 5))) {
                ++ j;
            }

            if (j > i) {
                break;
            }
        }

        if (j <= i) {
            ans2 = i;
            break;
        }
    }

    std::cout << ans1 << " " << ans2 << "\n";
}

H. 小鸡的排列构造

题意：要求构造一个排列，使得每个数在使用区间长度是偶数的区间或者区间长度是奇数的区间排序后位置改变。

这题可以猜结论，然后用I题代码验证。
下面是我的对拍代码。

点击查看代码 
#define ls(u) tr[u].lson
#define rs(u) tr[u].rson

const int N = 3e5 + 5;

struct Node {
	int lson, rson;
	int sum;
}tr[N << 5];

int tot = 0;
int root[N];

void build(int &u, int l, int r) {
	u = ++ tot;
	if (l == r) {
		return;
	}

	int mid = l + r >> 1;
	build(ls(u), l, mid); build(rs(u), mid + 1, r);
}

void modify(int &u, int v, int l, int r, int p, int x) {
	u = ++ tot;
	tr[u] = tr[v];
	tr[u].sum += x;
	if (l == r) {
		return;
	}

	int mid = l + r >> 1;
	if (p <= mid) {
		modify(ls(u), ls(v), l, mid, p, x);
	} else {
		modify(rs(u), rs(v), mid + 1, r, p, x);
	}
}

int query(int u, int v, int l, int r, int p) {
	if (r <= p) {
		return tr[u].sum - tr[v].sum;
	}

	int mid = l + r >> 1;
	if (p <= mid) {
		return query(ls(u), ls(v), l, mid, p);
	} else {
		return query(ls(u), ls(v), l, mid, p) + query(rs(u), rs(v), mid + 1, r, p);
	}
}

std::mt19937 gen(std::random_device{}());

int rand(int l, int r) {
	std::uniform_int_distribution<int> dis(l, r);
	return dis(gen);
}

void solve() {
    // int n, m;
    // std::cin >> n >> m;
    int n = 2000, m = 2000;
    std::vector<std::array<int, 3>> a(m);
    int t = rand(0, 1);
    // std::cerr << t << "\n";
    for (int i = 0; i < m; ++ i) {
    	// int l, r, c;
    	// std::cin >> l >> r >> c;
    	int l = rand(1, n - 2), r = rand(l + 1, n);
    	while ((r - l) % 2 != t) {
    		r = rand(l + 1, n);
    	}
    	int c = rand(l, r);
    	a[i] = {l, r, c};
    }

    std::vector<int> ans(n);
    for (int i = 0; i < n; ++ i) {
    	ans[i] = n - i;
    }

    if ((a[0][1] - a[0][0] + 1) & 1) {
    	for (int i = 1; i + 1 < n; i += 2) {
    		std::swap(ans[i], ans[i + 1]);
    	}
    }

    // for (int i = 0; i < n; ++ i) {
    // 	std::cout << ans[i] << " \n"[i == n - 1];
    // }

    tot = 0;
    build(root[0], 1, n);
    for (int i = 1; i <= n; ++ i) {
    	modify(root[i], root[i - 1], 1, n, ans[i - 1], 1);
    }

    for (auto & [l, r, c] : a) {
    	if (c == l + query(root[r], root[l - 1], 1, n, ans[c - 1]) - 1) {
    		std::cout << "!!!" <<  l << " " << r << " " << c << "\n";
    	}
    }
}

分类讨论一下，如果区间长度是偶数，则直接n,n−1,...,2,1倒着来就行了。这个还是容易想的，因为倒着来排序后区间会翻转。
否则如果是奇数，直接从第二个位置开始，两个两个交换就行了，直接猜的。

点击查看代码 
void solve() {
    int n, m;
    std::cin >> n >> m;
    std::vector<std::array<int, 3>> a(m);
    for (int i = 0; i < m; ++ i) {
    	int l, r, c;
    	std::cin >> l >> r >> c;
    	a[i] = {l, r, c};
    }

    std::vector<int> ans(n);
    for (int i = 0; i < n; ++ i) {
    	ans[i] = n - i;
    }

    if ((a[0][1] - a[0][0] + 1) & 1) {
    	for (int i = 1; i + 1 < n; i += 2) {
    		std::swap(ans[i], ans[i + 1]);
    	}
    }

    for (int i = 0; i < n; ++ i) {
    	std::cout << ans[i] << " \n"[i == n - 1];
    }
}

I. 小鸡的排列构造的checker

题意：一个排列中，对于m个询问，求[l,r]中的第c个在排序后位置有没有变。

没脑子想不出正解，直接上主席树了。
用主席树维护值域，然后对于每个查询，就是求[l,r]里有多少个小于等于pc的数。很板子。

点击查看代码 
#define ls(u) tr[u].lson
#define rs(u) tr[u].rson

const int N = 3e5 + 5;

struct Node {
	int lson, rson;
	int sum;
}tr[N << 5];

int tot = 0;
int root[N];

void build(int &u, int l, int r) {
	u = ++ tot;
	if (l == r) {
		return;
	}

	int mid = l + r >> 1;
	build(ls(u), l, mid); build(rs(u), mid + 1, r);
}

void modify(int &u, int v, int l, int r, int p, int x) {
	u = ++ tot;
	tr[u] = tr[v];
	tr[u].sum += x;
	if (l == r) {
		return;
	}

	int mid = l + r >> 1;
	if (p <= mid) {
		modify(ls(u), ls(v), l, mid, p, x);
	} else {
		modify(rs(u), rs(v), mid + 1, r, p, x);
	}
}

int query(int u, int v, int l, int r, int p) {
	if (r <= p) {
		return tr[u].sum - tr[v].sum;
	}

	int mid = l + r >> 1;
	if (p <= mid) {
		return query(ls(u), ls(v), l, mid, p);
	} else {
		return query(ls(u), ls(v), l, mid, p) + query(rs(u), rs(v), mid + 1, r, p);
	}
}

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::vector<int> a(n + 1);
    for (int i = 1; i <= n; ++ i) {
    	std::cin >> a[i];
    }

    tot = 0;
    build(root[0], 1, n);
    for (int i = 1; i <= n; ++ i) {
    	modify(root[i], root[i - 1], 1, n, a[i], 1);
    }

    while (m -- ) {
    	int l, r, c;
    	std::cin >> l >> r >> c;
    	std::cout << l + query(root[r], root[l - 1], 1, n, a[c]) - 1 << "\n";
    }
}

J. 铁刀磨成针

题意：有n回合，初始x攻击力，y个磨刀石。没回合可以选择磨不磨刀，磨刀会消耗一个磨刀石，然后x = x + 1，然后选择是否攻击，攻击会造成x伤害，x = x - 1。

如果我们先砍几刀再来磨刀，显然是不划算的，最差也是一边磨刀一边攻击。所以我们枚举前面某i回合刀并且不攻击，然后接下来回合分成两部分，一种是一边磨刀一边攻击，一种是磨不了刀，一直砍到结束，总伤害是一个等差序列，可以直接算。

点击查看代码 
void solve() {
    i64 n, x, y;
    std::cin >> n >> x >> y;
    i64 ans = 0;
    for (int i = 0; i <= std::min(n, y); ++ i) {
    	i64 m = n - i;
    	i64 t = std::min(y - i, m);
    	i64 sum = t * (x + i + 1);
    	m -= t;
    	i64 a = x + i;
    	m = std::min(m, a);
    	sum += m * (a + a - m + 1) / 2;
    	ans = std::max(ans, sum);
    }

    std::cout << ans << "\n";
}

E. 鸡翻题

题意：(x,x+1)一组，(x−2,x−1)一组，(x+2,x+3)一组，依次类推。求有没有一组和是k。

首先明显是一个奇数加一个偶数，所以k一定是奇数。既然k是奇数，那么(x,x+1)就固定了，检查有没有这样的一组就行，就是看每组奇偶性是不是和这个相同。

点击查看代码 
void solve() {
    int x, y;
    std::cin >> x >> y;
    if (y % 2 == 0 || y / 2 % 2 != x % 2) {
    	std::cout << "NO\n";
    } else {
	    std::cout << "YES\n";
    }

}

L. 变鸡器

题意：给你一个字符串，每次可以选择两个不一样的同时删去，最后能不能变成"CHICKEN"。

先检查字符够不够，然后检查CHICKEN是不是子序列。
然后减去对应的字符个数，那么问题就变成一个经典问题，也是上一场考过的知识点，有n个数，每次选两个数减一，问最多操作几次。如果max>=sum/2则可以配sum−max对，否则可以配sum−sum%2对。这里不求操作几次，而是求能不能全部匹配。

点击查看代码 
void solve() {
    int n;
    std::cin >> n;
    std::string s;
    std::cin >> s;
    std::vector<int> cnt(26);
    for (auto & c : s) {
    	++ cnt[c - 'A'];
    }

    std::string t = "CHICKEN";
    for (auto & c : t) {
    	if ( -- cnt[c - 'A'] < 0) {
    		std::cout << "NO\n";
    		return;
    	}
    }

    int j = 0;
    for (int i = 0; j < t.size() && i < n; ++ i) {
    	if (s[i] == t[j]) {
    		++ j;
    	}
    }

    if (j != t.size()) {
    	std::cout << "NO\n";
    	return;
    }

    int sum = std::accumulate(cnt.begin(), cnt.end(), 0);
    int max = *std::max_element(cnt.begin(), cnt.end());
    if (sum % 2 == 1 || max > sum / 2) {
    	std::cout << "NO\n";
    } else {
    	std::cout << "YES\n";
    }
}
posted @   maburb  阅读(107)  评论(0)  编辑  收藏  举报
相关博文：
· 2025牛客寒假算法基础集训营2
· 2025牛客寒假算法基础集训营3
· 2025牛客寒假算法基础集训营6
· 牛客寒假算法基础训练营1
· 2025牛客寒假算法基础集训营6 ptlks的题解
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！
点击右上角即可分享
微信分享提示