Codeforces Round 917 (Div. 2) A~F

已于 2023-12-29 20:28:58 修改
阅读量605 收藏 8
点赞数 8
分类专栏： codeforces题解 文章标签： 算法 OI codeforces
于 2023-12-27 11:58:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Code_Shark/article/details/135242130
版权

A.Least Product(思维)

题意：

给出一个数组 a 1 , a 2 , . . . , a n a_1, a_2, ..., a_n a1​,a2​,...,an​，你可以进行若干次以下操作：

  • 选择数组中的一个元素 a i a_i ai​，将这个数字修改为 0 ∼ a i 0 \sim a_i 0∼ai​之间的任意数字。

问，最少需要多少次操作可以使得 ∏ i = 1 n a i \prod\limits_{i = 1}^{n}a_i i=1∏n​ai​的结果最小，并输出对应的操作。

分析：

可以将问题分成两种情况：

  • 存在 a i = 0 a_i = 0 ai​=0或负数的出现次数为奇数，此时无论进行任何操作都无法使结果变得更小，输出0

  • 其他情况，由于数字只能被修改到 0 ∼ a i 0 \sim a_i 0∼ai​之间，那么正负数是无法互相转换的，因此，当结果为正数时，任选一个 a i a_i ai​，将其修改为 0 0 0，就能获得最小的结果

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;


