立即前往

活动

天翼云最新优惠活动,涵盖免费试用,产品折扣等,助您降本增效!
查看全部活动
热门活动
  • 智算采购季 热销S6云服务器2核4G限时88元/年起,部分主机可加赠对象存储组合包!
  • 免费体验DeepSeek,上天翼云息壤 NEW 新老用户均可免费体验2500万Tokens,限时两周
  • 云上钜惠 HOT 爆款云主机全场特惠,更有万元锦鲤券等你来领!
  • 算力套餐 HOT 让算力触手可及
  • 天翼云脑AOne NEW 连接、保护、办公,All-in-One!
  • 一键部署Llama3大模型学习机 0代码一键部署,预装最新主流大模型Llama3与StableDiffusion
  • 中小企业应用上云专场 产品组合下单即享折上9折起,助力企业快速上云
  • 息壤高校钜惠活动 NEW 天翼云息壤杯高校AI大赛,数款产品享受线上订购超值特惠
  • 天翼云电脑专场 HOT 移动办公新选择,爆款4核8G畅享1年3.5折起,快来抢购!
  • 天翼云奖励推广计划 加入成为云推官,推荐新用户注册下单得现金奖励
免费活动
  • 免费试用中心 HOT 多款云产品免费试用,快来开启云上之旅
  • 天翼云用户体验官 NEW 您的洞察,重塑科技边界

智算服务

打造统一的产品能力,实现算网调度、训练推理、技术架构、资源管理一体化智算服务
智算云(DeepSeek专区)
科研助手
  • 算力商城
  • 应用商城
  • 开发机
  • 并行计算
算力互联调度平台
  • 应用市场
  • 算力市场
  • 算力调度推荐
一站式智算服务平台
  • 模型广场
  • 体验中心
  • 服务接入
智算一体机
  • 智算一体机
大模型
  • DeepSeek-R1-昇腾版(671B)
  • DeepSeek-R1-英伟达版(671B)
  • DeepSeek-V3-昇腾版(671B)
  • DeepSeek-R1-Distill-Llama-70B
  • DeepSeek-R1-Distill-Qwen-32B
  • Qwen2-72B-Instruct
  • StableDiffusion-V2.1
  • TeleChat-12B

应用商城

天翼云精选行业优秀合作伙伴及千余款商品,提供一站式云上应用服务
进入甄选商城进入云市场创新解决方案
办公协同
  • WPS云文档
  • 安全邮箱
  • EMM手机管家
  • 智能商业平台
财务管理
  • 工资条
  • 税务风控云
企业应用
  • 翼信息化运维服务
  • 翼视频云归档解决方案
工业能源
  • 智慧工厂_生产流程管理解决方案
  • 智慧工地
建站工具
  • SSL证书
  • 新域名服务
网络工具
  • 翼云加速
灾备迁移
  • 云管家2.0
  • 翼备份
资源管理
  • 全栈混合云敏捷版(软件)
  • 全栈混合云敏捷版(一体机)
行业应用
  • 翼电子教室
  • 翼智慧显示一体化解决方案

合作伙伴

天翼云携手合作伙伴,共创云上生态,合作共赢
天翼云生态合作中心
  • 天翼云生态合作中心
天翼云渠道合作伙伴
  • 天翼云代理渠道合作伙伴
天翼云服务合作伙伴
  • 天翼云集成商交付能力认证
天翼云应用合作伙伴
  • 天翼云云市场合作伙伴
  • 天翼云甄选商城合作伙伴
天翼云技术合作伙伴
  • 天翼云OpenAPI中心
  • 天翼云EasyCoding平台
天翼云培训认证
  • 天翼云学堂
  • 天翼云市场商学院
天翼云合作计划
  • 云汇计划
天翼云东升计划
  • 适配中心
  • 东升计划
  • 适配互认证

开发者

开发者相关功能入口汇聚
技术社区
  • 专栏文章
  • 互动问答
  • 技术视频
资源与工具
  • OpenAPI中心
开放能力
  • EasyCoding敏捷开发平台
培训与认证
  • 天翼云学堂
  • 天翼云认证
魔乐社区
  • 魔乐社区

支持与服务

为您提供全方位支持与服务,全流程技术保障,助您轻松上云,安全无忧
文档与工具
  • 文档中心
  • 新手上云
  • 自助服务
  • OpenAPI中心
定价
  • 价格计算器
  • 定价策略
