图

最新推荐文章于 2024-02-27 13:24:44 发布
最新推荐文章于 2024-02-27 13:24:44 发布
阅读量496 收藏
点赞数
分类专栏： 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mysunnnyday/article/details/9384741
版权 
#ifndef __BASE_H__
#define __BASE_H__
#include <iostream>
#include "binomial heap.h"
using namespace std;
/*********************************stack**********************************/
template<class node>
class stack
{
public:
	stack(int n);
	~stack();
private:
	node *_s;
	int _size;
	int _height;
public:
	int height(){return _height;}
	void empty(){_height = 0;}
	bool push(const node& nd);
	bool pop(node& nd);
	void top(node& nd){nd = _s[_height-1];}
};
template <class node>
stack<node>::stack(int n)
{
	_s = new node[n];
	_size = n;
	_height = 0;
}

template <class node>
stack<node>::~stack()
{
	delete _s;
}

template <class node>
bool stack<node>::push(const node& nd)
{
	if (_height >= _size)return false;
	_s[_height++] = nd;
	return true;
}

template <class node>
bool stack<node>::pop(node& nd)
{
	if (_height <= 0)return false;
	nd = _s[--_height];
	return true;
}

/**********************************queue*********************************/
template<class node>
class queue
{
public:
	queue(int n);
	~queue();
private:
	node *_q;
	int _size;
	int _head;
	int _tail;
public:
	bool inqueue(const node &nd);
	bool dequeue(node &nd);
	int length(){return (_tail - _head + _size)%_size;}
	void empty(){_head = _tail = 0;}
};

template<class node>
queue<node>::queue(int n)
{
	_q = new node[n+1];
	_size = n+1;
	_head = _tail = 0;
}

template<class node>
queue<node>::~queue()
{
	if (_q)
	{
		delete _q;
	}
}


template<class node>
bool queue<node>::inqueue(const node &nd)
{
	if ((_tail+1)%_size== _head)return false;
	else
	{
		_q[_tail] = nd;
		_tail = (_tail+1)%_size;
		return true;
	}
}

template<class node>
bool queue<node>::dequeue(node &nd)
{
	if (_tail == _head)return false;
	else
	{
		nd = _q[_head];
		_head = (_head + 1)%_size;
		return true;
	}
}
/*********************************graph*************************************/
template <class vertex , class edge>
class graph
{
protected:
	int _vcnt , _ecnt;
	int _capacity;
	int *_prt;
	int *_dep;
	int *_vist;

public:
	graph(){_capacity = _vcnt = _ecnt = 0;_prt = _dep = _vist = NULL;}
	virtual bool insert_vertex(vertex ver) = 0;
	virtual bool insert_edge(int v1 , int v2 , edge ed) = 0;
	virtual bool BFS(int s) = 0 ;
	virtual bool DFS(int s) = 0 ;
	virtual bool DFS_stack(int s) = 0 ;
	virtual bool visit_result() = 0;
	int num_vertex(){return _vcnt;}
	int num_edge(){return _ecnt;}
};
/*******************************mtxgraph*************************************/
template <class vertex , class edge>
class mtxgraph : public graph<vertex , edge>
{
private:
	vertex *_ver;
	edge **_ed;
public:
	mtxgraph();
	mtxgraph(int n);
	mtxgraph(mtxgraph& mg);
	~mtxgraph();
	virtual bool insert_vertex(vertex ver);
	virtual bool insert_edge(int v1 , int v2 , edge ed);
	virtual bool BFS(int s);
	virtual bool DFS(int s);
	virtual bool DFS_stack(int s);
	virtual bool visit_result();
private:
	void DFSrecur(int s , int *color , int time , int pare);
};

template <class vertex , class edge>
mtxgraph<vertex , edge>::mtxgraph()
{
	_ver = NULL;
	_ed = NULL;
}

