组合数学实验——求欧拉迹算法

最新推荐文章于 2024-08-06 17:45:33 发布
最新推荐文章于 2024-08-06 17:45:33 发布
阅读量282 收藏
点赞数
文章标签： python
原文链接：https://my.oschina.net/wh1tew0lf/blog/14599
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

还是以前写的......

算法：组合数学中文第4版 机械工业出版社 P299

同样隐藏掉ID

//
//                                          //
//  Project Name: Eulerian_Trace            //
//                                          //
//  File Name: EGraph.h                     //
//                                          //
//  Author: Victor Zhang                    //
//                                          //
//  ID: 21*****92                           //
//                                          //
//  Create Date: May 17. 2009               //
//                                          //
//

struct ET_Node
{
	int point_one;
	int point_two;
	int route_num;
	ET_Node* right;
	ET_Node* down;
};

struct ET_Node_Head
{
	int ID;
	ET_Node_Head* next;
	ET_Node* right;
	ET_Node* down;
};

struct Link_Unit
{
	Link_Unit* next;
	int value;
};

class ETGraph
{
private:
	ET_Node_Head* head;
	Link_Unit* main_Link_Head;
private:
	ET_Node_Head* GetNodeHead(int);
	ET_Node* GetNode(int, int);
	int GetRoute(ET_Node*);
	int GetRoute(int, int);
	bool DelRoute(ET_Node*);
	bool AddNodeHead(int);
public:
	ETGraph()
	{
		head = NULL;
		main_Link_Head = NULL;
	};
	bool AddNode(int, int, int);

	bool SetRoute(int, int, int);

	Link_Unit* Find_Circle();
	bool Compose(Link_Unit*);
	void Find_ET();

	bool DelNode(int, int);
	bool DelRoute(int, int);
	void DelAllNodes();
	void DelLinks();

	bool ReadFromFile();
	void PrintToFile();

	~ETGraph()
	{
		DelAllNodes();
		DelLinks();
	};
};
//
//                                          //
//  Project Name: Eulerian_Trace            //
//                                          //
//  File Name: EGraph.cpp                   //
//                                          //
//  Author: Victor Zhang                    //
//                                          //
//  ID: 21*****92                           //
//                                          //
//  Create Date: May 17. 2009               //
//                                          //
//

#include <iostream>
#include <fstream>
#include <iomanip>

#include "ETGraph.h"

using namespace std;

ET_Node_Head* ETGraph::GetNodeHead(int ID)
{
	if (!(this->head)) return NULL;
	else
	{
		ET_Node_Head* p = NULL;
		p = this->head;
		while (p && (p->ID != ID))
			p = p->next;
		return p;
	};
};

ET_Node* ETGraph::GetNode(int i, int j)
{
	ET_Node_Head* p = this->GetNodeHead(i);
	if (!p) return NULL;
	ET_Node* pp = p->down;
	while (pp && (pp->point_two != j)) pp = pp->down;
	if (!pp) return NULL;
	return (pp->point_one == i) ? pp : NULL;
};

int ETGraph::GetRoute(ET_Node* p)
{
	if (!p) return 0;
	return p->route_num;
};

int ETGraph::GetRoute(int i, int j)
{
	return this->GetRoute(this->GetNode(i, j));
};

bool ETGraph::DelRoute(ET_Node* p)
{
	if (!p) return false;
	if (p->route_num <= 0) return false;
	p->route_num--;
	if (p->route_num == 0) this->DelNode(p->point_one, p->point_two);
	return true;
};

bool ETGraph::AddNodeHead(int ID)
{
	ET_Node_Head* p = new ET_Node_Head;
	if (!p) return false;
	p->next = NULL;
	if (!(this->head)) this->head = p;
	else
	{
		ET_Node_Head* p1;
		ET_Node_Head* p2;
		p1 = this->head;
		p2 = this->head;
		p2 = p1->next;
		while (p1 && p2 && (p2->ID < ID))
		{
			p1 = p2;
			p2 = p2->next;
		};
		if (!p2)
		{
			p1->next = p;
			p->next = NULL;
		}
		else if (p2->ID == ID)
		{
			delete p;
			return false;
		}
		else
		{
			p1->next = p;
			p->next = p2;
		};
	};
	p->ID = ID;
	p->down = p->right = NULL;
	return true;
};

