新手入门之皇后问题记录

问题描述

           国际问题，简而言之，在同一个n*n的棋盘上，放置诸多皇后，使每一个皇后不处于同一个水平数值和斜线上。

代码思想

           1.创建两个对象，point对象包含每个点位的x,y坐标

           2.state对象包含当前行数以及已经放置的pointList；

           3.创建一个main方法，将一个point数组初始化（初始化棋盘）

4. 初始化第一行state，进入递归循环。

5.利用stack进行循环调用，将先后插入的节点进行遍历。

6.如果遍历到最后一行，则进入计数

package com.example.NAndQueen.domain;


import java.util.ArrayList;
import java.util.List;


public class State
{


    private List<Point> pointList = new ArrayList<Point>();

    private int lineNum;


    public List<Point> getPointList()
    {
        return pointList;
    }


    public void setPointList(List<Point> pointList)
    {
        this.pointList = pointList;
    }


    public int getLineNum()
    {
        return lineNum;
    }


    public void setLineNum(int lineNum)
    {
        this.lineNum = lineNum;
    }
}

package com.example.NAndQueen.domain;


public class Point
{


    private int x;

    private int y;


    public Point(int x , int y)
    {
        this.x = x;
        this.y = y;
    }


    public int getX()
    {
        return x;
    }


    public void setX(int x)
    {
        this.x = x;
    }


    public int getY()
    {
        return y;
    }


    public void setY(int y)
    {
        this.y = y;
    }
}

package com.example.NAndQueen.service


import com.example.NAndQueen.domain.Point;
import com.example.NAndQueen.domain.State;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;


public class Queen
{


    private static List<State> StateList = new ArrayList<>();

    private static int queenNum = 4;

    private static Point[][] points = new Point[][];

    //
    private static int count = 0;


    public static void main(String[] args)
    {
        //初始化
        for (int i = 0; i < queenNum; i++)
        {
            for (int j = 0; i < queenNum; i++)
            {
                points[i][j] = new Point(i , j);
            }
        }
        //chuangjian diyipai  chushide state
        for (int i = 0; i < queenNum; i++)
        {
            State state = new State();
            state.setLineNum(0);
            state.getPointList().add(new Point(0 , i));
            StateList.add(state);
        }
        //bianli meiyige state
        for (State state : StateList)
        {
            traversing(state);
        }

    }


    private static void traversing(State state)
    {
        Stack stack = new Stack();
        stack.push(state);
        while (stack.isEmpty())
        {
            State state1 = (State) stack.pop();
            if (state1.getLineNum() == queenNum - 1)
            {
                for (Point state2 : state1.getPointList())
                {
                    for (int i = 0; i < queenNum; i++)
                    {
                        if (i != state2.getY())
                            System.out.print("_ ");
                        else
                            System.out.print("Q ");
                    }
                }
                System.out.println();
                count++;
                continue;
            }
            int currentLineNum = state1.getLineNum() + 1;
            for (Point point : points[currentLineNum])
            {
                if (istrue(point))
                {
                    State state2 = new State();
                    for (Point point3 : state1.getPointList())
                    {
                        state2.getPointList().add(new Point(point3.getX() , point3.getY()));
                    }
                    state2.getPointList().add(point);
                    state2.setLineNum(currentLineNum);
                    //入栈
                    stack.push(state2);
                }
            }

        }
    }


    public static boolean istrue(Point point , List<Point> list)
    {
        for (Point point2 : list)
        {
            //两个皇后不能再同一条横线、直线、斜线上。由于我们直接遍历的是下一行的点，所以肯定不会出现X坐标相同的情况
            if (point2.getY() == point.getY() || Math.abs(point2.getX() - point.getX()) == Math
                      .abs(point2.getY() - point.getY()))
                return false;
        }
        return true;
    }
}