template <class vertex , class edge>
mtxgraph<vertex , edge>::mtxgraph(int n)
{
	_capacity = n;
	_ver = new vertex[n];
	_ed = new edge *[n];
	_prt = new int[n];
	_dep = new int[n];
	_vist = new int[n];
	for (int i = 0 ; i < n ; i++)
	{
		_ed[i] = new edge[n];
		for (int j = 0 ; j < n ; j++)_ed[i][j] = 0;
		_prt[i] = -1;
		_dep[i] = -1;
	}
}

template <class vertex , class edge>
mtxgraph<vertex , edge>::~mtxgraph()
{
	if(_ver)
	{
		for (int i = 0 ; i < _capacity ; i++)delete _ed[i];
		delete _ver;
		delete _ed;
		delete _prt;
		delete _dep;
		delete _vist;
	}
}

template <class vertex , class edge>
mtxgraph<vertex , edge>::mtxgraph(mtxgraph& mg)
{
	_capacity = mg._capacity;
	_ver = new vertex[n];
	_ed = new edge *[n];
	_prt = new int[n];
	_dep = new int[n];
	_vist = new int[n];
	for (int i = 0 ; i < n ; i++)
	{
		_ed[i] = new edge[n];
	}
	_vcnt = mg._vcnt;
	_ecnt = mg._ecnt;
	int vercap = _capacity * sizeof(vertex);
	int edcap = _capacity * sizeof(edge);
	int prtcap = _capacity * sizeof(int);
	int depcap = _capacity * sizeof(int);
	int vistcap = _capacity * sizeof(int);
	memcpy(_ver , mg._ver , vercap);
	memcpy(_ed , mg._ed , edcap);
	memcpy(_prt , mg._prt , prtcap);
	memcpy(_dep , mg._dep , depcap);
	memcpy(_vist , mg._vist , vistcap);
	for (int i = 0 ; i < _capacity ; i++)
	{
		memcpy(_ed[i] , mg._ed[i] , edcap)
	}
}

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::insert_vertex(vertex ver)
{
	if (_vcnt >= _capacity)return false;
	_ver[_vcnt++] = ver;
	return true;
}

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::insert_edge(int v1 , int v2 , edge ed)
{
	if (v1 > _vcnt || v2 > _vcnt)return false;
	_ed[v1][v2] = ed;
	_ecnt++;
	return true;
}

#define WHITE 0
#define GRAY 1
#define BLACK -1

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::BFS(int s)
{
	if(s >= _vcnt)return false;
	int *color = new int[_vcnt];
	int vistc = 0;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_vist[i] = -1;
	}
	color[s] = GRAY;
	_dep[s] = 0;
	_prt[s] = -1;
	_vist[vistc++] = s;
	queue<int> _queue(_vcnt);
	_queue.inqueue(s);

	while (_queue.length() != 0)
	{
		int nd;
		_queue.dequeue(nd);
		color[nd] = BLACK;
		for (int i = 0 ; i < _vcnt ; i++)
		{
			if (_ed[nd][i] != 0 && color[i] == WHITE)
			{
				color[i] = GRAY;
				_dep[i] = _dep[nd] + 1;
				_vist[vistc++] = i;
				_prt[i] = nd;
				_queue.inqueue(i);
			}
		}
	}
	delete color;
	return true;
}

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::DFS(int s)
{
	if(s >= _vcnt)return false;
	int *color = new int[_vcnt];
	int time = 0;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_vist[i] = -1;
	}
	color[s] = GRAY;
	_dep[s] = 0;
	_prt[s] = -1;
	_vist[time] = s;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		if (_ed[s][i] != 0 && color[i] == WHITE)
		{
			color[i] = GRAY;
			DFSrecur(i , color , ++time , s);
		}
	}
	color[s] = BLACK;
	delete color;
	return true;
}

