├── README.md
└── main.cpp


/README.md:
--------------------------------------------------------------------------------
 1 | ## 前言  
 2 | + **团队名**：景  
 3 | + **成绩**：粤港澳复赛A榜第2，全国第12  
 4 | + **分工**:  
 5 | （1）[KITE-HZ](https://github.com/KITE-HZ "黄老哥")作为队长承担了大部分的编程工作和优化工作；  
 6 | （2）[Buerzhu](https://github.com/Buerzhu/ "Buerzhu")承担了多线程的优化工作以及部分编程和算法的优化工作;  
 7 | （3）[cxyanhk](https://github.com/cxyanhk "严老哥")承担了部分IO优化工作和部分算法优化工作；
 8 | 
 9 |   
10 | ##   优化  
11 | + **找环算法优化**  
12 | （1）基础是4+3，即在开始找环之前，先构建一个P3来存储路径倒数三个节点的信息；  
13 | （2）在构建P3的时候顺便用反向邻接表构建P1,P1找环比遍历子节点来寻找是否有头结点的找环方式更加高效；  
14 | （3）对路径中的第2、3、4、5使用P3来找环，可以同时减少路径上第4、5、6、7节点通过P1找环的工作；  
15 | （4）在反向遍历3层构建P3的过程中顺便统计有哪些点与起点的距离小于等于3，并利用这一点在正向遍历过程中剪枝，具体例子如下：  
16 | ```cpp
17 | //对于第五层的点，如果该点距离起点的距离大于3，则该点无环
18 | if(target.nodeLen[m]!=3 || G[l_it].first <= head || ccm*left<ccL || ccm>right*ccL)
19 |       continue;
20 | ```  
21 |   
22 | + **数据结构优化**  
23 | （1）使用数组来代替vector，减少扩容开销；  
24 | （2）类似的，使用一维和二维数组来存储邻接表和P3等信息，即尽量减少STL容器的使用；  
25 | （3）在节点去重工作的排序过程`sort(temp,temp+sumID)`中，由于temp中重复的节点过多，会大大增加排序时间，因此使用一个`bool idUnique[MAX_ID]`数组来存储那些已经在temp内的节点，从而避免重复存储。通过多次提交证明，大部分节点id大小在1亿以下；  
26 | （4）类似的，对小于1亿的节点使用数组进行hash映射，也可以减少部分映射时间；  
27 | （5）对前向邻接表排序后再构建后向邻接表，从而使得后向邻接表有序，减少部分排序工作；  
28 | （6）为了节省空间和寻址时间，在满足功能的情况下尽量使用较小的数据结构，例如，使用uint8_t来存储每个节点对应的字符串长度；
29 |   
30 | + **多线程优化**  
31 | （1）使用抢占式负载均衡方式进行多线程找环，一次任务分块的节点数为100；  
32 | （2）采用atomic_flag来构造自旋锁，可以避免互斥锁的系统调用的开销；    
33 | （3）通过多次提交证明，6线程工作效果较佳；  
34 |    
35 | + **其他优化**  
36 | （1）尽量使用局部变量；  
37 | （2）使用memcpy来代替部分赋值工作；  
38 | （3）使用循环展开；  
39 | （4）利用计算机系统的空间局部性合理设计数据结构；  
40 | （5）读取txt使用mmap;  
41 | （6）写入使用fwrite;  
42 | （7）在if判断中注意判断条件的顺序；  
43 | （8）将dfs递归改为迭代，减少函数调用的开销；  
44 | （9）用查表方式来代替部分判断
45 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
  1 | //#include<bits/stdc++.h>
  2 | #include<iostream>
  3 | #include<time.h>
  4 | #include<string>
  5 | #include<string.h>
  6 | #include<algorithm>
  7 | #include<vector>
  8 | #include<unordered_map>
  9 | #include<utility>
 10 | #include<atomic>
 11 | #include <sys/time.h>
 12 | #include <unistd.h>
 13 | 
 14 | #include <sys/stat.h>
 15 | #include <fcntl.h>
 16 | #include <stdio.h>
 17 | #include <stdlib.h>
 18 | #include <sys/mman.h>
 19 | #include <pthread.h>
 20 | 
 21 | using namespace std;
 22 | #define INF 0x7fffffff
 23 | #define MAX_ID 300000000 //id阈值，在映射过程中小于该阈值的id使用数组映射，大于该id的使用unorder_map映射
 24 | #define MAX_G 201326592 //1.5G，用一个一维数组G来存储所有节点的子节点信息，预先分配1.5G空间;用一个一维数组GR来存储所有节点的父节点信息，预先分配1.5G空间
 25 | #define MAX_EDGE 2000001 //设置最大边数为200w
 26 | #define MAXN 2000001 //设置最大节点数为200w
 27 | #define MAX_LEN 7
 28 | #define MIN_LEN 3
 29 | 
 30 | #define ansLen3 33*4000000 //level3,为每个线程中长度为3的环预先分配的空间，单位为字节
 31 | #define ansLen4 44*4000000 //level4，为每个线程中长度为4的环预先分配的空间，单位为字节
 32 | #define ansLen5 55*4000000 //level5，为每个线程中长度为5的环预先分配的空间，单位为字节
 33 | #define ansLen6 66*4000000 //level6，为每个线程中长度为6的环预先分配的空间，单位为字节
 34 | #define ansLen7 77*4000000 //level7，为每个线程中长度为7的环预先分配的空间，单位为字节
 35 | 
 36 | #define likely(x) __builtin_expect(!!(x), 1) 
 37 | #define unlikely(x) __builtin_expect(!!(x), 0)
 38 | 
 39 | #define THREAD_NUM 6//线程池线程数
 40 | #define BLOCKS 100//线程单次任务竞争和处理的id数目
 41 | //#define PRINT
 42 | 
 43 | 
 44 | pair<int,int> G[MAX_G]; //存储每个节点的出度子节点和转账值
 45 | pair<int,int> GR[MAX_G]; //存储每个节点的入度父节点和转账值
 46 | 
 47 | char idComma[MAXN][15]; //存储节点id的字符串形式，后跟逗号字符
 48 | char idLF[MAXN][15]; //存储节点id的字符串形式，后跟换行字符
 49 | char idCharLen[MAXN]; //存储每个节点转换为字符串之后的字符串长度
 50 | char* addrOffset[MAX_LEN-MIN_LEN+1][MAXN]; //每个节点环存储的内存偏移地址，第一维表示环长度（长度为3的环对应索引为0），第二维表示映射后的节点id（映射后的节点id从1开始）
 51 | char* addrStart[MAX_LEN-MIN_LEN+1][MAXN]; //每个节点环存储的内存起始地址，第一维表示环长度（长度为3的环对应索引为0），第二维表示映射后的节点id（映射后的节点id从1开始）
 52 | 
 53 | int GInd[MAXN][2];  //每个节点在pair<int,int> G[MAX_G]存储的出度子节点的占用的空间的地址，[0]表示占用空间的首地址，[1]表示占用空间的尾地址
 54 | int GRInd[MAXN][2];  //每个节点在pair<int,int> GR[MAX_G]存储的入度父节点的占用的空间的地址，[0]表示占用空间的首地址，[1]表示占用空间的尾地址
 55 | int idInDeg[MAXN];//每个节点的入度数
 56 | int idOutDeg[MAXN];//每个节点的出度数
 57 | int nodePairs[MAX_EDGE*3];  //存储的是未映射的id信息和转账信息，即从test_data.txt读取的每一行的信息
 58 | int temp[MAX_EDGE*2]; //用于存储nodePairs的id信息
 59 | bool idUnique[MAX_ID]; //标志位，标志某id之前是否被访问过
 60 | int idMapArr[MAX_ID]; //hash数组，用该数组来对小于MAX_ID的id进行id映射，大于MAX_ID的使用unordered_map进行映射
 61 | 
 62 | int minMoney=1000;
 63 | int blockSize; //所有节点划分后的任务块数
 64 | int edgeNum; //边数
 65 | int nodeNum; //节点数
 66 | int idFreeStart=1;//当前未分配到线程处理的id的最小节点
 67 | 
 68 | std::atomic_flag flag(ATOMIC_FLAG_INIT);//原子变量初始化，利用该变量的原子性来制造自旋锁
 69 | 
 70 | struct timeval startTime;
 71 | struct timeval endTime;
 72 | 
 73 | 
 74 | struct P3
 75 | {   //P3结构体
 76 |     int id[2]; //id信息
 77 |     int cc[2]; //转账信息
 78 | };
 79 | 
 80 | //线程初始化
 81 | struct Thread
 82 | {
 83 |     pthread_t tid;
 84 | 
 85 | 	//存储对应长度的环
 86 |     char ans3[ansLen3];
 87 |     char ans4[ansLen4];
 88 |     char ans5[ansLen5];
 89 |     char ans6[ansLen6];
 90 |     char ans7[ansLen7];
 91 | 
 92 |     int8_t nodeLen[MAXN];
 93 | 
 94 |     int pMapLen[MAXN];//P1
 95 |     int pMapMoney[MAXN];//存路径的第一个money
 96 | 
 97 |     P3 pMap3[15000][200];
 98 |     int pMap3Len[MAXN][3];//pMap3Len[i][0]存i的对应起点，pMap3Len[i][1]存k的个数,pMap3Len[i][2]存i在pMap的位置
 99 |     int iP3[MAXN];
100 |     int resCnt;
101 | 
102 | };
103 | 
104 | 
105 | void setTime() {
106 |     gettimeofday(&startTime, NULL);
107 | }
108 | 
109 | int getTime() {
110 |     gettimeofday(&endTime, NULL);
111 |     return int(1000 * (endTime.tv_sec - startTime.tv_sec) + (endTime.tv_usec - startTime.tv_usec) / 1000);
112 | }
113 | 
114 | //读取test_data.txt的每一行信息并存储到nodePairs中
115 | void readTxtMmap(string& inputFile){
116 |     int fd = open(inputFile.c_str(), O_RDONLY);
117 |     struct stat sb;
118 |     fstat(fd, &sb);
119 |     char *buffer = (char *)mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
120 |     if(buffer==nullptr || buffer==(void*)-1){
121 |       close(fd);
122 |       exit(-1);
123 |     }
124 |     close(fd);
125 | 
126 |     int val=0;
127 |     edgeNum=0;
128 |     bool flag=true;
129 |     while(*buffer)
130 |     {
131 |         if(*buffer<'0') // || *buffer>'9'
132 |         {
133 |             if(flag)
134 |             {
135 | 
136 |                 nodePairs[edgeNum]=val;
137 |                 ++edgeNum;
138 |                 val=0;
139 |                 flag=false;
140 |             }
141 |         }
142 |         else
143 |         {
144 |             val = val*10 + (*buffer - '0');
145 |             //val = (val<<3) + (val<<1) + (*buffer - '0');
146 |             flag=true;
147 |         }
148 |         *buffer++;
149 |     }
150 |     munmap(buffer, sb.st_size);
151 | }
152 | 
153 | 
154 | Thread* threadPool;
155 | 
156 | void buildGraph(string &inputFile){
157 | 
158 |     setTime();
159 |     readTxtMmap(inputFile);
160 |     threadPool=new Thread[THREAD_NUM];
161 | 
162 |     int sumID=0;
163 | 	//这一步操作是为了减少temp中的重复id数，从而减少sort排序的时间
164 |     for(int i=0,j=0;i<edgeNum;i+=3)
165 |     {
166 |         if(nodePairs[i]<MAX_ID){ 
167 |             if(idUnique[nodePairs[i]]==false){
168 |                 temp[j]=nodePairs[i];
169 |                 ++j;
170 |                 idUnique[nodePairs[i]]=true;
171 |                 ++sumID;
172 |             }
173 |         }else{
174 |             temp[j]=nodePairs[i];
175 |             ++j;
176 |             ++sumID;
177 |         }
178 | 
179 |         if(nodePairs[i+1]<MAX_ID){ //如果id大于MAX_ID，则使用数组映射
180 |             if(idUnique[nodePairs[i+1]]==false){
181 |                 temp[j]=nodePairs[i+1];
182 |                 ++j;
183 |                 idUnique[nodePairs[i+1]]=true;
184 |                 ++sumID;
185 |             }
186 |         }else{
187 |             temp[j]=nodePairs[i+1];
188 |             ++j;
189 |             ++sumID;
190 |         }
191 |     }
192 |     sort(temp,temp+sumID);
193 | 
194 | 
195 |     //获取非重复id节点
196 |     for(int i=0;i<sumID;++i)
197 |     {
198 |         if(temp[i]!=temp[nodeNum]){
199 |             ++nodeNum;
200 |             temp[nodeNum]=temp[i];
201 |         }
202 |     }
203 |     ++nodeNum;
204 | 
205 | 
206 |     
207 |     unordered_map<int,int> idMap;
208 |     char str[]="0123456789";
209 |     int num,k;
210 | 	//进行id映射并把id转换为字符串形式，方便后面环的存储
211 |     for(int i=0;i<nodeNum;i++)
212 |     {
213 |         if(temp[i]<MAX_ID){
214 |             idMapArr[temp[i]]=i+1;
215 |         }else{
216 |             idMap[temp[i]]=i+1;
217 |         }
218 |         num=temp[i];
219 |         k=0;
220 |         while(num>=0)
221 |         {
222 |             if(num<10)
223 |             {
224 |                 idComma[i+1][k++]=str[num];
225 |                 idComma[i+1][k++]=',';
226 |                 idComma[i+1][k]='\0';
227 |                 break;
228 |             }
229 |             idComma[i+1][k++]=str[num%10];
230 |             num/=10;
231 |         }
232 |         for(int j=0;j<=(k-2)/2;++j)
233 |         {
234 |             swap(idComma[i+1][j],idComma[i+1][k-2-j]);
235 |         }
236 |         idCharLen[i+1]=k;
237 |     }
238 |     for(int i=1;i<=nodeNum;++i)
239 |     {
240 |         memcpy(idLF[i],idComma[i],idCharLen[i]);
241 |         idLF[i][idCharLen[i]-1]='\n';
242 |     }
243 | 
244 | 	//nodePairs存储映射后的节点id信息
245 |     for(int i=0;i<edgeNum;i+=3)
246 |     {
247 |         nodePairs[i]=nodePairs[i]<MAX_ID?idMapArr[nodePairs[i]]:idMap[nodePairs[i]];
248 |         nodePairs[i+1]=nodePairs[i+1]<MAX_ID?idMapArr[nodePairs[i+1]]:idMap[nodePairs[i+1]];
249 |     }
250 | 
251 |     int u,v,c;
252 | 	//统计入度和出度信息
253 |     for(int i=0;i<edgeNum;i+=3)
254 |     {
255 |         u=nodePairs[i];
256 |         v=nodePairs[i+1];
257 |         ++GRInd[v][1];
258 |         ++GInd[u][1];
259 |     }
260 | 	//记录每个节点的父节点和子节点在GR和G中对应的位置信息
261 |     for(int i=2;i<=nodeNum;++i)
262 |     {
263 |         GRInd[i][0]=GRInd[i-1][1];
264 |         GRInd[i][1]+=GRInd[i-1][1];
265 | 
266 |         GInd[i][0]=GInd[i-1][1];
267 |         GInd[i][1]+=GInd[i-1][1];
268 |     }
269 | 
270 |     pair<int,int> tmpPair;
271 | 	//在G中存储每个节点的子节点信息
272 |     for(int i=0;i<edgeNum;i+=3)
273 |     {
274 |         u=nodePairs[i];
275 |         v=nodePairs[i+1];
276 |         c=nodePairs[i+2];
277 |         tmpPair=make_pair(v,c);
278 |         memcpy(G+GInd[u][0]+idOutDeg[u],&tmpPair,8);
279 |         ++idOutDeg[u];  //保存节点的出度数
280 |     }
281 | 
282 | #ifdef PRINT
283 |     printf("EdgeNum: %d\n",edgeNum/3);
284 |     printf("NodeNum: %d\n",nodeNum);
285 |     printf("AveDegs: %lf\n",double(edgeNum)/nodeNum/3.0);
286 |     cout<<"Build graph time: "<<getTime()<<endl;
287 | #endif
288 | 
289 | }
290 | 
291 | 
292 | void rmNode(){
293 |     setTime();
294 | 	//对每个节点的子节点根据id大小进行排序
295 |     for(int i=1;i<=nodeNum;++i){
296 |         if(idOutDeg[i]>1){
297 |             sort(G+GInd[i][0],G+GInd[i][1]);
298 |         }
299 |     }
300 | 
301 |     int u,v,c;
302 | 	//在GR中存储每个节点的父节点信息
303 |     for(int i=1;i<=nodeNum;++i){
304 |         for(int j=GInd[i][0];j<GInd[i][1];++j){
305 |             u=i;
306 |             v=G[j].first;
307 |             c=G[j].second;
308 |             GR[GRInd[v][0]+idInDeg[v]]=make_pair(u,c);
309 |             ++idInDeg[v];
310 |         }
311 |     }
312 | #ifdef PRINT
313 |     cout<<"Topo sort time: "<<getTime()<<endl;
314 | #endif
315 | }
316 | 
317 | 
318 | 
319 | static bool cmp(P3 a,P3 b);
320 | //找环并存环
321 | void doDFS(int index)
322 | {
323 |     setTime();
324 |     Thread& target=threadPool[index];
325 | 
326 |     int head,i,j,k,l,m,i_it,j_it,k_it,l_it,m_it,ii,iii,z;
327 |     int k0,k1,k2,k3,kk0,kk1,kk2,kk3,plen;
328 |     int idInDeghead,idInDegkk3,idInDegkk2,idInDegkk1,idOutDegi,idOutDegj,idOutDegk,idOutDegl,pMap3Lenmm;
329 |     int cc1,cc2,cc3,ccj,cck,ccL,ccm,ccFirst,ccLast,minccj,maxccj;
330 |     int pAddr;
331 |     int pInd,pInd2;
332 |     int path0,path1,path2,path3,path4,path5,path6;
333 |     bool vis[MAXN];  //节点是否被访问
334 | 
335 |     int localResCnt=0,iP3Len=0;
336 |     int idStart,idEnd;
337 |     int64_t left=5,right=3;
338 |     int64_t ccjLeft,ccjRight;
339 | 
340 |     char *addrOffset0=target.ans3,*addrOffset1=target.ans4,*addrOffset2=target.ans5,*addrOffset3=target.ans6,*addrOffset4=target.ans7;
341 |     char *addrBlock0,*addrBlock1,*addrBlock2,*addrBlock3,*addrBlock4;
342 | 
343 |     if(THREAD_NUM==1){
344 |         blockSize=nodeNum;
345 |     }else{
346 |         blockSize=BLOCKS;
347 |     }
348 | 
349 | 	//线程开始任务竞争，获取本次任务处理的id
350 |     while(flag.test_and_set());//在这里加锁
351 |     idStart=idFreeStart;
352 |     idFreeStart+=blockSize;//idFreeStart只能在加锁后访问
353 |     idEnd=idFreeStart;
354 |     flag.clear();//解锁
355 | 
356 | 	//初始化各种长度环的存储地址
357 |     addrBlock0=addrOffset0;
358 |     addrBlock1=addrOffset1;
359 |     addrBlock2=addrOffset2;
360 |     addrBlock3=addrOffset3;
361 |     addrBlock4=addrOffset4;
362 | 
363 |     for(int mm=0;mm<nodeNum;++mm)
364 |     {
365 | 		//如果当前任务块的id均处理完毕
366 |         if(idStart==idEnd){
367 |             //记录每块的起点地址
368 |             addrBlock0=addrOffset0;
369 |             addrBlock1=addrOffset1;
370 |             addrBlock2=addrOffset2;
371 |             addrBlock3=addrOffset3;
372 |             addrBlock4=addrOffset4;
373 | 
374 | 			//开始新一轮任务竞争
375 |             while(flag.test_and_set());//在这里加锁
376 |             idStart=idFreeStart;
377 |             idFreeStart+=blockSize;//idFreeStart只能在加锁后访问
378 |             idEnd=idFreeStart;
379 |             flag.clear();//解锁
380 |         }
381 | 
382 |         i=idStart;
383 |         if(i>nodeNum)
384 |             break;
385 | 
386 |         if(idOutDeg[i]>0)
387 |         {
388 |             head=i;
389 | 
390 |             for(int i_it=0;i_it<iP3Len;++i_it)
391 |             {
392 |                 target.nodeLen[target.iP3[i_it]]=0;//重置长度为4
393 |             }
394 | 
395 |             iP3Len=0;
396 |             idInDeghead=GRInd[head][1];
397 |             for(k3=GRInd[head][0];k3<idInDeghead;++k3) //构建P2
398 |             {
399 |                 kk3=GR[k3].first;
400 |                 cc3=GR[k3].second;
401 |                 if(kk3<=head)  // || cc3>left*maxccj || right*cc3<minccj
402 |                     continue;
403 | 
404 |                 target.pMapLen[kk3]=head;//此行构建P1
405 |                 target.pMapMoney[kk3]=cc3;
406 | 
407 |                 idInDegkk3=GRInd[kk3][1];
408 |                 for(k2=GRInd[kk3][0];k2<idInDegkk3;++k2)
409 |                 {
410 |                     kk2=GR[k2].first;
411 |                     cc2=GR[k2].second;
412 |                     if(kk2<=head || cc3*left<cc2 || cc3>right*cc2)
413 |                         continue;
414 | 
415 |                     idInDegkk2=GRInd[kk2][1];
416 |                     for(k1=GRInd[kk2][0];k1<idInDegkk2;++k1)
417 |                     {
418 |                         kk1=GR[k1].first;
419 |                         cc1=GR[k1].second;
420 |                         if(kk1<=head || kk1==kk3 || cc2*left<cc1 || cc2>right*cc1)
421 |                             continue;
422 | 
423 |                         if(target.pMap3Len[kk1][0]!=head){
424 |                             target.pMap3Len[kk1][0]=head;
425 |                             target.pMap3Len[kk1][1]=0;
426 |                             target.pMap3Len[kk1][2]=iP3Len;
427 |                             target.iP3[iP3Len]=kk1;//存kk2,同事避免重复
428 |                             target.nodeLen[kk1]=3;
429 |                             ++iP3Len;
430 | 
431 |                         }
432 |                         pInd=target.pMap3Len[kk1][1];
433 |                         pInd2=target.pMap3Len[kk1][2];
434 |                         target.pMap3[pInd2][pInd].id[0]=kk2;
435 |                         target.pMap3[pInd2][pInd].id[1]=kk3;
436 |                         target.pMap3[pInd2][pInd].cc[0]=cc1;
437 |                         target.pMap3[pInd2][pInd].cc[1]=cc3;
438 |                         ++target.pMap3Len[kk1][1];
439 |                     }
440 |                 }
441 |             }
442 | 
443 |             for(int pi=0;pi<iP3Len;++pi)
444 |             {
445 |                 pAddr=target.pMap3Len[target.iP3[pi]][1];
446 |                 if(pAddr>1){
447 |                     sort(target.pMap3[pi],target.pMap3[pi]+pAddr,cmp);//仅P3排序
448 |                 }
449 |             }
450 | 
451 | 
452 |             //开始寻环
453 |             vis[i]=true;
454 |             path0=i;
455 |             idOutDegi=GInd[i][1];
456 |             for(i_it=GInd[i][0];i_it<idOutDegi;++i_it)//level2
457 |             {
458 |                 ccj=G[i_it].second;
459 |                 if(G[i_it].first <= head)
460 |                     continue;
461 |                 j=G[i_it].first;
462 |                 ccjLeft=ccj*left;
463 |                 ccjRight=ccj*right;
464 | 
465 |                 vis[j]=true;
466 |                 path1=j;
467 | 
468 |                 if(target.pMap3Len[j][0]==head)
469 |                 {
470 |                     pAddr=target.pMap3Len[j][2];
471 |                     pMap3Lenmm=target.pMap3Len[j][1];
472 |                     for(z=0;z<pMap3Lenmm;++z)
473 |                     {
474 |                         ccFirst=target.pMap3[pAddr][z].cc[0];
475 |                         ccLast=target.pMap3[pAddr][z].cc[1];
476 |                         if(ccFirst*left<ccj || ccFirst>ccjRight || ccjLeft<ccLast || ccj>right*ccLast)
477 |                             continue;
478 | 
479 |                         path2=target.pMap3[pAddr][z].id[0];
480 |                         path3=target.pMap3[pAddr][z].id[1];
481 |                         memcpy((void *) addrOffset1,idComma[path0], idCharLen[path0]);
482 |                         addrOffset1 += idCharLen[path0];
483 |                         memcpy((void *) addrOffset1,idComma[path1], idCharLen[path1]);
484 |                         addrOffset1 += idCharLen[path1];
485 |                         memcpy((void *) addrOffset1,idComma[path2], idCharLen[path2]);
486 |                         addrOffset1 += idCharLen[path2];
487 |                         memcpy((void *) addrOffset1,idLF[path3], idCharLen[path3]);
488 |                         addrOffset1 += idCharLen[path3];
489 |                         ++localResCnt;
490 |                     }
491 |                 }
492 | 
493 |                 idOutDegj=GInd[j][1];
494 |                 for(j_it=GInd[j][0];j_it<idOutDegj;++j_it)//level3
495 |                 {
496 |                     cck=G[j_it].second;
497 |                     if(G[j_it].first <= head || cck*left<ccj || cck>ccjRight)
498 |                         continue;
499 |                     k=G[j_it].first;
500 | 
501 |                     vis[k]=true;
502 |                     path2=k;
503 | 
504 |                     if(target.pMapLen[k]==head)
505 |                     {
506 |                         ccLast=target.pMapMoney[k];
507 |                         if(ccLast*left>=cck && ccLast<=right*cck && ccjLeft>=ccLast && ccj<=right*ccLast)
508 |                         {
509 |                             memcpy((void *) addrOffset0,idComma[path0], idCharLen[path0]);
510 |                             addrOffset0 += idCharLen[path0];
511 |                             memcpy((void *) addrOffset0,idComma[path1], idCharLen[path1]);
512 |                             addrOffset0 += idCharLen[path1];
513 |                             memcpy((void *) addrOffset0,idLF[path2], idCharLen[path2]);
514 |                             addrOffset0 += idCharLen[path2];
515 |                             ++localResCnt;
516 |                         }
517 |                     }
518 | 
519 |                     if(target.pMap3Len[k][0]==head)//level6
520 |                     {
521 |                         pAddr=target.pMap3Len[k][2];
522 |                         pMap3Lenmm=target.pMap3Len[k][1];
523 |                         for(z=0;z<pMap3Lenmm;++z)
524 |                         {
525 |                             if(vis[target.pMap3[pAddr][z].id[0]] || vis[target.pMap3[pAddr][z].id[1]])
526 |                                 continue;
527 | 
528 |                             ccFirst=target.pMap3[pAddr][z].cc[0];
529 |                             ccLast=target.pMap3[pAddr][z].cc[1];
530 |                             if(ccFirst*left<cck || ccFirst>right*cck || ccjLeft<ccLast || ccj>right*ccLast)
531 |                                 continue;
532 | 
533 |                             path3=target.pMap3[pAddr][z].id[0];
534 |                             path4=target.pMap3[pAddr][z].id[1];
535 |                             memcpy((void *) addrOffset2,idComma[path0], idCharLen[path0]);
536 |                             addrOffset2 += idCharLen[path0];
537 |                             memcpy((void *) addrOffset2,idComma[path1], idCharLen[path1]);
538 |                             addrOffset2 += idCharLen[path1];
539 |                             memcpy((void *) addrOffset2,idComma[path2], idCharLen[path2]);
540 |                             addrOffset2 += idCharLen[path2];
541 |                             memcpy((void *) addrOffset2,idComma[path3], idCharLen[path3]);
542 |                             addrOffset2 += idCharLen[path3];
543 |                             memcpy((void *) addrOffset2,idLF[path4], idCharLen[path4]);
544 |                             addrOffset2 += idCharLen[path4];
545 |                             ++localResCnt;
546 |                         }
547 |                     }
548 | 
549 |                     idOutDegk=GInd[k][1];
550 |                     for(k_it=GInd[k][0];k_it<idOutDegk;++k_it)//level4
551 |                     {
552 |                         ccL=G[k_it].second;
553 |                         l=G[k_it].first;
554 |                         if(G[k_it].first <= head || ccL*left<cck || ccL>right*cck)////////////////////
555 |                             continue;
556 | 
557 |                         if(vis[l]==false)
558 |                         {
559 |                             vis[l]=true;
560 |                             path3=l;
561 |                             if(target.pMap3Len[l][0]==head)//level7
562 |                             {
563 |                                 pAddr=target.pMap3Len[l][2];
564 |                                 pMap3Lenmm=target.pMap3Len[l][1];
565 |                                 for(z=0;z<pMap3Lenmm;++z)
566 |                                 {
567 |                                     if(vis[target.pMap3[pAddr][z].id[0]] || vis[target.pMap3[pAddr][z].id[1]])
568 |                                         continue;
569 | 
570 |                                     ccFirst=target.pMap3[pAddr][z].cc[0];
571 |                                     ccLast=target.pMap3[pAddr][z].cc[1];
572 |                                     if(ccFirst*left<ccL || ccFirst>right*ccL || ccjLeft<ccLast || ccj>right*ccLast)
573 |                                         continue;
574 | 
575 |                                     path4=target.pMap3[pAddr][z].id[0];
576 |                                     path5=target.pMap3[pAddr][z].id[1];
577 | 
578 |                                     memcpy((void *) addrOffset3,idComma[path0], idCharLen[path0]);
579 |                                     addrOffset3 += idCharLen[path0];
580 |                                     memcpy((void *) addrOffset3,idComma[path1], idCharLen[path1]);
581 |                                     addrOffset3 += idCharLen[path1];
582 |                                     memcpy((void *) addrOffset3,idComma[path2], idCharLen[path2]);
583 |                                     addrOffset3 += idCharLen[path2];
584 |                                     memcpy((void *) addrOffset3,idComma[path3], idCharLen[path3]);
585 |                                     addrOffset3 += idCharLen[path3];
586 |                                     memcpy((void *) addrOffset3,idComma[path4], idCharLen[path4]);
587 |                                     addrOffset3 += idCharLen[path4];
588 |                                     memcpy((void *) addrOffset3,idLF[path5], idCharLen[path5]);
589 |                                     addrOffset3 += idCharLen[path5];
590 |                                     ++localResCnt;
591 |                                 }
592 |                             }
593 | 
594 |                             idOutDegl=GInd[l][1];
595 |                             for(l_it=GInd[l][0];l_it<idOutDegl;++l_it)
596 |                             {
597 |                                 ccm=G[l_it].second;
598 |                                 m=G[l_it].first;
599 |                                 if(target.nodeLen[m]!=3 || G[l_it].first <= head || ccm*left<ccL || ccm>right*ccL)
600 |                                     continue;
601 | 
602 |                                 if(vis[m]==false)//level5
603 |                                 {
604 |                                     vis[m]=true;
605 |                                     path4=m;
606 | 
607 |                                     pAddr=target.pMap3Len[m][2];
608 |                                     pMap3Lenmm=target.pMap3Len[m][1];
609 |                                     for(z=0;z<pMap3Lenmm;++z)
610 |                                     {
611 |                                         if(vis[target.pMap3[pAddr][z].id[0]] || vis[target.pMap3[pAddr][z].id[1]])
612 |                                             continue;
613 | 
614 |                                         ccFirst=target.pMap3[pAddr][z].cc[0];
615 |                                         ccLast=target.pMap3[pAddr][z].cc[1];
616 |                                         if(ccFirst*left<ccm || ccFirst>right*ccm || ccjLeft<ccLast || ccj>right*ccLast)
617 |                                             continue;
618 | 
619 |                                         path5=target.pMap3[pAddr][z].id[0];
620 |                                         path6=target.pMap3[pAddr][z].id[1];
621 | 
622 |                                         memcpy((void *) addrOffset4,idComma[path0], idCharLen[path0]);
623 |                                         addrOffset4 += idCharLen[path0];
624 |                                         memcpy((void *) addrOffset4,idComma[path1], idCharLen[path1]);
625 |                                         addrOffset4 += idCharLen[path1];
626 |                                         memcpy((void *) addrOffset4,idComma[path2], idCharLen[path2]);
627 |                                         addrOffset4 += idCharLen[path2];
628 |                                         memcpy((void *) addrOffset4,idComma[path3], idCharLen[path3]);
629 |                                         addrOffset4 += idCharLen[path3];
630 |                                         memcpy((void *) addrOffset4,idComma[path4], idCharLen[path4]);
631 |                                         addrOffset4 += idCharLen[path4];
632 |                                         memcpy((void *) addrOffset4,idComma[path5], idCharLen[path5]);
633 |                                         addrOffset4 += idCharLen[path5];
634 |                                         memcpy((void *) addrOffset4,idLF[path6], idCharLen[path6]);
635 |                                         addrOffset4 += idCharLen[path6];
636 |                                         ++localResCnt;
637 | 
638 |                                     }
639 | 
640 |                                     vis[m]=false;
641 |                                 }
642 |                             }
643 |                             vis[l]=false;
644 |                         }
645 |                     }
646 |                     vis[k]=false;
647 |                 }
648 |                 vis[j]=false;
649 |             }
650 |             //vis[i]=false;
651 |         }
652 | 
653 |         if(idStart==idEnd-1 || i==nodeNum){
654 |             addrStart[0][i]=addrBlock0;
655 |             addrStart[1][i]=addrBlock1;
656 |             addrStart[2][i]=addrBlock2;
657 |             addrStart[3][i]=addrBlock3;
658 |             addrStart[4][i]=addrBlock4;
659 | 
660 |             addrOffset[0][i]=addrOffset0;
661 |             addrOffset[1][i]=addrOffset1;
662 |             addrOffset[2][i]=addrOffset2;
663 |             addrOffset[3][i]=addrOffset3;
664 |             addrOffset[4][i]=addrOffset4;
665 |         }
666 | 
667 |         idStart++;
668 |     }
669 | 
670 |     target.resCnt = localResCnt;
671 | 
672 | #ifdef PRINT
673 |     cout<<"Index "<<index<<" DoDFS time: "<<getTime()<<endl;
674 | #endif
675 | }
676 | 
677 | //写result.txt
678 | void saveTxt(const string &outputFile){
679 |     setTime();
680 |     FILE *fp = fopen(outputFile.c_str(), "wb");
681 |     int resCnt=0;
682 |     for(int i=0;i<THREAD_NUM;i++)
683 |     {
684 |         resCnt+=threadPool[i].resCnt;
685 |     }
686 |     char temp[100];
687 |     int idx=sprintf(temp,"%d\n",resCnt);
688 |     temp[idx]='\0';
689 |     fwrite(temp,idx,sizeof(char),fp);
690 | 
691 |     int j;
692 |     for(int i=MIN_LEN;i<=MAX_LEN;++i) {
693 |         for(j=blockSize+1;j<nodeNum;j+=blockSize){
694 |             fwrite(addrStart[i-MIN_LEN][j-1],addrOffset[i-MIN_LEN][j-1]-addrStart[i-MIN_LEN][j-1],1,fp);
695 |         }
696 |         if(j-blockSize!=nodeNum+1)
697 |             fwrite(addrStart[i-MIN_LEN][nodeNum],addrOffset[i-MIN_LEN][nodeNum]-addrStart[i-MIN_LEN][nodeNum],1,fp);
698 |     }
699 |     fclose(fp);
700 | #ifdef PRINT
701 |     printf("Total Loops: %d\n",resCnt);
702 |     cout<<"Save time: "<<getTime()<<endl;
703 | #endif
704 | }
705 | 
706 | 
707 | static void* work(void* arg);
708 | 
709 | //开始创建子线程
710 | void createThreadPool()
711 | {
712 | 
713 |     for(int i=0;i<THREAD_NUM;i++)
714 |     {
715 |         int* index=new int(i);//线程在线程池中的序号
716 |         if(pthread_create(&threadPool[i].tid,NULL,work,index)!=0)//如果线程创建失败
717 |         {
718 |             printf("create thread failed\n");
719 |             exit(0);
720 |         }
721 |         else
722 |         {
723 | #ifdef PRINT
724 |             printf("create thread: %ld\n",threadPool[i].tid);
725 | #endif
726 |         }
727 |     }
728 | 
729 |     for(int i=THREAD_NUM-1;i>=0;i--)//等待所有子线程终止并回收线程资源
730 |     {
731 |         pthread_join(threadPool[i].tid,NULL);
732 |     }
733 | }
734 | 
735 | 
736 | //子线程的工作函数
737 | void* work(void* arg)
738 | {
739 |     int* p=(int*)arg;
740 |     int index=*p;//index是子线程在线程池中的序号
741 |     doDFS(index);
742 |     return NULL;
743 | }
744 | //P3的sort排序规则函数
745 | bool cmp(P3 a,P3 b)
746 | {
747 |     return (a.id[0]!=b.id[0])?(a.id[0]<b.id[0]):(a.id[1]<b.id[1]);
748 | }
749 | 
750 | 
751 | int main()
752 | {
753 |     //string inputFile = "test_data_2000w.txt";  //"/data/test_data.txt"
754 |     //string outputFile = "output.txt";  //"/projects/student/result.txt"
755 | 
756 |     string inputFile = "/data/test_data.txt"; //"/data/test_data.txt"
757 |     string outputFile = "/projects/student/result.txt"; //"/projects/student/result.txt"
758 | 
759 |     buildGraph(inputFile);
760 |     rmNode();
761 |     createThreadPool();
762 |     saveTxt(outputFile);
763 | 
764 |     return 0;
765 | }
766 | 
767 | 


--------------------------------------------------------------------------------