2020华为软挑总结——复赛方案一code

#include<iostream>
#include<fstream>
//#include<list>
#include<vector>
//#include<queue>
#include <sstream>
#include<assert.h>
#include<unordered_map>
#include<map>
#include<algorithm>
#include<string>
//#include<list>
#include<set>
#include <chrono>
#include <thread>
#include<future>
//#include<atomic>
#include<mutex>
//#include<mman.h>
//#include <sys/mman.h>


#include<sys/mman.h>
#include<sys/types.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>

using namespace std;


#define TEST
#define THREAD_NUM 4

typedef unsigned int uint;








/**/

//定义一个计时器类
class Timer
{
public:
	Timer() : beg_(clock_::now()) {}
	void reset() { beg_ = clock_::now(); }
	double elapsed() const {
		return std::chrono::duration_cast<second_>
			(clock_::now() - beg_).count();
	}
	void out(std::string message = "") {
		double t = elapsed();
		std::cout << message << " elasped time:" << t << "s\n";
		reset();
	}
private:
	typedef std::chrono::high_resolution_clock clock_;
	typedef std::chrono::duration<double, std::ratio<1> > second_;
	std::chrono::time_point<clock_> beg_;
};


//定义一个储存环的类
struct MyContainer
{
	int base[7] = { 0 };

	int rear = 0;

	void push_back(int& i)
	{
		base[rear] = i;
		++rear;

	}
	/*
		void out(ofstream& fout)
		{
			for (int i = 0; i < rear - 1; ++i)
			{
				fout << base[i] << ",";
			}
			fout << base[rear - 1];
		}


		bool operator<(MyContainer& ms2)
		{

			if (rear == ms2.rear)
			{
				for (int i = 0; i < rear; ++i)
				{
					if (base[i] == ms2.base[i])
					{
						continue;
					}
					return base[i] < ms2.base[i];
				}
			}
			else
			{
				return  rear < ms2.rear;
			}
		}*/
};

struct ArcTNode
{
	int arc;
	unsigned int money;
	bool operator<(ArcTNode& ms2)const
	{
		return arc < ms2.arc;
	}

};


struct VerTNode
{//顶点结构体
	unsigned int vex; //顶点信息
	char id_char[12];
	//list<ArcTNode> arcs; //用列表表示邻接矩阵的一行
	//int arcs[30] = { 0 }; // [0~14]的空间存放边的顶点值。
	vector<ArcTNode> arcs;
	vector<ArcTNode> arcs_reverse;

	//bool visited = false;
	//bool checked = false;
	/**************未知位置预分配空间*******************
	VerTNode()
	{

		arcs.reserve(100);
		arcs_reverse.reserve(100);
		vex = 0;
	}
	~VerTNode() {}*/

};


struct vector_3
{
	unsigned int value[3];
};

//最终答案
struct m_answer {
	char c[80] = {};
};

//
class AdjListGraph
{
public:
	vector<vector_3> tmp_arcs;
	VerTNode* vexs; //vector向量存储图所有顶点的全部信息
	int node_set_size;
	
	vector<m_answer> result[THREAD_NUM][5];
	vector<uint> result_stat[THREAD_NUM][5];
	uint answer_len[THREAD_NUM];
	
	//vector< vector< >>

	//vector<unsigned int> tmp_ms[THREAD_NUM]; //记录单个环
	vector<unsigned int> node_set;
	unordered_map<unsigned int, int> node_map;
	MyContainer tmp_ms[THREAD_NUM];
	//MyContainer tmp_ms1; //记录单个环  第一个线程使用。
	//MyContainer tmp_ms2; //记录单个环  第二个线程使用。
	//MyContainer tmp_ms3; //记录单个环  第三个线程使用。
	//unordered_set<int> blockedSet;
	//unordered_set<int> blockedSet1;
	/*
	std::mutex mu;

	void result_push_back(MyContainer& tmp_ms)
	{
		mu.lock();
		result.push_back(tmp_ms);//将单个环加入result之中
		mu.unlock();
	}*/


	void my_itoa(char* buf, unsigned int val)
	{
		unsigned int vals[10] = {};
		int len = 0;
		do
		{
			vals[len] = val % 10;
			val /= 10;
			++len;
		} while (val > 0);

		--len;
		char* p = buf;
		do
		{
			*p = vals[len] + '0';
			++p;
			--len;

		} while (len >= 0);
		*p = ',';
		++p;
		*p = '\0';
	}

