G-thinker gmatch 子图匹配 源码解析

最新推荐文章于 2023-11-29 13:19:00 发布
最新推荐文章于 2023-11-29 13:19:00 发布
阅读量451 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HNUPCJ/article/details/106576845
版权

本程序为匹配如下的子图
在这里插入图片描述

//########################################################################
//## Copyright 2018 Da Yan http://www.cs.uab.edu/yanda
//##
//## Licensed under the Apache License, Version 2.0 (the "License");
//## you may not use this file except in compliance with the License.
//## You may obtain a copy of the License at
//##
//## //http://www.apache.org/licenses/LICENSE-2.0
//##
//## Unless required by applicable law or agreed to in writing, software
//## distributed under the License is distributed on an "AS IS" BASIS,
//## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//## See the License for the specific language governing permissions and
//## limitations under the License.
//########################################################################

#include "subg-dev.h"

typedef char Label;

struct AdjItem //邻接节点 
{
	VertexID id;
	Label l;
};

struct GMatchValue //邻接节点的值 
{
	Label l;
	vector<AdjItem> adj;
};

typedef Vertex<VertexID, GMatchValue> GMatchVertex;//节点  包含id，value(label l,adj(id,l)) 
typedef Subgraph<GMatchVertex> GMatchSubgraph;
typedef Task<GMatchVertex, char> GMatchTask; //context = step

obinstream & operator>>(obinstream & m, AdjItem & v)
{
    m >> v.id;
    m >> v.l;
    return m;
}

ibinstream & operator<<(ibinstream & m, const AdjItem & v)
{
    m << v.id;
    m << v.l;
    return m;
}

ofbinstream & operator>>(ofbinstream & m, AdjItem & v)
{
    m >> v.id;
    m >> v.l;
    return m;
}

ifbinstream & operator<<(ifbinstream & m, const AdjItem & v)
{
    m << v.id;
    m << v.l;
    return m;
}

//------------------
obinstream & operator>>(obinstream & m, GMatchValue & Val)
{
    m >> Val.l;
    m >> Val.adj;
    return m;
}

ibinstream & operator<<(ibinstream & m, const GMatchValue & Val)
{
    m << Val.l;
    m << Val.adj;
    return m;
}

ofbinstream & operator>>(ofbinstream & m, GMatchValue & Val)
{
    m >> Val.l;
    m >> Val.adj;
    return m;
}

ifbinstream & operator<<(ifbinstream & m, const GMatchValue & Val)
{
    m << Val.l;
    m << Val.adj;
    return m;
}
//-------------------
// add a node to graph: only id and label of v, not its edges
// must make sure g.hasVertex(v.id) == true !!!!!!
void addNode(GMatchSubgraph & g, GMatchVertex & v) //添加节点 
{
	GMatchVertex temp_v;
	temp_v.id = v.id;
	temp_v.value.l = v.value.l;
	g.addVertex(temp_v);
}

void addNode(GMatchSubgraph & g, VertexID id, Label l) //根据id和label添加节点 
{
	GMatchVertex temp_v;
	temp_v.id = id;
	temp_v.value.l = l;
	g.addVertex(temp_v);
}

// add a edge to graph
// must make sure id1 and id2 are added first !!!!!!
void addEdge(GMatchSubgraph & g, VertexID id1, VertexID id2) //添加边  注意：匹配为无向图，所以需要添加两条边 
{
    GMatchVertex * v1, * v2;
    v1 = g.getVertex(id1);
    v2 = g.getVertex(id2);
    AdjItem temp_adj;
	temp_adj.id = v2->id;
	temp_adj.l = v2->value.l;
	v1->value.adj.push_back(temp_adj);
	temp_adj.id = v1->id;
	temp_adj.l = v1->value.l;
	v2->value.adj.push_back(temp_adj);
}

void addEdge_safe(GMatchSubgraph & g, VertexID id1, VertexID id2) //avoid redundancy
{
    GMatchVertex * v1, * v2;
    v1 = g.getVertex(id1);
    v2 = g.getVertex(id2);
    int i = 0;
    vector<AdjItem> & adj = v2->value.adj;
    for(; i<adj.size(); i++)
    	if(adj[i].id == id1) break;
    if(i == adj.size())
    {
    	AdjItem temp_adj;
		temp_adj.id = v2->id;
		temp_adj.l = v2->value.l;
		v1->value.adj.push_back(temp_adj);
		temp_adj.id = v1->id;
		temp_adj.l = v1->value.l;
		v2->value.adj.push_back(temp_adj);
    }
}