template <class vertex , class edge>
void mtxgraph<vertex , edge>::DFSrecur(int s , int *color , int time , int pare)
{
	color[s] = GRAY;
	_dep[s] = time;
	_prt[s] = pare;
	_vist[time] = s;

	for ( int i = 0 ; i < _vcnt ; i++)
	{
		if (_ed[s][i] != 0 && color[i] == WHITE)
		{
			color[i] = GRAY;
			DFSrecur(i , color , time+1 , s);
		}
	}
	color[s] = BLACK;
}

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::DFS_stack(int s)
{
	if (s > _vcnt)return false;
	int time = 0 , i;
	int *color = new int[_vcnt];
	for (i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_prt[i] = -1;
	}
	color[s] = GRAY;
	_prt[s] = -1;
	_dep[s] = 0;
	_vist[time++] = s;
	stack<int> _stack(_vcnt);
	_stack.push(s);

	while(_stack.height() != 0)
	{
		int nd;
		_stack.top(nd);
		for(i = 0 ; i < _vcnt ; i++)
		{
			if (_ed[nd][i] != 0 && color[i] == WHITE)
			{
				_stack.push(i);
				color[i] = GRAY;
				_prt[i] = nd;
				_dep[i] = time;
				_vist[time++] = i;
				break;
			}
		}
		if (i == _vcnt)
		{
			int nd;
			_stack.pop(nd);
			color[nd] = BLACK;
		}
	}
	return true;
}

template <class vertex , class edge>
bool mtxgraph<vertex , edge>::visit_result()
{
	if (_vcnt <= 0)return false;
	cout<<"visit result is:";
	for (int i = 0 ; i < _vcnt ; i++)
	{
		if (_vist[i] != -1)cout<<_ver[_vist[i]]<<",";
	}
	return true;
}
/****************************************************************************/
template <class edge>
struct lnkgphnd
{
	int _n;
	edge _e;
	struct lnkgphnd *next;
};


template <class vertex , class edge>
class lnkgraph : public graph<vertex , edge>
{
private:
	vertex *_ver;
	lnkgphnd<edge> **_nd;
public:
	lnkgraph();
	lnkgraph(int n);
	lnkgraph(lnkgraph& mg);
	~lnkgraph();
	virtual bool insert_vertex(vertex ver);
	virtual bool insert_edge(int v1 , int v2 , edge ed);
	virtual bool BFS(int s);
	virtual bool DFS(int s);
	virtual bool DFS_stack(int s);
	virtual bool visit_result();
	lnkgraph<vertex , edge> *Prim(int n);
private:
	void DFSrecur(int s , int *color , int time , int pare);
};

template <class vertex , class edge>
lnkgraph<vertex , edge>::lnkgraph()
{
	_nd = NULL;
}

template <class vertex , class edge>
lnkgraph<vertex , edge>::lnkgraph(int n)
{
	_capacity = n;
	_ver = new vertex[n];
	_nd = new lnkgphnd<edge>*[n];
	_prt = new int[n];
	_dep = new int[n];
	_vist = new int[n];
	for (int i = 0 ; i < n ; i++)
	{
		_nd[i] = NULL;
		_prt[i] = -1;
		_dep[i] = -1;
	}
}

template <class vertex , class edge>
lnkgraph<vertex , edge>::~lnkgraph()
{
	if(_nd)
	{
		for (int i = 0 ; i < _vcnt ; i++)
		{
			while(_nd[i])
			{
				lnkgphnd<edge> *nd = _nd[i];
				_nd[i] = nd->next;
				delete nd;
			}
		}
		delete _ver;
		delete _nd;
		delete _prt;
		delete _dep;
		delete _vist;
	}
}

