线段树 2017.4.20

最新推荐文章于 2019-07-18 07:43:17 发布
最新推荐文章于 2019-07-18 07:43:17 发布
阅读量489 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Only_AiR/article/details/52908709
版权

1、Codeforces 272C Dima and Staircase

解题思路：

区间更新

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (ll i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;

const ll mod = 1e9 + 7;
const ll INF = 0x7fffffff;
const ll maxn = 1e5 + 10;

ll n, m, w, h, ans;
ll a[maxn];
ll tree[4*maxn], lazy[4*maxn];

void build(ll low, ll high, ll _id);
void push_up(ll _id);
void update(ll Left, ll Right, ll val, ll low, ll high, ll _id);
void push_down(ll _id);
ll query(ll Left, ll Right, ll low, ll high, ll _id);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    scanf("%I64d", &n);
    for (ll i = 1; i <= n; ++i) {
        scanf("%I64d", &a[i]);
    }
    build(1, n, 1);
    scanf("%I64d", &m);
    while (m--) {
        scanf("%I64d %I64d", &w, &h);
        ans = query(1, w, 1, n, 1);
        printf("%I64d\n", ans);
        update(1, w, ans + h, 1, n, 1);
    }
    return 0;
}

ll query(ll Left, ll Right, ll low, ll high, ll _id)
{
    if (low == Left && high == Right) {
        if (lazy[_id]) {
            return lazy[_id];
        }
        return tree[_id];
    }
    push_down(_id);
    ll mid = (low + high) >> 1;
    if (Right <= mid) {
        return query(Left, Right, lson);
    } else if (Left > mid) {
        return query(Left, Right, rson);
    } else {
        return max(query(Left, mid, lson), query(mid + 1, Right, rson));
    }
    push_up(_id);
}

void update(ll Left, ll Right, ll val, ll low, ll high, ll _id)
{
    if (low == Left && high == Right) {
        tree[_id] = lazy[_id] = val;
        return;
    }
    push_down(_id);
    ll mid = (low + high) >> 1;
    if (Right <= mid) {
        update(Left, Right, val, lson);
    } else if (Left > mid) {
        update(Left, Right, val, rson);
    } else {
        update(Left, mid, val, lson), update(mid + 1, Right, val, rson);
    }
    push_up(_id);
}

void push_down(ll _id)
{
    if (lazy[_id]) {
        tree[_id] = lazy[_id];
        tree[_id<<1] = lazy[_id], tree[_id<<1|1] = lazy[_id];
        lazy[_id<<1] = lazy[_id], lazy[_id<<1|1] = lazy[_id];
        lazy[_id] = 0;
    }
}

void build(ll low, ll high, ll _id)
{
    if (low == high) {
        tree[_id] = a[low];
        return;
    }
    ll mid = (low + high) >> 1;
    build(lson), build(rson);
    push_up(_id);
}

void push_up(ll _id)
{
    tree[_id] = max(tree[_id<<1], tree[_id<<1|1]);
}


2、Codeforces 356A Knight Tournament

解题思路：

参考：http://www.cnblogs.com/dashuzhilin/p/4535178.html

刚开始写按照题目所给次序更新（写起来好麻烦的样子...调了好久）， TLE on test 37 了...QAQ

后来看题解发现只要按照相反次序更新就可以了

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <bitset>
#include <ctime>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define lson low, mid, _id<<1
#define rson mid+1, high, _id<<1|1

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<int, int> Pair;

const ll mod = 1e9 + 7;
const int INF = 0x7fffffff;
const int maxn = 3e5 + 10;

int n, m, cnt = 0;
int l[maxn], r[maxn], x[maxn];
int lazy[4*maxn];

void update(int Left, int Right, int val, int low, int high, int _id);
void push_down(int _id);
void query(int low, int high, int _id);
void push_up(int _id);

int main()
{
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
#endif // __AiR_H
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        scanf("%d %d %d", &l[i], &r[i], &x[i]);
    }
    for (int i = m; i >= 1; --i) {
        if (l[i] < x[i]) {
            update(l[i], x[i] - 1, x[i], 1, n, 1);
        }
        if (r[i] > x[i]) {
            update(x[i] + 1, r[i], x[i], 1, n, 1);
        }
    }
    query(1, n, 1);
    printf("\n");
    return 0;
}