bool ETGraph::AddNode(int i, int j, int r)
{
	if (this->GetNode(i, j)) return false;
	ET_Node* p = new ET_Node;
	ET_Node_Head* ph1 = this->GetNodeHead(i);
	ET_Node_Head* ph2 = this->GetNodeHead(j);
	if (!ph1)
	{
		this->AddNodeHead(i);
		ph1 = this->GetNodeHead(i);
	}
	if (!ph2)
	{
		this->AddNodeHead(j);
		ph2 = this->GetNodeHead(j);
	};
	if ((!ph1) || (!ph2))
	{
		delete p;
		delete ph1;
		delete ph2;
		return false;
	};
	p->point_one = i;
	p->point_two = j;
	p->route_num = r;
	ET_Node* p1;
	ET_Node* p2;
	p1 = p2 = ph1->down;
	if (p1) p2 = p1->down;
	while (p1 && p2 && (p2->point_two < j))
	{
		p1 = p2;
		p2 = p2->down;
	};
	if (!p1)
	{
		ph1->down = p;
		p->down = NULL;
	}
	else if (p1->point_two >= j)
	{
		ph1->down = p;
		p->down = p1;
	}
	else if (p2 && (p2->point_two == j))
	{
		delete p;
		return false;
	}
	else
	{
		p1->down = p;
		p->down = p2;
	};
	p1 = p2 = ph2->right;
	if (p1) p2 = p1->right;
	while (p1 && p2 && (p2->point_one > i))
	{
		p1 = p2;
		p2 = p2->right;
	};
	if (!p1)
	{
		ph2->right = p;
		p->right = NULL;
	}
	else if (p1->point_one <= i)
	{
		ph2->right = p;
		p->right = p1;
	}
	else if (p2 && (p2->point_one == i))
	{
		delete p;
		return false;
	}
	else
	{
		p1->right = p;
		p->right = p2;
	};
	return true;
};

bool ETGraph::SetRoute(int i, int j, int r)
{
	ET_Node* p;
	p = this->GetNode(i, j);
	if (!p) return false;
	p->route_num = r;
	return true;
};


Link_Unit* ETGraph::Find_Circle()
{
	if (!(this->main_Link_Head))
	{
		Link_Unit* p;
		Link_Unit* pp;
		ET_Node* pNd;
		if (!(this->head)) return NULL;
		pNd = this->head->down;
		p = new Link_Unit;
		if (!p) return NULL;
		p->value = this->head->ID;
		p->next = NULL;
		pp = this->main_Link_Head = p;
		ET_Node_Head* ph = this->GetNodeHead(pNd->point_two);
		this->DelRoute(pNd->point_one, pNd->point_two);
		while (ph && ph != this->head)
		{
			pNd = ph->right;
			if (pNd)
			{
				p = new Link_Unit;
				if (!p) return NULL;
				p->value = pNd->point_two;
				pp->next = p;
				p->next = NULL;
				pp = p;
				ph = this->GetNodeHead(pNd->point_one);
				this->DelRoute(pNd->point_one, pNd->point_two);
				continue;
			};
			pNd = ph->down;
			if (pNd)
			{
				p = new Link_Unit;
				if (!p) return NULL;
				p->value = ph->ID;
				pp->next = p;
				p->next = NULL;
				pp = p;
				ph = this->GetNodeHead(pNd->point_two);
				this->DelRoute(pNd->point_one, pNd->point_two);
				continue;
			};
			return NULL;
		};
		if (ph == this->head)
		{
			p = new Link_Unit;
			if (!p) return NULL;
			p->value = ph->ID;
			pp->next = p;
			p->next = NULL;
			return this->main_Link_Head;
		};
		return NULL;
	}
	else
	{
		Link_Unit* p;
		Link_Unit* pp;
		Link_Unit* pLh;
		ET_Node* pNd;
		ET_Node_Head* ph;
		ET_Node_Head* pHh;
		p = this->main_Link_Head;
		while (p)
		{
			ph = this->GetNodeHead(p->value);
			pNd = ph->right;
			if (pNd)
			{
				pHh = ph;
				ph = this->GetNodeHead(pNd->point_one);
				break;
			};
			pNd = ph->down;
			if (pNd)
			{
				pHh = ph;
				ph = this->GetNodeHead(pNd->point_two);
				break;
			};
			p = p->next;
		};
		if (!pNd) return NULL;
		p = new Link_Unit;
		if (!p) return NULL;
		pLh = p;
		p->value = pHh->ID;
		p->next = NULL;
		pp = pLh;
		this->DelRoute(pNd->point_one, pNd->point_two);
		while (ph && ph != pHh)
		{
			pNd = ph->right;
			if (pNd)
			{
				p = new Link_Unit;
				if (!p) return NULL;
				p->value = pNd->point_two;
				pp->next = p;
				p->next = NULL;
				pp = p;
				ph = this->GetNodeHead(pNd->point_one);
				this->DelRoute(pNd->point_one, pNd->point_two);
				continue;
			};
			pNd = ph->down;
			if (pNd)
			{
				p = new Link_Unit;
				if (!p) return NULL;
				p->value = pNd->point_one;
				pp->next = p;
				p->next = NULL;
				pp = p;
				ph = this->GetNodeHead(pNd->point_two);
				this->DelRoute(pNd->point_one, pNd->point_two);
				continue;
			};
			return NULL;
		};
		if (ph == this->head)
		{
			p = new Link_Unit;
			if (!p) return NULL;
			p->value = ph->ID;
			pp->next = p;
			p->next = NULL;
			return pLh;
		};
		return NULL;
	};
};