template <class vertex , class edge>
lnkgraph<vertex , edge>::lnkgraph(lnkgraph& mg)
{
	_capacity = mg._capacity;
	_ver = new vertex[n];
	_nd = new lnkgphnd<edge>*[n];
	_prt = new int[n];
	_dep = new int[n];
	_vist = new int[n];
	for (int i = 0 ; i < n ; i++)
	{
		_ed[i] = new edge[n];
	}
	_vcnt = mg._vcnt;
	_ecnt = mg._ecnt;
	int vercap = _capacity * sizeof(vertex);
	int ndcap = _capacity * sizeof(int);
	int prtcap = _capacity * sizeof(int);
	int depcap = _capacity * sizeof(int);
	int vistcap = _capacity * sizeof(int);

	memcpy(_ver , mg._ver , vercap);
	memcpy(_prt , mg._prt , prtcap);
	memcpy(_dep , mg._dep , depcap);
	memcpy(_vist , mg._vist , vistcap);
	for (int i = 0 ; i < _vcnt ; i++)
	{
		lnkgphnd *nd = mg._nd[i];
		lnkgphnd *dst = _nd[i];
		lnkgphnd<edge> *ndd;
		ndd = new lnkgphnd<edge>;
		memcpy(ndd , nd , sizeof(lnkgphnd<edge>));
		dst = ndd;
		while(nd)
		{
			ndd = new lnkgphnd<edge>;
			memcpy(ndd , nd , sizeof(lnkgphnd<edge>));
			dst->next = ndd;
			dst = ndd;
			nd = nd->next;
		}
		dst->next = NULL;
	}
}

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::insert_vertex(vertex ver)
{
	if (_vcnt >= _capacity)return false;
	_ver[_vcnt] = ver;
	_nd[_vcnt] = NULL;
	_vcnt++;
	return true;
}

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::insert_edge(int v1 , int v2 , edge ed)
{
	if (v1 >= _vcnt || v2 >= _vcnt)return false;
	lnkgphnd<edge> *nd = new lnkgphnd<edge>;
	nd->_n = v2;
	nd->_e = ed;
	nd->next = _nd[v1];
	_nd[v1] = nd;
	return true;
}

#define WHITE 0
#define GRAY 1
#define BLACK -1

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::BFS(int s)
{
	if(s >= _vcnt)return false;
	int *color = new int[_vcnt];
	int vistc = 0;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_vist[i] = -1;
	}
	color[s] = GRAY;
	_dep[s] = 0;
	_prt[s] = -1;
	_vist[vistc++] = s;
	queue<int> _queue(_vcnt);
	_queue.inqueue(s);

	while (_queue.length() != 0)
	{
		int nd;
		_queue.dequeue(nd);
		color[nd] = BLACK;
		lnkgphnd<edge> *p = _nd[nd];
		while(p)
		{
			if ( color[p->_n] == WHITE)
			{
				color[p->_n] = GRAY;
				_dep[p->_n] = _dep[nd] + 1;
				_vist[vistc++] = p->_n;
				_prt[p->_n] = nd;
				_queue.inqueue(p->_n);
			}
			p = p->next;
		}
	}
	delete color;
	return true;
}

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::DFS(int s)
{
	if(s >= _vcnt)return false;
	int *color = new int[_vcnt];
	int time = 0;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_vist[i] = -1;
	}
	color[s] = GRAY;
	_dep[s] = 0;
	_prt[s] = -1;
	_vist[time] = s;
	lnkgphnd<edge> *p = _nd[s];
	while(p)
	{
		if (color[p->_n] == WHITE)
		{
			color[p->_n] = GRAY;
			DFSrecur(p->_n , color , ++time , s);
		}
		p = p->next;
	}
	color[s] = BLACK;
	delete color;
	return true;
}

template <class vertex , class edge>
void lnkgraph<vertex , edge>::DFSrecur(int s , int *color , int time , int pare)
{
	color[s] = GRAY;
	_dep[s] = time;
	_prt[s] = pare;
	_vist[time] = s;
	lnkgphnd<edge> *p = _nd[s];
	while(p)
	{
		if ( color[p->_n] == WHITE)
		{
			color[p->_n] = GRAY;
			DFSrecur(p->_n , color , time+1 , s);
		}
		p = p->next;
	}
	color[s] = BLACK;
}

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::DFS_stack(int s)
{
	if (s > _vcnt)return false;
	int time = 0 , i;
	int *color = new int[_vcnt];
	for (i = 0 ; i < _vcnt ; i++)
	{
		color[i] = WHITE;
		_dep[i] = -1;
		_prt[i] = -1;
		_prt[i] = -1;
	}
	color[s] = GRAY;
	_prt[s] = -1;
	_dep[s] = 0;
	_vist[time++] = s;
	stack<int> _stack(_vcnt);
	_stack.push(s);

	while(_stack.height() != 0)
	{
		int nd;
		_stack.top(nd);
		lnkgphnd<edge> *p = _nd[nd];		
		while(p)
		{
			if (color[p->_n] == WHITE)
			{
				_stack.push(p->_n);
				color[p->_n] = GRAY;
				_prt[p->_n] = nd;
				_dep[p->_n] = time;
				_vist[time++] = p->_n;
				break;
			}
			p = p->next;
		}
		if (p == NULL)
		{
			int nd;
			_stack.pop(nd);
			color[nd] = BLACK;
		}
	}
	return true;
}

