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

最新推荐文章于 2024-06-11 08:56:11 发布
最新推荐文章于 2024-06-11 08:56:11 发布
阅读量1k 收藏 28
点赞数 18
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjdysq/article/details/136057303
版权

文章目录

A. Tokitsukaze and Bracelet

分情况讨论计数，时间复杂度 O ( n ) O(n) O(n)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
void solve()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)
    {
        int ans = 0;
        int a, b, c;
        cin >> a >> b >> c;
        if(a == 150)
        ans++;
        if(a == 200)
        ans += 2;
        if(b == 45)
        ans += 2;
        else if(b >= 34 && b <= 40)
        ans++;
        if(c == 45)
        ans += 2;
        else if(c >= 34 && c <= 40)
        ans++;
        cout << ans << '\n';
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

B. Tokitsukaze and Cats

考虑当前猫和左边，右边的猫共用一条边

遍历，遇到一只猫答案加 4 4 4,如果左边或者上边有猫，答案分别减 1 1 1，时间复杂度 O ( n m ) O(nm) O(nm)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int a[305][305];
void solve()
{
    int n, m, k;
    cin >> n >> m >> k;
    for(int i = 1;i <= k;i++)
    {
        int x, y;
        cin >> x >> y;
        a[x][y] = 1;
    }
    int ans = 0;
    for(int i = 1;i <= n;i++)
    {
        for(int j = 1;j <= m;j++)
        {
            if(a[i][j] == 1)
            {
                ans += 4;
                if(a[i - 1][j] == 1)
                ans--;
                if(a[i][j - 1] == 1)
                ans--;
            }
        }
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    //cin >> t;
    while (t--)
    solve();
    return 0;
}

D. Tokitsukaze and Slash Draw

题解是用最短路算法，但是在赛时用 d p dp dp瞎搞出来了

d p [ i ] [ j ] dp[i][j] dp[i][j], i i i为当前卡片的编号， j j j为目标卡片的位置

考虑三个转移态

1. 1. 1.从前一张卡片的当前位置转移来， d p [ i ] [ j ] = m a x ( d p [ i ] [ j ] , d p [ i − 1 ] [ j ] ) dp[i][j] = max(dp[i][j],dp[i-1][j]) dp[i][j]=max(dp[i][j],dp[i−1][j])

2. 2. 2.从前一张卡片的前一个位置转移来， d p [ i ] [ j ] = m a x ( d p [ i ] [ j ] , d p [ i − 1 ] [ ( j + v [ i ] + n − 1 ) % n + 1 ] ) dp[i][j]=max(dp[i][j],dp[i-1][(j + v[i] + n - 1) \% n + 1]) dp[i][j]=max(dp[i][j],dp[i−1][(j+v[i]+n−1)%n+1])

3. 3. 3.从当前卡片的前一个位置转移来，由于可能出现后面决定前面的情况，婆娑一这种情况下我用了一个 q u e u e queue queue去维护有变化的 d p dp dp值

时间复杂度 O ( n m l o g n ) O(nmlogn) O(nmlogn)

（顺便吐槽一下，手调记得删掉调试代码，硬吃了几发罚时）

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int dp[1005][5005];
int v[N], w[N];
void solve()
{
    int n, m, k;
    cin >> n >> m >> k;
    for(int i = 1;i <= m;i++)
    cin >> v[i] >> w[i];
    for(int i = 0;i <= m;i++)
    {
        for(int j = 0;j <= n;j++)
        dp[i][j] = INF;
    }
    dp[0][k] = 0;
    for(int i = 1;i <= m;i++)
    {
        for(int j = 1;j <= n;j++)
        {
            int pos = (j + n - 1) % n + 1;
            int ppos = (j - v[i] + n - 1) % n + 1;
            dp[i][pos] = min(dp[i][pos], dp[i - 1][pos]);
            dp[i][pos] = min(dp[i][pos], dp[i - 1][ppos] + w[i]);
            //cout << i << " " << pos << " " << dp[i][pos] << '\n';
        }
        for(int j = 1;j <= n;j++)
        {
            queue<int> q;
            int pos = (j + n - 1) % n + 1;
            int npos = (j + v[i] + n - 1) % n + 1;
            if(dp[i][npos] > dp[i][pos] + w[i])
            {
                dp[i][npos] = dp[i][pos] + w[i];
                q.push(npos);
            }
            while(!q.empty())
            {
                int tp = q.front();
                q.pop();
                pos = (tp + n - 1) % n + 1;
                npos = (tp + v[i] + n - 1) % n + 1;
                if(dp[i][npos] > dp[i][pos] + w[i])
                {
                    dp[i][npos] = dp[i][pos] + w[i];
                    q.push(npos);
                }
            }
        }
    }
    int ans = INF;
    for(int i = 1;i <= m;i++)
    ans = min(ans, dp[i][n]);
    if(ans == INF)
    cout << "-1" << '\n';
    else
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

EF. Tokitsukaze and Eliminate

看每种宝石中最后出现的那颗宝石的位置，每次操作消除最前面的宝石即可

用一个变量记录每次消除后剩余的宝石种类，从后往前遍历，时间复杂度 O ( n ) O(n) O(n)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int a[N];
void solve()
{
    map<int, int> m;
    map<int, int> nm;
    int n;
    cin >> n;
    int zl = 0, ans = 0;
    for(int i = 1;i <= n;i++)
    {
        cin >> a[i];
        m[a[i]]++;
        if(m[a[i]] == 1)
        zl++;
    }
    int nzl = 0, nex = zl;
    for(int i = n;i >= 1;i--)
    {
        nm[a[i]]++;
        m[a[i]]--;
        if(m[a[i]] == 0)
        nex--;
        if(nm[a[i]] == 1)
        nzl++;
        if(nzl == zl)
        {
            nm.clear();
            ans++;
            nzl = 0;
            zl = nex;
        }
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

G. Tokitsukaze and Power Battle (easy)

好怪啊，赛时没想到这样的时间复杂度是可行的

由题目可知，给对方留一个数才能取到最大值

用线段树维护区间和，每次查询从后往前在各个区间里找最大值，时间复杂度 O ( q l o g 2 n ) O(qlog^2n) O(qlog2n)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 1e9 + 7;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int ls(int x) { return 2 * x; }
int rs(int x) { return 2 * x + 1; }
ll num[N], a[N * 4], tag[4 * N];
void build(int s, int t, int p) {//建树调用
	// 对 [s,t] 区间建立线段树,当前根的编号为 p
	if (s == t) {
		a[p] = num[s];
		return;
	}
	int m = (s + t) / 2;
	build(s, m, ls(p));
	build(m + 1, t, rs(p));
	a[p] = a[ls(p)] + a[rs(p)];
}
void push_down(int s, int t, int p) {//查询过程和更新过程调用
	if (!tag[p] || s == t) return;
	int m = (s + t) / 2;
	a[ls(p)] += tag[p] * (m - s + 1); a[rs(p)] += tag[p] * (t - m);
	tag[ls(p)] += tag[p]; tag[rs(p)] += tag[p];
	tag[p] = 0;
}
void update(int l, int r, ll c, int s, int t, int p) {//区间加减时调用
	// [l, r] 为修改区间, c 为被修改的元素的变化量, [s, t] 为当前节点包含的区间, p为当前节点的编号
	if (l <= s && t <= r) {
		a[p] += (ll)(t - s + 1) * c; tag[p] += c;
		return;
	}
	int m = (s + t) / 2;
	push_down(s, t, p);
	if (m >= l) update(l, r, c, s, m, ls(p));
	if (m < r) update(l, r, c, m + 1, t, rs(p));
	a[p] = a[ls(p)] + a[rs(p)];
}
ll query(int l, int r, int s, int t, int p) {//查询区间和调用
	// [l, r] 为查询区间, [s, t] 为当前节点包含的区间, p 为当前节点的编号
	if (l <= s && t <= r)
		return a[p];
	push_down(s, t, p);
	int m = (s + t) / 2;
	ll sum = 0;
	if (m >= l) sum += query(l, r, s, m, ls(p));
	// 如果左儿子代表的区间 [s, m] 与询问区间有交集, 则递归查询左儿子
	if (m < r) sum += query(l, r, m + 1, t, rs(p));
	// 如果右儿子代表的区间 [m + 1, t] 与询问区间有交集, 则递归查询右儿子
	return sum;
}
int b[N];
void solve()
{
    int n, q;
    cin >> n >> q;
    for(int i = 1;i <= n;i++)
    cin >> num[i];
    build(1, n, 1);
    while(q--)
    {
        int tt, x, y;
        cin >> tt >> x >> y;
        if(tt == 1)
        update(x, x, y - query(x, x, 1, n, 1), 1, n, 1);
        else
        {
            int ans = query(x, y, 1, n, 1);
            ans = ans - 2 * query(y, y, 1, n, 1);
            for(int i = y - 1;i > x;i--)
            {
                if(query(x, i, 1, n, 1) <= ans)
                break;
                ans = max(ans, query(x, i, 1, n, 1) - 2 * query(i, i, 1, n, 1));
            }
            cout << ans << '\n';
        }
    }
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

I. Tokitsukaze and Short Path (plus)

对于任意两个点，它们两个的最小权值即为两个顶点值中大的那个 ∗ 2 *2 ∗2，所以我们只需要把权值进行排序，每个点都统领着比它小的点，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int a[N];
void solve()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)
    cin >> a[i];
    sort(a+1,a+n+1);
    int ans = 0;
    for(int i = n;i >= 1;i--)
    {
        int cnt = i - 1;
        ans = ans + cnt * 4 * a[i];
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

J. Tokitsukaze and Short Path (minus)

对于任意两个点，有两种选择：直接到达和先到最小权值点再到达

将权值从小到大排序后，两个点的路径权值为 m i n ( a [ 1 ] ∗ 4 , a [ i ] ∗ 2 ) min(a[1] * 4, a[i] * 2) min(a[1]∗4,a[i]∗2)， a [ i ] a[i] a[i]为两个点中权值较小的那个点，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 998244353;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int a[N];
void solve()
{
    int n;
    cin >> n;
    for(int i = 1;i <= n;i++)
    cin >> a[i];
    sort(a+1,a+n+1);
    int ans = 0;
    for(int i = 1;i <= n;i++)
    {
        int cnt = (n - i) * 2;
        ans = ans + cnt * min(a[1] * 4, a[i] * 2);
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}

K. Tokitsukaze and Password (easy)

暴力搜索就能过，时间复杂度算不太出来

一开始考虑的太多了，担心时间超限，所以加了很多限制条件，怎么都过不去。然后死马当作活马医，删了六十多行代码后居然过了…）
这个故事告诉我们，要敬畏暴力之神，不要想七想八（祭拜暴力之神cc）

#include <bits/stdc++.h>
#define int long long
#define YES "YES"
#define NO "NO"
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef __int128 lll;
typedef __uint128_t ulll;
typedef pair<int, int> pii;
const double eps = 1e-9;
const int N = 1e6 + 10;
const int INF = 1e18;
const int mod = 1e9 + 7;
const int base = 13331;
mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
int n, ans, mx;
string a, b;
int x[26];
map<int, int> mp;
void dfs(int pos, int cnt)
{
    //cout << pos << " " << cnt << '\n';
    if(pos == n)
    {
        if(cnt % 8 == 0 && cnt > 0 && cnt <= mx)
        ans = (ans + 1) % mod;
        return;
    }
    if(pos == 0)
    {
        if(a[pos] >= '0' && a[pos] <= '9')
        dfs(pos + 1, cnt * 10 + a[pos] - '0');
        else if(a[pos] == '_')
        {
            for(int i = 1;i <= 9;i++)
            dfs(pos + 1, cnt * 10 + i);
        }
        else
        {
            for(int i = 1;i <= b[pos] - '0';i++)
            {
                mp[i] = 1;
                x[a[pos] - 'a'] = i;
                dfs(pos + 1, cnt * 10 + i);
                mp[i] = 0;
                x[a[pos] - 'a'] = -1;
            }
        }
    }
    else
    {
        if(a[pos] >= '0' && a[pos] <= '9')
        dfs(pos + 1, cnt * 10 + a[pos] - '0');
        else if(a[pos] == '_')
        {
            for(int i = 0;i <= 9;i++)
            dfs(pos + 1, cnt * 10 + i);
        }
        else
        {
            if(x[a[pos] - 'a'] != -1)
            dfs(pos + 1, cnt * 10 + x[a[pos] - 'a']);
            else
            {
                for(int i = 0;i <= 9;i++)
                {
                    if(mp[i] == 0)
                    {
                        x[a[pos] - 'a'] = i;
                        mp[i] = 1;
                        dfs(pos + 1, cnt * 10 + i);
                        mp[i] = 0;
                        x[a[pos] - 'a'] = -1;
                    }
                }
            }
        }
    }
}
void solve()
{
    mp.clear();
    ans = 0;
    mx = 0;
    cin >> n;
    cin >> a;
    cin >> b;
    for(int i = 0;i <= 25;i++)
    x[i] = -1;
    for(int i = 0;i < n;i++)
    mx = mx * 10 + b[i] - '0';
    for(int i = 0;i < n;i++)
    {
        if(a[i] >= '0' && a[i] <= '9')
        {
            if(a[i] > b[i])
            {
                cout << "0" << '\n';
                return;
            }
            else if(a[i] < b[i])
            break;
        }
        else
        break;
    }
    if(a[0] == '0' && n > 1)
    {
        cout << "0" << '\n';
        return;
    }
    dfs(0, 0);
    if(n == 1)
    {
        if(a[0] >= '1' && a[0] <= '9')
        ;
        else
        ans++;
    }
    cout << ans << '\n';
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
    cin >> t;
    while (t--)
    solve();
    return 0;
}
木木警官
关注
  • 18
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
2024牛客寒假算法基础集训营3
zjdysq的博客
02-08 1423
文章目录A. 智乃与瞩目狸猫、幸运水母、月宫龙虾B. 智乃的数字手串C. 智乃的前缀、后缀、回文D. chino's bubble sort and maximum subarray sum（easy version）GH. 智乃的比较函数J. 智乃的相亲活动K. 智乃的“黑红树”LM. 智乃的36倍数 A. 智乃与瞩目狸猫、幸运水母、月宫龙虾 比较首个字母是否是不区分大小写同个字母，时间复杂度O(T)O(T)O(T) #include <bits/stdc++.h> #define int l
2024牛客寒假算法基础集训营1
m0_74176921的博客
02-02 2187
首先对于一个满减 ,满 a1 减 b1 ，如果另外一个满减，满 a2 减 b2 ,如果满足 a2>=a1，那么如果购买的金额 大于 a2 的时候，所获得的减免就是 b1+b2 ,于是我们想到先减免要求价格从小到大排序一下，利用前缀和记录 bi ,于是便获得了大于某个价格的最大减免，由于要求得是能购买的最大值，于是我们可以从减免要求价格从大往下开始遍历，如果当前价格减去减免额之后小于给定的 m ，说明是合法的，最终的原价就是 m+ 减免额。同时榜单上还有"向左"按钮与"向右"按钮来切换显示的题目。
2024牛客寒假算法基础集训营1 复盘
m0_73738728的博客
02-02 477
这一场总体上打得稀烂，自己的水平没有完全发挥出来。直接原因就是在一道简单题上卡住了，没有灵活变通，致使自己思路也混沌了，其实后面很多题都可以做。在赛场上要及时调整，做好决策。另外有一题数据范围没有看仔细，导致浪费了很多时间。有一题使用了静态数组，但规模开小了，少打了一个0，导致多WA了一发。这些问题以后都要注意。理论上ACM不需要对拍，但最好还是准备好相应的模板，以备不时之需。
2024牛客寒假算法基础集训营5
m0_73673533的博客
02-22 284
完全背包+加不少于的模型由于人数只有1000，那么 bi 实际有效的范围只有1000左右，并且，soyorin至少要花一次 p 的代价将消息通知给 1 个人，然后再让这个人去将消息通知给剩下的 n−1 个人。​ 那么问题就转化成了：将消息通知给 n−1 个人的最小代价，将消息通知给 bi 个人需要花费 ai 的代价，且 ai,bi 能用多次，也就是一个完全背包。注意一些细节。
2024牛客寒假算法基础集训营1部分题解
m0_51863774的博客
02-02 1082
2024牛客寒假算法基础集训营1
2024牛客寒假算法基础集训营4
心如冰清，天塌不惊
02-20 623
前往后遍历，如果（从上个割点开始的）前缀和对 k 的余数，在位置 j 和位置 i 的相同，说明区间 [j+1,i]的和能整除 k。可以进行任意次操作，每次操作选择数组 a 的两个元素，其中一个加 1，另一个减 1，要求每次操作后 a 的各元素仍然是正整数。例如数组 [20,12,16]，共有的约数有 1,2,4，最大的数是 4，因此 [20,12,16] 的最大公约数是 4。假设这些数的和是sum，这道题的本质上就是求，在sum的因子中，有多少个因子能把sum分解的个数是大于等于 n 个的。
2022牛客寒假算法基础集训营1
ygh2437068791的博客
12-29 360
2022牛客寒假算法基础集训营1，前几道简单中等题。
2020牛客暑期多校集训营第三场题解.pdf
01-20
题解
2020牛客多校暑期集训营第一场题解.pdf
01-20
2020牛客多校暑期集训营第一场题解.pdf
2020牛客暑期多校集训营第二场题解.pdf
01-20
2020牛客暑期多校集训营第二场题解.pdf
2020牛客暑期多校集训营第五场题解.pdf
01-20
2020牛客暑期多校集训营第五场题解.pdf
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1014
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 147
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 687
LeetCode 算法：轮转数组c++
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 759
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
最新发布
清隆学长的博客
06-11 325
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
牛客竞赛算法入门班怎么样
01-14
牛客竞赛算法入门班是一个针对算法竞赛初学者的培训班。它提供了系统的课程和习题，帮助学员掌握算法竞赛中常用的算法和数据结构，并提高解题能力。通过参加这个培训班，学员可以学到以下内容： 1. 算法基础知识：包括时间复杂度、空间复杂度、递归、排序算法等。 2. 数据结构：包括数组、链表、栈、队列、树、图等。 3. 常用算法：包括贪心算法、动态规划、回溯算法、分治算法等。 4. 算法竞赛技巧：包括如何优化算法、如何处理特殊情况、如何设计算法等。 5. 实战习题：提供大量的算法竞赛习题，帮助学员巩固所学知识并提高解题能力。 通过参加牛客竞赛算法入门班，学员可以系统地学习算法竞赛的基础知识和技巧，提高解题能力，并为参加算法竞赛打下坚实的基础。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值