void query(int low, int high, int _id)
{
    if (lazy[_id]) {
        for (int i = low; i <= high; ++i) {
            printf(++cnt == 1 ? "%d" : " %d", lazy[_id]);
        }
        return;
    }
    if (low == high) {
        printf(++cnt == 1 ? "0" : " 0");
        return;
    }
    int mid = (low + high) >> 1;
    query(lson), query(rson);
}

void update(int Left, int Right, int val, int low, int high, int _id)
{
    if (low == Left && Right == high) {
        lazy[_id] = val;
        return;
    }
    push_down(_id);
    int mid = (low + high) >> 1;
    if (Right <= mid) {
        update(Left, Right, val, lson);
    } else if (Left > mid) {
        update(Left, Right, val, rson);
    } else {
        update(Left, mid, val, lson), update(mid + 1, Right, val, rson);
    }
}

void push_down(int _id)
{
    if (lazy[_id]) {
        lazy[_id<<1] = lazy[_id], lazy[_id<<1|1] = lazy[_id];
        lazy[_id] = 0;
    }
}


3、ZOJ 2301 Color the Ball

离散化很优美啊！

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <cassert>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define lson low, mid, _id << 1
#define rson mid + 1, high, _id << 1 | 1

typedef long long ll;
typedef pair<int, int> pii;
struct Node { int x, y, z; };

const int INF = 0x7fffffff;
const int maxn = 1e6;
int N;
int l[maxn], r[maxn], key[maxn];
char cmd[2];
int tree[maxn];
vector<int> v;
vector<pii> ans;

int id(int x) { return lower_bound(v.begin(), v.end(), x) - v.begin() + 1; }
void update(int Left, int Right, int color, int low, int high, int _id);
void query(int low, int high, int _id);
int real(int x) { return v[x - 1]; }

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    while (scanf("%d", &N) != EOF) {
        if (N <= 0) { printf("Oh, my god\n"); continue; }
        v.clear(); memset(tree, -1, sizeof(tree)); ans.clear();
        for (int i = 0; i < N; ++i) {
            scanf("%d %d %s", &l[i], &r[i], cmd);
            if (cmd[0] == 'w') { key[i] = 1; }
            else { key[i] = -1; }
            v.push_back(l[i]); v.push_back(r[i]);
            if (l[i] > 1) { v.push_back(l[i] - 1); } v.push_back(r[i] + 1);
        }
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        for (int i = 0; i < N; ++i) { update(id(l[i]), id(r[i]), key[i], 1, (int)v.size(), 1); }
        query(1, (int)v.size(), 1);
        if ((int)ans.size() == 0) { printf("Oh, my god\n"); continue; }
        int Max = real(ans[0].second) - real(ans[0].first), ans_l = ans[0].first, ans_r = ans[0].second;
        int l_t = ans[0].first, r_t = ans[0].second;
        for (int i = 1; i < (int)ans.size(); ++i) {
            if (ans[i].first - 1 == ans[i - 1].second) {
                r_t = ans[i].second;
            } else {
                l_t = ans[i].first; r_t = ans[i].second;
            }
            if (real(r_t) - real(l_t) > Max) { Max = real(r_t) - real(l_t); ans_l = l_t; ans_r = r_t; }
        }
        printf("%d %d\n", real(ans_l), real(ans_r));
    }
#ifdef __AiR_H
    printf("Time used = %.2fs\n", (double)clock() / CLOCKS_PER_SEC);
#endif // __AiR_H
    return 0;
}

void query(int low, int high, int _id) {
    if (tree[_id]) {
        if (tree[_id] == 1) { ans.push_back(make_pair(low, high)); }
        return;
    }
    int mid = low + (high - low) / 2;
    query(lson); query(rson);
}