template <class vertex , class edge>
bool lnkgraph<vertex , edge>::visit_result()
{
	if (_vcnt <= 0)return false;
	cout<<"visit result is:";
	for (int i = 0 ; i < _vcnt ; i++)
	{
		if (_vist[i] != -1)cout<<_ver[_vist[i]]<<",";
	}
	return true;
}

template<class edge> struct package
{
	int i1;
	int i2;
	bh_node<edge> *pnd;
};

template <class vertex , class edge>
lnkgraph<vertex , edge> *lnkgraph<vertex , edge>::Prim(int n)
{
	lnkgraph<vertex , edge> *mst;
	if (n >= _vcnt || n < 0)return NULL;
	bh_node<edge> *bhnd;
	bool *isInHeap = new bool[_vcnt];
	package<edge> *pbag = new package<edge>[_vcnt];
	mst = new lnkgraph<vertex , edge>(_vcnt);
	bin_heap<edge> bh;
	for (int i = 0 ; i < _vcnt ; i++)
	{
		bh_node<edge> *nd = new bh_node<edge>;
		nd->sibling = nd->child = nd->parent = NULL;
		nd->degree = 0;
		nd->key = INT_MAX;
// 		bhdata[i*2] = i;
// 		bhdata[i*2+1] = -1;
		pbag[i].i1 = i;
		pbag[i].i2 = -1;
		pbag[i].pnd = nd;
		nd->data = &pbag[i];
		bh.bin_heap_insert(nd);
		isInHeap[i] = true;
	}

	bh.bin_heap_decrease_key(pbag[n].pnd,INT_MIN);
	while(!bh.bin_heap_is_empty())
	{
		bhnd = bh.bin_heap_extract_min();
		int i1 = ((package<edge>*)(bhnd->data))->i1;
		int i2 = ((package<edge>*)(bhnd->data))->i2;

		mst->insert_vertex(_ver[i1]);
		if (i2 != -1)
		{
			mst->insert_edge(i1,i2,bhnd->key);
			mst->insert_edge(i2,i1,bhnd->key);
		}
		isInHeap[i1] = false;

		lnkgphnd<edge> *p = _nd[i1];

		while(p)
		{
			if(isInHeap[p->_n] && p->_e < pbag[p->_n].pnd->key)
			{
				_prt[p->_n] = i1;
				((int*)(pbag[p->_n].pnd->data))[1] = i1;
				bh.bin_heap_decrease_key(pbag[p->_n].pnd , p->_e);
			}
			p = p->next;
		}

	}
	return mst;
}

#endif



// graph.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "base.h"

int _tmain(int argc, _TCHAR* argv[])
{
	lnkgraph<int , int> mtxg(9);
	for (int i = 1 ; i <= 9 ; i++)
	{
		mtxg.insert_vertex(i);
	}
	mtxg.insert_edge(0,1,4);
	mtxg.insert_edge(1,0,4);
	mtxg.insert_edge(0,7,8);
	mtxg.insert_edge(7,0,8);
	mtxg.insert_edge(1,7,11);
	mtxg.insert_edge(7,1,11);
	mtxg.insert_edge(1,2,8);
	mtxg.insert_edge(2,1,8);
	mtxg.insert_edge(2,3,7);
	mtxg.insert_edge(3,2,7);
	mtxg.insert_edge(2,8,2);
	mtxg.insert_edge(8,2,2);
	mtxg.insert_edge(2,5,4);
	mtxg.insert_edge(5,2,4);
	mtxg.insert_edge(3,4,9);
	mtxg.insert_edge(4,3,9);
	mtxg.insert_edge(3,5,14);
	mtxg.insert_edge(5,3,14);
	mtxg.insert_edge(4,5,10);
	mtxg.insert_edge(5,4,10);
	mtxg.insert_edge(5,6,2);
	mtxg.insert_edge(6,5,2);
	mtxg.insert_edge(6,7,1);
	mtxg.insert_edge(7,6,1);
	mtxg.insert_edge(6,8,6);
	mtxg.insert_edge(8,6,6);
	mtxg.insert_edge(7,8,7);
	mtxg.insert_edge(8,7,7);
	lnkgraph<int , int> *mst = mtxg.Prim(0);
	return 0;
}


