用C++写的图的算法。

最新推荐文章于 2023-01-20 10:25:57 发布
置顶 最新推荐文章于 2023-01-20 10:25:57 发布
阅读量494 收藏
点赞数 1
文章标签： c++ vector graph iterator null path
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jerryjerryone/article/details/7907472
版权

1.用到了设计模式里的template method,首先定义了一个图的虚基类GRAPH,在里面定义了一些虚方法的接口，然后在GRAPH里用这些虚方法实现了图的各个算法(BFS,DFS,Prim,Kruskal,Dijkstra,Floyd)。然后在GRAPH的子类AdjMatrixGRAPH和AdjListGRAPH里分别用邻接表和邻接矩阵表示图，并实现GRAPH中定义的接口，这样图的算法与图的表示进行了分离，并且后面再加别种图的表示只需要增加新的子类。

2.其中的图的算法跟各大教科书没任何区别，，里面有很多可以优化或者让代码更漂亮的地方。

3.为了把各算法的结果与结果的显示分离，在各算法中都传入了引用作为参数。

#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>

using namespace std;



struct Edge//边
{
	int v,w;//

	Edge( int v = -1, int w = -1 ):
		v( v ), w( w ){}

	void SetEdge( int vx, int wx )
	{
		v = vx;
		w = wx;
	}

	virtual void SetWeight( int wt )
	{
	}

	virtual int GetWeight() const
	{
		return 1;//默认权值为1
	}
};

struct WEdge:public Edge//加权边
{
	int weight;

	WEdge( int v = -1, int w = -1, int wt = 1 ):
		Edge( v, w ),weight( wt ){}

	virtual void SetWeight( int wt )
	{
		weight = wt;
	}

	virtual int GetWeight() const
	{
		return weight;
	}
};

bool LessWedge( const WEdge  & we1, const WEdge & we2 )
{
	return we1.GetWeight() < we2.GetWeight();
}

class GRAPH
{
private:

	void DFSearch( vector<bool> & vec, int n, vector< int > &Rslt )//
	{
		//cout << n <<" ";
		Rslt.push_back( n );
		vec[n] = true;

		for( int i = 0; i < VCnt; i++ )
		{
			if( edge( n, i ) && ( !vec[i] ) )
			{
				DFSearch( vec, i, Rslt );
			}
		}
	}

	void GenEVex( vector<WEdge> & vec )//生成边集数组
	{
		for( int v = 0; v < VCnt; v++ )
		{
			for( int w = v + 1; w < VCnt; w++ )
			{
				if( edge(  v, w ) )
				{
					WEdge eg( v , w, getweight( v, w ) );
					vec.push_back( eg  );
				}
			}
		}
	}

	//从一条边都一个顶点出发查找可达的最深节点
	int find( const vector<int> &vec, int m )
	{
		while( vec[m] != 0 )
		{
			m = vec[m];
		}
		return m;
	}

	//参数合法性判断
	bool IsLegal( int v )
	{
		return ( ( v > 0 ) && ( v < ( V() - 1 ) ) ) ? true:false;
	}

	bool IsLegal( vector< vector<int> > & vec )
	{
		if( vec.size() != V() )
		{
			return false;
		}

		for( vector< vector< int > >::iterator it = vec.begin(); it != vec.end(); it++ )
		{
			if( it->size() != V() )
			{
				return false;
			}
		}
		return true;
	}


	void DijkstraShortPath( int v0, vector<int> & p, vector<int> & pathlen )
	{
		vector<int> final;

		for( int i = 0; i < VCnt; i++ )
		{
			p.push_back( v0 );
			pathlen.push_back( INT_MAX );

			final.push_back( 0 );
		}
		
		pathlen[v0] = 0;
		final[v0] = 1;

		for( int i = 0; i < VCnt; i++ )
		{
			if( edge( v0 ,i ) )//v0与i之间有边，则把边的权值初始化pathlen
			{
				pathlen[i] = getweight( v0, i );
			}
		}

		//初始化结束,开始算法主体
		for( int v = 1; v < VCnt; v++ )
		{
			int min = INT_MAX;
			int k = 0;
			for( int w = 0; w < VCnt; w++ )
			{
				if( ( final[w] != 1 ) && ( min > pathlen[w] ) )
				{
					min = pathlen[w];
					k = w;
				}
			}
			final[k] = 1;
			int wt = 0;
			for( int w = 0; w < VCnt; w++ )
			{
				wt = getweight( k ,w );
				if(  ( final[w] != 1 ) &&  edge( k ,w ) &&( pathlen[w] > pathlen[k] + wt ) )
				{
					pathlen[w] = pathlen[k] + wt;
					p[w] = k;
				}
			}
		}
	}
protected:
	int VCnt;
	int ECnt;
	bool digraph;

public:

