【数据结构】数据结构学习+刷题

VIP文章 已于 2022-08-17 11:09:58 修改
阅读量1.7k 收藏
点赞数
文章标签： c++ 算法
于 2022-04-05 23:52:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MagicFromMe/article/details/123974424
版权

数据结构

一、线段树

ACwing

1.1275最大数（AcWing）

题目链接：https://www.acwing.com/problem/content/1277/
题意：给定一个有n个数的正整数序列，你可以进行两种操作：1.添加操作：想序列后添加一个数，序列长度变为n+1。2.询问操作：询问这个序列中最后L个数中最大的数是多少。一共有m次操作，输出每次的询问操作的答案。
思路：这道题就只有一个坑点，就是在添加的时候，每次都是(t + a) % p,所以你要用一个变量来存储上一次询问的值即可。其它的就是线段树的模板。接下来说一下这道题涉及到的线段树的几个模板：
1.先说一下线段树的每一个节点所需要存储那些信息，首先是必然包含左儿子和右儿子，然后其他的信息就是根据题意来增加了，在这个题中，它的询问操作是一个范围内的最大值，所以节点还需要存储一个最大值，简单来说，某个节点所存储的信息能够从它的左右儿子推导而来。

struct node
{
   
	int l, r;
	int v;
};

2.更新模板：更新某个节点的值。在这个题就是更新某个节点的最大值。

void pushup(int u)
{
   
	tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}

3.建树模板：建树的过程就是一个递归的过程，只要是没有到达叶子节点，就一直递归。

void build(int u, int l, int r)
{
   
	tr[u] = {
   l, r};
	if (l == r) return ;///叶子节点
	int mid = l + r >> 1;
	build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}

4.查询模板：这里先贴一个图就比较好理解：
在这里插入图片描述
假如我们现在建了一个范围是在1-10的树，那么我们现在要找1 - 6之间的最大值，那么我们是不是要将1-6分为1-5和6这两段里面去找，后面这个我们一眼就能看出是6，但是在代码中我们又怎么实现呢？首先我们要一直记住我们要找的范围是1-6，假如当前的节点的范围被1-6所包含，那么此时我们是不是就该直接返回当前节点的最大值，假如我们现在要求6-10之间的最大值，而我们现在的节点是6-8这个节点，那么此时的最大值是不是6-8的最值，然后找到9-10的最值，两者作比较就得到了最值，那么我们就证明到了包含的这种情况。然后，我们再找当前节点和要寻找的范围之间有没有交集，那边有交集就往那边找。下面我们直接看代码。

int query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;
    int v = 0;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));

    return v;
}

5.修改模板：我们是将x这个节点的值修改为v，就是要注意的一点是，在每次修改完左儿子和右儿子之后不要忘了更新父节点

int query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;
    int v = 0;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));

    return v;
}

AC代码

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 200010;
struct node
{
   
    int l, r;
    int v;
}tr[N * 4];
int m, p;

void pushup(int u)
{
   
    tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}

void build(int u, int l, int r)
{
   
    tr[u] = {
   l, r};
    if (l == r) return ;
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
}

int query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;
    int v = 0;
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));

    return v;
}