//计数程序 
class GMatchAgg:public Aggregator<size_t, size_t, size_t>  //all args are counts
{
private:
	size_t count;//该worker的匹配数 
	size_t sum;//总worker的匹配数 

public:

    virtual void init()
    {
    	sum = count = 0;
    }

    virtual void init_udf(size_t & prev) {
    	sum = 0;
    }

    virtual void aggregate_udf(size_t & task_count)//加入匹配数 
    {
    	count += task_count;
    }

    virtual void stepFinal_udf(size_t & partial_count) //统计子节点的数量 
    {
    	sum += partial_count; //add all other machines' counts (not master's)
    }

    virtual void finishPartial_udf(size_t & collector)
    {
    	collector = count;
    }

    virtual void finishFinal_udf(size_t & collector)//加入master的数量 
    {
    	sum += count; //add master itself's count 
    	if(_my_rank == MASTER_RANK) cout<<"the # of matched graph = "<<sum<<endl;
    	collector = sum;
    }
};

class GMatchTrimmer:public Trimmer<GMatchVertex> //过滤掉除了abcd的标记 
{
    virtual void trim(GMatchVertex & v) {
    	vector<AdjItem> & val = v.value.adj;
    	vector<AdjItem> newval;
        for (int i = 0; i < val.size(); i++) {
            if (val[i].l == 'a' || val[i].l == 'b' || val[i].l == 'c' || val[i].l == 'd')
            	newval.push_back(val[i]);
        }
        val.swap(newval);
    }
};

size_t graph_matching(GMatchSubgraph & g) //对标记为acbd的路径进行匹配 
{
	size_t count = 0;
	GMatchVertex & v_a = g.vertexes[0];//a节点 
	vector<AdjItem> & a_adj = v_a.value.adj;//a的邻接节点 
	vector<VertexID> GMatchQ; //record matched vertex instances
	//------
	GMatchQ.push_back(v_a.id);
	for(int j = 0; j < a_adj.size(); j++)
	{
		if(a_adj[j].l == 'c')
		{
			GMatchVertex * v_c = g.getVertex(a_adj[j].id);//c节点 
			GMatchQ.push_back(v_c->id);//添加c节点id到路径 
			vector<AdjItem> & c_adj = v_c->value.adj;//c节点的邻接节点 
			//find b
			vector<VertexID> b_nodes;//b节点数组 
			for(int k = 0; k < c_adj.size(); k++)
			{
				if(c_adj[k].l == 'b')
					b_nodes.push_back(c_adj[k].id);
			}
			if(b_nodes.size() > 1)
			{
				vector<bool> b_a(b_nodes.size(), false);//b_a[i] = whether b_nodes[i] links to v_a//是否与a连接 
				vector<vector<VertexID> > b_d;//b_d[i] = all b-d edges (d's IDs) of b_nodes[i]//d节点二维数组 
				for(int m = 0; m < b_nodes.size(); m++)
				{
					GMatchVertex * v_b = g.getVertex(b_nodes[m]);
					vector<AdjItem> & b_adj = v_b->value.adj;
					vector<VertexID> vec_d;
					for(int n = 0; n < b_adj.size(); n++)
					{
						if(b_adj[n].id == v_a.id)
							b_a[m] = true;
						if(b_adj[n].l == 'd')
							vec_d.push_back(b_adj[n].id);
					}
					b_d.push_back(vec_d);
				}
				for(int m = 0; m < b_nodes.size(); m++)
				{
					if(b_a[m])//与a节点连接的b节点 
					{
						GMatchQ.push_back(b_nodes[m]);//push vertex (3) into GMatchQ//添加 b节点id到路径 
						for(int n = 0; n < b_d.size(); n++)
						{
							if(m != n) //two b's cannot be the same node
							{
								GMatchQ.push_back(b_nodes[n]);//push vertex (4) into GMatchQ//添加其他b节点到路径 
								vector<VertexID> & vec_d = b_d[n];
								count += vec_d.size();//大小为其他节点到d的数量 
								/* //version that outputs the actual match
								for(int cur = 0; cur < vec_d.size(); cur++)
								{
									GMatchQ.push_back(vec_d[cur]);
									print_vec(GMatchQ);
									count++;
									GMatchQ.pop_back();//d
								}
								*/
								GMatchQ.pop_back();//b //将不与a连接的b节点进行弹出 
							}
						}
						GMatchQ.pop_back();//b  //将与a连接的b节点 
					}
				}
			}
			GMatchQ.pop_back();//c  //弹出c 
		}
	}
	GMatchQ.pop_back();//a  //弹出a 
	return count;
}