	GRAPH( int V, bool dig = false ):
	  VCnt( V ),ECnt( 0 ),digraph( dig ){}

	int V()
	{
		return VCnt;
	}

	int E()
	{
		return ECnt;
	}

	bool Directed()
	{
		return digraph;
	}

	virtual void insert( const Edge &e ) = 0;
	virtual void remove( const Edge & e ) = 0;
	virtual void setweight( int v, int w, int weight ) = 0;
	void setweight( const Edge & e, int weight )
	{
		return setweight( e.v, e.w, weight );
	}
	virtual int getweight( int v, int w ) = 0;
	virtual bool edge( int v, int w ) = 0;

	void BFS( vector< int > & Rslt )//Breadth-First-Search
	{
		vector<bool> visited;
		for( int i =0; i < VCnt; i++ )
		{
			visited.push_back( false );
		}
		deque<int> queue;

		for( int i = 0; i < VCnt; i++ )
		{
			if( !visited[i] )
			{
				queue.push_back( i );
				visited[i] = true;
			}
			while( !queue.empty() )
			{
				int node = queue.front();
				queue.pop_front();
				Rslt.push_back( node );

				for( int j = 0; j < VCnt; j++ )
				{
					if( edge( node, j ) && ( !visited[j] ) )
					{
						queue.push_back( j );
						visited[j] = true;
					}
				}
			}
		}
	}

	void DFS( vector< int > & Rslt )//Depth-First-Search
	{
		vector<bool> visited;
		for( int i = 0; i < VCnt; i++ )
		{
			visited.push_back( false );
		}

		for( int i = 0; i < VCnt; i++ )
		{
			if( ! visited[i] )
			{
				DFSearch( visited, i, Rslt );
			}
		}
	}

	void Prim( vector< Edge > & Rslt )
	{
		if( Directed() )
		{
			return;//只针对无向图
		}

		vector<int> vex;
		vector<int> lowcost;

		for( int i = 0; i < VCnt; i++ )
		{
			vex.push_back( 0 );//先放入第0个节点
			lowcost.push_back( INT_MAX );
		}

		lowcost[0] = 0;

		for( int i = 1; i< VCnt; i++ )
		{
			if( edge( 0, i ) )
			{
				lowcost[i] = getweight( 0, i );
			}
		}

		Edge e;
		for( int i = 1; i < VCnt; i++ )
		{
			int min = INT_MAX;
			int k = 0;
			for( int j = 1; j < VCnt; j++ )
			{
				if( ( lowcost[j] != 0 ) && ( lowcost[j] < min ) )
				{
					min = lowcost[j];
					k = j;
				}
			}

			lowcost[k] = 0;

			e.SetEdge( vex[k], k );
			Rslt.push_back( e );

			for( int i = 1; i < VCnt; i++ )
			{
				int wt = getweight( k ,i );
				if( ( lowcost[i] != 0 ) && edge( k , i ) &&( lowcost[i] > wt ) )
				{
					lowcost[i] = wt;
					vex[i] = k;
				}
			}
		}
	}

	void Kruskal( vector< Edge > &Rslt )
	{
		if( Directed() )
		{
			return;//只针对无向图
		}

		//此处把生成边集数组的过程提取重构成一个成员函数
		vector<WEdge> we;
		GenEVex( we );

		sort( we.begin(), we.end(), LessWedge );//把边按权值从小到大排序

		vector<int> evex;
		for( int v = 0; v < VCnt; v++ )
		{
			evex.push_back( 0 );
		}

		for( vector<WEdge>::iterator it = we.begin(); it != we.end(); it++ )
		{
			int m = find( evex, it->v );
			int n = find( evex, it->w );
			if( m != n )
			{
				Rslt.push_back( *it );
				evex[m] = n;
			}
		}

	}