void modify(int u, int x, int v)
{
   
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

signed main()
{
   
    int n = 0, last = 0;
    scanf("%d%d", &m, &p);
    build(1, 1, m);

    int x;
    char op[2];
    while (m --)
    {
   
        scanf("%s%d", op, &x);
        if (*op == 'Q') {
   last = query(1, n - x + 1, n); printf("%d\n", last); }
        else {
   modify(1, n + 1, (last + x) % p); n ++;}
    }

    return 0;
}
2.245. 你能回答这些问题吗

题目链接：https://www.acwing.com/problem/content/246/
题意：给你一个长度为n的数列，然后又m条指令，指令有两种：1.1 x y，查询区间[x,y]中的最大连续子段和。2.2 x y，把A[x]改成y。对于每一条查询指令输出查询的答案。
思路：首先考虑每个节点应该包含那些信息，左右儿子l,r肯定是包含的，然后最大连续子段和tmax肯定是包含的，接下来我们想一下最大连续子段和该怎么计算，我们先来看一个图
在这里插入图片描述
就上面的三个量，是不够推到的，假设要求的范围是上面的红括号内，那么这个时候的最大连续子段的合适1到左括号+2到右括号，所以还需要添加左范围的以1为结点的后缀和，加上以2为开始的到右括号的前缀和，所以还需要添加的是以lmax（最大后缀和）rmax（最大前缀和），那么求某个点开始的前缀和也会有两种情况，那么是只在前半段内或者包含了右边范围的一点，要么是rmax或者是sum+lmax，所以还需要添加三个变量，sum，lmax，rmax。

struct node
{
   
	int l, r;
	int sum, lmax, rmax, tmax;
}tr[N * 4];

接下来我们看更新操作，对于每一个结点我们需要维护的值有四个，sum，tmax，rmax，lmax。现在来看一下lmax怎么计算（rmax也是同理）
在这里插入图片描述
假设要求的前缀和是上面1，那么就是lmax，如果是第二种情况，那么就是l_sum + r_lmax，rmax也同理。我们又来看一下tmax怎么更新，现在左右儿子中的找到最大的tmax，或者是l.rmax+r.lmax。
补充：这里的最大前缀和和最大后缀和我们都是以某个节点的终点来找的。
上面我们找到了每个节点应该包含的信息，现在我们来看更新模板，我们要更新的是每个节点的最大连续子段和，那么就是找父节点和它的两个儿子的最大连续子段和的最大值，所以这里应该这样写：

void pushup(node &u, node &l, node &r)
{
   
	u.sum = l.sum + r.sum;
	u.lmax = max(l.max, l.max + r.lmax);
	u.rmax = max(r.max, r.sum + l.rmax);
	u.tmax = max(max(l.tmax, r.tmax), ;.rmax + r.lmax);
}
void push(int u)
{
   
	pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

建树和修改和之前的都差不多，唯一一点区别就是需要更新，我们现在来看一下查找操作，我们在查找的时候要记录四个量，所以我们干脆直接返回一个结构体，我们要考虑三种情况，只在左边，只在右边，或者横穿，前面两种情况好些，但是横穿这种情况，我们要找到左边的，在找到右边的，最后在更新，在返回。看代码：

Node query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
   
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}

AC代码：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 500010;

int n, m;
int w[N];
struct Node
{
   
    int l, r;
    int sum, lmax, rmax, tmax;
}tr[N * 4];

void pushup(Node &u, Node &l, Node &r)
{
   
    u.sum = l.sum + r.sum;
    u.lmax = max(l.lmax, l.sum + r.lmax);
    u.rmax = max(r.rmax, r.sum + l.rmax);
    u.tmax = max(max(l.tmax, r.tmax), l.rmax + r.lmax);
}

void pushup(int u)
{
   
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r)
{
   
    if (l == r) tr[u] = {
   l, r, w[r], w[r], w[r], w[r]};
    else
    {
   
        tr[u] = {
   l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, int v)
{
   
    if (tr[u].l == x && tr[u].r == x) tr[u] = {
   x, x, v, v, v, v};
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

Node query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
   
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            Node res;
            pushup(res, left, right);
            return res;
        }
    }
}

int main()
{
   
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    build(1, 1, n);

    int k, x, y;
    while (m -- )
    {
   
        scanf("%d%d%d", &k, &x, &y);
        if (k == 1)
        {
   
            if (x > y) swap(x, y);
            printf("%d\n", query(1, x, y).tmax);
        }
        else modify(1, x, y);
    }

    return 0;
}
3.AcWing 246. 区间最大公约数

题目链接：https://www.acwing.com/problem/content/247/
题意：给你一个长度为n的数列A，以及m条指令。1.c l r d，表示把A[l],A[l+1],……,A[r]都加上d。2.Q l r，表示询问A[l],A[l+1]……A[r]的最大公约数，对于每个询问，输出答案。
思路：对于第一条指令，它是将一个连续的范围都加上一个数，很快就想到了差分，那么对于求一个范围[L,R]的最大公约数，我们可以求gcd(a[L],gcd(b[L+1],b[L+2]……b[R]))，最大公约数具有结合律、分配律，（b数组是差分数组）。我们首先想一个每一个结点应该包含那些信息，首先肯定有左右儿子以及最大的公约数，但是我们还可以把差分数组包含在结构体内，就不用单独来储存了。

struct node
{
   
	int l, r;
	ll sum, d;///sum表示每个数对应的差分数组，d表示最大公约数。
}

我们再继续看查询，查询是在找最大的公约数，这里还是包含了三种情况，1.当前结点只在左边范围。2.当前节点只在右边范围。3.范围横跨当前结点的范围。所有查询该为：

node query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
   
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            node res;
            pushup(res, left, right);
            return res;
        }
    }
}