void update(int Left, int Right, int color, int low, int high, int _id) {
    if (tree[_id] == color) { return; }
    if (low == Left && high == Right) { tree[_id] = color; return; }
    int mid = low + (high - low) / 2;
    if (tree[_id]) { tree[_id << 1] = tree[_id]; tree[_id << 1 | 1] = tree[_id]; tree[_id] = 0; }
    if (Left > mid) { update(Left, Right, color, rson); }
    else if (Right <= mid) { update(Left, Right, color, lson); }
    else { update(Left, mid, color, lson); update(mid + 1, Right, color, rson); }
}


4、HDU 5306 Gorgeous Sequence

参考：

《区间最值操作与历史最值问题》杭州学军中学 吉如一

http://www.cnblogs.com/shenben/p/6641984.html


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <cassert>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define lc _id << 1
#define rc _id << 1 | 1
#define lson low, mid, lc
#define rson mid + 1, high, rc

typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x7fffffff;
const int maxn = 1e6 + 10;
int T, n, m, cmd, x, y, t;
int a[maxn], Max[maxn * 4], second[maxn * 4], num[maxn * 4];
ll sum[maxn * 4];

inline void push_up(int _id) {
    sum[_id] = sum[lc] + sum[rc]; Max[_id] = max(Max[lc], Max[rc]); num[_id] = 0;
    if (Max[_id] == Max[lc]) { num[_id] += num[lc]; }
    if (Max[_id] == Max[rc]) { num[_id] += num[rc]; }
    second[_id] = max(second[lc], second[rc]);
    if (Max[lc] != Max[rc]) { second[_id] = max(second[_id], min(Max[lc], Max[rc])); }
}
inline void push_down(int _id) {
    if (Max[_id] < Max[lc]) { sum[lc] += (ll)(Max[_id] - Max[lc]) * num[lc]; Max[lc] = Max[_id]; }
    if (Max[_id] < Max[rc]) { sum[rc] += (ll)(Max[_id] - Max[rc]) * num[rc]; Max[rc] = Max[_id]; }
}
void build(int low, int high, int _id) {
    if (low == high) { Max[_id] = a[low]; sum[_id] = a[low]; num[_id] = 1; second[_id] = 0; return; }
    int mid = (low + high) / 2; build(lson); build(rson); push_up(_id);
}
int query_max(int Left, int Right, int low, int high, int _id) {
    if (low == Left && high == Right) { return Max[_id]; }
    int mid = (high + low) / 2; push_down(_id);
    if (Right <= mid) { return query_max(Left, Right, lson); }
    else if (Left >= mid + 1) { return query_max(Left, Right, rson); }
    else { return max(query_max(Left, mid, lson), query_max(mid + 1, Right, rson)); }
}
ll query_sum(int Left, int Right, int low, int high, int _id) {
    if (low == Left && high == Right) { return sum[_id]; }
    int mid = (high + low) / 2; push_down(_id);
    if (Right <= mid) { return query_sum(Left, Right, lson); }
    else if (Left >= mid + 1) { return query_sum(Left, Right, rson); }
    else { return query_sum(Left, mid, lson) + query_sum(mid + 1, Right, rson); }
}
void update(int Left, int Right, int key, int low, int high, int _id) {
    if (key >= Max[_id]) { return; }
    if (low == high) { sum[_id] += (ll)key - Max[_id]; Max[_id] = key; return; }
    if (Left == low && Right == high && key > second[_id]) {
        sum[_id] += (ll)num[_id] * (key - Max[_id]); Max[_id] = key; return;
    }
    int mid = (low + high) / 2; push_down(_id);
    if (Right <= mid) { update(Left, Right, key, lson); }
    else if (Left >= mid + 1) { update(Left, Right, key, rson); }
    else { update(Left, mid, key, lson); update(mid + 1, Right, key, rson); }
    push_up(_id);
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d", &T);
    while (T--) {
        scanf("%d %d", &n, &m);
        for (int i = 1; i <= n; ++i) { scanf("%d", &a[i]); }
        build(1, n, 1);
        while (m--) {
            scanf("%d %d %d", &cmd, &x, &y);
            if (cmd == 1) { printf("%d\n", query_max(x, y, 1, n, 1)); }
            else if (cmd == 2) { printf("%I64d\n", query_sum(x, y, 1, n, 1)); }
            else {
                scanf("%d", &t); update(x, y, t, 1, n, 1);
            }
        }
    }
#ifdef __AiR_H
    printf("Time used = %.2fs\n", (double)clock() / CLOCKS_PER_SEC);
#endif // __AiR_H
    return 0;
}