	inline void ui2S(MyContainer& a, vector<m_answer>& b, vector<uint>& c, const uint& thread_index)
	{
		c.push_back(a.base[0]);
		m_answer s_temp;
		char* p1 = s_temp.c;
		char* p2 = NULL;
		for (unsigned int i = 0; i < a.rear; ++i)
		{
			p2 = vexs[a.base[i]].id_char;///
			while (*p2 != '\0')
			{
				*p1 = *p2;
				++p1;
				++p2;
			}
		}
		*p1 = '\0';
		--p1;
		*p1 = '\n';
		answer_len[thread_index] += strlen(s_temp.c);
		b.push_back(s_temp);
	}




	inline bool check(unsigned int& x, unsigned  int& y)const
	{

		return x <= 5ll * y && y <= 3ll * x;

	}
	//int ii = THREAD_NUM * (THREAD_NUM + 1);
	void FC(const int& NUM)// //主线程
	{
		//unsigned int  k = 0, k1 = 0, k2 = 0, k3 = 0, k4 = 0, k5 = 0, k6 = 0, k7 = 0;
		int pp1 = 0, pp2 = 0, pp3 = 0, pp4 = 0, pp5 = 0, pp6 = 0, pp7 = 0;
		unsigned int m1 = 0, m2 = 0, m3 = 0, m4 = 0, m5 = 0, m6 = 0, m7 = 0;
		//vector<bool> Visited(node_set_size, false);
		bool* Visited = new bool[node_set_size];
		bool* Neighborhood_3 = new bool[node_set_size];


		//int mei_fen = ;
		//金字塔形状分配各线程数据量
		//for (int i = NUM * (NUM + 1) * node_set_size / ii; i <= (NUM + 2) * (NUM + 1) * node_set_size / ii - 1; ++i)

			//平均分配
		//for (int i = NUM * node_set_size / THREAD_NUM; i <= node_set_size * (NUM + 1) / THREAD_NUM - 1; ++i)
		for (int i = NUM; i < node_set_size; i += THREAD_NUM)
		{
			//vector<bool> Neighborhood_3(node_set_size,false);
			//Neighborhood_3(node_set_size, false);
			/*******************反向寻找3邻域的点*********************/
			for (int ip = 0; ip < node_set_size; ++ip)
			{
				//if (Neighborhood_3[ip])
				{
					Neighborhood_3[ip] = false;
				}
			}
			//第一层
			//k = vexs[i].vex;
			//tmp_ms[NUM].push_back(k);
			//vexs[i].visited = true;
			//blockedSet.insert(i);
			Visited[i] = true;
			Neighborhood_3[i] = true;

			for (int j1 = 0; j1 < vexs[i].arcs_reverse.size(); ++j1)
			{
				pp1 = vexs[i].arcs_reverse[j1].arc;
				if (pp1 <= i)
				{
					continue;
				}
				//m1 = vexs[i].arcs_reverse[j1].money;
				//k1 = vexs[pp1].vex;


				第二层
				//tmp_ms[NUM].push_back(k1);
				//vexs[pp1].visited = true;
				//blockedSet.insert(pp1);
				Visited[pp1] = true;
				Neighborhood_3[pp1] = true;

				for (int j2 = 0; j2 < vexs[pp1].arcs_reverse.size(); ++j2)
				{
					pp2 = vexs[pp1].arcs_reverse[j2].arc;
					//m2 = vexs[pp1].arcs_reverse[j2].money;
					//k2 = vexs[pp2].vex;
					if (pp2 <= i)//|| !check(m2, m1)
					{
						continue;
					}
					第三层

					//tmp_ms[NUM].push_back(k2);
					//vexs[pp2].visited = true;
					//blockedSet.insert(pp2);
					Visited[pp2] = true;
					Neighborhood_3[pp2] = true;

					for (int j3 = 0; j3 < vexs[pp2].arcs_reverse.size(); ++j3)
					{
						pp3 = vexs[pp2].arcs_reverse[j3].arc;
						//m3 = vexs[pp2].arcs_reverse[j3].money;
						//k3 = vexs[pp3].vex;

						//|| !check(m3, m2)
						if (Visited[pp3] || pp3 <= i)//blockedSet.find(pp3) != blockedSet.end()
						{
							continue;
						}
						//Visited[pp3] = true;
						Neighborhood_3[pp3] = true;

					}
					//Visited[pp3] = false;


					//tmp_ms[NUM].rear -= 1;//第三层
					//vexs[pp2].visited = false;
					//blockedSet.erase(pp2);
					Visited[pp2] = false;

				}
				//tmp_ms[NUM].rear -= 1;//第二层
				//vexs[pp1].visited = false;
				//blockedSet.erase(pp1);
				Visited[pp1] = false;
			}
			//tmp_ms[NUM].rear -= 1;//第一层
			//vexs[i].visited = false;
			//blockedSet.erase(i);
			Visited[i] = false;






			/*******************正向循环找环*********************/
			//第一层
			//k = vexs[i].vex;
			tmp_ms[NUM].push_back(i);
			//vexs[i].visited = true;
			//blockedSet.insert(i);
			Visited[i] = true;
			for (int j1 = 0; j1 < vexs[i].arcs.size(); ++j1)
			{
				pp1 = vexs[i].arcs[j1].arc;
				if (pp1 <= i)
				{
					continue;
				}
				m1 = vexs[i].arcs[j1].money;
				//k1 = vexs[pp1].vex;

				第二层
				tmp_ms[NUM].push_back(pp1);
				//vexs[pp1].visited = true;
				//blockedSet.insert(pp1);
				Visited[pp1] = true;
				for (int j2 = 0; j2 < vexs[pp1].arcs.size(); ++j2)
				{
					pp2 = vexs[pp1].arcs[j2].arc;
					if (pp2 <= i)
					{
						continue;
					}
					m2 = vexs[pp1].arcs[j2].money;
					//k2 = vexs[pp2].vex;
					if (!check(m1, m2))
					{
						continue;
					}
					第三层

					tmp_ms[NUM].push_back(pp2);
					//vexs[pp2].visited = true;
					//blockedSet.insert(pp2);
					Visited[pp2] = true;
					for (int j3 = 0; j3 < vexs[pp2].arcs.size(); ++j3)
					{
						pp3 = vexs[pp2].arcs[j3].arc;
						if (pp3 < i)
						{
							continue;
						}
						m3 = vexs[pp2].arcs[j3].money;
						//k3 = vexs[pp3].vex;

						if (pp3 == i)
						{
							if (!check(m2, m3))
							{
								continue;
							}
							if (!check(m3, m1))
							{
								continue;
							}
							//result[0][NUM].push_back(tmp_ms[NUM]);//将单个环加入result之中
							//result_push_back(tmp_ms);
							ui2S(tmp_ms[NUM], result[NUM][0], result_stat[NUM][0], NUM);

							continue;
						}
						if (Visited[pp3])//blockedSet.find(pp3) != blockedSet.end()
						{
							continue;
						}
						if (!check(m2, m3))
						{
							continue;
						}

						第四层
						tmp_ms[NUM].push_back(pp3);
						//vexs[pp3].visited = true;
						//blockedSet.insert(pp3);
						Visited[pp3] = true;
						for (int j4 = 0; j4 < vexs[pp3].arcs.size(); ++j4)
						{
							pp4 = vexs[pp3].arcs[j4].arc;
							if (pp4 < i || !Neighborhood_3[pp4])
							{
								continue;
							}
							m4 = vexs[pp3].arcs[j4].money;
							//k4 = vexs[pp4].vex;

							if (pp4 == i)
							{
								if (!check(m3, m4))
								{
									continue;
								}
								if (!check(m4, m1))
								{
									continue;
								}

								//result[1][NUM].push_back(tmp_ms[NUM]);//将单个环加入result之中
								//result_push_back(tmp_ms);
								ui2S(tmp_ms[NUM], result[NUM][1], result_stat[NUM][1], NUM);

								continue;
							}
							if (Visited[pp4])
							{
								continue;
							}
							if (!check(m3, m4))
							{
								continue;
							}
							/**/
							第五层
							tmp_ms[NUM].push_back(pp4);
							//vexs[pp4].visited = true;
							//blockedSet.insert(pp4);
							Visited[pp4] = true;
							for (int j5 = 0; j5 < vexs[pp4].arcs.size(); ++j5)
							{
								pp5 = vexs[pp4].arcs[j5].arc;
								if (pp5 < i || !Neighborhood_3[pp5])
								{
									continue;
								}
								m5 = vexs[pp4].arcs[j5].money;
								//k5 = vexs[pp5].vex;

								if (pp5 == i)
								{
									if (!check(m4, m5))
									{
										continue;
									}
									if (!check(m5, m1))
									{
										continue;
									}

									//result[2][NUM].push_back(tmp_ms[NUM]);//将单个环加入result之中
									//result_push_back(tmp_ms);
									ui2S(tmp_ms[NUM], result[NUM][2], result_stat[NUM][2], NUM);
									continue;
								}
								if (Visited[pp5])
								{
									continue;
								}
								if (!check(m4, m5))
								{
									continue;
								}
								第六层
								tmp_ms[NUM].push_back(pp5);
								//vexs[pp5].visited = true;
								//blockedSet.insert(pp5);
								Visited[pp5] = true;
								for (int j6 = 0; j6 < vexs[pp5].arcs.size(); ++j6)
								{
									pp6 = vexs[pp5].arcs[j6].arc;
									if (pp6 < i || !Neighborhood_3[pp6])
									{
										continue;
									}
									m6 = vexs[pp5].arcs[j6].money;
									//k6 = vexs[pp6].vex;


									if (pp6 == i)
									{
										if (!check(m5, m6))
										{
											continue;
										}
										if (!check(m6, m1))
										{
											continue;
										}

										//result[3][NUM].push_back(tmp_ms[NUM]);//将单个环加入result之中
										//result_push_back(tmp_ms);
										ui2S(tmp_ms[NUM], result[NUM][3], result_stat[NUM][3], NUM);

										continue;
									}
									if (Visited[pp6])
									{
										continue;
									}
									if (!check(m5, m6))
									{
										continue;
									}
									第七层
									tmp_ms[NUM].push_back(pp6);
									//vexs[pp6].visited = true;
									//blockedSet.insert(pp6);
									Visited[pp6] = true;
									for (int j7 = 0; j7 < vexs[pp6].arcs.size(); ++j7)
									{
										pp7 = vexs[pp6].arcs[j7].arc;
										if (pp7 < i || !Neighborhood_3[pp7])
										{
											continue;
										}
										m7 = vexs[pp6].arcs[j7].money;
										//k7 = vexs[pp7].vex;


										if (pp7 == i)
										{
											if (!check(m6, m7))
											{
												continue;
											}
											if (!check(m7, m1))
											{
												continue;
											}

											//result[4][NUM].push_back(tmp_ms[NUM]);//将单个环加入result之中
											//result_push_back(tmp_ms);
											ui2S(tmp_ms[NUM], result[NUM][4], result_stat[NUM][4], NUM);

											continue;
										}
										/*if (Visited[pp7] )
										{
											continue;
										}
										if (!check(m6, m7))
										{
											continue;
										}*/
										第八层
										//tmp_vec.push_back(j);
										//vexs[j].visited = true;


									}
									//tmp_ms[NUM].pop_back();
									tmp_ms[NUM].rear -= 1;//第七层
									//vexs[pp6].visited = false;
									//blockedSet.erase(pp6);
									Visited[pp6] = false;

								}
								//tmp_ms[NUM].pop_back();
								tmp_ms[NUM].rear -= 1;//第六层
								//vexs[pp5].visited = false;
								//blockedSet.erase(pp5);
								Visited[pp5] = false;


							}
							//tmp_ms[NUM].pop_back();
							tmp_ms[NUM].rear -= 1;//第五层
							//vexs[pp4].visited = false;
							//blockedSet.erase(pp4);
							Visited[pp4] = false;

						}
						//tmp_ms[NUM].pop_back();
						tmp_ms[NUM].rear -= 1;//第四层
						//vexs[pp3].visited = false;
						//blockedSet.erase(pp3);
						Visited[pp3] = false;

					}
					//tmp_ms[NUM].pop_back();
					tmp_ms[NUM].rear -= 1;//第三层
					//vexs[pp2].visited = false;
					//blockedSet.erase(pp2);
					Visited[pp2] = false;

				}
				//tmp_ms[NUM].pop_back();
				tmp_ms[NUM].rear -= 1;//第二层
				//vexs[pp1].visited = false;
				//blockedSet.erase(pp1);
				Visited[pp1] = false;
			}
			//tmp_ms[NUM].pop_back();
			tmp_ms[NUM].rear -= 1;//第一层
			//vexs[i].visited = false;
			//blockedSet.erase(i);
			Visited[i] = false;
		}

		delete[] Visited;
		delete[] Neighborhood_3;
	}
	/*
		void FindCycle()
		{
			for (size_t i = 0; i < THREAD_NUM; i++)
			{
				FC(i);
			}
		}
	*/
	AdjListGraph()
	{
		/******************预分配空间******************
		size_t i;
		tmp_arcs.reserve(2000000);
		for (size_t i = 0; i < 2000000; ++i)
		{
			tmp_arcs[i].resize(3);
		}


		for (i = 0; i < 5; ++i)
		{

			for (size_t j = 0; j < THREAD_NUM; ++j)
			{
				result[i][j].reserve(200000);
			}

		}*/

		/******************未知的位置不预分配空间************************/
		for (size_t i = 0; i < THREAD_NUM; i++)
		{
			answer_len[i] = 0;
		}

	}
	~AdjListGraph()
	{
		delete[]vexs;
	}

