fork(38) download
copy 
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. /************** <HINT> ******************/
  5. // ピクロスのヒントの構造体
  6. typedef struct{
  7.     int length;
  8.     int *data;
  9. 	int sum;
  10. } hint;
  11. // ヒントのデータ割り当て
  12. hint* new_hint(int length)
  13. {
  14.     hint *h = (hint*)calloc(1,sizeof(hint));
  15.     h->length = length;
  16.     h->data = (int*)calloc(length,sizeof(int));
  17.     return h;
  18. }
  19. // ヒントのデータコピー（戻り値０で正常）
  20. int copy_hint(hint *src, hint *dst)
  21. {
  22.     int i;
  23.     int len = src->length;
  24.     // サイズチェック
  25.     if(src->length != dst->length) return -1;
  26.     // コピー
  27.     for(i=0;i<len;i++){
  28.         dst->data[i] = src->data[i];
  29.     }
  30. 	dst->sum = src->sum;
  31.     return 0;
  32. }
  33. // ヒントのクローンを作成
  34. hint* clone_hint(hint *h)
  35. {
  36.     hint *h2 = new_hint(h->length);
  37.     copy_hint(h,h2);
  38.     return h2;
  39. }
  40. // ヒントのデータ解放
  41. void delete_hint(hint *h)
  42. {
  43.     free(h->data);
  44.     free(h);
  45. }
  46. // ヒントの合計値をセットする
  47. int set_sum_hint(hint *h)
  48. {
  49.     int i;
  50.     int len = h->length;
  51. 	h->sum = 0;
  52.     for(i=0;i<len;i++){
  53. 		// 入力チェックも兼ねる
  54. 		if(h->data[i] < 1){
  55. 			return 0;
  56. 		}
  57.         h->sum += h->data[i];
  58.     }
  59. 	return h->sum;
  60. }
  61. // ヒントの最大長を得る
  62. int maxlen_hints(hint **h, int count)
  63. {
  64.     int i,len,max=0;
  65.     for(i=0;i<count;i++){
  66.         len = h[i]->length;
  67.         if(max<len) max = len;
  68.     }
  69.     return max;
  70. }
  71. /************** </HINT> ******************/
  72.  
  73. /************** <CELL> ******************/
  74. // セルの状態（不明・塗りつぶし・空白・決定不可能）
  75. typedef enum{
  76.     UNKNOWN, FILL, SPACE, ND
  77. } stat;
  78. // セルの構造体
  79. typedef struct{
  80.     stat stat;
  81. } cell;
  82. // セルのデータ割り当て
  83. cell* new_cell(void)
  84. {
  85.     cell *c = (cell*)calloc(1,sizeof(cell));
  86.     c->stat = UNKNOWN;
  87.     return c;
  88. }
  89. // セルのデータコピー（戻り値０で正常）
  90. int copy_cell(cell *src,cell *dst)
  91. {
  92.     dst->stat = src->stat;
  93.     return 0;
  94. }
  95. // セルのデータ解放
  96. void delete_cell(cell *c)
  97. {
  98.     free(c);
  99. }
  100. /************** </CELL> ******************/
  101.  
  102. /************** <PICLOS> ******************/
  103. // ピクロスの大きさの構造体
  104. typedef struct{
  105.     int x; // よこ
  106.     int y; // たて
  107. } size;
  108. // ピクロスのデータ
  109. typedef struct{
  110.     size size; // 大きさ
  111.     hint **hintX, **hintY; // ヒント
  112.     cell ***cell; // セル
  113. } piclos;
  114. // ピクロスのデータ割り当て
  115. piclos* new_piclos(int x, int y)
  116. {
  117.     int i,j;
  118.     piclos *p = (piclos*)calloc(1,sizeof(piclos));
  119.     p->size.x = x;
  120.     p->size.y = y;
  121.     // ヒント割り当て
  122.     p->hintX = (hint**)calloc(x,sizeof(hint*));
  123.     p->hintY = (hint**)calloc(y,sizeof(hint*));
  124.     // セル割り当て
  125.     p->cell = (cell***)calloc(x,sizeof(cell**));
  126.     for(i=0;i<x;i++){
  127.         p->cell[i] = (cell**)calloc(y,sizeof(cell*));
  128.         for(j=0;j<y;j++){
  129.             p->cell[i][j] = new_cell();
  130.         }
  131.     }
  132.     return p;
  133. }
  134. // ピクロスのデータコピー（戻り値０で正常）
  135. int copy_piclos(piclos *src, piclos *dst)
  136. {
  137.     int i,j,len;
  138.     int x = src->size.x;
  139.     int y = src->size.y;
  140.     // サイズチェック
  141.     if(src->size.x != dst->size.x) return -1;
  142.     if(src->size.y != dst->size.y) return -1;
  143.     // ヒントコピー
  144.     for(i=0;i<x;i++){
  145.         dst->hintX[i] = clone_hint(src->hintX[i]);
  146.     }
  147.     for(i=0;i<y;i++){
  148.         dst->hintY[i] = clone_hint(src->hintY[i]);
  149.     }
  150.     // セルコピー
  151.     for(i=0;i<x;i++){
  152.         for(j=0;j<y;j++){
  153.             copy_cell(src->cell[i][j],dst->cell[i][j]);
  154.         }
  155.     }
  156.     return 0;
  157. }
  158. // ピクロスのクローンを作成
  159. piclos* clone_piclos(piclos *p)
  160. {
  161.     piclos* p2 = new_piclos(p->size.x,p->size.y);
  162.     copy_piclos(p,p2);
  163.     return p2;
  164. }
  165. // ピクロスのデータ解放(del_hint = 1でヒントのデータも同時に開放/*解放忘れ防止*/)
  166. void delete_piclos(piclos *p, int del_hint)
  167. {
  168.     int i,j;
  169.     int x = p->size.x;
  170.     int y = p->size.y;
  171.     // セル解放
  172.     for(i=0;i<x;i++){
  173.         for(j=0;j<y;j++){
  174.             delete_cell(p->cell[i][j]);
  175.         }
  176.         free(p->cell[i]);
  177.     }
  178.     free(p->cell);
  179.     // ヒント解放
  180.     if(del_hint){
  181.         for(i=0;i<x;i++){
  182.             delete_hint(p->hintX[i]);
  183.         }
  184.         for(i=0;i<y;i++){
  185.             delete_hint(p->hintY[i]);
  186.         }
  187.     }
  188.     free(p->hintX);
  189.     free(p->hintY);
  190.     free(p);
  191. }
  192. /************** </PICLOS> ******************/
  193.  
  194. /************** <OUTPUT> ******************/
  195. void print_piclos_sub(piclos *p, char *s)
  196. {
  197.     int i,j,idx,len,lenX,lenY;
  198.     int x = p->size.x;
  199.     int y = p->size.y;
  200.     lenX = maxlen_hints(p->hintX, x);
  201.     lenY = maxlen_hints(p->hintY, y);
  202.     // 横方向のヒントの表示
  203.     for(i=0;i<lenX;i++){
  204.         for(j=0;j<lenY;j++) printf("   ");
  205.         for(j=0;j<x;j++){
  206.             len = p->hintX[j]->length;
  207.             idx = len-lenX+i;
  208.             if(idx >= 0){
  209.                 printf("%3d",p->hintX[j]->data[idx]);
  210.             }else{
  211.                 printf("   ");
  212.             }
  213.         }
  214.         printf("\n");
  215.     }
  216.     for(j=0;j<y;j++){
  217.         // 縦方向のヒントの表示
  218.         for(i=0;i<lenY;i++){
  219.             len = p->hintY[j]->length;
  220.             idx = len-lenY+i;
  221.             if(idx >= 0){
  222.                 printf("%3d",p->hintY[j]->data[idx]);
  223.             }else{
  224.                 printf("   ");
  225.             }
  226.         }
  227.         // セルの表示
  228.         for(i=0;i<x;i++){
  229.             switch(p->cell[i][j]->stat)
  230.             {
  231.             case UNKNOWN: printf("   "); break;
  232.             case FILL:    printf(" ##"); break;
  233.             case SPACE:   printf(s); break;
  234.             default:      printf(" ? "); break;
  235.             }
  236.         }
  237.         printf("\n");
  238.     }
  239.     printf("\n");
  240. }
  241. void print_piclos(piclos *p)
  242. {
  243. 	print_piclos_sub(p, " x ");
  244. }
  245. void print_piclos_fin(piclos *p)
  246. {
  247. 	print_piclos_sub(p, "   ");
  248. }
  249. /************** </OUTPUT> ******************/
  250.  
  251. /************** <INPUT> ******************/
  252. int s_count(char *s, char d)
  253. {
  254.     int i=0;
  255.     while(*s) if(*s++==d) i++;
  256.     return i;
  257. }
  258. int i_split(char *s, char d, int* res, int len)
  259. {
  260.     int i=0,a=0;
  261.     char c;
  262.     while(c=*s++){
  263.         if(c==d){
  264.             i++;a=0;
  265.             if(i>=len) return -2;
  266.         }else{
  267.             if(c < '0' || c > '9') return 0;
  268.             a *= 10;
  269.             a += (int)(c - '0');
  270.             res[i] = a;
  271.         }
  272.     }
  273.     return 1;
  274. }
  275.  
  276. int input_piclos_hints(piclos *p)
  277. {
  278.     int i,j,x,y,len,sum,res=1;
  279.     char str[255];
  280.     x = p->size.x;
  281.     y = p->size.y;
  282.     gets(str);//バッファクリア
  283.     puts("ピクロスのヒント（列方向）を入力してください。(空白区切りで各列ごとに改行)");
  284.     for(i=0;i<x;i++){
  285.         gets(str);
  286.         len = s_count(str,' ') + 1;
  287.         p->hintX[i] = new_hint(len);
  288.         if(!i_split(str,' ',p->hintX[i]->data,len))
  289. 		{
  290. 			res = 0; puts("入力エラーを検出しました。");
  291. 		}else{
  292. 			sum = set_sum_hint(p->hintX[i]);
  293. 			if(sum==0 || (sum+len-1)>p->size.y){
  294. 				res = 0; puts("入力エラーを検出しました。");
  295. 			}
  296. 		}
  297.     }
  298.     puts("ピクロスのヒント（行方向）を入力してください。(空白区切りで各列ごとに改行)");
  299.     for(i=0;i<y;i++){
  300.         gets(str);
  301.         len = s_count(str,' ') + 1;
  302.         p->hintY[i] = new_hint(len);
  303.         if(!i_split(str,' ',p->hintY[i]->data,len)){
  304. 			res = 0; puts("入力エラーを検出しました。");
  305. 		}else{
  306. 			sum = set_sum_hint(p->hintY[i]);
  307. 			if(sum==0 || (sum+len-1)>p->size.x){
  308. 				res = 0; puts("入力エラーを検出しました。");
  309. 			}
  310. 		}
  311.     }
  312. 	return(res);
  313. }
  314. /************** </INPUT> ******************/
  315.  
  316. /************** <DETECT> ******************/
  317.  
  318. // 現状とヒントから決定可能なセルを埋める(指定行/列)
  319. // 引数：row=行指定,col=列指定（0起点、行指定時はcol=-1,列指定時はrow=-1）
  320. // 戻り値：確定セルの増分（Nセル決定状態→N+Mセル決定状態：戻り値M）
  321. int detect_line(piclos *p, int row, int col)
  322. {
  323. 	hint *h; // 対象ヒント
  324. 	stat *w0,*w1; // 作業用セル状態
  325. 	int *blank; // 黒セルの間隔
  326. 	int blank_left, blank_right; // 左右の空白セル数
  327. 	// x,y:セル選択用イテレータ; dx,dy:イテレータの増分; idx,i,j:カウンタ変数; k:対象方向のセル数; n:blankの数; sum:合計値; ptr:現在操作中のblankを指す
  328. 	int dx,dy,x,y,idx,i,j,k,n,sum,ptr;
  329. 	int f0, f1; // フラグ
  330. 	// count:確定セル(新);count0:確定セル(旧);
  331. 	int count=0, count0=0;
  332. 	// 引数チェック
  333. 	if(!(row==-1 || col==-1)) return -1;
  334. 	// 計算方向の初期化
  335. 	if(row==-1){ dx = 0; dy = 1; x = col; y = 0; k = p->size.y; h = p->hintX[x]; n = h->length; }
  336. 	if(col==-1){ dx = 1; dy = 0; x = 0; y = row; k = p->size.x; h = p->hintY[y]; n = h->length; }
  337. 	// 確定セルを数える
  338. 	x *= dy; y *= dx; // イテレータ初期化
  339. 	for(i=0;i<k;i++){
  340. 		if(p->cell[x][y]->stat != UNKNOWN) count0++;
  341. 		x += dx; y += dy;
  342. 	}
  343. 	if(count0 == k) return 0; // すべて確定しているようなので終了
  344. 	// 作業領域の準備
  345. 	w0 = (stat*)calloc(k,sizeof(stat));
  346. 	w1 = (stat*)calloc(k,sizeof(stat));
  347. 	x *= dy; y *= dx; // イテレータ初期化
  348. 	for(i=0;i<k;i++){
  349. 		w0[i] = p->cell[x][y]->stat;
  350. 		x += dx; y += dy;
  351. 	}
  352. 	// blank初期化
  353. 	blank = (int*)calloc(n,sizeof(int));
  354. 	for(i=0;i<n-1;i++){
  355. 		blank[i] = 1;
  356. 	}
  357. 	// 決定可能なセルの探索
  358. 	ptr = 0;
  359. 	f0 = 1;
  360. 	while(f0){
  361. 		// 現構成における合計値の計算
  362. 		sum = h->sum;
  363. 		for(i=0;i<n-1;i++) sum += blank[i];
  364. 		// 選択可能なすべての左右の空白セル数に対して
  365. 		for(blank_left = 0; blank_left <= (k-sum); blank_left++){
  366. 			blank_right = (k-sum) - blank_left;
  367. 			// 仮データの生成
  368. 			idx=0;
  369. 			for(i=0;i<blank_left;i++)		w1[idx++] = SPACE;
  370. 			for(i=0;i<n;i++){
  371. 				for(j=0;j<(h->data[i]);j++)	w1[idx++] = FILL;
  372. 				for(j=0;j<(blank[i]);j++)	w1[idx++] = SPACE;
  373. 			}
  374. 			for(i=0;i<blank_right;i++)		w1[idx++] = SPACE;
  375. 			// 確定済のデータとの整合性は取れているのか
  376. 			f1 = 1;
  377. 			x *= dy; y *= dx; // イテレータ初期化
  378. 			for(i=0;i<k;i++){
  379. 				if(p->cell[x][y]->stat != UNKNOWN){
  380. 					if(p->cell[x][y]->stat != w1[i]) f1 = 0;
  381. 				}
  382. 				x += dx; y += dy;
  383. 			}
  384. 			// 整合性が取れているのであれば比較して新しい候補を作る
  385. 			if(f1 == 1){
  386. 				for(i=0;i<k;i++){
  387. 					if(w0[i] == UNKNOWN){
  388. 						w0[i] = w1[i];
  389. 					}else{
  390. 						if(w0[i]!=w1[i]) w0[i] = ND; 
  391. 					}
  392. 				}
  393. 			}
  394. 		}
  395. 		// 次の構成を生成する
  396. 		if(n == 1 && h->data[0] == sum){ // 全塗りの場合
  397. 			f0 = 0;
  398. 		}else{
  399. 			ptr = (sum == k)?ptr+1:0;
  400. 			blank[ptr]++;
  401. 			for(i=0;i<ptr;i++) blank[i] = 1;
  402. 			f0 = (blank[n-1]==0);
  403. 		}
  404. 	}
  405. 	// 結果の上書き
  406. 	x *= dy; y *= dx; // イテレータ初期化
  407. 	for(i=0;i<k;i++){
  408. 		if(w0[i] == ND){
  409. 			p->cell[x][y]->stat = UNKNOWN;
  410. 		}else{
  411. 			p->cell[x][y]->stat = w0[i];
  412. 		}
  413. 		x += dx; y += dy;
  414. 	}
  415. 	// 作業領域の破棄
  416. 	free(blank);
  417. 	free(w0);
  418. 	free(w1);
  419. 	// 確定セルを数える
  420. 	x *= dy; y *= dx; // イテレータ初期化
  421. 	for(i=0;i<k;i++){
  422. 		if(p->cell[x][y]->stat != UNKNOWN) count++;
  423. 		x += dx; y += dy;
  424. 	}
  425. 	// if(count-count0 != 0) print_piclos(p);
  426. 	return count-count0;
  427. }
  428. int detect_all(piclos *p)
  429. {
  430. 	int i,count=0;
  431. 	for(i=0;i<(p->size.x);i++)
  432. 		count += detect_line(p,-1,i);
  433. 	for(i=0;i<(p->size.y);i++)
  434. 		count += detect_line(p,i,-1);
  435. 	return count;
  436. }
  437. void detect(piclos *p)
  438. {
  439. 	while(detect_all(p)){
  440. 		// print_piclos(p);
  441. 	}
  442. }
  443. /************* </DETECT> ******************/
  444.  
  445. /************* <ELIMINATE> ****************/
  446. // 未確定のセルを数える
  447. int countUNKNOWN_piclos(piclos *p)
  448. {
  449. 	int i,j,cnt=0;
  450. 	for(i=0;i<p->size.x;i++)
  451. 		for(j=0;j<p->size.y;j++)
  452. 			if(p->cell[i][j]->stat == UNKNOWN)
  453. 				cnt++;
  454. 	return cnt;
  455. }
  456. // 行の整合性を判定
  457. int line_enable(piclos *p, int row, int col)
  458. {
  459. 	hint *h; // 対象ヒント
  460. 	stat *w; // 作業用セル状態
  461. 	int *blank; // 黒セルの間隔
  462. 	int blank_left, blank_right; // 左右の空白セル数
  463. 	// x,y:セル選択用イテレータ; dx,dy:イテレータの増分; idx,i,j:カウンタ変数; k:対象方向のセル数; n:blankの数; sum:合計値; ptr:現在操作中のblankを指す
  464. 	int dx,dy,x,y,idx,i,j,k,n,sum,ptr;
  465. 	int f0, f1; // フラグ
  466. 	int enable = 0;
  467. 	// 引数チェック
  468. 	if(!(row==-1 || col==-1)) return -1;
  469. 	// 計算方向の初期化
  470. 	if(row==-1){ dx = 0; dy = 1; x = col; y = 0; k = p->size.y; h = p->hintX[x]; n = h->length; }
  471. 	if(col==-1){ dx = 1; dy = 0; x = 0; y = row; k = p->size.x; h = p->hintY[y]; n = h->length; }
  472. 	// 作業領域の準備
  473. 	w = (stat*)calloc(k,sizeof(stat));
  474. 	// blank初期化
  475. 	blank = (int*)calloc(n,sizeof(int));
  476. 	for(i=0;i<n-1;i++){
  477. 		blank[i] = 1;
  478. 	}
  479. 	// 決定可能なセルの探索
  480. 	ptr = 0;
  481. 	f0 = 1;
  482. 	while(f0){
  483. 		// 現構成における合計値の計算
  484. 		sum = h->sum;
  485. 		for(i=0;i<n-1;i++) sum += blank[i];
  486. 		// 選択可能なすべての左右の空白セル数に対して
  487. 		for(blank_left = 0; blank_left <= (k-sum); blank_left++){
  488. 			blank_right = (k-sum) - blank_left;
  489. 			// 仮データの生成
  490. 			idx=0;
  491. 			for(i=0;i<blank_left;i++)		w[idx++] = SPACE;
  492. 			for(i=0;i<n;i++){
  493. 				for(j=0;j<(h->data[i]);j++)	w[idx++] = FILL;
  494. 				for(j=0;j<(blank[i]);j++)	w[idx++] = SPACE;
  495. 			}
  496. 			for(i=0;i<blank_right;i++)		w[idx++] = SPACE;
  497. 			// 確定済のデータとの整合性は取れているのか
  498. 			f1 = 1;
  499. 			x *= dy; y *= dx; // イテレータ初期化
  500. 			for(i=0;i<k;i++){
  501. 				if(p->cell[x][y]->stat != UNKNOWN){
  502. 					if(p->cell[x][y]->stat != w[i]) f1 = 0;
  503. 				}
  504. 				x += dx; y += dy;
  505. 			}
  506. 			if(f1 == 1) enable++;
  507. 		}
  508. 		// 次の構成を生成する
  509. 		if(n == 1 && h->data[0] == sum){
  510. 			f0 = 0;
  511. 		}else{
  512. 			ptr = (sum == k)?ptr+1:0;
  513. 			blank[ptr]++;
  514. 			for(i=0;i<ptr;i++) blank[i] = 1;
  515. 			f0 = (blank[n-1]==0);
  516. 		}
  517. 	}
  518. 	// 作業領域の破棄
  519. 	free(blank);
  520. 	free(w);
  521. 	return enable;
  522.  
  523. }
  524. // 全セルの整合性を判定
  525. int piclos_enable(piclos *p)
  526. {
  527. 	int i,res=1;
  528. 	for(i=0;i<p->size.x;i++)
  529. 		if(line_enable(p,-1,i) == 0) res = 0;
  530. 	for(i=0;i<p->size.y;i++)
  531. 		if(line_enable(p,i,-1) == 0) res = 0;
  532. 	return res;
  533. }
  534. // 終了判定
  535. int is_finish_piclos(piclos *p)
  536. {
  537. 	return((countUNKNOWN_piclos(p) == 0) && piclos_enable(p));
  538. }
  539. // 選択が有効であるかを判定する
  540. int elm_selection_enable(piclos *src, int x, int y, stat st)
  541. {
  542. 	int enable;
  543. 	piclos *p = clone_piclos(src);
  544. 	p->cell[x][y]->stat = st;
  545. 	enable = (line_enable(p,-1,x) && line_enable(p,y,-1));
  546. 	delete_piclos(p,1);
  547. 	return enable;
  548. }
  549. // 塗潰せるセルを選ぶ(組み合わせが最も少ない場所から選ぶことで消去法の繰り返しを減らす)
  550. int elm_select(piclos *p, int *x, int *y)
  551. {
  552. 	int min=9999; // 全ての行・列について組み合わせ可能なパターンの個数を調べた場合の最小値
  553. 	int orient=0; // 組み合わせ数が最小となるものの方向。行方向:0; 列方向:1;
  554. 	int index=-1; // 組み合わせ数が最小となるもの行・列番号
  555. 	int a,i,k,dx,dy;
  556. 	// 最小探索
  557. 	for(i=0;i<p->size.y;i++){
  558. 		a = line_enable(p,i,-1);
  559. 		if(a > 1 && a < min){ min = a; orient=0; index=i; }
  560. 	}
  561. 	for(i=0;i<p->size.x;i++){
  562. 		a = line_enable(p,-1,i);
  563. 		if(a > 1 && a < min){ min = a; orient=1; index=i; }
  564. 	}
  565. 	// おかC
  566. 	if(index==-1) return 0;
  567. 	// イテレータ初期化
  568. 	if(orient){ dx = 0; dy = 1; *x = index; *y = 0; k = p->size.y; }
  569. 	else{ dx = 1; dy = 0; *x = 0; *y = index; k = p->size.x; }
  570. 	// 探索
  571. 	for(i=0;i<k;i++){
  572. 		if(p->cell[*x][*y]->stat == UNKNOWN){
  573. 			if(elm_selection_enable(p,*x,*y,FILL)){
  574. 				return 1;
  575. 			}
  576. 		}
  577. 		*x+=dx;*y+=dy;
  578. 	}
  579. 	return 0;
  580. }
  581. // 消去法の実装
  582. int elmination(piclos *src)
  583. {
  584. 	int x,y;
  585. 	piclos *p = clone_piclos(src);
  586. 	if(elm_select(p,&x,&y)){
  587. 		// 塗潰し可能なセルを塗潰したと仮定して解いてみる
  588. 		p->cell[x][y]->stat = FILL;
  589. 		detect(p);
  590. 		if(!piclos_enable(p)){
  591. 			// 仮定が間違っている場合、空白にして解いてみる。
  592. 			copy_piclos(src,p);
  593. 			p->cell[x][y]->stat = SPACE;
  594. 			detect(p);
  595. 			if(!piclos_enable(p)){
  596. 				// 塗潰しでも空白でもだめなので親の仮定がまちがい
  597. 				delete_piclos(p,1);
  598. 				return 0;
  599. 			}
  600. 		}
  601. 		if(is_finish_piclos(p)){
  602. 			// 終了判定をクリアすればめでたく終了
  603. 			copy_piclos(p, src);
  604. 			delete_piclos(p,1);
  605. 			return 1; // やったね！
  606. 		}else{
  607. 			// クリアできていないので再帰的に消去法を用いる
  608. 			if(elmination(p)){
  609. 				// 消去法の継続により解が求められた。
  610. 				copy_piclos(p, src);
  611. 				delete_piclos(p,1);
  612. 				return 1;
  613. 			}else{
  614. 				if(p->cell[x][y]->stat == SPACE){
  615. 					// 塗潰しでも空白でもだめなので親の仮定がまちがい
  616. 					delete_piclos(p,1);
  617. 					return 0;
  618. 				}
  619. 				// 空白にして解いてみる。
  620. 				copy_piclos(src,p);
  621. 				p->cell[x][y]->stat = SPACE;
  622. 				detect(p);
  623. 				if(!piclos_enable(p)){
  624. 					// 塗潰しでも空白でもだめなので親の仮定がまちがい
  625. 					delete_piclos(p,1);
  626. 					return 0;
  627. 				}
  628. 				// 終了判定をクリアすればめでたく終了
  629. 				if(is_finish_piclos(p)){
  630. 					copy_piclos(p, src);
  631. 					delete_piclos(p,1);
  632. 					return 1; // やったね！
  633. 				}else{
  634. 					// クリアできていないので再帰的に消去法を用いる
  635. 					if(elmination(p)){
  636. 						// 消去法で解が求められた。
  637. 						copy_piclos(p, src);
  638. 						delete_piclos(p,1);
  639. 						return 1;
  640. 					}else{
  641. 						// 塗潰しでも空白でもだめなので親の仮定がまちがい
  642. 						delete_piclos(p,1);
  643. 						return 0;
  644. 					}
  645. 				}
  646. 			}
  647. 		}
  648. 	}else{
  649. 		// 選択可能なセルがないので親の仮定がまちがい
  650. 		delete_piclos(p,1);
  651. 		return 0;
  652. 	}
  653. }
  654. /************* </ELIMINATE> ****************/
  655.  
  656. int main(void)
  657. {
  658.     piclos *p;
  659.     int x,y;
  660. 	puts("ピクロスの列の数を入力してください。");scanf("%d",&x);if(x<1){puts("ERROR.");return 0;}
  661.     puts("ピクロスの行の数を入力してください。");scanf("%d",&y);if(y<1){puts("ERROR.");return 0;}
  662.     p = new_piclos(x,y);
  663.     if(!input_piclos_hints(p)){
  664. 	    delete_piclos(p,1);
  665. 		return 0;// ERROR
  666. 	}
  667. 	detect(p);
  668. 	if(!is_finish_piclos(p)) elmination(p);
  669.     print_piclos_fin(p);
  670.     delete_piclos(p,1);
  671.     return 0;
  672. }
  673.  