void solve() {
    int n;
    cin >> n;
    int zero = 0, sign = 0;
    for (int i = 1; i <= n; i++) {
        int a;
        cin >> a;
        if (a == 0) {
            zero = 1;
        } else if (a < 0) {
            sign++;
        }
    }
    if (zero || sign % 2 == 1) cout << 0 << endl;
    else {
        cout << 1 << endl;
        cout << "1 0" << endl;
    }
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

B.Erase First or Second Letter(思维)

题意：

给出一个长度为 n n n的字符串 s s s，你可以进行若干次以下操作：

  • 移除第一个字符

  • 移除第二个字符

问：经过若干次操作后，可以获得多少种不同的非空字符串？

分析：

将字符串划分为前后两部分，枚举两部分的分界点，每次枚举完分界点后，将后半部分视为不进行修改的部分，仅会对前半部分进行操作，那么由于每次枚举的后半部分均不同，为了保证方案的独立性，前半部分仅保留一个字符，那么此时的方案数就是前半部分中包含的不同字母的数量。

使用计数数组或set动态记录不同字符数量，每次枚举分界点后更新前半部分字符种类并记录到答案中即可。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

int vis[30];

void solve() {
    memset(vis, 0, sizeof (vis));
    int n;
    string s;
    cin >> n >> s;
    int cnt = 0, ans = 0;
    for (int i = 0; i < n; i++) {
        vis[s[i] - 'a']++;
        if (vis[s[i] - 'a'] == 1) cnt++;
        ans += cnt;
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

C.Watering an Array(枚举)

题意：

给出一个长度为 n n n的数组 a a a,你将在接下来的 d d d天里每天选择执行以下两个操作之一：

  • 给所有的 a 1 , a 2 , . . . , a b i a_1, a_2, ..., a_{b_i} a1​,a2​,...,abi​​加上一，其中 b i b_i bi​为题目给出的第 i i i天的操作数。

  • 数组 a a a中 a i = i a_i = i ai​=i的数量就是你本轮获得的得分，然后将 a a a数组所有元素修改为 0 0 0

问：最多可以获得多少得分？

Tips:由于天数较多，因此 b b b数组采用 b = [ v 1 , v 2 , . . . , v k , v 1 , v 2 , . . . , v k , . . . ] b = [v_1, v_2, ..., v_k, v_1, v_2, ..., v_k, ...] b=[v1​,v2​,...,vk​,v1​,v2​,...,vk​,...]的形式给出。

分析：

如果数组 a a a开始全部为 0 0 0，那么最优策略就是操作 1 , 2 1,2 1,2轮流进行，可以获得 ⌊ d 2 ⌋ \lfloor\frac{d}{2}\rfloor ⌊2d​⌋点得分（注意：开始时若 a 1 ≥ 1 a_1 \ge 1 a1​≥1，则需要使用一次操作 2 2 2将 a 1 a_1 a1​修改为 0 0 0，此时得分为 ( ⌊ d − 1 2 ⌋ + 开始时数组元素可以产生的得分 (\lfloor\frac{d - 1}{2}\rfloor + \text{开始时数组元素可以产生的得分} (⌊2d−1​⌋+开始时数组元素可以产生的得分）。

而由于初始的数组是包含初始数字的，且长度为 n n n的数组最多可以产生 n n n点得分，因此，只需要在 2 × n − 1 2 \times n - 1 2×n−1的操作次数内均有可能超过循环操作获取的 n n n点固定得分。

枚举第一次进行操作 2 2 2前会进行多少次操作 1 1 1，每次遍历数组统计得分，剩余的操作次数使用最优策略进行。记录过程中最大的得分即可。

坑点

既然获取的长度为 n n n的数字最高可以产生 n n n点得分，那么只枚举 n n n次操作是否就够了？

反例：

原数组为 2 , 1 , 2 , . . . , n − 1 2, 1, 2, ..., n - 1 2,1,2,...,n−1，给出的 b b b数组为 [ 1 , 1 , . . . , 1 , n ] [1, 1, ..., 1, n] [1,1,...,1,n]，其中 b i = n b_i = n bi​=n前有 ( 2 × n ) − 4 (2 \times n) - 4 (2×n)−4个1，此时 d = 2 × n d = 2 \times n d=2×n。

可以发现，枚举 0 ∼ n 0 \sim n 0∼n次操作 1 1 1，均无法产生额外得分，此时获得的最高总分为 ⌊ d − 1 2 ⌋ = n − 1 \lfloor \frac{d - 1}{2} \rfloor = n - 1 ⌊2d−1​⌋=n−1，而依次使用 ( 2 × n ) − 3 (2 \times n) - 3 (2×n)−3次操作 1 1 1，再进行操作 2 2 2，可以获得 n − 1 n - 1 n−1点得分，此时还剩下两次操作，还可以继续一次最优策略，最后得分为 n n n。

代码：

#include<bits/stdc++.h>

using namespace std;
typedef long long LL;
const int MAXN = 3e5 + 5e2;

LL a[MAXN], b[MAXN];

void solve() {
    LL n, k, d;
    cin >> n >> k >> d;
    LL ans = 0;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 0; i < k; i++) cin >> b[i];
    for (int i = 0; i <= 2 * n && i < d; i++) {
        LL cnt = 0;
        for (int j = 1; j <= n; j++) if (a[j] == j) cnt++;
        ans = max(ans, cnt + (d - i - 1) / 2);
        for (int j = 1; j <= b[i % k]; j++) {
            if (a[j] == j) cnt--;
            a[j]++;
            if (a[j] == j) cnt++;
        }
    }
    cout << ans << endl;
}

int main() {
    int Case;
    cin >> Case;
    while (Case--) {
        solve();
    }
    return 0;
}

D.Yet Another Inversions Problem(树状数组+逆序对)

题意：

给定一个由 1 1 1到 2 n − 1 2n-1 2n−1的奇数组成的排列 p 0 , p 1 , … , p n − 1 p_0,p_1,…,p_{n−1} p0​,p1​,…,pn−1​和一个由 0 0 0到 k − 1 k-1 k−1的整数组成的排列 q 0 , q 1 , … , q k − 1 q_0,q_1,…,q_{k−1} q0​,q1​,…,qk−1​。定义长度为 n k nk nk的数组 a 0 , a 1 , … , a n k − 1 a_0,a_1,…,a_{nk−1} a0​,a1​,…,ank−1​如下：对于所有 0 ≤ i < n 0 \le i \lt n 0≤i<n和所有 0 ≤ j < k 0 \le j \lt k 0≤j<k，有 a i ⋅ k + j = p i ⋅ 2 q j a_{i⋅k+j}=p_i⋅2^{q_j} ai⋅k+j​=pi​⋅2qj​。例如，如果 p = [ 3 , 5 , 1 ] p=[3,5,1] p=[3,5,1]且 q = [ 0 , 1 ] q=[0,1] q=[0,1]，那么 a = [ 3 , 6 , 5 , 10 , 1 , 2 ] a=[3,6,5,10,1,2] a=[3,6,5,10,1,2]。所有数组都是从零开始索引的。注意，数组 a a a中每个元素是唯一确定的。计算数组 a a a中逆序对 ( i , j ) ( 0 ≤ i < j < n k ) (i,j)(0 \le i < j < nk) (i,j)(0≤i<j<nk)的数量，结果对 998244353 998244353 998244353取模。

分析：

对于同一个 a i a_i ai​，逆序对个数仅取决于 q {q} q的逆序对个数。

考虑用树状数组求逆序对个数的过程。对该过程稍作修改，可以得到下面的算法：
对于 a i a_i ai​，大小在 ( a i , 2 a i ) (a_i,2a_i) (ai​,2ai​)之间的数而言， a i ⋅ 2 p j a_i⋅2^{p_j} ai​⋅2pj​与这些数能够形成的逆序对为 ( a i ⋅ 2 p j , a x ⋅ 2 p j − 1 ) (a_i⋅2^{p_j},a_x⋅2^{p_j-1}) (ai​⋅2pj​,ax​⋅2pj​−1), ( a i ⋅ 2 p j , a x ⋅ 2 p j − 2 ) (a_i⋅2^{p_j},a_x⋅2^{p_j-2}) (ai​⋅2pj​,ax​⋅2pj​−2)…… ( a i ⋅ 2 p j , a x ⋅ 2 0 ) (a_i⋅2^{p_j},a_x⋅2^0) (ai​⋅2pj​,ax​⋅20)，共有 p j p_j pj​个， a i a_i ai​与这些数所能形成的逆序对数量为 ∑ i = 0 k p i = ( 0 + k − 1 ) × k 2 \sum\limits_{i=0}^{k}p_i=(0+k-1)\times\frac{k}{2} i=0∑k​pi​=(0+k−1)×2k​。同理对大小在 ( 2 a i , 4 a i ) (2a_i,4a_i) (2ai​,4ai​)的数而言， a i a_i ai​与这些数所能形成的逆序对数量为 ∑ i = 0 k p i = ( 0 + k − 2 ) × k − 1 2 \sum\limits_{i=0}^{k}p_i=(0+k-2)\times\frac{k-1}{2} i=0∑k​pi​=(0+k−2)×2k−1​，如此不断向上倍增求答案，直到上限。

相反的，对于大小在 ( a i 2 , a i ) (\frac{a_i}{2},a_i) (2ai​​,ai​)之间的数，可以按相同的方式考虑，如此不断向下除二求答案，直到下限。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const LL mod = 998244353;
const LL N = 5e5;

struct BIT {
    LL n;
    vector<LL> tr;

    BIT(LL n) : n(n), tr(n + 1, 0) {
    }

    LL lowbit(LL x) {
        return x & -x;
    }

    void modify(LL x, LL m) {
        for (LL i = x; i <= n; i += lowbit(i)) {
            tr[i] += m;
        }
    }

    void modify(LL l, LL r, LL m) {
        modify(l, m);
        modify(r + 1, -m);
    }

    LL query(LL x) {
        LL res = 0;
        for (LL i = x; i; i -= lowbit(i))
            res += tr[i];
        return res;
    }

    LL query(LL x, LL y) {
        return query(y) - query(x);
    }
};

LL tmp[N];

LL merge_sort(LL q[], LL l, LL r) {
    if (l >= r)
        return 0;

    LL mid = (l + r) >> 1;
    LL res = merge_sort(q, l, mid) + merge_sort(q, mid + 1, r);
    LL i = l, j = mid + 1, k = 0;
    while (i <= mid && j <= r) {
        if (q[i] <= q[j]) tmp[k++] = q[i++];
        else {
            res += mid - i + 1;
            tmp[k++] = q[j++];
        }
    }

    while (i <= mid)
        tmp[k++] = q[i++];
    while (j <= r)
        tmp[k++] = q[j++];

    for (LL i = l, j = 0; i <= r; i++, j++)
        q[i] = tmp[j];

    return res;
}

void solve() {
    LL n, k;
    cin >> n >> k;
    BIT num(4 * n + 5), sum(k + 5);
    LL a[n], b[k];
    for (LL i = 0; i < n; i++) {
        cin >> a[i];
        num.modify(a[i], 1);
    }
    for (LL i = 0; i < k; i++) {
        cin >> b[i];
    }
    LL ans = merge_sort(b, 0, k - 1);
    ans *= n;
    ans %= mod;
    for (LL i = 0; i < n; i++) {
        LL x = a[i];
        LL cnt = 1;
        while (x < 2 * n) {
            LL t = x * 2;
            LL nn = num.query(x, t);
            if (nn == 0) {
                x = t;
                cnt++;
                continue;
            }
            LL end = max(1LL * 0, k - cnt);
            LL ns = (1 + end) * end / 2;
            ans += ns * nn;
            ans %= mod;
            x = t;
            cnt++;
        }
        x = a[i];
        cnt = 1;
        while (1) {
            if (x == 1)
                break;
            LL t = (x + 1) / 2;
            LL nn = num.query(t - 1, x - 1);
            if (nn == 0) {
                x = t;
                cnt++;
                continue;
            }
            LL st = min(k, cnt);
            LL cntt = k - st + 1;
            LL res = k - cntt;
            LL ns = k * res + (st + k) * cntt / 2;
            ans += nn * ns;
            ans %= mod;;
            x = t;
            cnt++;
        }
        num.modify(a[i], -1);
    }
    cout << ans << endl;
}

int main() {
    LL t = 1;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

E.Construct Matrix(构造)

题意：

给定一个偶数 n n n和一个整数 k k k。构造一个大小为 n × n n×n n×n的矩阵，由数字 0 0 0和 1 1 1组成，使其满足以下条件，或者输出不可能

所需满足的条件:

  • 矩阵中所有数的和正好是 k k k;
  • 第 i i i行中所有数字按位异或对每个 i i i都是相同的;
  • 第 j j j列中所有数字按位异或对每个 j j j都是相同的。

分析：

首先，因为所有列的 X O R XOR XOR的 X O R XOR XOR显然为 0 0 0（因为 n n n为偶），因此所有数的 X O R XOR XOR也为 0 0 0，故 k k k不可能为奇数。

如果 k k k是 4 4 4的倍数，这种情况是比较简单的。易知一个 2 x 2 2x2 2x2的全 1 1 1矩阵可以在不破坏原矩阵的情况下被添加进去，那么不断添加这样的矩阵就可以了。

如果 k ≡ 2 ( m o d 4 ) k≡2(mod4) k≡2(mod4)，不妨假设 k ≤ n 2 2 k \le \frac{n^2}{2} k≤2n2​，如果不满足，令 k ′ = n 2 − k k^{'}=n^2-k k′=n2−k，构造完再全部取反即可。当 k = 2 k=2 k=2时，显然不存在满足条件的矩阵。当 k = 6 k=6 k=6时，可以构造出一个 3 × 3 3 \times 3 3×3的矩阵，如下：

1 1 0
1 0 1
0 1 1

当 k ≥ 6 k≥6 k≥6时，考虑将上面这个矩阵放在前 4 4 4行 4 4 4列的位置，然后其他位置再通过添加 2 × 2 2\times2 2×2的全 1 1 1矩阵，即可构造满足要求的矩阵。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int N = 1005;
int T, n, k;
bool mat[N][N];
int draw_first2block = 0;

void reset() {
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            mat[i][j] = 0;
    draw_first2block = 0;
}

void draw() {
    mat[1][1] = mat[1][2] = mat[2][1] = mat[2][3] = mat[3][2] = mat[3][3] = 1;
    draw_first2block = 1;
}

void solve(int cnt) {
    int i = 1, j = 0;
    while (cnt) {
        if (++j > n / 2) {
            ++i;
            j = 1;
        }
        if (i <= 2 && j <= 2 && draw_first2block)
            continue;
        --cnt;
        mat[i * 2][j * 2] = mat[i * 2 - 1][j * 2] = mat[i * 2][j * 2 - 1] = mat[i * 2 - 1][j * 2 - 1] = 1;
    }
}

void reverse() {
    for (int i = 1; i <= n; ++i)
        for (int j = 1; j <= n; ++j)
            mat[i][j] ^= 1;
}

int main() {
    cin >> T;
    while (T--) {
        cin >> n >> k;
        if (n == 2 && k == 2) {
            cout << "Yes\n0 1\n1 0\n";
            continue;
        }
        bool check = false;
        if (k % 4 == 0) {
            check = true;
            reset();
            solve(k / 4);
        } else {
            bool reversed = false;
            if (k * 2 > n * n) {
                reversed = true;
                k = n * n - k;
            }
            if (k % 4 == 2 && k != 2) {
                check = true;
                reset();
                draw();
                solve((k - 6) / 4);
                if (reversed)
                    reverse();
            }
        }
        if (check) {
            cout << "Yes\n";
            for (int i = 1; i <= n; ++i) {
                for (int j = 1; j <= n; ++j)
                    cout << (mat[i][j] ? '1' : '0') << " \n"[j == n];
            }
        } else cout << "No\n";
    }
    return 0;
}

F.Construct Tree(bitset)

题意：

给定一个整数数组 l 1 , l 2 , … , l n l_1,l_2,…,l_n l1​,l2​,…,ln​和一个整数 d d d。是否能构造一棵满足以下三个条件的树:

  • 该树包含 n + 1 n+1 n+1个节点。
  • 第 i i i条边的长度等于 l i l_i li​。
  • 该树的（加权）直径等于 d d d。

分析：

考虑形式化地描述这个问题。先把 l l l排序。然后相当于是否存在一个 1 , 2 , … , n {1,2,…,n} 1,2,…,n的子集S，使得 ∑ i ∈ S l i = d \sum\limits_{i∈S}{l_i}=d i∈S∑​li​=d， ∃ T ⊆ S ∃T⊆S ∃T⊆S， m a x ( l i ) ≤ m i n ( ∑ i ∈ T l i , ∑ i ∈ S ∧ i ∉ T l i ) max(l_i)≤min(\sum\limits_{i\in T}{l_i},\sum\limits_{i\in S∧i\notin T}{l_i}) max(li​)≤min(i∈T∑​li​,i∈S∧i∈/T∑​li​)。

注意到若 n − 1 ∈ S ∧ n ∈ S n−1∈S∧n∈S n−1∈S∧n∈S，则第二个条件一定满足，让 n − 1 ∈ T n−1∈T n−1∈T且 n ∉ T n \notin T n∈/T即可。所以如果 l 1 , l 2 … l n − 2 l_1,l_2…l_n-2 l1​,l2​…ln​−2能凑出来 d − a n − 1 − a n d−a_{n−1}−a_n d−an−1​−an​就可行。

然后依次讨论 m a x ( i ) = n − 1 max(i)=n−1 max(i)=n−1（ i ∉ S i \notin S i∈/S）或 n n n的情况:

  • 若 m a x ( i ) = n − 1 max(i)=n−1 max(i)=n−1（ i ∉ S i \notin S i∈/S），那么 n ∈ S n∈S n∈S。若前 n − 2 n−2 n−2个元素能凑出来和为 x x x和 d − x − a n d−x−a_n d−x−an​的两个不相交集合，且 a n − 1 ≤ m i n ( x + a n , d − x − a n ) a_{n-1}≤min(x+a_n,d−x−a_n) an−1​≤min(x+an​,d−x−an​)$就可行。
  • 若 m a x ( i ) = n max(i)=n max(i)=n（ i ∉ S i \notin S i∈/S），那么若前 n − 1 n−1 n−1个元素能凑出来和为 x x x和 d − x d−x d−x的两个不相交集合，且 a n ≤ m i n ( x , d − x ) a_n≤min(x,d−x) an​≤min(x,d−x)就可行。

使用 b i t s e t bitset bitset进行优化。

代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;
const int maxn = 2005;

int n, m, a[maxn];
bitset<maxn> f[maxn], g;

void solve() {
    cin >> n >> m;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    sort(a + 1, a + n + 1);
    for (int i = 0; i <= m; ++i) {
        f[i].reset();
    }
    g.reset();
    f[0].set(0);
    g.set(0);
    for (int i = 1; i < n; ++i) {
        if (i == n - 1) {
            if (a[n - 1] + a[n] <= m && g.test(m - a[n - 1] - a[n])) {
                cout << "Yes" << endl;
                return;
            }
            for (int j = 0; j <= m - a[n]; ++j) {
                if (a[i] <= min(j + a[n], m - a[n] - j) && f[j].test(m - j - a[n])) {
                    cout << "Yes" << endl;
                    return;
                }
            }
        }
        for (int j = m; ~j; --j) {
            f[j] |= (f[j] << a[i]);
            if (j >= a[i]) {
                f[j] |= f[j - a[i]];
            }
        }
        g |= (g << a[i]);
    }
    for (int i = a[n]; i <= m - a[n]; ++i) {
        if (f[i].test(m - i)) {
            cout << "Yes" << endl;
            return;
        }
    }
    cout << "No" << endl;
}

int main() {
    int T = 1;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}

学习交流

以下为学习交流QQ群，群号： 546235402，每周题解完成后都会转发到群中，大家可以加群一起交流做题思路，分享做题技巧，欢迎大家的加入。

AC-Panda
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Educational Codeforces Round 83 (Rated for Div. 2) D
01-20
C(n-2,i-1)*C(j-1,n-2)*(i-1) __ j: n-1 -> m 我们发现内层循环，每次只是j加一，我们就可以只用一次组合数剩下的用差量表示 对于外层循环同理 只有(i-1) * C(n-2,i-1) i会每次加一。我们也只算一次剩下的用差量...
Codeforces Round #628 (Div. 2) A~~D
01-03
A #include using namespace std; typedef long long ll; int main(){ int t; cin>>t; while(t--){ ll x; cin>>x; cout<<1>>t; while(t--){ st.clear(); ll n; cin >>n; ll re
Codeforces Round 917 (Div. 2)（Codeforces日记）
weixin_74088105的博客
12-25 638
还是需要锻炼思维，就类似于C的状态转换，想出来直接就秒了。
Codeforces Round 917 (Div. 2)
Lanthamum的博客
12-24 540
############################################################################B.不会。A.考虑有没有负数，偶数（把没有负数考虑进去了）就要改变一个数为0，为min，如果是奇数就不用考虑
Codeforces Round 917 (Div. 2) D. Yet Another Inversions Problem
m0_73500785的博客
12-28 1045
个人练习记录
Codeforces Round 917 (Div. 2) 前三题
2203_75752922的博客
12-25 537
可以发现除了第一次执行操作2会获得值和下标相等元素个数的分数之外，我们之后每次执行操作2最多只能获得1分(执行完操作2之后，每次执行操作1最多有一个满足条件的元素)，那么我们可以一天执行操作1，下一天执行操作2，每两天获得1分，这是第一种保底的方法。第二种方法则是先执行i天操作1，让满足条件的元素尽可能变多，然后执行操作2，之后就和第一种方法一样每两天获得1分。给定一个数组，可以对其中任意元素操作任意次，操作规则：可以用0-a[i]之间的任意数替换a[i],，求使得数组所有元素之积最小的操作次数。
Codeforces Round 950 (Div. 3)（A~F2）
weixin_61825750的博客
06-04 1454
G题只会暴力..不会数据结构暴力模拟即可。
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #630 (Div. 2) D. Walk on Matrix（构造）
01-03
上面代码跑出来的dp[n][m]是0，然后从（1，1）（1，2）（2，2）（2，3）这样的相与值是k (看懂ans+k是啥应该就懂了) 代码： int main() { std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0); int ans=(1&...
Codeforces Round #628 (Div. 2)
01-03
给两两节点放一个数字（0~n-2 唯一） 给你一棵树，求所有任意两节点相连的路以外的路上的数字的最小值最小 思路 构造 若一个点连了三条边及以上，则这个点的边从最小值开始赋值。其他边从最大点开始赋值。 证明：一...
Codeforces Round 917 (Div. 2) A - C 题解
m0_63322121的博客
12-25 797
备注 ：此题解的[]为数学中的集合表示。
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 420
【代码】力扣LCP 08.剧情触发时间。
排序——希尔排序
2301_80662872的博客
06-16 419
当序列越有顺序时，插入排序的时间效率就越高。时间复杂度：O(N^2)（虽然时间复杂度是N^2，那是在逆序的序列情况下，在现实中这种情况一般不会出现）空间复杂度：O(1)gap＞1：预排序，目的是让序列变得更有序。时间复杂度：O(N^1.3)空间复杂度：O(1)
代码随想录二刷DAY1~3
最新发布
illuosion7的博客
06-16 569
没做出来，发现问题了，滑动的应当是右指针for()里面填，这样一来，sum的初始化应当放到for的外面。//这句初始化很重要，我们要让反转后的最后一个元素指向nullptr，那么head的pre自然应该初始化为nullptr。题面：在一个排序的链表中，存在重复的节点，请删除该链表中重复的节点，重复的节点不保留。//条件也重要呀，不用判它的next，手写模拟就知道了。这题有难度，要求重复的节点不保留，显然需要三指针了。// 如果是最长，一发现不符合，就扩。//如果是最长，一发现不符合，就扩。
6-11 函数题：某范围中的最小值
qq_2937655951的博客
06-13 428
6-11 函数题：某范围中的最小值 分数 5 作者 雷丽兰 单位 宜春学院 有n(n
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 320
给定二叉树的根节点 root ，返回所有左叶子之和。
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 654
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
机器学习分类及算法
追求更专业的设计
06-12 996
1.1.1.5K近邻KNN还有 聚类（k-means）、随机森林等
Codeforces Round 798 (Div. 2)
09-08
Codeforces Round 798 (Div. 2)是一个Codeforces竞赛系列中的一场比赛。根据提供的引用内容，我们可以看到一些参赛选手的AC代码链接。这些链接中包含了一些参赛选手在比赛中解答的题目的代码。 其中，AC代码链接是一种解答题目的代码，题目为"E. ANDfinity"。AC代码链接是另一种解答题目的代码，题目同样为"E. ANDfinity"。AC代码链接是解答题目"C. Infected Tree"的代码。 因此，Codeforces Round 798 (Div. 2)是一场包含了题目"E. ANDfinity"和"C. Infected Tree"的Codeforces竞赛。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值