	//建图
	void CreateFromFile(string& FileName)
	{//由数据文件FileName创建图

		

		//size_t i;

		//打开文件，fd为文件描述符
		int fd = open(FileName.c_str(), O_RDONLY);
		//cout << "fd   " << fd << endl;

		//文件长度
		int len = lseek(fd, 0, SEEK_END);
		//cout << "len   " << len << endl;

		//文件映射
		char* data = (char*)mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);

		//关闭文件，若放在此处不行就放在文件末尾munmap函数之前
		close(fd);

		auto p_end = data;
		//unsigned int num_s[3];//用来存放数据

		vector_3 value;

		tmp_arcs.reserve(2000000);
		node_set.reserve(4000000);

		while (*p_end != '\0')
		{
			for (short int i = 0; i < 3; ++i)
			{
				value.value[i] = strtoul(p_end, &p_end, 10);//将char数组转换为unsigned int类型，保存在数组num_s中
				++p_end;
				if (i < 2)
				{
					//node_set.insert(tmp_arcs[tmp_arcs_size][i]);
					//node_set[node_set_size++] = tmp_arcs.data_line[tmp_arcs_size][i];
					//node_set.insert(value.value[i]);
					node_set.push_back(value.value[i]);
				}
			}
			//tmp_arcs_size += 1;

			tmp_arcs.push_back(value);
		}
		// 解除映射，释放空间
		munmap(data, len);