Success #stdin #stdout 0.13s 1864KB
comments (?)
stdin
copy 
20
20
2
1 2
2 3
2 3
3 1 1
2 1 1
1 1 1 2 2
1 1 3 1 3
2 6 4
3 3 9 1
5 3 2
3 1 2 2
2 1 7
3 3 2
2 4
2 1 2
2 2 1
2 2
1
1
3
5
3 1
2 1
3 3 4
2 2 7
6 1 1
4 2 2
1 1
3 1
6
2 7
6 3 1
1 2 2 1 1
4 1 1 3
4 2 2
3 3 1
3 3
3
2 1
stdout
copy 
ピクロスの列の数を入力してください。
ピクロスの行の数を入力してください。
ピクロスのヒント（列方向）を入力してください。(空白区切りで各列ごとに改行)
ピクロスのヒント（行方向）を入力してください。(空白区切りで各列ごとに改行)
                                   1  1                                    
                                   1  1     3     3                        
                             3  2  1  3  2  3  5  1  2  3     2  2         
                    1  2  2  1  1  2  1  6  9  3  2  1  3  2  1  2  2      
                 2  2  3  3  1  1  2  3  4  1  2  2  7  2  4  2  1  2  1  1
              3                               ## ## ##                     
              5                            ## ## ## ## ##                  
           3  1                            ## ## ##    ##                  
           2  1                            ## ##       ##                  
        3  3  4                   ## ## ##    ## ## ##    ## ## ## ##      
        2  2  7             ## ##       ## ##          ## ## ## ## ## ## ##
        6  1  1       ## ## ## ## ## ##    ##          ##                  
        4  2  2    ## ## ## ##          ## ##       ## ##                  
           1  1                         ##          ##                     
           3  1                      ## ## ##       ##                     
              6                      ## ## ## ## ## ##                     
           2  7    ## ##          ## ## ## ## ## ## ##                     
        6  3  1 ## ## ## ## ## ##       ## ## ##    ##                     
  1  2  2  1  1 ##    ## ##       ## ##    ##       ##                     
     4  1  1  3          ## ## ## ##       ##    ##       ## ## ##         
        4  2  2                         ## ## ## ##    ## ##    ## ##      
        3  3  1                         ## ## ##       ## ## ##    ##      
           3  3                      ## ## ##             ## ## ##         
              3                   ## ## ##                                 
           2  1                   ## ##    ##
https://ideone.com/oHUXA
language:
C (gcc 8.3)
created:
12 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!