更新函数，需要更新的是差分和以及最大公约数，最大公数等于两个数的最大公约数的公约数：

void pushup(node &u, node &l, node &r)
{
   
    u.sum = l.sum + r.sum;
    u.d = gcd(l.d, r.d);
}

void pushup(int u)
{
   
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

在说一下修改函数，因为这里的修改是在一个范围内添加一个数，所以我们想到了差分，所以修改函数为：

void modify(int u, int x, ll v)
{
   
    if (tr[u].l == x && tr[u].r == x) {
   ll b = tr[u].sum + v; tr[u] = {
   x, x, b, b}; }
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

AC代码

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 500010;

struct node
{
   
    int l, r;
    ll sum, d;
}tr[N * 4];

int n, m;
ll w[N];

ll gcd(int a, int b)
{
   
    return b ? gcd(b, a % b) : a;
}

void pushup(node &u, node &l, node &r)
{
   
    u.sum = l.sum + r.sum;
    u.d = gcd(l.d, r.d);
}

void pushup(int u)
{
   
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}

void build(int u, int l, int r)
{
   
    if (l == r) {
   ll b = w[r] - w[r - 1]; tr[u] = {
   l, r, b, b};}
    else
    {
   
        tr[u].l = l, tr[u].r = r;
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int x, ll v)
{
   
    if (tr[u].l == x && tr[u].r == x) {
   ll b = tr[u].sum + v; tr[u] = {
   x, x, b, b}; }
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

node query(int u, int l, int r)
{
   
    if (tr[u].l >= l && tr[u].r <= r) return tr[u];
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (r <= mid) return query(u << 1, l, r);
        else if (l > mid) return query(u << 1 | 1, l, r);
        else
        {
   
            auto left = query(u << 1, l, r);
            auto right = query(u << 1 | 1, l, r);
            node res;
            pushup(res, left, right);
            return res;
        }
    }
}

int main()
{
   
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> w[i];
    build(1, 1, n);

    int l, r;
    ll d;
    char op[2];
    while (m --)
    {
   
        scanf("%s%d%d", op, &l, &r);
        if (*op == 'Q')
        {
   
            auto left = query(1, 1, l);
            node right = {
   0, 0, 0, 0};
            if (l + 1 <= r) right = query(1, l + 1, r);
            printf("%lld\n", abs(gcd(left.sum, right.d)));
        }
        else
        {
   
            scanf("%lld", &d);
            ///差分
            modify(1, l, d);
            if (r + 1 <= n) modify(1, r + 1, -d);
        }
    }

    return 0;
}
4.AcWing 247. 亚特兰蒂斯

题目链接：https://www.acwing.com/problem/content/249/
题意：给你描绘了一个地图，地图上的图形都是矩形，有可能有重合，问你这些矩形的面积是多少。
思路：线段树+扫描线。
如图，假设是给定的图形：
在这里插入图片描述
那么我们变换一下，得到了应该求的面积的区域：
在这里插入图片描述
我们将重合的部分去掉，就得到了实际的面积区域，我们在做如下变换：
在这里插入图片描述
那么我们要求的面积就是图中绿色的阴影部分，那么我们现在的问题就是每一个竖条间的阴影部分的高度是多少，因为两个竖条之间的距离好找，现在的难点就是找高度。我们现在可以在纵坐标上做一个线段树，在此之前我们还需要做一个操作，就是把阴影部分的每一条竖着的边加上一个权值，看成一个带边权的有向边，如下图：
在这里插入图片描述
这样我们就把每条边看作了一个有权值的边。然后我们只需要在每一个竖边对应的y轴上加上它的权值，这样我们从左往右看，就可以把每个边看作一个操作。然后我们通过看每个线段内的权值，就可以知道当前区间被多少个矩形覆盖，那么我们现在可以进行两个操作：1.将某个区间[L,R] + k（k = 1或者k = -1)。2.整个区间中，长度大于0的区间总长是多少。那么我们线段树所需要维护的有：cnt，被覆盖的次数，len，不考虑祖先节点cnt的前提下，cnt>0的区间总长。现在我们要知道扫描线的几个性质：1.永远只考虑根节点的信息。2.所有的操作都是成对出现的，且先加后减。（这里就说明了可以不用pushdown）。我们使用扫描线来求面积，顾名思义，就是用一根竖直的线从左向右的扫描，但后的动态的保存面积，只有是遇到区间的cnt是大于0的就更新面积。
那么我们现在来看一下每个节点所包含的信息，左右儿子，当前区间出现的次数，以及当前区间的长度，所以一共包含了四个量：

struct node
{
   
    int l, r;
    int cnt;
    double len;
}tr[N * 8];

这里在补充一下，因为题目中说明了坐标不一定是整数，那么可能就会有小数，所以这里我们需要离散化来保存坐标：

vector<double> ys;
int find(double x)
{
   
    return lower_bound(ys.begin(), ys.end(), x) - ys.begin();
}

继续，我们上面找到了线段树上每个线段的信息，现在我们要考虑扫描线的信息了

struct Segment
{
   
    double x, y1, y2;
    int k;///判断是那个竖边
    bool operator < (const Segment &t) const
    {
   
        return x < t.x;
    }
}seg[N * 2];

接下来我们先看主函数，因为我们每次都是从根节点获得信息，根节点中保存了当前状态下y轴的那些区间出现了的次数，我们在跟新了答案之后还需要进行操作，因为可能遇到边权是-1的竖边，所以我们需要修改，如下：

double res = 0;
        for (int i = 0; i < n * 2; i++)
        {
   
            if (i > 0) res += tr[1].len * (seg[i].x - seg[i - 1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }

然后是pushup函数，这里要分成这么几种情况：1.完全覆盖，那么此时的tr[u].cnt大于0，那么可以直接得到区间长度，2.tr[u].cnt = 0，但是不是叶子节点，那么父节点的长度就等于两个儿子节点的长度，3.是叶子节点，那么长度就等于0。所以pushup函数就是：

void pushup(int u)
{
   
    ///完全覆盖，
    if (tr[u].cnt) tr[u].len = ys[tr[u].r + 1] - ys[tr[u].l];
    ///不完全覆盖，cnt = 0，首先判断是不是叶节点。
    else if (tr[u].l != tr[u].r) tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    else tr[u].len = 0;///叶子节点
}

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;

struct Segment
{
   
    double x, y1, y2;
    int k;///判断是那个竖边
    bool operator < (const Segment &t) const
    {
   
        return x < t.x;
    }
}seg[N * 2];

struct node
{
   
    int l, r;
    int cnt;
    double len;
}tr[N * 8];

int n;
vector<double> ys;

int find(double x)
{
   
    return lower_bound(ys.begin(), ys.end(), x) - ys.begin();
}

void pushup(int u)
{
   
    ///完全覆盖，
    if (tr[u].cnt) tr[u].len = ys[tr[u].r + 1] - ys[tr[u].l];
    ///不完全覆盖，cnt = 0，首先判断是不是叶节点。
    else if (tr[u].l != tr[u].r) tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
    else tr[u].len = 0;///叶子节点
}

void build(int u, int l, int r)
{
   
    tr[u] = {
   l, r, 0, 0};
    if (l != r)
    {
   
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    }
}

void modify(int u, int l, int r, int k)
{
   
    if (tr[u].l >= l && tr[u].r <= r) {
   tr[u].cnt += k; pushup(u);}
    else
    {
   
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, k);
        if (r > mid) modify(u << 1 | 1, l, r, k);
        pushup(u);
    }
}

int main()
{
   
    int T = 1;
    while (cin >> n, n)
    {
   
        ys.clear();
        for (int i = 0, j = 0; i < n; i++)
        {
   
            double x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
            seg[j ++] = {
   x1, y1, y2, 1}, seg[j ++] = {
   x2, y1, y2, -1};
            ys.push_back(y1), ys.push_back(y2);
        }

        sort(ys.begin(), ys.end());
        ys.erase(unique(ys.begin(), ys.end()), ys.end());

        build(1, 0, ys.size() - 2);///建树，0开始，-2。
        sort(seg, seg + n * 2);

        double res = 0;
        for (int i = 0; i < n * 2; i++)
        {
   
            if (i > 0) res += tr[1].len * (seg[i].x - seg[i - 1].x);
            modify(1, find(seg[i].y1), find(seg[i].y2) - 1, seg[i].k);
        }

        printf("Test case #%d\n", T ++ );
        printf("Total explored area: %.2lf\n\n", res);
    }

    return 0;
}
5.AcWing 1277. 维护序列

题目链接：https://www.acwing.com/problem/content/1279/
题意：这个跟第二题类似，只不过操作边长了三种：1.把数列中的一段数全部乘一个值；2.把数列中的一段数全部加一个值；3.询问数列中的一段数的和，由于答案可能很大，你只需输出这个数模 P 的值。
思路：这个题主要是pushdown有一些改变，我们向下维护，是要维护当前节点的两个儿子节点，然后要把ada = 0，mul = 1，然后我们在单独建一个函数来计算向下维护的节点的add、mul以及sum值，代码如下：

void eval(node &t, int add, int mul)
{
   
    t.sum = ((ll)t.sum * mul + (ll)(t.r - t.l + 1) * add) % p;
    t.mul = (ll)t.mul * mul % p;
    t.add = ((ll)t.add * mul + add) % p;
}

void pushdown(int u)
{
   
    eval(tr[u << 1], tr[u].add, tr[u].mul);
    eval(tr[u << 1 | 1], tr[u].add, tr[u].mul);
    tr[u].add = 0, tr[u].mul = 1;
}

AC代码：

#include <bits/stdc++.h>

using namespace std;

const int N = 100010;
typedef long long ll;

struct node
{
   
    int l, r;
    ll sum, add, mul
最低0.47元/天 解锁文章
309摸鱼巨人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法基础知识介绍+刷题总结
04-28
常见的数据结构介绍 排序与查找算法介绍 刷题总结
C语言笔记：结构体
m0_62934529的博客
03-18 425
1. 结构体的声明 1.1 结构的基础知识 结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。如：对于人来说，姓名，年龄，性别等就是成员变量 1.2 结构的声明 struct tag //声明一个结构体类型，并不占用空间 { member-list; }variable-list; 如：声明一个结构体类型 - 书： #include <stdio.h> #include <string.h > //声明了一个结构体类型 - 书
【题解】集合操作
cqbzlydd的博客
07-24 142
题意 定义一个可重集合 s ，一次操作为将 s 中最大值减去 p 。 小 L 想知道，如果给你 s 和 p 以及操作次数 k ，你能求出最后的集合吗？ k<=10^18 。 Solution： 因为思路比较有借鉴意义，所以写了。 首先 k 的范围不允许模拟。考虑到最大值有单调性，所以二分最终序列最大值，因为每次减去的数一定，可以直接算。可以证明剩下的操作不超过 n 次，暴力枚举即可。 #include<bits/stdc++.h> using namespace std; typedef
东华码蹄集第21周oj赛（光潮的幻像，分苹果，马走日，码哥猜想）
s1050712899的博客
10-21 958
码蹄集
基础算法--差分
weixin_30877227的博客
07-08 386
输入一个长度为n的整数序列。 接下来输入m个操作，每个操作包含三个整数l, r, c，表示将序列中[l, r]之间的每个数加上c。 请你输出进行完所有操作后的序列。 输入格式 第一行包含两个整数n和m。 第二行包含n个整数，表示整数序列。 接下来m行，每行包含三个整数l，r，c，表示一个操作。 输出格式 共一行，包含n个整数，表示最终序列。 数据范围 1≤n,m≤100000 ...
一个长度为n的整数序列,a_1,...,a_n。然后考虑在一个空序列b上进行n次以下操作: 1、将a_i放入b序列的末尾 2、逆置b序列,输出操作n次的b序列。
On_my_wayy的博客
03-26 6473
public class Test7 {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        while (in.hasNextInt()) {            int n = in.nextInt();            int[] nums = n...
期末刷题数据结构习题集
10-05
期末刷题数据结构习题集
大厂算法和数据结构刷题
07-28
大厂算法和数据结构刷题java实现
大厂算法和数据结构刷题班.zip
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
数据结构与常用算法的学习、刷题.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
BZOJ3236：[AHOI2013]作业——题解
weixin_34129145的博客
04-03 82
https://www.lydsy.com/JudgeOnline/problem.php?id=3236 第一种做法： 建两棵主席树分别处理两个问题。 第一个问题水，第二个问题参考SPOJ3267/DQUERY：D-query 但是代码量巨大，显然不能写。 第二种做法： 参考：https://blog.csdn.net/clover_hxy/article/details/56...
2022-04-21每日刷题打卡
fnmdpnmsl的博客
04-21 1044
2022-04-21每日刷题打卡 代码源——每日一题 互质 - 题目 - Daimayuan Online Judge 题目描述 给你一个包含n个正整数的序列 A=(A1,A2,…,An),找到 [1,m]中每一个满足下列条件的 k： gcd(Ai,k)=1, 1≤i≤n 输入描述 第一行输入两个整数 n, m 第二行输入n个整数代表序列A 输出描述 第一行输出一个整数代表满足条件的k的数量 接下里每一行输出一个整数，代表一个满足条件的k 样例输入 3 12 6 1 5 样例输出 3 1 7 11 数据
算法题——最好一样
weixin_44711603的博客
04-03 532
算法题——最好一样题目内容解题思路代码合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 题目内容 题目描述： 给出一个序列包含n个...
算法题
qq_45206551的博客
04-02 1351
不能超过 时间限制：C/C++语言 1000MS；其他语言 3000MS 内存限制：C/C++语言 65536KB；其他语言 589824KB 题目描述： 给出一个序列包含n个正整数的序列A，你可以从中删除若干个数，使得剩下的数字中的最大值和最小值之差不超过x，请问最少删除多少个数字。 输入 输入第一行仅包含两个正整数n和x，表示给出的序列的长度和给定的正整数。(1<=n<=1000,...
第5周作业
qq_45697521的博客
03-21 434
A - 最大矩形 问题描述 给一个直方图，求直方图中的最大矩形的面积。例如，下面这个图片中直方图的高度从左到右分别是2, 1, 4, 5, 1, 3, 3, 他们的宽都是1，其中最大的矩形是阴影部分。 Input 输入包含多组数据。每组数据用一个整数n来表示直方图中小矩形的个数，你可以假定1 <= n <= 100000. 然后接下来n个整数h1, …, hn, 满足 0 <=...
【C语言】给定一个包含0，1，···，n中n个数的序列，找出0···n中没有出现在序列中的那个数
weixin_52192405的博客
03-24 410
给定一个包含0，1，···，n中n个数的序列，找出0···n中没有出现在序列中的那个数
『差分』BZOJ3043数列操作
Ronaldo7_ZYB的博客
09-18 561
Problem\mathrm{Problem}Problem 给定一个长度为n的数列{a1,a2…an}，每次可以选择一个区间[l,r]，使这个区间内的数都加一或者都减一。 问至少需要多少次操作才能使数列中的所有数都一样,并求出在保证最少次数的前提下,最终得到的数列有多少种。 Solution\mathrm{Solution}Solution 由于是区间修改，我们考虑将区间修改转化为单点修改。 那...
信息学奥赛第十四节 —— LIST链表
smallrain6的博客
05-11 1456
LIST的结构 list：链表。与vector与deque不同，它不要求计算机申请一片连续的空间。每个list都是由若干个结点构成的，而每个结点也包括三个部分： 存储的元素 指向前一个结点的指针 指向后一个结点的指针 list没有下标，因此需要使用迭代器进行访问。list不支持sort，但是其支持sort成员函数。 算法来源于生活，链表的结构，与灯笼类似。 LIST的一些函数 remove(val) —— 删除与val相等的所有元素 empty() —— 判断链表是否为空 reverse() ——
牛妹爱数列_牛客练习赛67
weixin_43911947的博客
08-16 261
题目链接：https://ac.nowcoder.com/acm/contest/6885/D 题意 给你一个长度为n的仅包含01的序列a，并执行以下操作 单点修改：0->1 ，1->0 前缀修改：将1~x上的所有点修改 问最少操作，使得序列全变0 思路 简单dp。 dp[i][0]表示把1到i的所有点变成0需要的最少操作 dp[i][1]表示把1到i的所有点变成1需要的最少操作 转移方程： 当a[i]==0时，dp[i][0]要么前面全是0（dp[i-1][0]），
考研数据结构刷题网站
08-21
- *1* [《数据结构知识点总结》计算机考研复试应届生求职刷题必备.pdf](https://download.csdn.net/download/liuning940307/31275197)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值