5、Codeforces 444C DZY Loves Colors

参考：

《小清新线段树》吉如一


http://blog.csdn.net/kalilili/article/details/46038733

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <vector>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cctype>
#include <ctime>
#include <cassert>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); ++i)
#define eps 1e-9
#define lc _id << 1
#define rc _id << 1 | 1
#define lson low, mid, lc
#define rson mid + 1, high, rc

typedef long long ll;
typedef pair<int, int> pii;

const int INF = 0x7fffffff;
const int maxn = 1e5 + 10;
int lazy[maxn * 4];
ll add[maxn * 4], sum[maxn * 4];
ll t;
int n, m, l, r, x, type;

inline void push_up(int _id) {
    sum[_id] = sum[lc] + sum[rc];
    if (lazy[lc] == lazy[rc]) { lazy[_id] = lazy[lc]; }
}
void build(int low, int high, int _id) {
    if (low == high) { lazy[_id] = low; return; }
    int mid = low + (high - low) / 2; build(lson); build(rson);
}
inline void push_down(int _id, int low, int mid, int high) {
    if (lazy[_id] == 0) { return; }
    add[lc] += add[_id]; sum[lc] += add[_id] * (mid - low + 1);
    add[rc] += add[_id]; sum[rc] += add[_id] * (high - mid);
    add[_id] = 0;
    lazy[lc] = lazy[_id]; lazy[rc] = lazy[_id]; lazy[_id] = 0;
}
void update(int Left, int Right, int key, int low, int high, int _id) {
    if (low == high) { sum[_id] += abs(lazy[_id] - key); lazy[_id] = key; return; }
    if (Left == low && high == Right && lazy[_id]) {
        t = abs(lazy[_id] - key); add[_id] += t; lazy[_id] = key;
        sum[_id] += t * (high - low + 1); return;
    }
    int mid = low + (high - low) / 2; push_down(_id, low, mid, high);
    if (Right <= mid) { update(Left, Right, key, lson); }
    else if (Left >= mid + 1) { update(Left, Right, key, rson); }
    else { update(Left, mid, key, lson); update(mid + 1, Right, key, rson); }
    push_up(_id);
}
ll query(int Left, int Right, int low, int high, int _id) {
    if (Left == low && Right == high) { return sum[_id]; }
    int mid = low + (high - low) / 2; push_down(_id, low, mid, high);
    if (Right <= mid) { return query(Left, Right, lson); }
    else if (Left >= mid + 1) { return query(Left, Right, rson); }
    else { return query(Left, mid, lson) + query(mid + 1, Right, rson); }
}

int main() {
#ifdef __AiR_H
    freopen("in.txt", "r", stdin);
//    freopen("out2.txt", "w", stdout);
#endif // __AiR_H
    scanf("%d %d", &n, &m);
    build(1, n, 1);
    while (m--) {
        scanf("%d %d %d", &type, &l, &r);
        if (type == 1) {
            scanf("%d", &x); update(l, r, x, 1, n, 1);
        } else {
            printf("%I64d\n", query(l, r, 1, n, 1));
        }
    }
#ifdef __AiR_H
    printf("Time used = %.2fs\n", (double)clock() / CLOCKS_PER_SEC);
#endif // __AiR_H
    return 0;
}


