[转]Eight Queens algorithm With ABAP

If you have time and interest in eight queens algorithm, then you can read this article, it is done by ABAP and tested in ECC6.

REPORT z_8queen NO STANDARD PAGE HEADING.

*Store where the queen is
DATA: BEGIN OF row ,
val TYPE i,
END OF row .
DATA: i_row LIKE row OCCURS 0 WITH HEADER LINE .

*How many ways we can achieve
DATA: oktimes TYPE i .
data: queen type i.

*Define the number of queen
CONSTANTS: queenmax TYPE i VALUE 8 .

*Input queen number
PARAMETERS: p_num TYPE i DEFAULT queenmax.

START-OF-SELECTION .
PERFORM main_process .

*&---------------------------------------------------------------------*
*& Form MAIN_PROCESS
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
FORM main_process .
DATA: l_num TYPE i . "The first place
DATA: l_s(50) TYPE c . "Output string
DATA: l_time(10) TYPE c.

queen = p_num + 1.
* Init place table
DO queenmax TIMES .
i_row-val = -1 .
APPEND i_row .
ENDDO.
l_num = 1 .
* recursion
PERFORM place_queen USING l_num.

* Get ways of algorithm

l_time = oktimes .
CONDENSE l_time .
CONCATENATE 'Eight Queens have' l_time 'ways to solve it.' INTO l_s
SEPARATED BY space.
WRITE: l_s .
ENDFORM. " MAIN_PROCESS
*&---------------------------------------------------------------------*
*& Form place_queen
*&---------------------------------------------------------------------*
* text
*----------------------------------------------------------------------*
FORM place_queen USING p_num.
* Local data definition
DATA: l_i TYPE i .
DATA: l_num TYPE i .
* Temp variants
DATA: l_k TYPE i .
DATA: l_t1 TYPE i .
DATA: l_t2 TYPE i .

* Safe place
DATA: BEGIN OF qsave OCCURS 0 ,
val TYPE i ,
END OF qsave .

* Init safe place, make all place be safe
DO queenmax TIMES .
qsave-val = 1 .
APPEND qsave .
ENDDO.

l_i = 1 .
l_num = p_num .

* This loop get the safe place
WHILE l_i < l_num .
READ TABLE i_row INDEX l_i .
READ TABLE qsave INDEX i_row-val .
qsave-val = 0 .
MODIFY qsave INDEX i_row-val.

l_k = l_num - l_i .
l_t1 = i_row-val + l_k .
l_t2 = i_row-val - l_k .

* Mark safe place
* If a queen's place is I_ROW[i]=j, then the unsafe place is row k column j
* and column j+k-i and j-k+i

IF l_t1 >= 1 AND l_t1 < queen .
READ TABLE qsave INDEX l_t1 .
qsave-val = 0 .
MODIFY qsave INDEX l_t1 .
ENDIF.

IF l_t2 >= 1 AND l_t2 < queen .
READ TABLE qsave INDEX l_t2 .
qsave-val = 0 .
MODIFY qsave INDEX l_t2 .
ENDIF.
l_i = l_i + 1 .
ENDWHILE .

l_i = 1 .
* Below loop is to get the queen's place
WHILE l_i < queen .
READ TABLE qsave INDEX l_i .
IF qsave-val = 0 .
* If this place is not safe, then get the next place
l_i = l_i + 1 .
CONTINUE .
ENDIF.

* if not the last place
IF p_num < queenmax.
READ TABLE i_row INDEX p_num .
i_row-val = l_i .
MODIFY i_row INDEX p_num .
l_num = p_num + 1 .
* Get the next queen's place
PERFORM place_queen USING l_num .
ELSE .
* The last queen, give her the last place
READ TABLE i_row INDEX p_num .
i_row-val = l_i .
MODIFY i_row INDEX p_num.
* The ways of place add 1 and output
oktimes = oktimes + 1 .
WRITE: '--------------------------------------------------------------------------------',/.
LOOP AT i_row .
WRITE: i_row-val .
ENDLOOP .
WRITE: / .
ENDIF.
l_i = l_i + 1 .
ENDWHILE .
ENDFORM. " PLACE_QUEEN