993.二叉树的堂兄弟结点 之妙不可言的位操作

leetcode[993]二叉树的堂兄弟节点 Python3实现(dfs查找深度和父节点) # 在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 # # 如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。 # # 我们给出了具有唯一值的二叉树的根节点 root ,以及树中两个不同节点的值 x 和 y 。 # # 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true 。否则,返回 false。 # # # # 示例 1: # # # # 输入:root = [1,2,3,4], x = 阅读详情

993. 二叉树的堂兄弟结点

题目:

在二叉树中,根结点位于深度 0 处,每个深度为 k 的结点的子结点位于深度 k+1 处。

如果二叉树的两个结点深度相同,但 父结点不同 ,则它们是一对堂兄弟结点。

我们给出了具有唯一值的二叉树的根结点 root ,以及树中两个不同结点的值 x 和 y 。

只有与值 x 和 y 对应的结点是堂兄弟结点时,才返回 true 。否则,返回 false。

来源:力扣(LeetCode)

github题解仓库

blog:https://blog.youkuaiyun.com/github_39329077

解法一:

判断是否为堂兄弟:深度相同,父结点不同。所以要有depth参数和parent参数,fun函数作先序遍历时找到target(x or y)就以pair的形式返回深度和父结点的值(因为二叉树中各结点值唯一所以可以仅用父结点的val来判断父结点是否相同),x、y进入fun找到自己的位置后直接返回结果并作剪枝操作,避免浪费时间作无用的搜索。

即:DFS+pair+剪枝

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        pair<int, int> p_x = fun(root, nullptr, 0, x);
        pair<int, int> p_y = fun(root, nullptr, 0, y);
        if(p_x.first == p_y.first && p_x.second != p_y.second)
            return true;
        else
            return false;
    }
    pair<int, int> fun(TreeNode* root, TreeNode* parent, int depth, int target) {
        if(!root)
            return make_pair(-1, -1);
        if(root->val == target) {
            return make_pair(depth, parent == nullptr ? -1: parent->val);//需注意下parent为根结点时
        }
        pair<int, int> p = fun(root->left, root, depth+1, target);
        if(p.first == -1 && p.second == -1)
            p = fun(root->right, root, depth+1, target);
        return p;
    }
};

从@guaidaokakaxi那学到的对位操作的小技巧,只要数据范围小于2^16就可以同时将两个数放入一个32位的int型变量里。(这题数据比较小都够放4个数了

即:DFS+int位操作,确实优雅些

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        int temp_x = fun(root, nullptr, 0, x);
        int temp_y = fun(root, nullptr, 0, y);
        int depth_x = temp_x >> 16;
        int depth_y = temp_y >> 16;
        if(depth_x != depth_y)
            return false;
        int parent_x_val = temp_x & 0x0000ffff;
        int parent_y_val = temp_y & 0x0000ffff;
        if(parent_x_val != parent_y_val)
            return true;
        else
            return false;
    }
    int fun(TreeNode* root, TreeNode* parent, int depth, int target) {
        if(!root)
            return 0;
        if(root->val == target) {
            return (depth << 16) + (parent == nullptr ? 0 : parent->val);
        }
        int temp = fun(root->left, root, depth+1, target);
        if(temp == 0)
            temp = fun(root->right, root, depth+1, target);
        return temp;
    }
};

解法二:

这个解法从@Edward Elric那学到的,妙不可言!类似堆排序时,用数组建堆,这里我们只用数组存树,不作调整,index为结点序号也是结点在数组中的下标(从1开始),自上而下,从左至右的分配序号,遇到空结点就跳过这个序号(各结点位置的序号永远与一个完全二叉树的序号一一对应,只是本题的树可以不完全)。

那么对任一序号为k的结点,其父结点的序号就是k/2,其左孩子就是k * 2,右孩子就是k * 2+1,同时最精彩的地方来了! 对于树中同一层的结点,其序号(index)二进制下的最高比特位是相同的,如序号分别为10[1010],12[1100]的结点都在第4层,他们最高2次幂都是8[1000]。

所以就有:

1.通过对下标值除2来判断父结点。

2.通过判断最高比特位是否相同来判断是否属于同一层。