__AiR_H
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CGAL_5.2_lib_dll_VS2017.rar
03-17
4. **静态库和动态库** - **静态库（.lib）**：在编译时链接，将CGAL的代码直接合并到目标程序中，避免了运行时依赖库的问题，但会使生成的可执行文件较大。 - **动态库（.dll）**：在运行时链接，程序执行时需要...
2017.5北师大版小学数学二年级下册阶段性试卷.doc
10-13
4. 最大最小数的概念：第四题指出最大的三位数是999，最小的四位数是1000，它们之间的差值是999。 5. 千位和个位数字的意义：第五题涉及数位的概念，一个四位数如果千位和个位上都是3，其他位上是0，则这个数是3003...
线段树 2017.4.26
追风蹑影
04-21 422
1、BZOJ 4364 [IOI2014]wall砖墙 解题思路： 维护区间最大值和最小值以及区间是否相同 加读入优化和不加读入优化 #include #include #include #include #include #include #include #include #include #include #include #include #in
2017.7.20. 线段树
AVALON_X的博客
12-24 411
线段树照样先把题目打出来：敌兵布阵【线段树模板1】 题目背景 HDU 1166 敌兵布阵本系统暂无测试数据，请到 HDU 评测。题目描述 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了 N 个工兵营地，Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每
线段树专题测试2017.1.21
adx33526的博客
01-21 69
　　很单纯的一道线段树题。稍微改一下pushDown()就行了。 Code(线段树模板竟然没超100行) 1 #include<iostream> 2 #include<sstream> 3 #include<cstdio> 4 #include<cmath> 5 #include<cstd...
数据结构专题测试 2017.4.4 - 线段树
adx33526的博客
04-05 68
　　打两个lazy标记，覆盖操作(modify)，把mlazy改为x,clazy改为0，增加操作(change)，把clazy增加x。pushDown时候先更新mlazy，再更新clazy。 　　但是数据有些问题(然后十个点全崩掉了)，l > r的情况修改操作无视，查询操作输出0。 Code 1 #include<iostream> 2 #i...
2017.3.4 树状数组&线段树 考试小结
JK_spc的博客
03-11 323
2017.3.4考试小结这个星期刚学了树状数组就考试 考的一脸懵逼 第一题就有个大坑，看都没看就往里跳 So 爆0 ~
2017.4.21
more time
07-18 149
2017.4.21 今天继续学习线段树，更为高级的区间修改。 uva 11992 训练指南 P207 这里涉及了区间全部改成一个数和都加上一个新的，核心思想就是懒标记。 http://paste.ubuntu.com/24425415/ 可以当模版用了。
2017.4.17
more time
07-18 130
2017.4.17 本来想来机房学信号的，结果naive.以后还是去找个教室学吧 今天本来准备学zkw线段树，后来想想没有什么学习的必要，现阶段的题目都可以做。递归写法思考复杂度比较低。 然后就做了一个线段树的基础应用。 虽然之前也写过，不过重写一遍，运用刘汝佳的模板，才是自己的东西。 uvalive 2191 Potentimeters http://paste.ubuntu.
2017.9.26 树链剖分+线段树 解题报告
onepointo
09-26 508
Description 给出一颗树 三种操作 从u到v的简单路径上的所有点的值都增加v。 从u到v的简单路径上的所有点的值都变为v。 询问从u到v的简单路径上的所有点的值的和是否能表示成两个质数相加的和。【解题报告】 写起来浑身难受，可能是因为没有看黄历吧。 想着很简单，链剖+线段树（区间加，区间赋值，区间求和）+线筛判素数。 写着很恼火。代码如下：#pragma GCC optim
2017.3.18 机房测试(线段树，树链剖分)
onepointo
03-20 369
丁神远在上海依然不忘为我们出题。。。
UCF Local Programming Contest 2017 I. Rotating Cards
01-20
4. **区间查询与单点修改**： - 区间查询函数`sum(int x)`用于计算从位置x开始到当前范围内的元素之和。 - 单点修改函数`add(int x, ll c)`用于在位置x处增加值c，这里用到了低bit技巧来加速更新过程。 5. **...
opencv_contrib最新版，截止到2017.2.25
03-03
4. **BackgroundSubtractorMOG2**: 是一种背景减除算法，常用于视频分析，可以分离前景和背景，如在视频监控中检测移动对象。 5. **aruco**: 这是用于实现ArUco标记检测的模块。ArUco标记是一种二维编码的黑白图案...
计算机图形学源代码.zip
09-06
4. **着色器**：包括顶点着色器、片段着色器、几何着色器等，它们在GPU上运行，用于计算像素颜色、光照效果等。 5. **光照模型**：理解不同类型的光源（点光源、平行光、聚光灯）和光照模型（Lambertian、Phong、...
mpu6050陀螺仪使用方法开发教程文档.docx
07-30
mpu6050陀螺仪使用方法
【SCI顶级】龙格库塔算法RUN-CNN-LSTM-Multihead-Attention温度预测【含源码 5747期】.zip
07-30
CSDN海神之光上传的全部代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：Main .m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除Main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法-CNN-LSTM-Mutilhead-Attention回归预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO-CNN-LSTM-Mutilhead-Attention回归预测 4.4.2 粒子群算法PSO/蛙跳算法SFLA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.3 灰狼算法GWO/狼群算法WPA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.4 鲸鱼算法WOA/麻雀算法SSA-CNN-LSTM-Mutilhead-Attention回归预测 4.4.5 萤火虫算法FA/差分算法DE-CNN-LSTM-Mutilhead-Attention回归预测
大模型的数学之魂：统计学习理论精要
07-30
大型机器学习模型，通常简称为“大模型”，是指具有数十亿甚至数千亿参数的深度神经网络模型。这些模型因为其庞大的参数量和复杂的计算结构，能够处理非常复杂的任务和数据，展现出强大的表达能力和预测性能。大模型在自然语言处理、计算机视觉、语音识别和推荐系统等多个领域都有广泛的应用。 大模型的设计目的是通过训练海量数据来学习复杂的模式和特征，从而具备强大的泛化能力，能够对未见过的数据做出准确的预测。与参数较少、层数较浅的小模型相比，大模型虽然需要更多的计算资源和时间来训练和推理，但它们展现出了一种被称为“涌现能力”的特性，即从原始训练数据中自动学习并发现新的、更高层次的特征和模式。 大模型的发展历程可以分为几个阶段，从早期的卷积神经网络模型发展到以Transformer为代表的全新神经网络模型，再到当前以GPT为代表的预训练大模型阶段。Transformer架构因其自注意力机制而成为大模型的核心技术，它使得模型能够更好地理解和处理文本数据中的长距离依赖关系。 大模型的分类主要包括语言大模型（NLP）、视觉大模型（CV）和多模态大模型。语言大模型专注于处理文本数据和理解自然语言，而视觉大模型用
唯美淡雅四页.zip
最新发布
07-30
【简历模板】工作总结、商业计划书、述职报告、读书分享、家长会、主题班会、端午节、期末、夏至、中国风、卡通、小清新、岗位竞聘、公司介绍、读书分享、安全教育、文明礼仪、儿童故事、绘本、防溺水、夏季安全、科技风、商务、炫酷、企业培训、自我介绍、产品介绍、师德师风、班主任培训、神话故事、巴黎奥运会、世界献血者日、防范非法集资、3D快闪、毛玻璃、人工智能等等各种样式的ppt素材风格。 设计模板、图片素材、PPT模板、视频素材、办公文档、小报模板、表格模板、音效配乐、字体库。 广告设计：海报，易拉宝，展板，宣传单，宣传栏，画册，邀请函，优惠券，贺卡，文化墙，标语，制度，名片，舞台背景，广告牌，证书，明信片，菜单，折页，封面，节目单，门头，美陈，拱门，展架等。 电商设计：主图，直通车，详情页，PC端首页，移动端首页，钻展，优惠券，促销标签，店招，店铺公告等。 图片素材：PNG素材，背景素材，矢量素材，插画，元素，艺术字，UI设计等。 视频素材：AE模板，会声会影，PR模板，视频背景，实拍短片，音效配乐。 办公文档：工作汇报，毕业答辩，企业介绍，总结计划，教学课件，求职简历等PPT/WORD模板。
线段树基础讲解与应用
"框架建树-线段树入门" 线段树是一种数据结构，用于高效地处理区间上的操作，如查询、更新等。在【标题】中提到的“框架建树”是指构建线段树的过程，它通过递归的方式将线段进行分割，最终形成一棵树形结构。 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值