主席树

最新推荐文章于 2025-02-16 22:20:51 发布
最新推荐文章于 2025-02-16 22:20:51 发布
阅读量1.7k 收藏 1
点赞数 2
分类专栏： 树 ACM模版篇 数据结构 ACM模板-f_zyj 文章标签： 主席树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/f_zyj/article/details/51975700
版权

ACM模版

查询区间有多少个不同的数

/*
 *  给出一个序列,查询区间内有多少个不相同的数 
 */
const int MAXN = 30010;
const int M = MAXN * 100;
int n, q, tot;
int a[MAXN];
int T[MAXN], lson[M], rson[M], c[M];

int build(int l, int r)
{
    int root = tot++;
    c[root] = 0;
    if (l != r)
    {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int update(int root, int pos, int val)
{
    int newroot = tot++, tmp = newroot;
    c[newroot] = c[root] + val;
    int l = 1, r = n;
    while (l < r)
    {
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        }
        else
        {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int query(int root, int pos)
{
    int ret = 0;
    int l = 1, r = n;
    while (pos < r)
    {
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            r = mid;
            root = lson[root];
        }
        else
        {
            ret += c[lson[root]];
            root = rson[root];
            l = mid + 1;
        }
    }
    return ret + c[root];
}

int main()
{
    //  freopen("in.txt", "r", stdin);
    //  freopen("out.txt", "w", stdout);
    while (scanf("%d", &n) == 1)
    {
        tot = 0;
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        T[n + 1] = build(1, n);
        map<int,int> mp;
        for (int i = n; i >= 1; i--)
        {
            if (mp.find(a[i]) == mp.end())
            {
                T[i] = update(T[i + 1], i, 1);
            }
            else
            {
                int tmp = update(T[i + 1], mp[a[i]], -1);
                T[i] = update(tmp, i, 1);
            }
            mp[a[i]] = i;
        }
        scanf("%d", &q);
        while (q--)
        {
            int l, r;
            scanf("%d%d", &l, &r);
            printf("%d\n", query(T[l], r));
        }
    }
    return 0;
}

静态区间第k小

参考题目链接：
POJ 2104 K-th Number

const int MAXN = 100010;
const int M = MAXN * 30;
int n, q, m, tot;
int a[MAXN], t[MAXN];
int T[MAXN], lson[M], rson[M], c[M];

void Init_hash()
{
    for (int i = 1; i <= n; i++)
    {
        t[i] = a[i];
    }
    sort(t + 1, t + 1 + n);
    m = (int)(unique(t + 1, t + 1 + n) - t - 1);
}

int build(int l, int r)
{
    int root = tot++; c[root] = 0;
    if (l != r)
    {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int hash_(int x)
{
    return (int)(lower_bound(t + 1, t + 1 + m, x) - t);
}

int update(int root, int pos, int val)
{
    int newroot = tot++, tmp = newroot;
    c[newroot] = c[root] + val;
    int l = 1, r = m;
    while (l < r)
    {
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        }
        else
        {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int query(int left_root, int right_root, int k)
{
    int l = 1, r = m;
    while ( l < r)
    {
        int mid = (l + r) >> 1;
        if (c[lson[left_root]] - c[lson[right_root]] >= k )
        {
            r = mid;
            left_root = lson[left_root];
            right_root = lson[right_root];
        }
        else
        {
            l = mid + 1;
            k -= c[lson[left_root]] - c[lson[right_root]];
            left_root = rson[left_root];
            right_root = rson[right_root];
        }
    }
    return l;
}

int main()
{
    //  freopen("in.txt","r",stdin);
    //  freopen("out.txt","w",stdout);
    while (scanf("%d%d", &n, &q) == 2)
    {
        tot = 0;
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        Init_hash();
        T[n + 1] = build(1, m);
        for (int i = n; i; i--)
        {
            int pos = hash_(a[i]);
            T[i] = update(T[i + 1], pos, 1);
        }
        while (q--)
        {
            int l, r, k;
            scanf("%d%d%d", &l, &r, &k);
            printf("%d\n", t[query(T[l], T[r + 1], k)]);
        }
    }
    return 0;
}

树上路径点权第k大

/*
 *  LCA + 主席树
 */
//  主席树部分
const int MAXN = 200010;
const int M = MAXN * 40;
int n, q, m, TOT;
int a[MAXN], t[MAXN];
int T[MAXN], lson[M], rson[M], c[M];
void Init_hash()
{
    for (int i = 1; i <= n; i++)
    {
        t[i] = a[i];
    }
    sort(t + 1, t + 1 + n);
    m = (int)(unique(t + 1, t + n + 1) - t - 1);
    return ;
}

int build(int l, int r)
{
    int root = TOT++;
    c[root] = 0;
    if (l != r)
    {
        int mid = (l + r) >> 1;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int hash_(int x)
{
    return (int)(lower_bound(t + 1, t + 1 + m, x) - t);
}

int update(int root, int pos, int val)
{
    int newroot = TOT++, tmp = newroot;
    c[newroot] = c[root] + val;
    int l = 1, r = m;
    while (l < r)
    {
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            lson[newroot] = TOT++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        }
        else
        {
            rson[newroot] = TOT++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

int query(int left_root, int right_root, int LCA, int k)
{
    int lca_root = T[LCA];
    int pos = hash_(a[LCA]);
    int l = 1, r = m;
    while (l < r)
    {
        int mid = (l + r) >> 1;
        int tmp = c[lson[left_root]] + c[lson[right_root]] - 2 * c[lson[lca_root]] + (pos >= l && pos <= mid);
        if (tmp >= k)
        {
            left_root = lson[left_root];
            right_root = lson[right_root];
            lca_root = lson[lca_root];
            r = mid;
        }
        else
        {
            k -= tmp;
            left_root = rson[left_root];
            right_root = rson[right_root];
            lca_root = rson[lca_root];
            l = mid + 1;
        }
    }
    return l;
}

//  LCA部分
int rmq[2 * MAXN];  //  rmq数组,就是欧拉序列对应的深度序列

struct ST
{
    int mm[2 * MAXN];
    int dp[2 * MAXN][20];   //  最小值对应的下标
    void init(int n)
    {
        mm[0] = -1;
        for (int i = 1; i <= n; i++)
        {
            mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
            dp[i][0] = i;
        }
        for (int j = 1; j <= mm[n]; j++)
        {
            for (int i = 1; i + (1 << j) - 1 <= n; i++)
            {
                dp[i][j] = rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
            }
        }
        return ;
    }
    int query(int a, int b) //  查询[a,b]之间最小值的下标
    {
        if (a > b)
        {
            swap(a, b);
        }
        int k = mm[b - a + 1];
        return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
    }
};

//  边的结构体定义
struct Edge
{
    int to, next;
};

Edge edge[MAXN * 2];
int tot, head[MAXN];
int F[MAXN * 2];    //  欧拉序列,就是dfs遍历的顺序,长度为2*n-1,下标从1开始
int P[MAXN];        //  P[i]表示点i在F中第一次出现的位置
int cnt;
ST st;

void init()
{
    tot = 0;
    memset(head, -1, sizeof(head));
    return ;
}

void addedge(int u, int v)  //  加边,无向边需要加两次
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
    return ;
}

void dfs(int u, int pre, int dep)
{
    F[++cnt] = u;
    rmq[cnt] = dep;
    P[u] = cnt;
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (v == pre)
        {
            continue;
        }
        dfs(v, u, dep + 1);
        F[++cnt] = u;
        rmq[cnt] = dep;
    }
    return ;
}

void LCA_init(int root, int node_num)   //  查询LCA前的初始化
{
    cnt = 0;
    dfs(root, root, 0);
    st.init(2 * node_num - 1);
    return ;
}

int query_lca(int u, int v)              //  查询u,v的lca编号
{
    return F[st.query(P[u], P[v])];
}

void dfs_build(int u, int pre)
{
    int pos = hash_(a[u]);
    T[u] = update(T[pre], pos, 1);
    for (int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if (v == pre)
        {
            continue;
        }
        dfs_build(v, u);
    }
    return ;
}


int main()
{
    //  freopen("in.txt", "r", stdin);
    //  freopen("out.txt", "w", stdout);
    while (scanf("%d%d", &n, &q) == 2)
    {
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
        }
        Init_hash();
        init();
        TOT = 0;
        int u, v;
        for (int i = 1; i < n; i++)
        {
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }
        LCA_init(1, n);
        T[n + 1] = build(1, m);
        dfs_build(1, n + 1);
        int k;
        while (q--)
        {
            scanf("%d%d%d", &u, &v, &k);
            printf("%d\n", t[query(T[u], T[v], query_lca(u, v), k)]);
        }
    }
    return 0;
}

动态第区间第k大

参考题目链接：
ZOJ 2112 ???这个有些尴尬，现在正处于系统维护阶段……进不去ZOJ

/*
 *  树状数组套主席树
 */
const int MAXN = 60010;
const int M = 2500010;
int n, q, m, tot;
int a[MAXN], t[MAXN];
int T[MAXN], lson[M], rson[M],c[M];
int S[MAXN];

struct Query
{
    int kind;
    int l, r, k;
} query[10010];

void Init_hash(int k)
{
    sort(t, t + k);
    m = (int)(unique(t, t + k) - t);
    return ;
}

int hash_(int x)
{
    return (int)(lower_bound(t, t + m, x) - t);
}

int build(int l, int r)
{
    int root = tot++;
    c[root] = 0;
    if (l != r)
    {
        int mid = (l + r) / 2;
        lson[root] = build(l, mid);
        rson[root] = build(mid + 1, r);
    }
    return root;
}

int Insert(int root, int pos, int val)
{
    int newroot = tot++, tmp = newroot;
    int l = 0, r = m - 1;
    c[newroot] = c[root] + val;
    while (l < r)
    {
        int mid = (l + r) >> 1;
        if (pos <= mid)
        {
            lson[newroot] = tot++;
            rson[newroot] = rson[root];
            newroot = lson[newroot];
            root = lson[root];
            r = mid;
        }
        else
        {
            rson[newroot] = tot++;
            lson[newroot] = lson[root];
            newroot = rson[newroot];
            root = rson[root];
            l = mid + 1;
        }
        c[newroot] = c[root] + val;
    }
    return tmp;
}

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

int use[MAXN];

void add(int x, int pos, int val)
{
    while (x <= n)
    {
        S[x] = Insert(S[x], pos, val);
        x += lowbit(x);
    }
    return ;
}
int sum(int x)
{
    int ret = 0;
    while (x > 0)
    {
        ret += c[lson[use[x]]];
        x -= lowbit(x);
    }
    return ret;
}

int Query(int left, int right, int k)
{
    int left_root = T[left - 1];
    int right_root = T[right];
    int l = 0, r = m - 1;
    for (int i = left - 1; i; i -= lowbit(i))
    {
        use[i] = S[i];
    }
    for (int i = right; i; i -= lowbit(i))
    {
        use[i] = S[i];
    }
    while (l < r)
    {
        int mid = (l + r) / 2;
        int tmp = sum(right) - sum(left - 1) + c[lson[right_root]] - c[lson[left_root]];
        if (tmp >= k)
        {
            r = mid;
            for (int i = left - 1; i; i -= lowbit(i))
            {
                use[i] = lson[use[i]];
            }
            for (int i = right; i; i -= lowbit(i))
            {
                use[i] = lson[use[i]];
            }
            left_root = lson[left_root];
            right_root = lson[right_root];
        }
        else
        {
            l = mid + 1;
            k -= tmp;
            for (int i = left - 1; i; i -= lowbit(i))
            {
                use[i] = rson[use[i]];
            }
            for (int i = right; i; i -= lowbit(i))
            {
                use[i] = rson[use[i]];
            }
            left_root = rson[left_root];
            right_root = rson[right_root];
        }
    }
    return l;
}

void Modify(int x, int p, int d)
{
    while (x <= n)
    {
        S[x] = Insert(S[x], p, d);
        x += lowbit(x);
    }
    return ;
}

int main()
{
    //  freopen("in.txt", "r", stdin);
    //  freopen("out.txt", "w", stdout);
    int Tcase;
    scanf("%d", &Tcase);
    while (Tcase--)
    {
        scanf("%d%d", &n, &q);
        tot = 0;
        m = 0;
        for (int i = 1; i <= n; i++)
        {
            scanf("%d", &a[i]);
            t[m++] = a[i];
        }
        char op[10];
        for (int i = 0; i < q; i++)
        {
            scanf("%s", op);
            if (op[0] == 'Q')
            {
                query[i].kind = 0;
                scanf("%d%d%d", &query[i].l, &query[i].r, &query[i].k);
            }
            else
            {
                query[i].kind = 1;
                scanf("%d%d", &query[i].l, &query[i].r);
                t[m++] = query[i].r;
            }
        }
        Init_hash(m);
        T[0] = build(0, m - 1);
        for (int i = 1; i <= n; i++)
        {
            T[i] = Insert(T[i - 1], hash_(a[i]), 1);
        }
        for (int i = 1; i <= n; i++)
        {
            S[i] = T[0];
        }
        for (int i = 0; i < q; i++)
        {
            if (query[i].kind == 0)
            {
                printf("%d\n", t[Query(query[i].l, query[i].r, query[i].k)]);
            }
            else
            {
                Modify(query[i].l, hash_(a[query[i].l]), -1);
                Modify(query[i].l, hash_(query[i].r), 1);
                a[query[i].l] = query[i].r;
            }
        }
    }
    return 0;
}

2017.8.6 修改 静态区间第K大 为 静态区间第K小

主席树_主席树模板_
09-30
供信息学奥林匹克竞赛选手使用 主席树模板
主席树详解（基础）
nxhx_的博客
12-24 3266
可持久化线段树，又称主席树，本文详解它的构成和基础用法
可持久化线段树（主席树）
帅比王的博客
08-29 4183
摘要 主席树，又称可持久化线段树，属于可持久化数据结构。“主席”这一名词是由于发明者缩写为HJT，和某位主席拼音缩写相同（有些牵强），故将该数据结构称为主席树。 主席树既保留了线段树的灵活，也拥有了可持久化数据结构的特点，在处理某些特定问题时有着其它数据结构不具有的优势。 本文将首先介绍什么是“可持久化数据结构”，随后介绍主席树的思想，关于代码实现将结合例题讲解。 可持久化数据结构 可持久数据结构...
可持久化线段树/主席树
最新发布
Maxwell_Newton的博客
02-16 807
具体来说，可持久化线段树是可以保存所有历史版本的线段树，每次插入，都会创建一颗新树，保存这次插入后版本的线段树，返回这个版本的线段树根节点，后面想查询一个历史版本时，就使用这个版本的根节点，进行线段树查询就行了，具体查询和线段树正常查询完全一样。个点，线段树中剩余的点其实完全没有变化，那其实我们可以在每次插入时，只对受到影响的点创建新的版本，然后接到未受影响的点上，这样每次插入，创建新版本的复杂度就是。小于左子树的元素个数，就进入左子树，否则进入右子树，知道来到叶节点，就是我们要找的元素的值。
主席树（POJ-2104、HDU-2665）
hnjzsyjyj的专栏
12-15 3454
【算法分析】 主席树名称来源于其发明人黄嘉泰的姓名的首字母缩写HJT与我们某位主席姓名的首字母缩写一样。 主席树的经典应用在于求某个区间内的第K小/大数的值。比如区间第K大问题，就是给定一个数列a，询问给定区间[L,R]的第K大值。如对数列a=[4,1,3,2,5]，针对询问L=2，R=5，K=2，其答案为2。 主席树是一种可持久化数据结构，即可持久化权值线段树。 为了实现可持久化，就要保存线...
主席树简介及应用
hnjzsyjyj的专栏
09-12 3078
【主席树简介】 主席树，即可持久化线段树，又称函数式线段树，是重要的可持久化数据结构之一。所谓可持久化，是指可以回溯到历史版本。 主席树的本质，就是在有数据更新时，在基准线段树的基础上采用“结点复用”的方式仅仅增加少量结点来维护历史数据，而不是通过存储不同版本线段树的方式来维护历史数据，从而达到减少时空消耗的目的，避免出现TLE（Time Limit Exceeded）及MLE（Memory Limit Exceeded）错误。主席树空间一般建议是开n<<5（n为基准线段树的结点数）。 如在..
【学习笔记】浅谈主席树（可持久化线段树）
菜狗成长为蒟蒻之路
05-18 1446
主席树上没有主席，就跟老婆饼里没有老婆，Bamboo_Day 里没有 Bamboo 是一样的。之所以叫主席树，是因为发明这个数据结构的人名字缩写为hjt跟某位伟大的主席一样。主席树是在的基础上发展出来的，所以你要先学会当然你还要学会。
主席树.ppt
07-08
主席树.ppt
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
区间第k大 主席树代码
11-03
普通的主席树 区间第k大 代码 包含了简单的注释，和线段树很相似
AdvancedDataStructures:大学时期学习数据结构的C ++源码，包含AVL树，Treap，多个有序链表合并，二叉查找树，二项堆，红黑树，扭曲树，跳表，栈与数量相互模拟以及最小（大）值改善，主席树的C ++版实现，欢迎指出错误和提交贡献
03-23
AdvancedDataStructures:大学时期学习数据结构的C ++源码，包含AVL树，Treap，多个有序链表合并，二叉查找树，二项堆，红黑树，扭曲树，跳表，栈与数量相互模拟以及最小（大）值改善，主席树的C ++版实现，欢迎指出...
主席树（可持久化线段树）
孙煜晗的博客
11-04 6880
2019.11.4 今天总算弄会主席树了，发现确实不难，但是需要跳出常规线段树的思维，特别是处理子树上面 主席树的定义与作用 主席树，也称可持久化线段树，那么什么是可持久化线段树呢，即为一颗记录了所有更新过程的线段树。能够处理出从第i次更新到第j次更新的线段树变化，具体作用一会见例题。 主席树的功能 记录所有过程的线段树，按正常思维是需要开O(N*M)这么大的空间的，时间也为O（n*m），...
关于主席树
two_big_monkey的博客
03-24 2054
什么是主席树？ 主席树又叫做可持久化线段树，其实后者才是它的大名只是大家都图方便就叫前者了。 可持久化线段树，一听名字就知道它的两个终点：可持久化，线段树。 都要学主席树了，线段树是什么总归都知道的吧，那什么是可持久化呢？ 可持久化理解起来其实也很简单，说白了就是可以查询历史节点就可以叫可持久化了，所以可持久化线段树的意思就是可以查询线段树的历史节点就是可持久化了。 如何实现可持久化？ 我们这边先给出一棵线段树吧。 画的不好，大家理解一下就行了 假设说我现在想要单点修改最左边的叶子节点 在这里插入图片描述
可持久化数据结构-线段树(主席树）
zje11的博客
01-06 1318
可持久化线段树的概念和简单运用
树状结构之主席树
weixin_30349597的博客
08-22 472
主席树搞了一个多星期TAT，，，，，，也只是大致领悟而已！！！ 主席树又称函数式线段树，顾名思义，也就是通过函数来实现的线段树，至于为什么叫主席树，那是因为是fotile主席创建出来的这个数据结构（其实貌似是当初主席不会划分树而自己想出来的另一个处理方式。。。。是不是很吊呢？ ORZ...)不扯了，切入正题。 主席树就是利用函数式编程的思想来使线段树支持询问历史版本、同时充分利用它们之间的共同...
【算法学习】主席树入门
热门推荐
Pengwill's Blog
07-04 2万+
主席树入门 原理 主席树入门 主席树，也叫做可持久化线段树，准确来说，应该叫做可持久化权值线段树，因为其中的每一颗树都是一颗权值线段树。 所谓权值线段树，就是指线段树的叶子节点保存的是当前值的个数。这样说起来比较抽象，下面用具体例子来简单阐述。 如有数列：2 1 2 5 1 1 1 3，不难统计出，数列中数字1出现了4次，数字2出现了2次，数字3、数字5都出现了1次，对于这...
主席树入门详解
SCUEC__zhazhahui的博客
01-15 977
简介 主席树全称应为可持久化权值线段树，可用于解决区间第k小问题。但可能由于这个的影响力比较大，现在主席树也被泛指为可持久化线段树。 主席树树是由NOI选手黄嘉泰（HJT，咱也不敢说）首先使用的。黄嘉泰原话：“这种求k 大的方法（函数式线段树）应该是我最早开始用的”。 可持久化线段树 可持久化数据结构 (Persistent data structure) 是可以保留每一个历史版本，并且支持操作的不可变特性 (immutable)。 可持久化线段树即保留多个历史版本（第k个版本即第k次修改后，第k+1次版本
详解——主席树
weixin_30657541的博客
07-04 292
由来 主席树又称函数式线段树，顾名思义，也就是通过函数来实现的线段树 然而我并不知道什么是函数式线段树，某位大爷说：“主席树与可持...
mcu8660点名观看主席怎么设置
07-17
MCU8660是一款华为的视频会议芯片组，用于支持网络视频会议系统。关于设置MCU8660设备以便点名观看主席的功能，通常涉及到系统的配置步骤： 1. 登录到MCU的Web管理界面：首先需要通过IP地址连接到MCU的Web界面，管理员账号和密码一般是出厂预设的，可以查阅用户手册或联系设备供应商获取。 2. 找到会议控制功能：在管理界面中，找到会议管理或者功能设置模块，这通常包含会议选项、角色管理等。 3. 设置主席权限：在会议配置中，选择“主席模式”或者类似选项，赋予某用户“主席”权限。主席有更多操作权限，包括点名发言权。 4. 点名设置：在点名设置中，可以设定如何触发点名，比如手动点击或者通过语音命令。还可以指定被点名的成员显示方式。 5. 保存并应用更改：确认所有设置无误后，记得保存并应用新的配置。 请注意，具体的步骤可能会因设备型号和软件版本的不同而有所差异，建议参考官方文档或联系技术支持进行操作。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值