20.8 Problem: Fractals

20.8 Problem: Fractals 693

4

5 public class SierpinskiTriangle extends JApplet {

6 private JTextField jtfOrder = new JTextField("0", 5); // Order

7private SierpinskiTrianglePanel trianglePanel =

8 new SierpinskiTrianglePanel(); // To display the pattern

9

10public SierpinskiTriangle() {

11// Panel to hold label, text field, and a button

12JPanel panel = new JPanel();

13panel.add(new JLabel("Enter an order: "));

14panel.add(jtfOrder);

15jtfOrder.setHorizontalAlignment(SwingConstants.RIGHT);

17// Add a Sierpinski triangle panel to the applet

18add(trianglePanel);

19add(panel, BorderLayout.SOUTH);

21// Register a listener

25}

26});

27}

28

29static class SierpinskiTrianglePanel extends JPanel {

30private int order = 0;

31

32/** Set a new order */

33public void setOrder(int order) {

34this.order = order;

35repaint();

36}

37

38protected void paintComponent(Graphics g) {

39super.paintComponent(g);

43Point p2 = new Point(10, getHeight() - 10);

44Point p3 = new Point(getWidth() - 10, getHeight() - 10);

46displayTriangles(g, order, p1, p2, p3);

49private static void displayTriangles(Graphics g, int order,

50Point p1, Point p2, Point p3) {

51if (order >= 0) {

52// Draw a triangle to connect three points

54g.drawLine(p1.x, p1.y, p3.x, p3.y);

55g.drawLine(p2.x, p2.y, p3.x, p3.y);

57// Get the midpoint on each edge in the triangle

58Point p12 = midpoint(p1, p2);

59Point p23 = midpoint(p2, p3);

60Point p31 = midpoint(p3, p1);

62// Recursively display three triangles

20.9 Problem: Eight Queens 695

20.9 Problem: Eight Queens

This section gives a recursive solution to the Eight Queens problem presented at the beginning of the chapter. The task is to find a solution to place a queen in each row on a chessboard such that no two queens can attack each other. You may use a two-dimensional array to represent a chessboard. However, since each row can have only one queen, it is sufficient to use a one-dimensional array to denote the position of the queen in the row. So, you may define array queens as follows:

int[] queens = new int[8];

Assign j to queens[i] to denote that a queen is placed in row i and column j. Figure 20.11(a) shows the contents of array queens for the chessboard in Figure 20.11(b).

queens[0] 0 queens[1] 4 queens[2] 7 queens[3] 5 queens[4] 2 queens[5] 6 queens[6] 1 queens[7] 3

FIGURE 20.11 queens[i] denotes the position of the queen in row i.

Listing 20.10 gives the program that displays a solution for the Eight Queens problem.

LISTING 20.10 EightQueens.java

1 import java.awt.*;

2 import javax.swing.*;

3

4 public class EightQueens extends JApplet {

5 public static final int SIZE = 8; // The size of the chessboard 6 private int[] queens = new int[SIZE]; // Queen positions

7

8public EightQueens() {

10add(new ChessBoard(), BorderLayout.CENTER); // Display solution

11}

15for (int i = 1; i <= row; i++)

16if (queens[row - i] == column // Check column

17|| queens[row - i] == column - i // Check upleft diagonal

18|| queens[row - i] == column + i) // Check upright diagonal

19return false; // There is a conflict

20return true; // No conflict

21}

696 Chapter 20 Recursion

The program invokes search(0) (line 9) to start a search for a solution at row 0, which recursively invokes search(1), search(2), Á , and search(7) (line 30).

The recursive search(row) method returns true if all row are filled (lines 25–26). The method checks whether a queen can be placed in column 0, 1, 2, Á , and 7 in a for loop (line 28). Place a queen in the column (line 29). If the placement is valid, recursively search for the next row by invoking search(row + 1) (line 30). If search is successful, return true (line 31) to exit the for loop. In this case, there is no need to look for the next column in the row. If there is no solution for a queen to be placed on any column of this row, the method returns false (line 35).

Suppose you invoke search(row) for row 3, as shown in Figure 20.12(a). The method tries to fill in a queen in column 0, 1, 2, and so on in this order. For each trial, the isValid(row, column) method (line 30) is called to check whether placing a queen at the specified position causes a conflict with the queens placed earlier. It ensures that no queen is placed in the same column (line 16), no queen is placed in the upper left diagonal (line 17), and no queen is placed in the upper right diagonal (line 18), as shown in Figure 20.12(a). If isValid(row, column) returns false, check the next column, as shown Figure 20.12(b). If isValid(row, column) returns true, recursively invoke search(row + 1), as shown in Figure 20.12(d). If search(row + 1) returns false, check the next column on the preceding row, as shown Figure 20.12(c).