mysunnnyday
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java图片上查找图片算法
01-21
　屏幕截图，得到图A，(查找的目标图片为图B)； 　遍历图A的像素点，根据图B的尺寸，得到图B四个角映射到图A上的四个点； 　得到的四个点与图B的四个角像素点的值比较。如果四个点一样，执行步骤4；否则，回到...
MIT算法导论-第12讲-最小生成树-Prim算法
清文的博客
01-15 1796
问题定义输入：无向图G=（V，E），每条边有一个权重，另假设所有权值是不同的输出：一棵生成树，连接了所有顶点，权重总和最小。分析过程(http://www.cnblogs.com/numbersix/p/4909750.html) MST拥有最优子结构：去掉MST的一条边，MST分裂成两个子树T1、T2，则T1、T2分别是子图G1、G2的MST。子图G1只包含T1的顶点， 子图G2只包含T2的顶点，
最小生成树之Prim算法
热门推荐
Enstein_Jun
08-23 1万+
普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点，且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克发现；并在1957年由美国计算机科学家罗伯特·普里姆独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。
[Python] 斐波那契堆的实现
倒霉茄子的博客
11-01 1711
[Python] 斐波那契堆的实现斐波那契堆是一种基于堆的数据结构，其用途主要为： - 实现“可合并堆” -某些在斐波那契堆中常数摊还时间内完成的操作频繁使用的应用具体函数（操作）：首先介绍堆中元素（节点）的实现： 元素初始化def __init__(self, key): self.key=key #关键字 self.degree=0 #元素在堆中的度
网络算法-python实现prim(基于堆)
weixin_53284122的博客
06-30 1861
网络算法-python实现prim(基于堆)
《编写高质量代码：改善Python程序的91个建议》读后感
weixin_33831196的博客
11-18 102
编写高质量代码：改善Python程序的91个建议  http://book.douban.com/subject/25910544/ 1.（建议16）is 用于判断两个对象的id是否相等，==才是判断值是否相等 2.（建议23）for，while，和try语句后面都可以跟else语句，可以简化代码 3.（建议18） __init__.py模块可以写代码，import时只需要 import 包...
最全的android图片加密
11-26
在加密图片时，我们可以在原始数据中随机插入一些无关的字节，使得即使获取了加密后的数据，没有正确的“混入”规则也无法还原原图。这种方法可以进一步提高数据的安全性，防止针对AES等标准加密方式的攻击。 在...
Android 图片浏览全屏缩放
05-10
在Android开发中，实现图片浏览的全屏缩放效果是一项常见的需求，特别是在社交应用中，如QQ好友动态和微信朋友圈。这种功能不仅需要提供良好的用户体验，还需要考虑性能和内存优化，因为图片通常较大，处理不当可能...
C# winform 图片定位 图片相似度匹配 查询图1在图2中的位置
05-06
图片定位主要是确定一张小图片（查询图）在大图片（背景图）中的精确位置。通常，这涉及到图像特征匹配、模板匹配或基于深度学习的方法。在WinForm应用中，我们可以使用OpenCV库，这是一个强大的跨平台计算机视觉库...
c#生成自定义图片方法代码实例
08-26
在远程缩略图的生成中，我们使用 URL 来获取图片，然后使用 SaveImage 方法来保存缩略图。 通过本篇文章，读者可以了解如何使用 C# 语言来生成自定义图片，并掌握相关的编程技术。这将有助于读者更好地掌握 C# 语言...
斐波那契堆（Fibonacci Heap）
02-25
在clion中对fibonacci heap的完全实现，亲测有效。
Implementation-of-Prim-s-Algorithm-using-Fibonacci-Heap:使用斐波那契堆方案和简单方案实现的 Prim 算法
06-09
使用斐波那契堆的 Prim-s 算法的实现 使用斐波那契堆方案和简单方案实现的 Prim 算法
最小生成树 Kruskal 和 Prim算法及堆优化
m0_60777643的博客
05-12 2650
解决最小生成树的问题之前，我们先要明白生成树/最小生成树是什么。 对一个具有 n 个点的连通图进行遍历，对于遍历后的子图，其包含原图中所有的点且保持图连通，最后的结构一定是一个具有 n-1 条边的树，通常称为生成树。 如果是连通网，则生成树 边的权就是每条边的权的总和。所谓最小生成树，也就是权最小的生成树。一个图的生成树不唯一 在生成树问题中，最常见的问题就是最小生成树问题，所谓最小生成树，就是对于一个有 n 个点的无向连通图的生成树，其包含原图中的所有点，且保持图连通的边权总和...
算法7-9：prim堆优化详解（C++代码）（小白向）
weixin_45962388的博客
02-06 3640
Part -1 前置算法 了解图的存储，本文使用邻接表来存储图。 Part 1 最小生成树 什么是最小生成树？《算法导论》给了我们一个很好的解释 最小生成树在许多领域都有它的作用。譬如网络的连接，每一个节点（计算机）断网后，最小生成树就会重新计算，所以算法的速度还是不容忽视的。 最小生成树其实是最小权重生成树的简称。 ——百度百科 Part 2 prim 接下来要介绍的prim算法就是用来生成最小生成树的。 prim是一种贪心算法。 过程 初始化 变量名解释 Dis，表示到整棵树的距离。 Path
最小生成树---朴素Prim算法，堆优化版Prim算法
最新发布
weixin_63001635的博客
02-27 1238
给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合。由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中。
prim算法堆优化
m0_46398202的博客
12-10 2904
首先，prim算法的思想是，从一个起点开始，通过不断的纳入与当前生成树距离最短的且不在生成树中的点来构造最小生成树，当所有点都纳入到生成树以后，就得到了最小生成树。使用邻接表来存储图，能使得所需的空间最小。通过一个数组来存放各个点到当前生成树的最短距离，可以避免重复比较，从而提升效率。但我们所要获取的是该数组里的距离最小的那个点。如果没有进行堆优化，那从这个数组里找出最小距离的点的时间复杂度是O（n）,通过堆优化，我们获取最小值的时间复杂度则为O（log2n）,在图的点数目很大时，能有效的提升效率。 #in
最小生成树（朴素prim算法+堆优化）
m0_73938823的博客
08-01 819
(2)堆优化版用小根堆+邻接表，适合稀疏图(复杂度：mlogm)(m为边数)（1）朴素prim算法适合稠密图（复杂度：n^2)
Prim堆优化
Superb_day
08-21 470
#include<bits/stdc++.h> #define R register int//优化,可忽略 #define P pair <int,int> using namespace std; int k,n,m; int cnt,sum,dis[10005],vis[10005]; vector <int> E[200005];//存点 vector <int> W[200005];//存边 inline void add(int u,int v,.
Prim算法和Kruskal算法到底哪个好？
仰望天空，妳我亦是行人.
03-08 1551
遇到困难时首先想到的不应该是退缩，而是探索！文章粗浅，希望对大家有帮助！【最小生成树】Prim算法和Kruskal算法的区别对比Prim算法（java）克鲁斯卡尔算法（Kruskal）详解。
elementui 轮播图图片
09-02
在 ElementUI 中使用轮播图组件需要引入 Carousel、CarouselItem 组件，并在 Carousel 组件中通过 v-for 指令循环渲染图片。 以下是一个简单的示例代码： ```vue (item, index) in images" :key="index"> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值