基础服务
  • 售前咨询
  • 在线支持
  • 在线支持
  • 工单服务
  • 建议与反馈
  • 用户体验官
  • 服务保障
  • 客户公告
  • 会员中心
增值服务
  • 红心服务
  • 客户支持计划
  • 专家技术服务
  • 备案管家

了解天翼云

天翼云秉承央企使命,致力于成为数字经济主力军,投身科技强国伟大事业,为用户提供安全、普惠云服务
品牌介绍
  • 关于天翼云
  • 智算云
  • 天翼云4.0
  • 新闻资讯
  • 天翼云APP
基础设施
  • 全球基础设施
  • 产品能力
  • 信任中心
最佳实践
  • 精选案例
  • 超级探访
  • 云杂志
  • 分析师和白皮书
  • 天翼云·创新直播间
市场活动
  • 2025智能云生态大会
  • 2024智算云生态大会
  • 2023云生态大会
  • 2022云生态大会
  • 天翼云中国行
天翼云
  • 活动
  • 智算服务
  • 产品
  • 解决方案
  • 应用商城
  • 合作伙伴
  • 开发者
  • 支持与服务
  • 了解天翼云
    • 关系数据库SQL Server版
    • 企业主机安全
    • 云防火墙
    • CDN加速
    • 物理机
    • GPU云主机
    • 天翼云电脑(政企版)
    • 天翼云电脑(公众版)
    • 云主机备份
    • 弹性云主机
      搜索发现
      关系数据库SQL Server版企业主机安全云防火墙CDN加速物理机GPU云主机天翼云电脑(政企版)天翼云电脑(公众版)云主机备份弹性云主机
    • 文档
    • 控制中心
    • 备案
    • 管理中心
    • 登录
    • 免费注册

    数据结构之并查集

    首页 知识中心 数据库 文章详情页

    数据结构之并查集

    2025-02-11 09:39:39 阅读次数:11

    数组,查集,示例,集合

    并查集相关概念 

    并查集是一种树型的数据结构,用于处理一些不相交集合的合并及查询问题(即所谓的并、查)。比如说,我们可以用并查集来判断这两个人是否是亲戚(有没有最近公共祖先)或者两个人是否属于一个阵营等。

    虽然并查集是一种树形结构,但是其底层的实现和堆一样是一个数组。这个数组的大小就代表了我们要处理的集合大小,而这个数组下标对应的值就是这个下标的根结点。如下所示:

    数据结构之并查集

    通过上述图片我们可以知道一下几个结论:

    1、查找元素属于哪个集合沿着数组表示树形关系以上一直找到根(即:树中中元素为负数的位置);

    2、查看两个元素是否属于同一个集合沿着数组表示的树形关系往上一直找到树的根,如果根相同表明在同一个集合,否则不在;

    3、将两个集合归并成一个集合,即将一个集合的根结点对应的值改为另一个集合的根结点即可;

    在改动的时候要注意:

    (1):另一个集合被改的下标为未被改的集合的根结点

    (2):未被改的集合的根结点的值要发生改变:加上另一个集合根结点的值。

    4、集合的个数:遍历数组,数组中元素为负数的个数即为集合的个数。

    模拟实现并查集

    public class UnionFindSet {
        public int[] elem;
    
        // 将数组初始化为-1,证明每个元素刚开始都是一个独立的集合
        public UnionFindSet() {
            elem = new int[10];
            Arrays.fill(elem, -1);
        }
    
        public UnionFindSet(int n) {
            elem = new int[n];
            Arrays.fill(elem, -1);
        }
    
        // 找到val对应的根结点
        public int findRoot(int val) {
            // 注意val是数组的下标
            // 得判断下标的合法性
            if (val < 0) {
                throw new IndexOutOfBoundsException("数据下标不合法");
            }
            // 只有当数组下标对应的值为负数时,才算找到了根节点
            while (elem[val] >= 0) {
                val = elem[val];
            }
            return val;
        }
    
        // 合并两个元素
        public void union(int val1, int val2){
            if (val1 < 0 || val2 < 0) {
                throw new IndexOutOfBoundsException("数据下标不合法");
            }
            // 先找到对应的根结点
            int index1 = findRoot(val1);
            int index2 = findRoot(val2);
            // 如果根结点一致,就无需合并了
            if (index1 == index2) {
                return;
            }
            
            // 这种合并方法会导致两棵树的高低不均匀
           /* elem[index1] += elem[index2];
            elem[index2] = index1;*/
    
            // 开始合并:看哪个树高,就把哪个树作为母树
            if (index1 < index2) {
                // index1树高
                elem[index1] += elem[index2];
                elem[index2] = index1;
            } else {
                // index2树高
                elem[index2] += elem[index1];
                elem[index1] = index2;
            }
        }
    
        // 判断两个元素是否在同一个集合中
        public boolean isSameSet(int val1, int val2) {
            // 看看找到的根结点是否一样
            int index1 = findRoot(val1);
            int index2 = findRoot(val2);
            if (index1 == index2) {
                return true;
            }
            return false;
        }
    
        // 求数组中集合的个数
        public int getCountSet() {
            int count = 0;
            for (int x : elem) {
                // 如果元素下标对应的值为负树,则说明是一个集合
                if (x < 0) {
                    count++;
                }
            }
            return count;
        }
    
        // 打印集合中的全部元素
        public void printElem() {
            for (int i = 0; i < elem.length; i++) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
    

    总体实现还是比较简单的。 

    并查集的应用

    547.省份数量

    题目:

    有 n 个城市,其中一些彼此相连,另一些没有相连。如果城市 a 与城市 b 直接相连,且城市 b 与城市 c 直接相连,那么城市 a 与城市 c 间接相连。

    省份 是一组直接或间接相连的城市,组内不含其他没有相连的城市。

    给你一个 n x n 的矩阵 isConnected ,其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连,而 isConnected[i][j] = 0 表示二者不直接相连。

    返回矩阵中 省份 的数量。

     

    示例 1:

    数据结构之并查集
    输入:isConnected = [[1,1,0],[1,1,0],[0,0,1]]
    输出:2
    

    示例 2:

    数据结构之并查集
    输入:isConnected = [[1,0,0],[0,1,0],[0,0,1]]
    输出:3
    
    

    提示:

    • 1 <= n <= 200
    • n == isConnected.length
    • n == isConnected[i].length
    • isConnected[i][j] 为 1 或 0
    • isConnected[i][i] == 1
    • isConnected[i][j] == isConnected[j][i]

    思路:通过阅读题目可知:相邻的城市被称为一组省份,而我们要做的就是把省份的数量统计出来。利用并查集的思想就是:把相邻的城市合并成一个集合,然后再求集合的数量。相邻的城市就是 isConnected[i][j] == 1,因此只需要遍历数组,如果相邻,就合并;最后再看集合的数量。

    代码实现:

    class Solution {
        public int findCircleNum(int[][] isConnected) {
            // 因为这个数组并不是按照我们的要求来创建的,因此得发生改变
            // 重新创建一个数组
            // ufs底层的数组的长度就是城市的个数(因为最终合并的还是城市)
            UnionFindSet ufs = new UnionFindSet(isConnected.length); 
            // 遍历数组将相邻的城市合并成一组省份
            for (int i = 0; i < isConnected.length; i++) {
                // 根据 提示可知:isConnected[i][j] == isConnected[j][i]
                // 即 j = i+1,也是可以的(类似去重了)
                for (int j = 0; j < isConnected[i].length; j++) {
                    if (isConnected[i][j] == 1) {
                        ufs.union(i, j);
                    }
                }
            }
            return ufs.getCountSet();
        }
    }
    
    class UnionFindSet {
        public int[] elem;
    
        // 将数组初始化为1,证明每个元素刚开始都是一个独立的集合
        public UnionFindSet() {
            elem = new int[10];
            Arrays.fill(elem, -1);
        }
    
        public UnionFindSet(int n) {
            elem = new int[n];
            Arrays.fill(elem, -1);
        }
    
        // 找到val对应的根结点
        public int findRoot(int val) {
            // 注意val是数组的下标
            // 得判断下标的合法性
            if (val < 0) {
                throw new IndexOutOfBoundsException("数据下标不合法");
            }
            while (elem[val] >= 0) {
                val = elem[val];
            }
            return val;
        }
    
        // 合并两个元素
        public void union(int val1, int val2){
            if (val1 < 0 || val2 < 0) {
                throw new IndexOutOfBoundsException("数据下标不合法");
            }
            // 先找到对应的根结点
            int index1 = findRoot(val1);
            int index2 = findRoot(val2);
            // 如果根结点一致,就无需合并了
            if (index1 == index2) {
                return;
            }
    
           /* elem[index1] += elem[index2];
            elem[index2] = index1;*/
    
            // 开始合并:看哪个树高,就把哪个树作为母树
            if (index1 < index2) {
                // index1树高
                elem[index1] += elem[index2];
                elem[index2] = index1;
            } else {
                // index2树高
                elem[index2] += elem[index1];
                elem[index1] = index2;
            }
        }
    
        // 判断两个元素是否在同一个集合中
        public boolean isSameSet(int val1, int val2) {
            // 看看找到的根结点是否一样
            int index1 = findRoot(val1);
            int index2 = findRoot(val2);
            if (index1 == index2) {
                return true;
            }
            return false;
        }
    
        // 求数组中集合的个数
        public int getCountSet() {
            int count = 0;
            for (int x : elem) {
                // 如果元素下标对应的值为负树,则说明是一个集合
                if (x < 0) {
                    count++;
                }
            }
            return count;
        }
    
        // 打印集合中的全部元素
        public void printElem() {
            for (int i = 0; i < elem.length; i++) {
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }

    上面是其中一种处理方式:创建一个新的同等大小的数组,并实现一个并查集;另外一种方式是:直接创建一个数组,实现部分方法:合并、求根、求集合个数。

    代码实现:

    class Solution {
        public int findCircleNum(int[][] isConnected) {
            // 创建一个新的数组
            int[] nums = new int[isConnected.length];
            Arrays.fill(nums, -1);
            for (int i = 0; i < isConnected.length; i++) {
                for (int j = 0; j < isConnected[i].length; j++) {
                    if (isConnected[i][j] == 1) {
                        union(nums, i, j);
                    }
                }
            }
            return getCountSet(nums);
        }
    
        private int getCountSet(int[] nums) {
            int count = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] < 0) {
                    count++;
                }
            }
            return count;
        }
    
        private void union(int[] nums, int i, int j) {
            // 合并两个集合
            int index1 = findRoot(nums, i);
            int index2 = findRoot(nums, j);
            // 同一个集合就不做处理
            if (index1 == index2) {
                return;
            }
            // 根据母树的高度来处理
            if (index1 < index2) {
                nums[index1] += nums[index2];
                nums[index2] = index1;
            } else {
                nums[index2] += nums[index1];
                nums[index1] = index2;
            }
        }
    
        private int findRoot(int[] nums, int i) {
            // 题目给的数据都是合法的
            while (nums[i] >= 0) {
                i = nums[i];
            }
            return i;
        }
    }

    990.等式方程的可满足性 

    题目:

    给定一个由表示变量之间关系的字符串方程组成的数组,每个字符串方程 equations[i] 的长度为 4,并采用两种不同的形式之一:"a==b" 或 "a!=b"。在这里,a 和 b 是小写字母(不一定不同),表示单字母变量名。

    只有当可以将整数分配给变量名,以便满足所有给定的方程时才返回 true,否则返回 false。 

     

    示例 1:

    输入:["a==b","b!=a"]
    输出:false
    解释:如果我们指定,a = 1 且 b = 1,那么可以满足第一个方程,但无法满足第二个方程。没有办法分配变量同时满足这两个方程。
    

    示例 2:

    输入:["b==a","a==b"]
    输出:true
    解释:我们可以指定 a = 1 且 b = 1 以满足满足这两个方程。
    

    示例 3:

    输入:["a==b","b==c","a==c"]
    输出:true
    

    示例 4:

    输入:["a==b","b!=c","c==a"]
    输出:false
    

    示例 5:

    输入:["c==c","b==d","x!=z"]
    输出:true
    
    

    提示:

    1. 1 <= equations.length <= 500
    2. equations[i].length == 4
    3. equations[i][0] 和 equations[i][3] 是小写字母
    4. equations[i][1] 要么是 '=',要么是 '!'
    5. equations[i][2] 是 '='

    思路:其实就是遍历数组,将等价的方程字母放置一个集合。第二次遍历的时候,如果出现了不在这个集合中的元素,那么就肯定不满足;如果遍历完成之后,没有返回,那么就满足了。这里其实运用的是并查集的思想。

    代码实现:

    错误代码示例:

    class Solution {
        // 错误解法:
        public boolean equationsPossible(String[] equations) {
            Set<Character> set = new TreeSet<>();
            for (int i = 0; i < equations.length; i++) {
                char ch1 = equations[i].charAt(0);
                char ch2 = equations[i].charAt(3);
                // 属于同一个集合就入
                if ((equations[i].charAt(1) == '=') && (ch1 != ch2) ) {
                    set.add(ch1);
                    set.add(ch2);
                }
            }
    
            for (int i = 0; i < equations.length; i++) {
                char ch1 = equations[i].charAt(0);
                char ch2 = equations[i].charAt(3);
                // !下并存在集合中或者本身相同,就返回false
                if (equations[i].charAt(1) == '!') {
                    if ((set.contains(ch1) && set.contains(ch2)) || (ch1 == ch2) ) {
                        return false;
                    }
                }
            }
            return true;
        }
    }

    上面的代码可以跑过大部分的情况,但是还有一种情况是不行的。如下图所示: 

    数据结构之并查集

    因此,正确的解法是用并查集。

    class Solution {
        public boolean equationsPossible(String[] equations) {
            // 普通的集合行不通,只能用并查集解决
            int[] nums = new int[26]; // 26个小写的英文字母
            Arrays.fill(nums, -1);
            for (int i = 0; i < equations.length; i++) {
                char ch1 = equations[i].charAt(0);
                char ch2 = equations[i].charAt(3);
                if (equations[i].charAt(1) == '=') {
                    union(nums, ch1-'a', ch2-'a');
                }
            }
    
            for (int i = 0; i < equations.length; i++) {
                char ch1 = equations[i].charAt(0);
                char ch2 = equations[i].charAt(3);
                if (equations[i].charAt(1) == '!') {
                    if (isSameSet(nums, ch1-'a', ch2-'a')) {
                        return false;
                    }
                }
            }
            return true;
        }
    
        private boolean isSameSet(int[] nums, int i, int j) {
            return findRoot(nums, i) == findRoot(nums, j);
        }
    
        private void union(int[] nums, int i, int j) {
            int index1 = findRoot(nums, i);
            int index2 = findRoot(nums, j);
            if (index1 == index2) {
                return;
            }
            if (index1 < index2) {
                nums[index1] += nums[index2];
                nums[index2] = index1;
            } else {
                nums[index2] += nums[index1];
                nums[index1] = index2;
            }
        }
    
        private int findRoot(int[] nums, int i) {
            while (nums[i] >= 0) {
                i = nums[i];
            }
            return i;
        }

     好啦!本期 数据结构之并查集 的学习之旅就到此结束啦!我们下一期再一起学习吧!

    版权声明:本文内容来自第三方投稿或授权转载,原文地址:https://blog.csdn.net/2301_80854132/article/details/141330447,作者:我要学编程(ಥ_ಥ),版权归原作者所有。本网站转在其作品的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系,请发邮件至ctyunbbs@chinatelecom.cn沟通。

    上一篇:scanf与printf函数的详细介绍及其用法

    下一篇:数据结构-二叉树中的递归

    相关文章

    2025-04-23 08:18:21

    【JavaScript 】什么是 Express.js?(Node.js Web 框架)

    【JavaScript 】什么是 Express.js?(Node.js Web 框架)

    2025-04-23 08:18:21
    API , js , Web , 示例
    2025-04-22 09:28:31

    零基础玩转C语言系列第五章——数组模块

    零基础玩转C语言系列第五章——数组模块

    2025-04-22 09:28:31
    下标 , 二维 , 数组 , 数组名 , 编译器
    2025-04-22 09:28:19

    java8开发常用的日期操作,纯干货分享

    java8开发常用的日期操作,纯干货分享

    2025-04-22 09:28:19
    Date , Java , 日期 , 时间 , 示例
    2025-04-22 09:27:28

    量子机器学习:颠覆性的前沿技术

    量子机器学习:颠覆性的前沿技术

    2025-04-22 09:27:28
    学习 , 机器 , 比特 , 示例
    2025-04-22 09:27:17

    随想录一刷·数组part2

    随想录一刷·数组part2

    2025-04-22 09:27:17
    数组 , 有序 , 链表
    2025-04-22 09:27:17

    指针的理解(三)

    指针的理解(三)

    2025-04-22 09:27:17
    int , 函数指针 , 变量 , 指针 , 数组
    2025-04-22 09:27:17

    蓝桥杯算法竞赛系列第九章·巧解哈希题,用这3种数据类型足矣

    蓝桥杯算法竞赛系列第九章·巧解哈希题,用这3种数据类型足矣

    2025-04-22 09:27:17
    key , map , nums , 哈希 , 数组
    2025-04-22 09:24:51

    怎么只用语言实现扫雷?

    怎么只用语言实现扫雷?

    2025-04-22 09:24:51
    代码 , 实现 , 数组 , 游戏
    2025-04-22 09:24:51

    蓝桥杯算法竞赛系列第十章·nSum问题的代码框架

    蓝桥杯算法竞赛系列第十章·nSum问题的代码框架

    2025-04-22 09:24:51
    nums , target , 数组
    2025-04-18 08:02:09

    django从入门到实战(四)——模板介绍及使用

    Django 的模板语法主要包括变量、标签、过滤器和模板继承等。

    2025-04-18 08:02:09
    使用 , 变量 , 模板 , 示例 , 自定义 , 过滤器
    查看更多
    推荐标签

    作者介绍

    天翼云小翼
    天翼云用户

    文章

    32777

    阅读量

    4820940

    查看更多

    最新文章

    Sqoop基础理论与常用命令详解(超详细)

    2025-04-16 09:26:45

    文心一言 VS 讯飞星火 VS chatgpt (262)-- 算法导论20.1 1题

    2025-04-15 09:19:45

    数据结构:顺序表的奥秘

    2025-04-15 09:18:39

    java使用JDBC方式操作mysql数据库示例

    2025-04-11 07:15:54

    恕我直言你可能真的不会java第4篇:Stream管道流Map操作

    2025-04-09 09:14:24

    for...in、for...of和其他循环的区别

    2025-03-28 07:42:34

    查看更多

    热门文章

    数组的升序排序 字符串的方法

    2023-04-21 03:15:03

    redis-数据类型-普通集合

    2023-03-29 10:07:52

    数据结构 数组 小结

    2023-03-01 02:55:22

    数据结构入门(第一天)

    2023-02-24 09:05:57

    数据结构入门(第三天)

    2023-02-24 09:42:48

    List集合对象去重及按属性去重的8种方法-java基础总结系列第六篇

    2023-05-23 08:22:30

    查看更多

    热门标签

    数据库 mysql 字符串 数据结构 MySQL redis 算法 java oracle sql python 数据 索引 数组 SQL
    查看更多

    相关产品

    弹性云主机

    随时自助获取、弹性伸缩的云服务器资源

    天翼云电脑(公众版)

    便捷、安全、高效的云电脑服务

    对象存储

    高品质、低成本的云上存储服务

    云硬盘

    为云上计算资源提供持久性块存储

    查看更多

    随机文章

    scanf与printf函数的详细介绍及其用法

    List集合对象去重及按属性去重的8种方法-java基础总结系列第六篇

    数组的升序排序 字符串的方法

    【数据结构】顺序表(长期维护)

    for...in、for...of和其他循环的区别

    前端项目实战96-属性值处理

    • 7*24小时售后
    • 无忧退款
    • 免费备案
    • 专家服务
    售前咨询热线
    400-810-9889转1
    关注天翼云
    • 权益商城
    • 天翼云APP
    • 天翼云微信公众号
    服务与支持
    • 备案中心
    • 售前咨询
    • 智能客服
    • 自助服务
    • 工单管理
    • 客户公告
    • 涉诈举报
    账户管理
    • 管理中心
    • 订单管理
    • 余额管理
    • 发票管理
    • 充值汇款
    • 续费管理
    快速入口
    • 权益商城
    • 文档中心
    • 最新活动
    • 免费试用
    • 信任中心
    • 天翼云学堂
    云网生态
    • 甄选商城
    • 渠道合作
    • 云市场合作
    了解天翼云
    • 关于天翼云
    • 天翼云APP
    • 服务案例
    • 新闻资讯
    • 联系我们
    热门产品
    • 云电脑
    • 弹性云主机
    • 云电脑政企版
    • 天翼云手机
    • 云数据库
    • 对象存储
    • 云硬盘
    • Web应用防火墙
    • 服务器安全卫士
    • CDN加速
    热门推荐
    • 云服务备份
    • 边缘安全加速平台
    • 全站加速
    • 安全加速
    • 云服务器
    • 云主机
    • 智能边缘云
    • 应用编排服务
    • 微服务引擎
    • 共享流量包
    更多推荐
    • web应用防火墙
    • 密钥管理
    • 等保咨询
    • 安全专区
    • 应用运维管理
    • 云日志服务
    • 文档数据库服务
    • 云搜索服务
    • 数据湖探索
    • 数据仓库服务
    友情链接
    • 中国电信集团
    • 189邮箱
    • 天翼企业云盘
    • 天翼云盘
    ©2025 天翼云科技有限公司版权所有 增值电信业务经营许可证A2.B1.B2-20090001
    公司地址:北京市东城区青龙胡同甲1号、3号2幢2层205-32室
    • 用户协议
    • 隐私政策
    • 个人信息保护
    • 法律声明
    备案 京公网安备11010802043424号 京ICP备 2021034386号