	//path和pathlen都必须是V*V的二维数组
	void Dijkstra( vector< vector< int > > &path, vector< vector< int > > &pathlen )
	{
		if( ! IsLegal( path ) || ! IsLegal( pathlen ) )
		{
			cout << "Please input the right para!" << endl;
			return;
		}

		for( int v = 0; v < VCnt; v++ )
		{
			DijkstraShortPath( v, path[v], pathlen[v] );
		}
	}

	//path和pathlen都是V*V的二维数组
	void Floyd( vector< vector< int > > &path, vector< vector< int > > &pathlen )
	{
		if( ! IsLegal( path ) || ! IsLegal( pathlen ) )
		{
			cout << "Please input the right para!" << endl;
			return;
		}
		
		for( int v = 0; v < VCnt; v++ )
		{
			path[v].assign( VCnt, 0 );
			pathlen[v].assign( VCnt, 0 );
			for( int w = 0; w < VCnt; w++ )
			{
				path[v][w] = w;
				pathlen[v][w] = getweight( v, w );
			}
		}

		for( int k = 0; k < VCnt; k++ )
		{
			for( int v = 0; v  < VCnt; v++ )
			{
				for( int w = 0; w < VCnt; w++ )
				{
					if(  ( pathlen[v][w] > pathlen[v][k] + pathlen[k][w] ) && ( pathlen[v][k] != INT_MAX ) &&( pathlen[k][w] != INT_MAX ) )
					{
						pathlen[v][w] = pathlen[v][k] + pathlen[k][w];
						path[v][w] = path[v][k];
					}
				}
			}
		}
	}

};

class AdjMatrixGRAPH:public GRAPH
{
private:
	vector< vector<int> > adj;

public:

	AdjMatrixGRAPH( int V, bool dig = false ):
		GRAPH( V, dig ),adj(V)
		{
			for( int i = 0; i < V; i++  )
			{
				adj[i].assign( V, INT_MAX );
				adj[i][i] = 0;
			}
		}

	void insert( const Edge &e )
	{
		if( !edge( e.v, e.w ) )
		{
			ECnt++;//add an edge
		
			adj[e.v][e.w] = e.GetWeight();

			if( !Directed() )
			{
				adj[e.w][e.v] = e.GetWeight();
			}
		}
		else
		{
			cout << "edge " << e.v << "-" << e.w << " already exist" << endl;
			return;
		}
	}


	void remove( const Edge & e )
	{
		if( adj[e.v][e.w] != INT_MAX )
		{
			ECnt--;
		}
		adj[e.v][e.w] = INT_MAX;

		if( !Directed() )
		{
			adj[e.w][e.v] = INT_MAX;
		}
	}

	void setweight( int v, int w, int weight )
	{
		if( edge( v, w ) )
		{
			adj[v][w] = weight;

			if( !Directed() )//无向图
			{
				adj[w][v] = weight;
			}
		}
		else
		{
			cout << "Add weight error,edge "<< v <<","<< w <<" not exist" << endl;
			return;
		}
	}

	int getweight( int v, int w )
	{
		return adj[v][w];
	}

	bool edge( int v, int w )
	{
		return adj[v][w] == INT_MAX?false:true;
	}
};

struct node
{
	int v;
	int weight;
	node * next;

	node( int x = 0, node * t = 0, int wt = 0 ):
		v( x ),next( t ),weight( wt ){}
};

class AdjListGRAPH:public GRAPH
{
private:
	vector< node * > adj;

	node * get( int v, int w )//查找边v-w所在节点
	{
		node * t = adj[v];
		while( t != NULL )
		{
			if( t->v == w )
			{
				return t;
			}
			else
			{
				t = t->next;
			}
		}

		return NULL;
	}

public:
	AdjListGRAPH( int V, bool dig = false ):
		GRAPH( V, dig )
		{
			adj.assign( V, ( node * )NULL );
		}