判断最高位的比特是否相同,Edw用的是java里的toBinaryString(x).lentght()来实现的,而c++里没有这个方法所以我想到了用异或操作,两个数相异或时,若最高位均为1,1^1 = 0, 则这两个数中的任一个数一定大于异或后的结果,否则总有一个数小于这个结果。(完美

最后为节省空间可以换成map<int, int>存树

即:数组存树+序号特性判断

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        buildTree(root, 1);
        if(mp.find(x) == mp.end() || mp.find(y) == mp.end())
            return false;
        int num_x = mp.find(x)->second;
        int num_y = mp.find(y)->second;
        if(num_x/2 != num_y/2 && (num_x>(num_x^num_y) && num_y>(num_x^num_y)))
            return true;
        else
            return false;
    }
    void buildTree(TreeNode* root, int index) {
        if(!root)
            return;
        mp[root->val] = index;
        buildTree(root->left, index<<1);
        buildTree(root->right, (index<<1)+1);
    }
private:
    unordered_map<int, int> mp; 
};

既然我们只x,y在树上的序号,数组也可以不要,遍历的过程中存下他们的下标最后返回即可,同时还可以用到上面学到的int存两数的小技巧。

称之:一”位“到底:

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        int temp = 0;
        buildTree(root, 1, x, y, temp);
        if(!temp || !(temp&0xffff0000) || !(temp&0x0000ffff))
            return false;
        int num_x = temp>>16;
        int num_y = temp&0x0000ffff;
        if(num_x/2 != num_y/2 && (num_x>(num_x^num_y) && num_y>(num_x^num_y)))
            return true;
        else
            return false;
    }
    int buildTree(TreeNode* root, int index, int target_x, int target_y, int &temp) {
        if(!root)
            return temp;
        if(root->val == target_x)//各结点的值唯一所以不会重复加
            temp += index<<16;
        else if(root->val == target_y)
            temp += index;
        if(temp&0xffff0000 && temp&0x0000ffff)//必要的剪枝
            return temp;
        temp = buildTree(root->left, index<<1, target_x, target_y, temp);
        if(!(temp&0xffff0000) || !(temp&0x0000ffff))//必要的剪枝
            temp = buildTree(root->right, (index<<1)+1, target_x, target_y, temp);
        return temp;
};

temp太多还是换种写法:

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        int temp = 0;
        buildTree(root, 1, x, y, temp);
        if(!temp || !(temp&0xffff0000) || !(temp&0x0000ffff))
            return false;
        int num_x = temp>>16;
        int num_y = temp&0x0000ffff;
        if(num_x/2 != num_y/2 && (num_x>(num_x^num_y) && num_y>(num_x^num_y)))
            return true;
        else
            return false;
    }
    void buildTree(TreeNode* root, int index, int target_x, int target_y, int &temp) {
        if(!root)
            return ;
        if(root->val == target_x)//各结点的值唯一所以不会重复加
            temp += index<<16;
            else if(root->val == target_y)
                temp += index;
        if(temp&0xffff0000 && temp&0x0000ffff)
            return ;
        buildTree(root->left, index<<1, target_x, target_y, temp);
        if(!(temp&0xffff0000) || !(temp&0x0000ffff))
            buildTree(root->right, (index<<1)+1, target_x, target_y, temp);
        return ;
    }
};

解法三:

BFS

用preDepth来判断是否还在同一层,用comParent来判断当前结点的左右孩子是否就是所要找的x,y。

class Solution {
public:
    bool isCousins(TreeNode* root, int x, int y) {
        queue<pair<TreeNode*, int> > qu;
        int curDepth =1, preDepth = 1;
        bool find_x = false, find_y = false, comParent = false;
        qu.push(make_pair(root, curDepth));
        if(root->val == x || root-> val == y)
            return false;
        while(!qu.empty()) {
            auto [cur,curDepth] = qu.front();
            if(preDepth != curDepth && (find_x || find_y))//若遍历到下一层,仅找到一个数,直接不符合
                return false;
            preDepth = curDepth;//将当前结点的深度赋给preDepth用于对下个结点判断是否换层了
            qu.pop();
            if(cur->left) {
                qu.push(make_pair(cur->left, curDepth+1));
                if(cur->left->val == x) find_x = true, comParent = true;
                    else if(cur->left->val == y) find_y = true, comParent = true;
            }
            if(find_x && find_y)
                return true;
            if(cur->right) {
                qu.push(make_pair(cur->right, curDepth+1));
                if(cur->right->val == x) find_x = true;
                    else if(cur->right->val == y) find_y = true;
            }
            if(find_x && find_y)
            	return comParent ? false : true;
            comParent = false;
        }
        return false;
    }
};