bool ETGraph::Compose(Link_Unit* p)
{
	if (!p) return false;
	if (!(this->main_Link_Head))
	{
		this->main_Link_Head = p;
		return true;
	}
	else if (p == this->main_Link_Head)
		return true;
	else
	{
		Link_Unit* ph;
		ph = this->main_Link_Head;
		while (ph && (ph->value != p->value)) ph = ph->next;
		if (!ph) return false;
		Link_Unit* pn;
		pn = ph->next;
		Link_Unit* pd = p;
		p = p->next;
		delete pd;
		ph->next = p;
		while (p->next) p = p->next;
		p->next = pn;
		return true;
	};
};

void ETGraph::Find_ET()
{
	Link_Unit* p;
	p = this->Find_Circle();
	while (p)
	{
		this->Compose(p);
		p = this->Find_Circle();
	};
	return;
};


bool ETGraph::DelNode(int i, int j)
{
	ET_Node* p = this->GetNode(i, j);
	if (!p) return false;

	ET_Node_Head* ph = this->GetNodeHead(i);
	if (!ph) return false;
	ET_Node* pp = ph->down;
	ET_Node* pn = p->down;
	if (pp == p)
	{
		ph->down = pn;
	}
	else
	{
		while (pp && pp->down != p) pp = pp->down;
		if (!pp) return false;
		pp->down = pn;
	};

	ph = this->GetNodeHead(j);
	if (!ph) return false;
	pp = ph->right;
	pn = p->right;
	if (pp == p)
	{
		ph->right = pn;
	}
	else
	{
		while (pp && pp->right != p) pp = pp->right;
		if (!pp) return false;
		pp->right = pn;
	};

	delete p;
	return true;
};

bool ETGraph::DelRoute(int i, int j)
{
	return this->DelRoute(this->GetNode(i, j));
};

void ETGraph::DelAllNodes()
{
	ET_Node_Head* h = this->head;
	ET_Node* p;
	ET_Node* pn;
	while (h)
	{
		p = h->down;
		while (p)
		{
			pn = p->down;
			delete p;
			p = pn;
		};
		this->head = h->next;
		delete h;
		h = this->head;
	};
};

void ETGraph::DelLinks()
{
	Link_Unit* p;
	while (this->main_Link_Head)
	{
		p = this->main_Link_Head->next;
		delete this->main_Link_Head;
		this->main_Link_Head = p;
	};
};

bool ETGraph::ReadFromFile()
{
	ifstream inputFile ("Graph_data.txt", ios::in);
	if (!inputFile)
	{
		cout<<"Error in reading file :\"Graph_data.txt\"."<<endl;
		system("pause");
		return false;
	};
	try
	{
		int f = 9;
		int i;
		int j;
		int r;
		i = j = r = 0;
		inputFile>>i>>j>>r;
		if (!(this->AddNode(i, j, r))) return false;
		while(inputFile>>i>>j>>r)
			if (!(this->AddNode(i, j, r)))
				return false;
	}
	catch(...)
	{
		cout<<"Error in reading file :\"Graph_data.txt\"."<<endl;
		system("pause");
		inputFile.close();
		this->DelAllNodes();
		return false;
	};
	inputFile.close();
	return true;
};

