fork(1) download 
  1.  
  2. /*
  3. puzzdra_solver
  4.  
  5. パズドラのルート解析プログラムです
  6.  
  7. コンパイラはMinGWを推奨します
  8.  
  9. コマンドは以下の通りです
  10. g++ -O2 -std=c++11 -fopenmp puzzdra_solver.cpp -o puzzdra_solver
  11.  
  12. なるべく少ない時間でなるべく大きいコンボを出したいです
  13.  
  14. printf("TotalDuration:%fSec\n", t_sum);
  15. printf("Avg.NormalCombo #:%f/%f\n", avg / (double)i, MAXCOMBO / (double)i);
  16.  
  17. これらが改善されればpull request受け付けます
  18.  
  19. チェック1：これを10コンボできるか
  20.  
  21. 962679
  22. 381515
  23. 489942
  24. 763852
  25. 917439
  26.  
  27. 914769
  28. 264812
  29. 379934
  30. 355886
  31. 951279
  32. チェック2：1000盤面平均落ちコンボ数が9.20付近か
  33.  
  34. チェック3：1000盤面平均コンボ数が理論値付近か
  35.  
  36. 全チェック達成したら合格
  37. */
  38. #pragma warning(disable:4710)
  39. #pragma warning(disable:4711)
  40. #pragma warning(disable:4820)
  41. #include <vector>
  42. #include <cfloat>
  43. #include <cstdio>
  44. #include <cstring>
  45. #include <climits>
  46. #include <ctime>
  47. #include <cstdlib>
  48. #include <cmath>
  49. #include <string>
  50. #include <iostream>
  51. #include <cstdint>
  52. #include <algorithm>
  53. #include <cassert>
  54. #include <random>
  55. #include <queue>
  56. #include <deque>
  57. #include <list>
  58. #include <map>
  59. #include <array>
  60. #include <chrono>
  61. #include <fstream>
  62. #include <functional>
  63. #include <unordered_map>
  64. #ifdef _OPENMP
  65. #include <omp.h>
  66. #endif
  67. using namespace std;
  68. #define DLT(ST,ED) ((double)((ED)-(ST))/CLOCKS_PER_SEC)//時間差分
  69. #define XX(PT)  ((PT)&15)
  70. #define YY(PT)  XX((PT)>>4)
  71. #define YX(Y,X) ((Y)<<4|(X))
  72. #define DIR 4//方向
  73. #define ROW 5//縦//MAX6
  74. #define COL 6//横//MAX7
  75. #define DROP 6//ドロップの種類//MAX9
  76. #define TRN  155//手数//MAX155
  77. #define STP YX(7,7)//無効手[無効座標]
  78. #define MAX_TURN 150//最大ルート長//MAX150
  79. #define BEAM_WIDTH 10000//ビーム幅//MAX200000
  80. #define PROBLEM 1000//問題数
  81. #define BONUS 10//評価値改善係数
  82. #define MAX(a, b) ((a) > (b) ? (a) : (b))
  83. #define NODE_SIZE MAX(500,4*BEAM_WIDTH)
  84. typedef char F_T;//盤面型
  85. typedef char T_T;//手数型
  86. typedef unsigned long long ll;
  87. enum { EVAL_NONE = 0, EVAL_FALL, EVAL_SET, EVAL_FS, EVAL_COMBO };
  88. void init(F_T field[ROW][COL]); //初期配置生成関数
  89. void fall(int x,F_T field[ROW][COL]); //ドロップの落下処理関数
  90. void set(F_T field[ROW][COL], int force); //空マスを埋める関数
  91. void show_field(F_T field[ROW][COL]); //盤面表示関数
  92. unsigned int rnd(int mini, int maxi); //整数乱数
  93. //上下左右に連結しているドロップを再帰的に探索していく関数
  94. int chain(int nrw, int ncl, F_T d, F_T field[ROW][COL], F_T chkflag[ROW][COL], F_T delflag[ROW][COL]);
  95. int evaluate(F_T field[ROW][COL], int flag); //コンボ数判定関数
  96. int sum_e(F_T field[ROW][COL]);//落とし有り、落ちコン無しコンボ数判定関数
  97. int sum_evaluate(F_T field[ROW][COL]);//落としも落ちコンも有りコンボ数判定関数
  98. void operation(F_T field[ROW][COL], T_T route[TRN]); //スワイプ処理関数
  99.  
  100. int evaluate2(F_T field[ROW][COL], int flag, int* combo, ll* hash);//落とし減点評価関数
  101. int sum_e2(F_T field[ROW][COL], int* combo, ll* hash);//評価関数
  102.  
  103. ll xor128();//xorshift整数乱数
  104. ll zoblish_field[ROW][COL][DROP+1];
  105.  
  106.  
  107. struct node {//どういう手かの構造体
  108. 	T_T movei[TRN];//スワイプ移動座標
  109. 	int score;//評価値
  110. 	int combo;//コンボ数
  111. 	int nowC;//今どのx座標にいるか
  112. 	int nowR;//今どのy座標にいるか
  113. 	int prev;//1手前は上下左右のどっちを選んだか
  114. 	int prev_score;//1手前の評価値
  115. 	int improving;//評価値改善回数
  116. 	ll hash;//盤面のハッシュ値
  117. 	node() {//初期化
  118. 		this->score = 0;
  119. 		this->prev = -1;
  120. 		//memset(this->movei, STP, sizeof(this->movei));
  121. 	}
  122. 	bool operator < (const node& n)const {//スコアが高い方が優先される
  123. 		return score < n.score;
  124. 	}
  125. }fff[NODE_SIZE];
  126. struct Action {//最終的に探索された手
  127. 	int score;//コンボ数
  128. 	int maxcombo;//理論コンボ数
  129. 	T_T moving[TRN];//スワイプ移動座標
  130. 	Action() {//初期化
  131. 		this->score = 0;
  132. 		//memset(this->moving, STP, sizeof(this->moving));
  133. 	}
  134. };
  135. Action BEAM_SEARCH(F_T f_field[ROW][COL]); //ルート探索関数
  136. double part1 = 0, part2 = 0, part3 = 0, part4 = 0, MAXCOMBO = 0;
  137. Action BEAM_SEARCH(F_T f_field[ROW][COL]) {
  138.  
  139. 	int stop = 0;//理論最大コンボ数
  140.  
  141. 	int drop[DROP + 1] = { 0 };
  142. 	for (int row = 0; row < ROW; row++) {
  143. 		for (int col = 0; col < COL; col++) {
  144. 			if (1 <= f_field[row][col] && f_field[row][col] <= DROP) {
  145. 				drop[f_field[row][col]]++;
  146. 			}
  147. 		}
  148. 	}
  149. 	for (int i = 1; i <= DROP; i++) {
  150. 		stop += drop[i] / 3;
  151. 	}
  152. 	MAXCOMBO += (double)stop;
  153.  
  154. 	deque<node>dque;
  155. 	double start, st;
  156. 	//1手目を全通り探索する
  157. 	dque.clear();
  158. 	for (int i = 0; i < ROW; i++) {
  159. 		for (int j = 0; j < COL; j++) {
  160. 			node cand;
  161. 			cand.nowR = i;//y座標
  162. 			cand.nowC = j;//x座標
  163. 			cand.prev = -1;//1手前はない
  164. 			cand.movei[0] = (T_T)YX(i, j);//1手目のyx座標
  165. 			for (int trn = 1; trn < TRN; trn++) {
  166. 				cand.movei[trn] = STP;
  167. 			}
  168. 			F_T ff_field[ROW][COL];
  169. 			memcpy(ff_field,f_field,sizeof(ff_field));
  170. 			int cmb;
  171. 			ll ha;
  172. 			cand.prev_score=sum_e2(ff_field,&cmb,&ha);
  173. 			cand.improving=0;
  174. 			cand.hash=ha;
  175. 			dque.push_back(cand);
  176. 		}
  177. 	}         // L, U,D,R //
  178. 	int dx[DIR] = { -1, 0,0,1 },
  179. 		dy[DIR] = { 0,-1,1,0 };
  180. 	Action bestAction;//最善手
  181. 	int maxValue = 0;//最高スコア
  182.  
  183. 	bestAction.maxcombo = stop;
  184.  
  185. 	unordered_map<ll, bool> checkNodeList[ROW*COL];
  186.  
  187. 	//2手目以降をビームサーチで探索
  188. 	for (int i = 1; i < MAX_TURN; i++) {
  189. 		int ks = (int)dque.size();
  190. 		start = omp_get_wtime();
  191. #pragma omp parallel for private(st),reduction(+:part1,part4)
  192. 		for (int k = 0; k < ks; k++) {
  193. #ifdef _OPENMP
  194. 			if (i == 1 && k == 0) {
  195. 				printf("Threads[%d/%d]\n",
  196. 					omp_get_num_threads(),
  197. 					omp_get_max_threads());
  198. 			}
  199. #endif
  200. 			node temp = dque[k];//que.front(); que.pop();
  201. 			F_T temp_field[ROW][COL]; 
  202. 			memcpy(temp_field, f_field, sizeof(temp_field));
  203. 			operation(temp_field, temp.movei);
  204. 			for (int j = 0; j < DIR; j++) {//上下左右の4方向が発生
  205. 				node cand = temp;
  206. 				if (0 <= cand.nowC + dx[j] && cand.nowC + dx[j] < COL &&
  207. 					0 <= cand.nowR + dy[j] && cand.nowR + dy[j] < ROW) {
  208. 					if (cand.prev + j != 3) {
  209. 						F_T field[ROW][COL];//盤面
  210. 						memcpy(field,temp_field,sizeof(temp_field));//盤面をもどす
  211. 						F_T tmp=field[cand.nowR][cand.nowC];
  212. 						field[cand.nowR][cand.nowC]=field[cand.nowR+dy[j]][cand.nowC+dx[j]];
  213. 						field[cand.nowR+dy[j]][cand.nowC+dx[j]]=tmp;
  214. 						cand.nowC += dx[j];
  215. 						cand.nowR += dy[j];
  216. 						cand.movei[i] = (T_T)YX(cand.nowR, cand.nowC);
  217. 						st = omp_get_wtime();
  218. 						int cmb;
  219. 						ll ha;
  220. 						cand.score = sum_e2(field, &cmb,&ha);
  221. 						cand.combo = cmb;
  222. 						cand.hash=ha;
  223. 						part1 += omp_get_wtime() - st;
  224. 						cand.prev = j;
  225. 						st = omp_get_wtime();
  226. 						//#pragma omp critical
  227. 											//{ pque.push(cand); }
  228. 						fff[(4 * k) + j] = cand;
  229. 						part4 += omp_get_wtime() - st;
  230. 					}
  231. 					else {
  232. 						cand.combo = -1;
  233. 						fff[(4 * k) + j] = cand;
  234. 					}
  235. 				}
  236. 				else {
  237. 					cand.combo = -1;
  238. 					fff[(4 * k) + j] = cand;
  239. 				}
  240. 			}
  241. 		}
  242. 		part2 += omp_get_wtime() - start;
  243. 		start = omp_get_wtime();
  244. 		dque.clear();
  245. 		vector<pair<int, int> >vec;
  246. 		int ks2 = 0;
  247. 		for (int j = 0; j < 4 * ks; j++) {
  248. 			if (fff[j].combo != -1) {
  249. 				if(fff[j].score>fff[j].prev_score){fff[j].improving=fff[j].improving+1;}
  250. 				fff[j].prev_score=fff[j].score;
  251. 				vec.push_back(make_pair(fff[j].score+(BONUS*fff[j].improving), j));
  252. 				ks2++;
  253. 			}
  254. 		}
  255. 		sort(vec.begin(), vec.end());
  256. 		int push_node=0;
  257. 		for (int j = 0; push_node < BEAM_WIDTH && j < ks2; j++) {
  258. 			node temp = fff[vec[ks2-1-j].second];
  259. 			if (maxValue < temp.combo) {//コンボ数が増えたらその手を記憶する
  260. 				maxValue = temp.combo;
  261. 				bestAction.score = maxValue;
  262. 				memcpy(bestAction.moving, temp.movei, sizeof(temp.movei));
  263. 				//コンボ数が理論値になったらreturn
  264. 				if (temp.combo == stop) { return bestAction; }
  265. 			}
  266. 			if (i < MAX_TURN - 1) {
  267. 			int pos=(temp.nowR*COL)+temp.nowC;
  268. 			if(!checkNodeList[pos][temp.hash]){
  269. 				checkNodeList[pos][temp.hash]=true;
  270. 				dque.push_back(temp);
  271. 				push_node++;
  272. 			}
  273. 			}
  274. 		}
  275. 		part3 += omp_get_wtime() - start;
  276. 	}
  277. 	return bestAction;
  278. }
  279. void show_field(F_T field[ROW][COL]) {
  280. 	for (int i = 0; i < ROW; i++) {
  281. 		for (int j = 0; j < COL; j++) {
  282. 			printf("%d", field[i][j]);
  283. 		}
  284. 		printf("\n");
  285. 	}
  286. }
  287. void fall(int x,F_T field[ROW][COL]) {
  288. 		int tgt;
  289. 		for (tgt = ROW - 1; tgt >= 0 && field[tgt][x] != 0; tgt--);
  290. 		for (int i = tgt - 1; i >= 0; i--) {
  291. 			if (field[i][x] != 0) {
  292. 				F_T c = field[i][x];
  293. 				field[i][x] = 0;
  294. 				field[tgt][x] = c;
  295. 				tgt--;
  296. 			}
  297. 		}
  298. }
  299. void init(F_T field[ROW][COL]) { set(field, !0); }
  300. void set(F_T field[ROW][COL], int force) {
  301. 	for (int i = 0; i < ROW; i++) {
  302. 		for (int j = 0; j < COL; j++) {
  303. 			if (field[i][j] == 0 || force) {//空マスだったらうめる
  304. 				field[i][j] = (F_T)rnd(force ? 0 : 1, DROP);//1-DROPの整数乱数
  305. 			}
  306. 		}
  307. 	}
  308. }
  309. int chain(int nrw, int ncl, F_T d, F_T field[ROW][COL],
  310. 	F_T chkflag[ROW][COL], F_T delflag[ROW][COL]) {
  311. 	int count = 0;
  312. #define CHK_CF(Y,X) (field[Y][X] == d && chkflag[Y][X]==0 && delflag[Y][X] > 0)
  313. 	//連結している同じ色の消去ドロップが未探索だったら
  314. 	if (CHK_CF(nrw, ncl)) {
  315. 		++count; //連結ドロップ数の更新
  316. 		chkflag[nrw][ncl]=1;//探索済みにする
  317. 			//以下上下左右に連結しているドロップを再帰的に探索していく
  318. 		if (0 < nrw && CHK_CF(nrw - 1, ncl)) {
  319. 			count += chain(nrw - 1, ncl, d, field, chkflag, delflag);
  320. 		}
  321. 		if (nrw < ROW - 1 && CHK_CF(nrw + 1, ncl)) {
  322. 			count += chain(nrw + 1, ncl, d, field, chkflag, delflag);
  323. 		}
  324. 		if (0 < ncl && CHK_CF(nrw, ncl - 1)) {
  325. 			count += chain(nrw, ncl - 1, d, field, chkflag, delflag);
  326. 		}
  327. 		if (ncl < COL - 1 && CHK_CF(nrw, ncl + 1)) {
  328. 			count += chain(nrw, ncl + 1, d, field, chkflag, delflag);
  329. 		}
  330. 	}
  331. 	return count;
  332. }
  333. int evaluate(F_T field[ROW][COL], int flag) {
  334. 	int combo = 0;
  335.  
  336. 	while (1) {
  337. 		int cmb = 0;
  338. 		F_T chkflag[ROW][COL]={0};
  339. 		F_T delflag[ROW][COL]={0};
  340. 		for (int row = 0; row < ROW; row++) {
  341. 			for (int col = 0; col < COL; col++) {
  342. 				F_T num=field[row][col];
  343. 				if (col <= COL - 3 && num == field[row][col + 1] && num == field[row][col + 2] && num > 0) {
  344. 					delflag[row][col]=1;
  345. 					delflag[row][col+1]=1;
  346. 					delflag[row][col+2]=1;
  347. 				}
  348. 				if (row <= ROW - 3 && num == field[row + 1][col] && num == field[row + 2][col] && num > 0) {
  349. 					delflag[row][col]=1;
  350. 					delflag[row+1][col]=1;
  351. 					delflag[row+2][col]=1;
  352. 				}
  353. 			}
  354. 		}
  355. 		for (int row = 0; row < ROW; row++) {
  356. 			for (int col = 0; col < COL; col++) {
  357. 				if (delflag[row][col] > 0) {
  358. 					if (chain(row, col, field[row][col], field, chkflag, delflag) >= 3) {
  359. 						cmb++;
  360. 					}
  361. 				}
  362. 			}
  363. 		}
  364. 		combo += cmb;
  365. 		//コンボが発生しなかったら終了
  366. 		if (cmb == 0 || 0 == (flag & EVAL_COMBO)) { break; }
  367. 		for (int row = 0; row < ROW; row++) {
  368. 			for (int col = 0; col < COL; col++) {
  369. 				//コンボになったドロップは空になる
  370. 				if (delflag[row][col]> 0) { field[row][col] = 0; }
  371. 			}
  372. 		}
  373.  
  374. 		if (flag & EVAL_FALL){
  375. 		for(int x=0;x<COL;x++){
  376. 		fall(x,field);
  377. 		}
  378. 		}//落下処理発生
  379. 		if (flag & EVAL_SET){set(field, 0);}//落ちコン発生
  380.  
  381. 	}
  382. 	return combo;
  383. }
  384. int evaluate2(F_T field[ROW][COL], int flag, int* combo, ll* hash) {
  385. 	int ev = 0;
  386. 	*combo = 0;
  387. 	ll ha=0;
  388. 	int oti = 0;
  389. 	while (1) {
  390. 		int cmb = 0;
  391. 		int cmb2 = 0;
  392. 		F_T chkflag[ROW][COL]={0};
  393. 		F_T delflag[ROW][COL]={0};
  394. 		for (int row = 0; row < ROW; row++) {
  395. 			for (int col = 0; col < COL; col++) {
  396. 				F_T num = field[row][col];
  397. 				if(oti==0){
  398. 					ha ^= zoblish_field[row][col][(int)num];
  399. 				}
  400. 				if (col <= COL - 3 && num == field[row][col + 1] && num == field[row][col + 2] && num > 0) {
  401. 					delflag[row][col]=1;
  402. 					delflag[row][col+1]=1;
  403. 					delflag[row][col+2]=1;
  404. 				}
  405. 				if (row <= ROW - 3 && num == field[row + 1][col] && num == field[row + 2][col] && num > 0) {
  406. 					delflag[row][col]=1;
  407. 					delflag[row+1][col]=1;
  408. 					delflag[row+2][col]=1;
  409. 				}
  410. 			}
  411. 		}
  412.  
  413. 		F_T cnt[DROP + 1] = { 0 };
  414. 		F_T drop[DROP + 1][ROW * COL][2] = { 0 };
  415.  
  416. 		for (int row = 0; row < ROW; row++) {
  417. 			for (int col = 0; col < COL; col++) {
  418. 				drop[field[row][col]][cnt[field[row][col]]][0] = (F_T)row;
  419. 				drop[field[row][col]][cnt[field[row][col]]][1] = (F_T)col;
  420. 				cnt[field[row][col]]++;
  421. 				if (delflag[row][col]>0) {
  422. 					int c = chain(row, col, field[row][col], field, chkflag, delflag);
  423. 					if (c >= 3) {
  424. 						cmb++;
  425. 						if (c == 3) { cmb2 += 30; }
  426. 						else { cmb2 += 20; }
  427. 					}
  428. 				}
  429. 			}
  430. 		}
  431. 		F_T erase_x[COL]={0};
  432. 		for (int i = 1; i <= DROP; i++) {
  433. 			for (int j = 0; j < cnt[i] - 1; j++) {
  434. 				int d1 = (int)drop[i][j][0];
  435. 				int d2 = (int)drop[i][j][1];
  436. 				int d3 = (int)drop[i][j + 1][0];
  437. 				int d4 = (int)drop[i][j + 1][1];
  438. 				int add = max(d1 - d3, d3 - d1) + max(d2 - d4, d4 - d2);
  439. 				add += add;
  440. 				add /= 3;
  441. 				cmb2 -= add;
  442. 				if (delflag[d1][d2]> 0) {
  443. 					field[d1][d2] = 0;
  444. 					erase_x[d2]=1;
  445. 				}
  446. 				if (delflag[d3][d4] > 0) {
  447. 					field[d3][d4] = 0;
  448. 					erase_x[d4]=1;
  449. 				}
  450. 			}
  451. 		}
  452. 		*combo += cmb;
  453. 		ev += cmb2;
  454. 		//コンボが発生しなかったら終了
  455. 		if (cmb == 0 || 0 == (flag & EVAL_COMBO)) { break; }
  456. 		oti++;
  457. 		if (flag & EVAL_FALL){//落下処理発生
  458. 		for(int x=0;x<COL;x++){
  459. 		if(erase_x[x]==1){
  460. 		fall(x,field);
  461. 		}
  462. 		}
  463. 		}
  464. 		if (flag & EVAL_SET){set(field, 0);}//落ちコン発生
  465.  
  466. 	}
  467. 	ev += oti;
  468. 	*hash=ha;
  469. 	return ev;
  470. }
  471. int sum_e2(F_T field[ROW][COL], int* combo, ll* hash) {//落とし有り、落ちコン無し評価関数
  472. 	return evaluate2(field, EVAL_FALL | EVAL_COMBO, combo,hash);
  473. }
  474. int sum_e(F_T field[ROW][COL]) {//落とし有り、落ちコン無しコンボ数判定関数
  475. 	return evaluate(field, EVAL_FALL | EVAL_COMBO);
  476. }
  477. int sum_evaluate(F_T field[ROW][COL]) {//落としも落ちコンも有りコンボ数判定関数
  478. 	return evaluate(field, EVAL_FS | EVAL_COMBO);
  479. }
  480. //移動した後の盤面を生成する関数
  481. void operation(F_T field[ROW][COL], T_T route[TRN]) {
  482. 	int prw = (int)YY(route[0]), pcl = (int)XX(route[0]), i;
  483. 	for (i = 1; i < MAX_TURN; i++) {
  484. 		if (route[i] == STP) { break; }
  485. 		//移動したら、移動前ドロップと移動後ドロップを交換する
  486. 		int row = (int)YY(route[i]), col = (int)XX(route[i]);
  487. 		F_T c = field[prw][pcl];
  488. 		field[prw][pcl] = field[row][col];
  489. 		field[row][col] = c;
  490. 		prw = row, pcl = col;
  491. 	}
  492. }
  493. unsigned int rnd(int mini, int maxi) {
  494. 	static mt19937 mt((int)time(0));
  495. 	uniform_int_distribution<int> dice(mini, maxi);
  496. 	return dice(mt);
  497. }
  498. ll xor128() {//xorshift整数乱数
  499. 	static unsigned long long rx = 123456789, ry = 362436069, rz = 521288629, rw = 88675123;
  500. 	ll rt = (rx ^ (rx << 11));
  501. 	rx = ry; ry = rz; rz = rw;
  502. 	return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
  503. }
  504. int main() {
  505.  
  506. 	int i, j, k;
  507.  
  508. 	for(i=0;i<ROW;++i){
  509. 	for(j=0;j<COL;++j){
  510. 	for(k=0;k<=DROP;k++){
  511. 	zoblish_field[i][j][k]=xor128();
  512. 	}
  513. 	}
  514. 	}
  515.  
  516. 	double avg = 0;//平均コンボ数
  517. 	double start;
  518. 	double t_sum = 0;
  519. 	double oti_avg = 0;//平均落ちコンボ数
  520. 	for (i = 0; i < PROBLEM; i++) {//PROBLEM問解く
  521. 		F_T f_field[ROW][COL]; //スワイプ前の盤面
  522. 		F_T field[ROW][COL]; //盤面
  523. 		F_T oti_field[ROW][COL];//落ちコン用盤面
  524. 		printf("input:No.%d/%d\n", i + 1, PROBLEM);
  525. 		init(f_field); set(f_field, 0);//初期盤面生成
  526. 		show_field(f_field);//盤面表示
  527. 		/*
  528. 		for (j = 0; j < ROW; j++) {
  529. 			string s = "";
  530. 			cin >> s;
  531. 			for (k = 0; k < COL; k++) {
  532. 				f_field[j][k] = s[k] - '0';
  533. 			}
  534. 		}
  535. 		*/
  536. 		start = omp_get_wtime();
  537. 		Action tmp = BEAM_SEARCH(f_field);//ビームサーチしてtmpに最善手を保存
  538. 		double diff = omp_get_wtime() - start;
  539. 		t_sum += diff;
  540. 		printf("(x,y)=(%d,%d)", XX(tmp.moving[0]), YY(tmp.moving[0]));
  541. 		for (j = 1; j < MAX_TURN; j++) {//y座標は下にいくほど大きくなる
  542. 			if (tmp.moving[j] == STP) { break; }
  543. 			if (XX(tmp.moving[j]) == XX(tmp.moving[j - 1]) + 1) { printf("R"); } //"RIGHT"); }
  544. 			if (XX(tmp.moving[j]) == XX(tmp.moving[j - 1]) - 1) { printf("L"); } //"LEFT"); }
  545. 			if (YY(tmp.moving[j]) == YY(tmp.moving[j - 1]) + 1) { printf("D"); } //"DOWN"); }
  546. 			if (YY(tmp.moving[j]) == YY(tmp.moving[j - 1]) - 1) { printf("U"); } //"UP"); }
  547. 		} printf("\n");
  548. 		memcpy(field, f_field, sizeof(f_field));
  549. 		operation(field, tmp.moving);
  550. 		printf("output:No.%d/%d\n", i + 1, PROBLEM);
  551. 		show_field(field);
  552. 		memcpy(oti_field, field, sizeof(field));
  553. 		int combo = sum_e(field);
  554. 		int oti = sum_evaluate(oti_field);
  555. 		printf("Normal:%d/%dCombo\n", combo, tmp.maxcombo);
  556. 		printf("Oti:%dCombo\n", oti);
  557. 		printf("elapsed time:%fSec\n", diff);
  558. 		printf("------------\n");
  559. 		avg += (double)combo;
  560. 		oti_avg += (double)oti;
  561. 	}
  562. 	printf("TotalDuration:%fSec\n", t_sum);
  563. 	printf("Avg.NormalCombo #:%f/%f\n", avg / (double)i, MAXCOMBO / (double)i);
  564. 	printf("Avg.OtiCombo #:%f\n", oti_avg / (double)i);
  565. 	printf("p1:%f,p2:%f,p3:%f,p4:%f\n", part1, part2, part3, part4);
  566. 	j = getchar();
  567. 	return 0;
  568. }
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
compilation info 
prog.cpp: In function ‘Action BEAM_SEARCH(F_T (*)[6])’:
prog.cpp:190:11: error: ‘omp_get_wtime’ was not declared in this scope
   start = omp_get_wtime();
           ^~~~~~~~~~~~~
prog.cpp:190:11: note: suggested alternative: ‘timer_gettime’
   start = omp_get_wtime();
           ^~~~~~~~~~~~~
           timer_gettime
prog.cpp: In function ‘int main()’:
prog.cpp:536:11: error: ‘omp_get_wtime’ was not declared in this scope
   start = omp_get_wtime();
           ^~~~~~~~~~~~~
prog.cpp:536:11: note: suggested alternative: ‘timer_gettime’
   start = omp_get_wtime();
           ^~~~~~~~~~~~~
           timer_gettime
stdout 
Standard output is empty
https://ideone.com/XWTNcI
language:
C++14 (gcc 8.3)
created:
5 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!