class GMatchComper:public Comper<GMatchTask, GMatchAgg> //顶点拉取程序 
{
public:
    virtual void task_spawn(VertexT * v)
    {
    	if(v->value.l == 'a')//加入含有bc的a节点 
    	{
    		GMatchTask * t = new GMatchTask;
			addNode(t->subG, *v);
			t->context = 1; //context is step number
			vector<AdjItem> & nbs = v->value.adj;
			bool has_b = false;
			bool has_c = false;
			for(int i=0; i<nbs.size(); i++)
				if(nbs[i].l == 'b')
				{
					t->pull(nbs[i].id);//拉取b节点 
					has_b = true;
				}
				else if(nbs[i].l == 'c')
				{
					t->pull(nbs[i].id);//拉取a节点 
					has_c = true;
				}
			if(has_b && has_c) add_task(t);
            else delete t;
    	}
    }

    virtual bool compute(SubgraphT & g, ContextT & context, vector<VertexT *> & frontier)
    {
    	//match c
    	if(context == 1) //context is step number
    	{
    		VertexID rootID = g.vertexes[0].id; //root = a-matched vertex
			//cout<<rootID<<": in compute"<<endl;//@@@@@@@@@@@@@
			hash_set<VertexID> label_b; //Vb (set of IDs)
			vector<VertexT *> label_c; //Vc
			for(int i = 0; i < frontier.size(); i++) {//set Vb and Vc from frontier
				if(frontier[i]->value.l == 'b')
					label_b.insert(frontier[i]->id);
				else if(frontier[i]->value.l == 'c')
					label_c.push_back(frontier[i]);
			}
			//------
			hash_set<VertexID> bList; //vertices to pull 拉取节点 
			for(int i = 0 ; i < label_c.size(); i++)
			{
				VertexT * node_c = label_c[i]; //get v_c
				vector<AdjItem> & c_nbs = node_c->value.adj; //get v_c's adj-list
				vector<VertexID> U1, U2;
				for(int j = 0; j < c_nbs.size(); j++) //set U1 & U2
				{
					AdjItem & nb_c = c_nbs[j];
					if(nb_c.l == 'b')
					{
						VertexID b_id = nb_c.id;
						if(label_b.find(b_id) != label_b.end())
							U1.push_back(b_id);//找得到 
						else
							U2.push_back(b_id);//找不到 
					}
				}
				//------
				if(U1.empty()) //子图匹配c必须指向a指向的b 
					continue;
				else if(U1.size() == 1)  
				{
					if(U2.empty()) continue;
					else
						bList.insert(U2.begin(), U2.end());
				}
				else
				{
					bList.insert(U1.begin(), U1.end());
					bList.insert(U2.begin(), U2.end());
				}
				//------
				//add v_c and edges (v_a, v_c)
				addNode(g, *node_c);
				addEdge(g, rootID, node_c->id);
				//------
				for(int j = 0; j < U1.size(); j++)
				{
					if(!g.hasVertex(U1[j]))
					{
						addNode(g, U1[j], 'b'); //add v_b
						addEdge(g, rootID, U1[j]); //add (v_a, v_b)
					}
					addEdge(g, node_c->id, U1[j]); //add (v_c, v_b) //this is forgotten to mention in CoRR's version
				}
			}
			//pull bList
			for(auto it = bList.begin(); it != bList.end(); it++) pull(*it);
			//cout<<rootID<<": step 1 done"<<endl;//@@@@@@@@@@@@@
			//------
			context++;
			return true;
    	}
    	else //step == 2
    	{
    		hash_set<VertexID> Vc;
    		//get Vc from g  
    		for(int i=0; i<g.vertexes.size(); i++)  //读出满足条件的c节点 
    		{
    			VertexT & v = g.vertexes[i];
    			if(v.value.l == 'c') Vc.insert(v.id);
    		}
    		//------
    		for(int i=0; i<frontier.size(); i++) //对所有本地节点进行遍历 
    		{
    			VertexT* v_b = frontier[i];
    			vector<AdjItem> & adj_b = v_b->value.adj;
    			//construct Vd
    			vector<VertexID> Vd;
    			for(int j=0; j<adj_b.size(); j++)
    			{
    				if(adj_b[j].l == 'd') Vd.push_back(adj_b[j].id);
    			}
    			//------
    			if(!Vd.empty())  //对所有含有D的本地节点进行处理 
    			{
    				//add v_b
    				if(!g.hasVertex(v_b->id)) addNode(g, *v_b);  //加入相应的b节点 
					//add (v_b, v_c), where v_c \in bList
					for(int j=0; j<adj_b.size(); j++)
					{
						VertexID b_id = adj_b[j].id; //v_c 
						if(Vc.find(b_id) != Vc.end()) //邻接点必须含有满足条件的c 
						{
							//add edge v_b, v_c
							addEdge_safe(g, b_id, v_b->id);  //添加(b,c) 
						}
					}
    				//add v_d and (v_b, v_d)
    				for(int j=0; j<Vd.size(); j++)  //把所有的d加到图中 
    				{
    					if(!g.hasVertex(Vd[j])) addNode(g, Vd[j], 'd');
    					addEdge(g, Vd[j], v_b->id);
    				}
    			}
    		}
    		//run single-threaded mining code
			size_t count = graph_matching(g);  //查找满足条件的子图 
			GMatchAgg* agg = get_aggregator();
			agg->aggregate(count);
			//cout<<rootID<<": step 2 done"<<endl;//@@@@@@@@@@@@@
			return false;
    	}
    }
};