void ETGraph::PrintToFile()
{
	ofstream outputFile ("Graph_output.txt", ios::out);
	Link_Unit* p;
	p = this->main_Link_Head;
	while (p)
	{
		cout<<p->value<<" ";
		outputFile<<p->value<<" ";
		p = p->next;
	};
};
//
//                                          //
//  Project Name: Eulerian_Trace            //
//                                          //
//  File Name: main.cpp                     //
//                                          //
//  Author: Victor Zhang                    //
//                                          //
//  ID: 21*****92                           //
//                                          //
//  Create Date: May 17. 2009               //
//                                          //
//

#include <iostream>

using namespace std;

#include "ETGraph.h"

void main()
{
	ETGraph a;
	a.ReadFromFile();
	a.Find_ET();
	a.PrintToFile();
	system("pause");
};

转载于:https://my.oschina.net/wh1tew0lf/blog/14599

weixin_34389926
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
欧拉图的构造算法
09-25
欧拉图的构造算法 欧拉图的构造 构造欧拉图算法
jupyter下载
Einstein·Jun
08-06 252
Anaconda下载 参考链接：https://blog.csdn.net/qq_48372575/article/details/125630622 设置Jupyter Notebook的代码路径 在“此电脑”中搜索。删除最后一个""后面的的内容，包括“\”。 用记事本打开它。 按下ctrl+F就可以开始查找。查找内容如下： 找到之后，右键该文件，找到“发送到”，找到“桌面快捷方式”。然后就会发现桌面上已经建立好了！
在 Python 和 C++ 环境下安装和使用 ONNX Runtime
CDBmax的博客
08-03 325
对于 GPU 版本的 ONNX Runtime，需要安装 CUDA 和 cuDNN。请检查 CUDA 执行提供程序的要求以获取兼容版本的 CUDA 和 cuDNN。通过上述步骤和示例代码，您可以在 Python 和 C++ 环境下安装并使用 ONNX Runtime 进行模型推理。《windows端可以用 vs编辑器配置相应的头文件、库文件》《这部分可以去B站有很多教学视频讲的更详细》
【面试题】寻找两个正序数组的中位数
联系方式：927632640
08-06 320
面试学习给定两个大小分别为 m 和 n 的正序数组 nums1 和 nums2，我们需要找到这两个数组的中位数。下面是详细的解题步骤和 Python 代码示例。
Java 设计模式之桥接模式（Bridge Pattern）
微笑听雨
08-05 958
桥接模式（Bridge Pattern）是一种用于将抽象部分与其实现部分分离的结构型设计模式。这种模式通过组合关系而不是继承关系来连接抽象与实现，使代码更具扩展性和维护性。桥接模式的核心思想是将抽象和实现解耦，使得两者可以独立变化。桥接模式（Bridge Pattern）是一种结构型设计模式，旨在将抽象部分与其实现部分分离，从而使两者可以独立地变化。桥接模式通过组合关系代替继承关系，将抽象和实现解耦，使代码更具扩展性和维护性。
书生大模型实战营第三期——入门岛——python基础知识
最新发布
qq_46576562的博客
08-06 165
昇思基础课程打卡（SPONGE课前学习）9.使用静态图加速
cftang9999的专栏
08-06 324
AI编译框架分为两种运行模式，分别是动态图模式以及静态图模式。MindSpore默认情况下是以动态图模式运行，但也支持手工切换为静态图模式。
PAI-DSW中对齐NoteBook和命令行的Python环境
MilkLeong的博客
08-02 736
我认为在最开始NoteBook和命令行的Python环境是一致的，只是我前面在部署LLaMA-Factory时进行了如下操作将命令行的Python环境改成了/root/anaconda3/bin/python。具体详见。
python中的三元表达式
cyj0919的博客
08-01 279
三元表达式是一种简洁的方式来根据某个条件选择两个值中的一个。它由三个部分组成：条件判断、冒号(:)、然后是两个可能的结果。
python---为某个项目使用虚拟环境
weixin_45880844的博客
08-01 710
通过在虚拟环境中开发，你可以确保你的代码在不同环境中（包括生产环境）的表现一致，因为依赖是被隔离和明确定义的。：如果你正在开发自己的Python包，并且希望在项目中使用它，你可以轻松地将包链接到虚拟环境中进行测试。：虚拟环境允许你为特定项目使用不同版本的Python解释器，即使全局环境中使用的是另一版本。：不同项目可能需要不同版本的库。：虚拟环境可以包含安全补丁或特定版本的库，而不影响全局环境中的库，这有助于减少安全风险。：在虚拟环境中，你可以安全地尝试新的包或工具，而不会影响到你主要的工作环境。
pycharm无法导入pyside2模块；“ModuleNotFoundError: No module named ‘PySide2“
yrx020307的博客
08-01 274
出现报错““ModuleNotFoundError: No module named ‘PySide2’””后，看来很多博客，都不能解决，只有这篇博客提供了思路；2）.ui转化为.py后，点击运行，报错““ModuleNotFoundError: No module named ‘PySide2’””https://blog.csdn.net/weixin_61891798/article/details/127097989。按照博客的指引，和命令行的提示，我找到了pyside2的包；
灰狼优化算法（GWO）与门控循环单元（GRU）结合的预测模型（GWO-GRU）及其Python和MATLAB实现
qq_45441438的博客
08-03 1035
这一创新性的实践强调了优化算法在深度学习中的重要性，未来的研究可以进一步探索GWO在其他深度学习模型中的应用，以及如何将多种优化算法结合以应对更为复杂的预测任务。通过不断的实验与分析，能够推动时序数据分析领域的进一步发展，开辟更广泛的应用可能性。- 在智能电网中，通过采集历史用电数据，使用GRU进行预测，GWO优化其超参数，从而准确预测未来的电力需求，辅助电网的合理调配。- 在股票市场中，利用历史价格、交易量等数据进行预测，通过GRU捕捉趋势变化，并通过GWO优化模型的参数，提高预测的准确性。
python3 pyside6图形库学习笔记及实践（三）
qq_27489877的博客
08-05 702
本系列文章为b站PySide6教程以及官方文档的学习笔记。本文内容包括菜单栏、上下文菜单、折叠菜单以及资源的加载。
python库（18）：Sympy库
u013938578的博客
08-05 368
Python SymPy是一个强大的符号计算库，用于解决数学问题、代数运算、微积分、代数方程求解和符号化处理等任务。SymPy的设计目标是提供一个开源、可扩展的符号计算工具，使数学建模和问题求解变得更加容易。本文将提供关于Python SymPy的全面指南，包括基本概念、安装和配置、符号表达式、代数运算、微积分、方程求解、矩阵操作以及实际应用场景。将通过丰富的示例代码来帮助深入理解SymPy的使用。与我们常用的数学库NumPy不同，Sympy能够处理符号表达式，而不仅仅是数值计算。
PyTorch 基础教程
longma666666的博客
08-02 395
Python深色版本37 # 定义网络层1113 # 定义前向传播过程18。
Getting error when import openai to python
suiusoar
08-06 525
将 OpenAI 的库导入到 Python 项目中时遇到错误
2023华为od机试C卷【掌握单词的个数】Python
weixin_43837522的博客
08-01 610
?
使用Python做一个微信机器人
2401_82817454的博客
08-01 3476
了解http的对这个接口参数应该不陌生，首先url为接口地址，data为请求的参数，header为请求的头，header中不能设置header 中不能设置 Referer。bindscroll EventHandle 滚动时触发，event.detail = {scrollLeft, scrollTop, scrollHeight, scrollWidth, deltaX, deltaY}当然，这种智能回复的算法和数据库我们自己肯定是没有的，所以我们借助于gewe框架的开放API接口来完成我们的功能。
python调用IP摄像头
m0_62588333的博客
08-01 178
值得注意的是，把那个source变成自己的摄像头的地址即可，把下面完整的代码拷贝运行就可以啦，快去试试吧。直接去浏览器搜索，并找到对应的下面的这个即可，也可以用我提供的这个链接去下载。二、勾选RTSP服务器，然后记下这里的局域网地址，后续会用到。三、在代码中调用即可。
数据结构之图的遍历问题分析及解决算法——欧拉路径与回路的求解思路
在“数据结构之图的遍历调研资料”中，包含了关于图的遍历问题的详细介绍，其中包括欧拉路径、哈密顿回路、中国邮递员问题、旅行推销员问题等算法思想分析。 首先，我们来看一下欧拉路径的问题。欧拉路径就是一条...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值