看了@Qian的写法,太美了,贴来膜拜下

每次直接将一层的结点放入队列,并存下找到的x,y的父结点,然后一并处理。

class Solution {
public:
    using PTT = pair<TreeNode*, TreeNode*>;
    bool isCousins(TreeNode* root, int x, int y) {
        // 使用队列q来进行bfs
        // 其中pair中,p.first 记录当前结点的指针,p.second 记录当前结点的父结点的指针
        queue<PTT> q;
        q.push({root, nullptr});
        while(!q.empty()) {
            int n = q.size();
            vector<TreeNode*> rec_parent;
            for(int i = 0; i < n; i++) {
                auto [cur, parent] = q.front(); q.pop();
                if(cur->val == x || cur->val == y)
                    rec_parent.push_back(parent);
                if(cur->left) q.push({cur->left, cur});
                if(cur->right) q.push({cur->right, cur});
            }
            // `x` 和 `y` 都没出现
            if(rec_parent.size() == 0)
                continue;
            // `x` 和 `y` 只出现一个
            else if(rec_parent.size() == 1)
                return false;
            // `x` 和 `y` 都出现了
            else if(rec_parent.size() == 2)
                // `x` 和 `y` 父结点 相同/不相同 ?
                return rec_parent[0] != rec_parent[1];
        }
        return false;
    }
};

作者:QianK
链接:https://leetcode-cn.com/problems/cousins-in-binary-tree/solution/c-you-ya-bfs-by-qiank-9vk9/
来源:力扣(LeetCode)

小技巧:

  • 数组存树时,下标从1开始,各层结点序号的最高比特位相同。用(x > (x^y) && y > (x^y))来判断是否同层
  • int作位操作,存多个数
  • 善用容器的size()函数