	void insert(const Edge &e )
	{
		if( !edge( e.v, e.w ) )
		{
			node * t = new node;
			t->v = e.w;
			t->weight = e.GetWeight();
			t->next = NULL;

			if( adj[e.v] == NULL )
			{
				adj[e.v] = t;
			}
			else
			{
				t->next = adj[e.v];
				adj[e.v] = t;
			}

			ECnt++;

			if( !Directed() )
			{
				node * t = new node;
				t->v = e.v;
				t->weight = e.GetWeight();
				t->next = NULL;

				if( adj[e.w] == NULL )
				{
					adj[e.w] = t;
				}
				else
				{
					t->next = adj[e.w];
					adj[e.w] = t;
				}
			}
		}
		else
		{
			cout << "edge "<< e.v << "-" << e.w << "already exists!" << endl;
		}
	}

	void remove( const Edge & e )
	{
		node * t = adj[e.v];
		node * prev = t;
		while( t != NULL )
		{
			if( t->v == e.w )
			{
				prev->next = t->next;
				delete t;

				ECnt--;
			}
			else
			{
				prev = t;
				t = t->next;
			}
		}

		if( !Directed() )
		{
			node * t = adj[e.w];
			node * prev = t;
			while( t != NULL )
			{
				if( t->v == e.v )
				{
					prev->next = t->next;
					delete t;
				}
				else
				{
					prev = t;
					t = t->next;
				}
			}
		}
	}

	void setweight( int v, int w, int weight )
	{
		node * t = get( v, w );
		if( t != NULL )
		{
			t->weight = weight;
		}
		else
		{
			cout << "edge " << v << "-" << w << " not exist!" << endl;
		}

		if( !Directed() )
		{
			t = get( w, v );
			if( t != NULL )
			{
				t->weight = weight;
			}
		}
	}

	int getweight( int v, int w )
	{
		if( v == w )//同一个点，距离为0
		{
			return 0;
		}
		node * t = get( v, w );
		if( t != NULL )
		{
			return t->weight;
		}
		return INT_MAX;
	}

	bool edge( int v, int w )
	{
		node * t = get( v, w );
		if( t != NULL )
		{
			return true;
		}
		return false;
	}
};



int main()
{

	//GRAPH *g = new AdjMatrixGRAPH( 9 );
	GRAPH *g = new AdjListGRAPH( 9 );


	Edge e( 0,1 );
	g->insert( e );

	e.SetEdge( 1,2 );
	g->insert( e );

	e.SetEdge(2,3);
	g->insert( e );

	e.SetEdge(3,4);
	g->insert( e );

	e.SetEdge(4,5);
	g->insert( e );

	e.SetEdge(5,0);
	g->insert( e );

	e.SetEdge(1,8);
	g->insert( e );

	e.SetEdge(2,8);
	g->insert( e );

	e.SetEdge(1,6);
	g->insert( e );

	e.SetEdge(3,8);
	g->insert( e );

	e.SetEdge(3,6);
	g->insert( e );

	e.SetEdge(3,7);
	g->insert( e );

	e.SetEdge(4,7);
	g->insert( e );

	e.SetEdge(5,6);
	g->insert( e );

	e.SetEdge(6,7);
	g->insert( e );
	

	vector< int > Rslt;
	//g->BFS( Rslt );
	//g->DFS( Rslt );



	g->setweight( 0,1,10 );
	g->setweight( 0,5,11 );
	g->setweight( 1,2,18 );
	g->setweight( 1,6,16 );
	g->setweight( 1,8,12 );
	g->setweight( 2,3,22 );
	g->setweight( 2,8,8 );
	g->setweight( 3,4,20 );
	g->setweight( 3,6,24 );
	g->setweight( 3,7,16 );
	g->setweight( 3,8,21 );
	g->setweight( 4,5,26 );
	g->setweight( 4,7,7 );
	g->setweight( 5,6,17 );
	g->setweight( 6,7,19 );


	vector< Edge > ERslt;
	g->Prim( ERslt );
	g->Kruskal( ERslt );

/*
	WEdge e( 0,1,1 );
	g->insert( e );

	e.SetEdge( 0,2 );
	e.SetWeight( 5 );
	g->insert( e );

	e.SetEdge( 1,2 );
	e.SetWeight( 3 );
	g->insert( e );

	e.SetEdge( 1,3 );
	e.SetWeight( 7 );
	g->insert( e );

	e.SetEdge( 1,4 );
	e.SetWeight( 5 );
	g->insert( e );

	e.SetEdge(2,4);
	e.SetWeight( 1 );
	g->insert( e );

	e.SetEdge(2,5);
	e.SetWeight( 7 );
	g->insert( e );

	e.SetEdge(3,4);
	e.SetWeight( 2 );
	g->insert( e );

	e.SetEdge(3,6);
	e.SetWeight( 3 );
	g->insert( e );

	e.SetEdge(4,5);
	e.SetWeight( 3 );
	g->insert( e );

	e.SetEdge(4,6);
	e.SetWeight( 6 );
	g->insert( e );

	e.SetEdge(4,7);
	e.SetWeight( 9 );
	g->insert( e );

	e.SetEdge(5,7);
	e.SetWeight( 5 );
	g->insert( e );

	e.SetEdge(6,7);
	e.SetWeight( 2 );
	g->insert( e );

	e.SetEdge(6,8);
	e.SetWeight( 7 );
	g->insert( e );

	e.SetEdge(7,8);
	e.SetWeight( 4 );
	g->insert( e );



	vector< vector< int > > pathvec( g->V() );
	for( vector< vector< int > >::iterator it = pathvec.begin(); it != pathvec.end(); it++ )
	{
		it->assign( g->V(), 0 );
	}

	vector< vector< int > > pathlenvec( g->V() );
	for( vector< vector< int > >::iterator it = pathlenvec.begin(); it != pathlenvec.end(); it++ )
	{
		it->assign( g->V(), 0 );
	}
	//g->Dijkstra( pathvec, pathlenvec );
	g->Floyd( pathvec, pathlenvec );
*/
	return 0;
}