class GMatchWorker:public Worker<GMatchComper>
{
public:
	GMatchWorker(int num_compers) : Worker<GMatchComper>(num_compers){}

    virtual VertexT* toVertex(char* line)  //输入处理 
    {
        VertexT* v = new VertexT;
        char * pch;
        pch = strtok(line, " \t");
        v->id = atoi(pch);
        pch = strtok(NULL, " \t");
        v->value.l = *pch;
        vector<AdjItem> & nbs = v->value.adj;
        AdjItem temp;
        while((pch=strtok(NULL, " ")) != NULL)
        {
        	temp.id = atoi(pch);
        	pch = strtok(NULL, " ");
        	temp.l = *pch;
        	nbs.push_back(temp);
        }
        return v;
    }

    virtual void task_spawn(VertexT * v, vector<GMatchTask> & tcollector) //标记匹配abc 
	{
    	if(v->value.l != 'a') return;
    	GMatchTask t;
    	addNode(t.subG, *v);
    	t.context = 1;
		vector<AdjItem> & nbs = v->value.adj;
		bool has_b = false;
		bool has_c = false;
		for(int i=0; i<nbs.size(); i++) //节点为a且邻接点含有bc 
			if(nbs[i].l == 'b')
			{
				t.pull(nbs[i].id);
				has_b = true;
			}
			else if(nbs[i].l == 'c')
			{
				t.pull(nbs[i].id);
				has_c = true;
			}
		if(has_b && has_c) tcollector.push_back(t);
	}
};