通过树的边序列建立一颗孩子-兄弟结点的二叉树  自上而下输入边来建立树的存储结构(例如#A,AB,AC,BD,##),求树的深度。 立即下载

相关推荐

啥是PLCnext?它能干啥?

简单来说,PLCnext是基于Linux操作系统的一个控制器运行时,所以它原生具备的两个特点:1.原生兼容IEC611312.原生兼容Linux各类应用PLCnext的控制器大概长下面这样(AXC F 1152、2152),通过背板总线连接IO、通过网口连接Profinet或者上位机。

博客 1650

Leetcode 993:二叉树的堂兄弟节点(超详细的解法!!!)

在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同,但父节点不同,则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root,以及树中两个不同节点的值 x 和 y。 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true。否则,返回 false。 示例 1: 输入:root = [1,2,3,...

coordinate的博客 3237

Win10管理员权限的‘暗门’:从mmc.exe被阻止,聊聊UAC与自动提权那些事儿

本文深入解析Windows 10中UAC(用户账户控制)与自动提权机制,探讨mmc.exe被阻止的深层原因及解决方案。从UAC工作原理到自动提权机制,再到具体诊断与修复步骤,帮助用户理解并解决权限管理问题,同时平衡安全性与便利性。

weixin_30521161的博客 421

993. 二叉树的堂兄弟节点

分析: isCousins(root,x,y)能够判断符合值x、y的两个结点是否是堂兄弟结点,普通二叉树 堂兄弟结点是当且仅当x、y位于同一层并且父节点不同时才是堂兄弟结点 x、y的值不相同 设x对应结点p,y对应节点q 思路1 思路1:找到这两个结点,然后记录这两个结点的层次,并且记录这两个结点的父节点是谁,得到以上信息就能判断了 实现是用的层序遍历 class Solution: def isCousins(self, root: TreeNode, x: int, y: int) ->

1115

逆向拆解Android车机:VehicleHal如何通过HIDL与CarService通信?

本文深入剖析了Android Automotive OS中VehicleHal与CarService通过HIDL进行通信的底层机制。从逆向工程视角出发,详细介绍了如何捕获和分析HIDL调用日志,解析关键属性数据结构,并演示了利用SocketComm工具进行恶意属性注入攻击的实战路径,为车机系统安全评估提供了技术参考。

soda5的博客 723

AIGC实战:用ComfyUI和Lora微调打造专属原神角色(含完整工作流)

本文详细介绍了如何利用ComfyUI和Lora微调技术打造专属原神风格角色,涵盖从环境配置、数据集准备到工作流构建和Lora训练的全过程。通过模块化节点设计和高级控制技术,创作者可实现高度个性化的AIGC艺术创作,提升二次元角色生成的效率与质量。

weixin_29185199的博客 355

二叉树题目:二叉树的堂兄弟结点

文章目录题目标题和出处难度题目描述要求示例数据范围解法一思路和算法代码复杂度分析解法二思路和算法代码复杂度分析 题目 标题和出处 标题:二叉树的堂兄弟结点 出处:993. 二叉树的堂兄弟结点 难度 3 级 题目描述 要求 给你具有唯一值的二叉树的根结点 root\texttt{root}root,以及树中两个不同结点的值 x\texttt{x}x 和 y\texttt{y}y,如果值 x\texttt{x}x 和 y\texttt{y}y 对应的结点是堂兄弟结点,返回 true\texttt{true}tr

stormsunshine的博客 464

Apifox接口测试+自动化测试

Apifox 接口测试+自动化测试快速入门!

程序员小杨哥的博客 1万+

二叉树的堂兄弟结点

这道题是2024-2-8的签到题,题目难度为简单。考察的知识点为DFS算法。在二叉树中,根节点位于深度0处,每个深度为k的节点的子节点位于深度k+1处。如果二叉树的两个节点深度相同,但,则它们是一对堂兄弟节点。我们给出了具有唯一值的二叉树的根节点root,以及树中两个不同节点的值x和y。只有与值x和y对应的节点是堂兄弟节点时,才返回true。否则,返回false。

hand2some2的博客 448

【Matlab】刃边法计算mtf

摘要:刃边法是一种测量光学系统调制传输函数(MTF)的常用方法。本文介绍了基于Matlab的MTF计算实现方案,包括图像灰度化、梯度计算、刀口方向选择、梯度投影等关键步骤,并给出了完整的代码实现。该方案可通过添加图像预处理、多方向计算、函数封装等方式进行扩展,提高MTF计算的准确性和实用性,适用于不同应用场景的光学系统性能评估需求。(148字)

unber的博客 391

3、流程引擎下载安装与部署

camunda有多种使用方式,此处先使用独立平台的方式部署引擎,这种用法适合分布式,微服务化,多语言异构系统的使用方式。

leyoliu的博客 5524

Leetcode 993:二叉树的堂兄弟结点

题目描述 在二叉树中,根节点位于深度0处,每个深度为k的结点的子节点位于k+1处。如果二叉树的两个结点深度相同,但父节点不同,则他们是一对堂兄弟结点。我们给出了具体唯一值的二叉树的根节点root,以及树中两个不同祭祀按的值x和y。只有与x和y对应的结点是堂兄弟结点时,才返回true。否则,f返回false 示例1 输入:[1,2,3,4],x = 4,y = 3 输出:false 示例2...

weixin_35338624的博客 459

【Cesium开发实战】解决加载白膜数据位置不合适问题(地底或浮空)

解决白膜位置地底或者浮空问题。

莫言情怼的博客 570

力扣993. 二叉树的堂兄弟节点

993. 二叉树的堂兄弟节点

LNsupermali的博客 989

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

LeetCode 993. 二叉树的堂兄弟节点

截止到目前我已经写了 600多道算法题,其中部分已经整理成了pdf文档,目前总共有1000多页(并且还会不断的增加),大家可以免费下载 下载链接:https://pan.baidu.com/s/1hjwK0ZeRxYGB8lIkbKuQgQ 提取码:6666 public boolean isCousins(TreeNode root, int x, int y) { //两个队列一个存放树的节点,一个存放节点对应的值 Queue<TreeNode> queue = n.

数据结构和算法 1429

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

993. 二叉树的堂兄弟节点 + 2641. 二叉树的堂兄弟节点 II

我们要计算所有点的堂兄的和,就需要使用层序遍历,先求出下一层所有结点的和nextLevelSum,然后再通过一次遍历,遍历当前层的所有结点,并计算出当前节点的左右孩子的和curSum,接下来就可以更新当前节点的左右孩子,即用nextLevelSum - curSum就是当前节点左右孩子的所有堂兄弟结点的和。这一题相对上一题就复杂了一点,不只是需要判断某两个点是否为堂兄弟,而是需要将所有点的值都更新为它的堂兄弟的结点的和。,一个节点的深度指的是从树根节点到这个节点经过的边数。的节点的子节点位于深度。

cqjnovo的博客 1426

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

⭐算法入门⭐《二叉树》简单07 —— LeetCode 993. 二叉树的堂兄弟节点

《二叉树》简单07 —— LeetCode 993. 二叉树的堂兄弟节点

英雄哪里出来 6172

Leetcode.993 二叉树的堂兄弟节点

输入:root = [1,2,3,null,4,null,5], x = 5, y = 4。输入:root = [1,2,3,null,4], x = 2, y = 3。输入:root = [1,2,3,4], x = 4, y = 3。我们给出了具有唯一值的二叉树的根节点。如果二叉树的两个节点深度相同,但。对应的节点是堂兄弟节点时,才返回。的父结点也不相同,故 结点。在二叉树中,根节点位于深度。,以及树中两个不同节点的值。的节点的子节点位于深度。

感觉画质不如...原神的博客 871

二叉树的堂兄弟节点

目录993. 二叉树的堂兄弟节点思路分析DFSBFS 993. 二叉树的堂兄弟节点 在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root ,以及树中两个不同节点的值 x 和 y 。 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true 。否则,返回 false。 示例 1: 输入:root = [1,2,3,4], x = 4, y =

qq_43413774的博客 1334

Leetcode993:二叉树的堂兄弟节点

Leetcode993:二叉树的堂兄弟节点 题目描述:   1.二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。   2.如果二叉树的两个节点深度相同,但 父节点不同 ,则它们是一对堂兄弟节点。   3.我们给出了具有唯一值的二叉树的根节点 root ,以及树中两个不同节点的值 x 和 y 。只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true 。否则,返回 false。    思路:   昨天夜里12点还没睡,就打开Leetcode瞄了一眼今天的题目,乍一

qq_37297658的博客 325

leetcode993. 二叉树的堂兄弟节点

在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同,但父节点不同,则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root,以及树中两个不同节点的值 x 和 y。 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true。否则,返回 false。 示例 1: 输入:root = [1,2,3,4], x =...

ShawDa's Blog 1040

【Leetcode_总结】993. 二叉树的堂兄弟节点 - python

Q: 在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同,但父节点不同,则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root,以及树中两个不同节点的值 x 和 y。 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true。否则,返回 false。   示例 1: 输入:root = [...

maka_uir的博客 503

LeetCode 993. 二叉树的堂兄弟节点——每日一题

本题主要考察了二叉树的遍历,可以使用 宽度优先搜索 在遍历的同时使用 map 记录每个节点的值、深度以及其父节点。遍历完成之后直接进行比较即可。

晴空๓ 705

【leetcode 993】【二叉树的堂兄弟节点】

leetcode 993【二叉树的堂兄弟节点】 这道题给出二叉树root,x和y,要解决的问题是在树中找到x和y,并且确定它们是否为堂兄弟节点的关系。 题目链接 https://leetcode-cn.com/problems/cousins-in-binary-tree/ 解题思路与代码思路: 队列实现、BFS 广度优先遍历每一层,存入队列中,判断x和y是否在同一层,如果在,就是判断是否为堂兄弟节点。在同一层中,只有相邻节点并且右边的节点的索引为奇数、左边节点索引为偶数时,才是同一个父节点。如果不满足上

zyuPp的博客 386

LeetCode993.Cousins in Binary Tree(二叉树的堂兄弟节点 )

993.Cousins in Binary Tree(二叉树的堂兄弟节点 )DescriptionDifficulty: easyExample 1:Example 2:Example 3:Note:分析参考代码 Description In a binary tree, the root node is at depth 0, and children of each depth k node ...

red_tongue的博客 466

leetcode -993 二叉树的堂兄弟节点 -java版

文章目录题目代码 题目 在二叉树中,根节点位于深度 0 处,每个深度为 k 的节点的子节点位于深度 k+1 处。 如果二叉树的两个节点深度相同,但父节点不同,则它们是一对堂兄弟节点。 我们给出了具有唯一值的二叉树的根节点 root,以及树中两个不同节点的值 x 和 y。 只有与值 x 和 y 对应的节点是堂兄弟节点时,才返回 true。否则,返回 false。 示例 1: 输入:root = [1...

lingle1的博客 550
上一篇: 206.反转链表 递归,原地,栈,队列
下一篇: 523. 连续的子数组和 同余定理,前缀和,set
会悟
博客等级 码龄9年 22粉丝 36原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值