		sort(node_set.begin(), node_set.end());
		node_set.erase(unique(node_set.begin(), node_set.end()), node_set.end());


		node_set_size = node_set.size();
		//vexs.resize(node_set_size);

		vexs = new VerTNode[node_set_size];

		//auto temp_iter = node_set.begin();

		size_t i;
		for (i = 0; i < node_set_size; ++i)
		{
			/*vexs[i].vex = *temp_iter;
			node_map[*temp_iter] = i;
			++temp_iter;*/

			vexs[i].vex = node_set[i];
			//转换为字符串存在
			my_itoa(vexs[i].id_char, node_set[i]);

			node_map[node_set[i]] = i;
			
		}


		int j, k;
		ArcTNode aa;
		for (i = 0; i < tmp_arcs.size(); ++i)
		{

			k = node_map[tmp_arcs[i].value[0]];
			j = node_map[tmp_arcs[i].value[1]];
			aa.money = tmp_arcs[i].value[2];


			//正向
			aa.arc = j;
			vexs[k].arcs.push_back(aa);

			//反向
			aa.arc = k;
			vexs[j].arcs_reverse.push_back(aa);
		}

		for (i = 0; i < node_set_size; i++)
		{
			sort(vexs[i].arcs.begin(), vexs[i].arcs.end());
		}

	}


	//输出结果
	void PrintResult(string& outFileName)
		/*********************写入文件+交替写入+mmap写+***********************/
		//void PrintResult_mmap_X(string& FileName)
	{



		//3、输出
		uint size[5] = { 0,0,0,0,0 };
		uint total_size = 0;
		for (uint i = 0; i < THREAD_NUM; ++i)
		{
			for (uint j = 0; j < 5; ++j)
			{
				size[j] += result[i][j].size();
				total_size += result[i][j].size();
				//cout << result[j][i].size() << "\t";
			}
			//cout << "\n";
		}



#ifdef TEST
		/**/
		cout << "Cycle Total  " << total_size << "\n";
		/**/
		for (int j = 0; j < THREAD_NUM; ++j)
		{
			for (int i = 0; i < 5; ++i)
			{
				cout << result[i][j].size() << "\t";
			}
			cout << "\n";
		}
#endif // TEST
		//cout << "result size:" << total_size << endl;

		//Timer time2;
		//5、进行输出

		string total_size_s = to_string(total_size) + "\n";
		int len = total_size_s.size() + 1;
		for (int i = 0; i < THREAD_NUM; ++i)
		{
			len += answer_len[i];
		}

		// 打开文件
		int fd = open(outFileName.c_str(), O_RDWR | O_CREAT, 0666);
		//先给文件申请一个大小，写入一个字符进行保证
		lseek(fd, len - 1, 0);


		//cout << len << endl;



		write(fd, "h", 1);//可能就是这个文件搞的鬼
		// 使用mmap函数建立内存映射
		char* addr = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

		// 内存映射建立好了，此时可以关闭文件了
		close(fd);
		auto iter = addr;


		memcpy(addr, total_size_s.c_str(), total_size_s.size());
		addr += total_size_s.size();

		//交替进行输出
		uint t[THREAD_NUM];
		uint process_id = 0;
		for (uint i = 0; i < 5; ++i)
		{
			for (uint j = 0; j < THREAD_NUM; ++j)
				t[j] = 0;

			process_id = 0;
			while (size[i])
			{
				for (uint j = 0; j < THREAD_NUM; ++j)
				{
					while (t[j] < result_stat[j][i].size() && result_stat[j][i][t[j]] == process_id)
					{

						memcpy(addr, result[j][i][t[j]].c, strlen(result[j][i][t[j]].c));
						addr += strlen(result[j][i][t[j]].c);

						++t[j];
						--size[i];
					}
					++process_id;

				}
			}
		}
		memcpy(addr, "\n", 1);
		munmap(iter, len);
	}
};