int main(int argc, char* argv[])
{
    init_worker(&argc, &argv);
    WorkerParams param;
    param.input_path = argv[1];  //input path in HDFS
    int thread_num = atoi(argv[2]);  //number of threads per process
    param.force_write=true;
    param.native_dispatcher=false;
    //------
	GMatchTrimmer trimmer;//子节点过滤器 
    GMatchAgg aggregator;//计数器 
    GMatchWorker worker(thread_num);
	worker.setTrimmer(&trimmer);
    worker.setAggregator(&aggregator);
    worker.run(param);
    worker_finalize();
    return 0;
}
HNUJSY
关注
Ai-Thinker-Open_ESP32-S2-CAMERA_LAN完整代码压缩包
10-26
《ESP32-S2开发详解：基于Ai-Thinker-Open_ESP32-S2-CAMERA_LAN的完整代码实践》 在物联网领域，ESP32-S2芯片因其高性能、低功耗和丰富的外设接口而备受关注。Ai-Thinker推出的Open_ESP32-S2-CAMERA_LAN项目，旨在...
【G-thinker】G-thinker部分源码解析
HNUJSY
07-20 751
从主函数可以看到，子图匹配程序中GMatchWorker继承了worker，主函数声明了workerparams并且传入了路径和线程参数，设置了继承了Trimmer作为节点过滤的GMatchTrimmer和继承了作为结果汇总的Aggregator的GMatchAgg，然后运行worker中的run函数，可以看出work类似进程，在此处开启了worker进程。 进入Worker.h中，查看worker的构造函数，我们传入了线程数，每个线程对应一个comper，req_counter中记录本worker到其.
【论文阅读】D2Match: Leveraging Deep Learning and Degeneracy for Subgraph Matching
malo12的博客
11-29 1359
子图匹配是基于图的应用程序的基本组成部分，由于其高阶组合特性而具有挑战性。现有的研究通常通过组合优化或基于学习的方法来解决它。然而，它们存在指数计算成本或搜索匹配没有理论保证的问题。在本文中，我们利用深度学习和简并性的效率进行子图匹配来开发d2匹配。更具体地说，我们首先证明了子图匹配可以退化为子树匹配，然后等价于在一个二部图上找到一个完美的匹配。然后，我们可以通过在图神经网络上内置的树状结构聚合机制来实现线性时间复杂度的实现。此外，还可以很容易地在D2匹配中加入圆的结构和节点属性，以提高匹配性能。
SAScode: 1比N病例对照匹配（gmatch）
Liuyi1750的博客
04-24 1958
SAS
图算法（二十五）：子图匹配（Subgraph Matching）【基本的图查询操作，意在发掘图重要的子结构】【适用场景：社交网络分析、群体发现、异常检测】【在一个给定的大图里找到与给定小图同构的子图】
u013250861的博客
05-28 4715
一、概述 子图匹配（subgraph matching）算法的目的是在一个给定的大图里面找到与一个给定小图同构的子图，这是一种基本的图查询操作，意在发掘图重要的子结构。 适用场景：子图匹配（subgraph matching）算法适用于社交网络分析、生物信息学、交通运输、群体发现、异常检测等领域。 二、 三、 参考资料： 子图匹配（Subgraph Matching） ...
子图同构进阶版-advanced subgraph matching
wrk226的博客
09-26 256
local candidate reduction 在之前的compute candidate的基础上增加一个profile选项，profile包含S中每个node的neighbour所拥有的label(可以重复)，按照字母顺序排序，在判断candidate时考虑是否G中对应的node(v)的profile包含S中node(u)的profile 伪代码： candidate_node=list...
ai-thinker-esp8266-at-firmware-dout-v1.5.4.1-a-20171130
10-21
此压缩包"ai-thinker-esp8266-at-firmware-dout-v1.5.4.1-a-20171130"包含了针对该芯片的AT固件，由AI-Thinker公司提供。AT固件是基于命令行接口（Command Line Interface, CLI）的软件，使得开发者能够通过简单的...
AiThinker_A6-master_GSM_ai-thinker_ESP8266；_源码
10-02
_源码" 提供的是一个基于Ai-Thinker A6模块和ESP8266微控制器的GSM通信库的源代码。这个项目的核心是实现这两款硬件之间的有效通信，以便在物联网(IoT)应用中利用GSM网络进行数据传输。 【Ai-Thinker A6模块】：Ai-...
esp32-cam-ai-thinker:有关使用ESP-IDF的AI Thinker ESP32-CAM的信息和示例
05-05
该存储库的目的是集中ESP32-CAM AI Thinker的信息和示例。 ESP32-CAM AI Thinker通常与OV2640传感器一起出售 例子 与PlatformIO一起运行 要运行示例，请确保已安装PlatformIO 。 如果还没有的话，请参考。 闪烁的 ...
Ai-Thinker_AT_安信可ESP8266_AT固件
08-10
在本资源中，我们关注的是Ai-Thinker公司为ESP8266开发的AT固件，它使得用户可以通过简单的AT命令进行通信和控制。 AT（Automatic Test）命令集是一种通用的串行通信协议，最初用于电话交换机的测试，现在被广泛...
图像匹配（直方图子块匹配）
12-24
1、掌握基于DSP的数字图像的读取、显示与处理方法。 2、掌握基于C语言的数字图像直方图匹配与识别方法。
python决策树代码
01-16
python决策树代码
论文导读 | 海量图上的Top-k图模式匹配问题
weixin_48167662的博客
04-20 535
北京大学周雨奇 编者按 原文《Top-k Graph Pattern Matching over Large Graphs》由Jiefeng Cheng，Xianggang Zeng,Jeffrey Xu Yu发表于ICDE 2013。 本文主要关注如何有效地找到图匹配的前k个评分最高的结果（top-k answers for a graph pattern query），尤其是在有环图中。 论文地址： https://dl.acm.org/doi/10.1109/ICDE.2013...
python地图匹配_坐标点地图匹配方法
weixin_39722196的博客
12-08 2281
1.概述1.1.背景随着公司业务发展，车定位轨迹数据越来越多，目前发现轨迹数据存在偏移问题，本文主要目的在于用图数据库和空间数据库来解决偏移问题，做到轨迹纠偏，将偏移的定位点放置到附近的道路上。例如在上图中有个点不在轨迹上，也不在道路上，本文将通过计算的方法给它找到附近最近的道路上的点。1.2.绑路方法绑路的方法主要分为以下几个步骤：1、获取路网数据保存至Neo4j数据库2、将路网中的点数据保存到...
子图同构问题Ullmann 算法（二）
热门推荐
编程小栈
10-07 1万+
写在前面的画以上的内容均出自这篇论文ullmann algorithm，所有的表述竟可能的和论文中的表述保持一致。 我要做的事情就是竟可能的讲的很清楚，尽可能的做到准确完备。谨以此系列献给 my best love, grandpa~ 还有昆明宝石蓝的天空，2月的梨花，三月的樱花，10月的桂花，星光璀璨的星空陪我入梦乡，安静而又安抚人的环境，总是让我心很静，那些美好的事物总是想让我保持一颗干净温暖
找出一个图中所有的强连通子图
zzran的专栏
05-17 8529
如果一个有向图中的没对顶点都可以从通过路径可达，那么就称这个图是强连通的。一个 strongly connected component就是一个有向图中最大的强连通子图。下图中就有三个强连通子图： 应用kosaraju算法，可以在O（v+e）的时间内找到强连通子图。下面是kosaraju算法的具体步骤： 1，创建一个stack，对图进行深度优先遍历。对于每一个节点，当应用DFS遍历其所
位图和TOP（K）解法
yanchenzhi的博客
03-23 543
之前在面试的被问到过10亿QQ号的排序和去重，当时没有考虑过内存的问题，直接就说快排然后去重。后来也想到了hash，但是仍然没有考虑过内存问题。所以在此总结一下此类问题。 位图 位图就是每一位都用来存放状态，适合于大规模数据，因为二进制为0,1，所以有两种状态，存在和不存在的判断。位图其实就是一个数组，只不过每一位都代表了另一个数，也可以看做是直接定址的哈希。 我们将大数先除以32，划分到新的小...
GraphLite 实现子图匹配
Kalikali的专栏
12-13 5228
同步图运算模型 许多大数据都以图的形式存在，非图结构的大数据也通常会被转化为图数据结构进行分析。对于大型图数据的计算，一些常见的处理软件如Neo4j等采用的是遍历的方法，另一些采用的如Giraph、Pregel等则采用的是同步图运算的方式。 后者采用的同步图运算模型主要有两个特点，一是BSP(Bulk Synchronous Processing)模型，即块同步计算模型，其主要思想是将全部计算分为...
2025年软考高级 - 信息系统项目管理师考试备考全攻略
最新发布
11-09
2025年软考高级 - 信息系统项目管理师考试备考全攻略
Ai-Thinker LoRaWAN Class A/C AT命令规格
本文档是Ai-Thinker针对LoRaWAN Class A/C模组（如RHF76-052AM/RHF76-052CM，版本需高于2.1.0）编写的AT命令规格说明书，旨在提供模块使用的AT命令格式和功能描述。LoRaWAN Class A/C是一种低功耗广域网络技术，适用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值