jerryjerryone
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
图算法（c++模板）
11-01
用c++模板写的图算法，包括广搜、深搜、最小生成树算法（prim、kruskal）、单源最短路径（bellman-ford、dijkstra）、拓扑排序，prim、dijkstra算法使用优先级队列实现
图的基本算法——C/C++
Strive_LiJiaLe的博客
04-19 393
图的结构体定义 typedef struct vertex { int number; //顶点的编号 }VertexType; //别名，顶点的类型 typedef struct matrix { int n; //顶点个数 int e; //边数 int adjMat[MAXV][MAXV]; //邻接矩阵数组 VertexType ver[MAXV]; //存放顶点信息 }MatGraph; //别名，完整的
图核心算法（c++）
crazyfox的博客
08-04 249
1. 图的遍历 leetcode207 这道题对应拓扑排序，有向图是否有环的问题 1.1 BFS（广度优先搜索） 第一次做法 class Solution { public: bool canFinish(int numCourses, vector<vector<int>>& prerequisites) { // 0.初始化准备 unordered_set<int> temp; vector&
算法V（C++实现）图算法 C++算法：图算法 （第3版
05-27
算法经典书籍 普林斯顿大学教授大作，用c++描述，利于学习算法及c++
C++算法-图算法（pdf版）
06-23
c++算法-图算法(第三版)一书的pdf版
面试题 写一个堆排序算法 c++
01-15
一个堆排序算法 c++写的 逻辑相同 可自行 改为java 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一个堆排序算法 c++ 写一...
C++ 数据结构算法集合.zip
12-28
C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据结构算法集合 C++ 数据...
C++ 图像压缩算法
03-17
本篇文章将详细探讨基于C++实现的图像压缩算法，特别是如何利用霍夫曼（Huffman）编码进行图像压缩。 首先，我们需要理解图像的基本构成。图像通常由像素矩阵表示，每个像素包含红、绿、蓝（RGB）三个颜色通道的...
C++递归算法实例代码
08-28
C++递归算法实例代码 本文主要介绍了C++递归算法实例代码，着重于解决逻辑表达式的判断问题，通过递归算法实现了对逻辑表达式的计算和判断。下面是本文中涉及到的知识点： 1. 递归算法的特点：递归算法有三个特点...
使用C++实现相关算法及其数据结构源码
最新发布
08-09
使用C++实现相关算法及其数据结构源码 List：线性表实现 数组实现 链表实现 StackAndQueue: 栈和队列实现 数组实现 链表实现 String: 串实现 数组实现 KMP算法 BinTree: 二叉树实现 数组实现 先序遍历 中序遍历 ...
C++图像处理算法
11-03
《Visual C++数字图像处理技术详解》.(刘海波,沈晶).[PDF]完整目录版
精彩编程与编程技巧-实现图片平铺于窗体中...
10-08
精彩编程与编程技巧-实现图片平铺于窗体中 ...
算法—图（C++实现)
m0_58086930的博客
09-18 712
1.定义 class Edge; class Node { public: int value;//点的值 int in;//入度 int out;//出度 list<Node*> nexts;//由该节点射出的点 list<Edge*> edges;//由该节点射出的边 Node(int val) { value = val; in = 0;out = 0; } }; class Edge {//有向边，无向边可由有向边转化 public: int we
算法导论：c++实现图
imcy的博客
02-26 895
图的表示 这里用结构体来表示图G，和图顶点GraphNode，后面要用到的顶点颜色用枚举类型表示 enum color { white = 0, gray, black }; struct graphNode { char name; //顶点名 struct graphNode *pre; //前驱节点 int d; //深...
c++数据结构与算法 图
开到荼蘼的博客
03-27 506
图的定义： 图：用线或者边连接在一起的节点集合。G=(V,E) 当且仅当(i,j)是图的边，则称节点i,j是邻接的。 有向图和无向图； 加权图； 一条路径，如果除第一个和最后一个节点之外，其他节点各不相同，则这条路径称为简单路径； 生成树：设G是一个无向图，G是联通的，当且仅当G的每一对顶点之间都有一条路径。假设G是联通的，但G的有些边对联通来说是不必要的，去掉这些边依然联通 子...
C++及图像算法基础知识（二）
ChuanjieZhu
09-26 812
PS：为了面试准备的，总结的有点粗糙。   1.使用了未初始化的局部变量 错误：     正确：     2.指针与指向指针的指针 Pointer to an integer value int* i   Pointer to a pointer to an integer value int** i   3.i++ 与++i的区别 use ++i...
【一】图算法之Dijkstra算法及C++实现
Allen_Duke的博客
04-13 2968
0. 前言 由于之前一个比赛用到了路径规划，于是就学习了一些图论中路径规划的算法，所以将自己的学习后的代码记录下来以作备忘。但也是只学了图搜索这类的方法，基于采样的RRT等其他方法个人认为不适合我的应用场景，所以也没有了解。 1. Dijkstra算法 单源最短路径问题：给定一个图G=(V，E)G=(V，E)G=(V，E)，求源结点s∈Vs∈Vs∈V到图中每个结点v∈Vv∈Vv∈V的最短路径。 Dijkstra算法就适用于解决带权重的有向图（或无向图）上的单源最短路径问题，同时算法要求图中所有边的权重非负。
c++数据结构-图（详解附算法代码，一看就懂）
我的博客
01-20 6738
有向图：边上有箭头，只能从箭头的引出的结点到被指向的结点，不能逆着箭头走。无向图：边上无箭头，可以随便走。结点的度：无向图中与结点相连的边的数量。结点的入度：有向图中以结点为终点的边的数量。结点的出度：有向图中以结点为起点的边的数量。权值：可以理解为边的长度。连通：如果结点 U 和 V 之间通过若干个边和结点能从 U 到达 V，则称 U 和 V 连通。回路：起点和终点相同的路径。
C++实现图算法（一）
热门推荐
Ai
03-21 1万+
图算法（一） 对图的顶点和边进行了封装。
用c++写图像液化算法
04-05
抱歉，我是一名语言模型AI，无法编写代码。但是，我可以向您提供图像液化算法的大致思路： 图像液化算法通常会对图像进行模糊处理，以模拟液体的流动效果。具体实现方法如下： 1. 定义一个半径r，表示图像中每个像素点的液化半径。 2. 对于每个像素点，计算它周围r个像素点的平均颜色值，并将该像素点的颜色值设置为这个平均值。 3. 重复这个过程，直到整张图像变得模糊、模糊半径达到一个阈值或达到预期的效果为止。 4. 为了使效果更加逼真，可以在处理时考虑像素点的深度信息，使得离观察者更近的像素点流动得更快，离观察者更远的像素点流动得更慢。 以上是图像液化算法的大致思路，具体实现方式还需要根据具体的编程语言和图像处理库进行调整。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值