int main()
{
	
#ifdef TEST
	Timer timer;
	Timer timer1;
#endif // TEST

	AdjListGraph g;
	

#ifdef TEST
	//定义输入文件路径
	//定义输入文件路径
	//string s = "test_data28W.txt";//697518
	//string s = "test_data.txt";//43
	//string s = "test_data1.txt";//9153
	//string s = "test_data2.txt";//1004812
	//string s = "minidata.txt"; //3
	string s = "test_data_196.txt";//19630345
	//定义输出文件路径
	string outFileName = "result.txt";
	g.CreateFromFile(s);
#endif // TEST
#ifndef TEST
	/******************比赛用的输入文件******************/
	string s = "//data//test_data.txt";//文件地址//data//test_data.txt /***************************/
	g.CreateFromFile(s);//建邻接表结构图  //Total elasped time:0.166665s
	/*******************比赛用的输出文件**********************/
	string outFileName = "//projects//student//result.txt";projects//student//************************/

#endif // !TEST

#ifdef TEST
	timer1.out("CreateGraph");
	Timer timer2;
#endif // TEST


	多线程找环
#if THREAD_NUM==1
	g.FC(THREAD_NUM - 1);
#endif // THREAD_NUM==1
#if THREAD_NUM!=1
	size_t i;
	std::future <void> m[THREAD_NUM - 1];
	//std::thread t[THREAD_NUM - 1];
	for (i = 0; i < THREAD_NUM - 1; ++i)
	{
		//t[i] = std::thread(&AdjListGraph::FC, &g, i);
		m[i] = std::async(&AdjListGraph::FC, &g, i);
	}
	g.FC(THREAD_NUM - 1);
	for (i = 0; i < THREAD_NUM - 1; ++i)
	{
		m[i].wait();
		//t[i].join();
	}
#endif // THREAD_NUM!=1


#ifdef TEST
	timer2.out("FindCycle");
	Timer timer3;
#endif // TEST

	
	g.PrintResult(outFileName);//输出结果
	

#ifdef TEST
	timer3.out("SaveFile");
	timer.out("Total");
#endif // TEST


	return 0;

}