启发式搜索之八皇后问题

问题描述->移步前面

主要公式fx=gx+hx
* g(x)：针对于初始节点，到目标节点实际所需要付出的带价
* h(x)：针对初始节点，到目标节点所需要的估计带价
* 在八皇后问题上，估计带价，是自己预定的，此处设置，其为皇后的碰撞对数，当然，估计是最优
* 的问题，就是0，无碰撞才是最优的结果。
注释都有，自行消化

package Heuristically_reserach_eight_queen;

/**
 * @Author CRH
 * @Date 2020/11/25 10:05
 */
public class Heuristically_research_egith_queen {
    /**
     * 启发式搜索，包含有序搜索算法，以及A*算法，
     * 主要公式fx=gx+hx
     * g(x)：针对于初始节点，到目标节点实际所需要付出的带价
     * h(x)：针对初始节点，到目标节点所需要的估计带价
     * 在八皇后问题上，估计带价，是自己预定的，此处设置，其为皇后的碰撞对数，当然，估计是最优
     * 的问题，就是0，无碰撞才是最优的结果。
     */
    public static void main(String[] args){
        int[] queen_array = new int[8];
        int[] queen_array1 ={1,1,1,1,1,1,1,1};
        queen_array = init_queen(queen_array);//初始化完成
       // System.out.println("-----------测试点-----------------------"+function_g(queen_array1,7));

        begin_heuristcally(queen_array,0);
    }
    //开始查找
    public static void begin_heuristcally(int[] queen_array,int index){
        //其实和之前的评价函数类似，等同于，该点进行评估，然后针对，是否在该点进行落子，落皇后
        int hx = 0;
        int fx  = function_g(queen_array,index);;
        for (int i = 0; i < 8; i++) {
            queen_array[index]=i;
            int gx = function_g(queen_array,index);//这是该位置，实际评估的函数值
            //然后开始进行评定
            fx = gx +hx;
            if (fx>0){
                //假设gx>fx说明该点，不满足条件，与预估不符合，然后开始将其，复原，寻找下一节点,具体操作就是，将其往下，继续走
            }else if (fx == 0){
                //现行判断是否达到出口条件，然后考虑是否进入下一步
                if (index==7){//表示问题已经到了最后一步，但是还是最优，进而表明其实优解
                    System.out.println("--------------------已经找到最优解-----------------------");
                    print_queen(queen_array);
                    break;
                }else {
                    //表明，这个地方，为优解，进而向下一步进行->index+1;
                    begin_heuristcally(queen_array,(index+1)%8);//直接进行取取余，不用担心下标越界
                }
            }

        }
    }

    //初始化函数
    public static int[] init_queen(int[] queen_array){
        for (int i = 0; i < queen_array.length; i++) {
            //queen_array[i] = (int)(Math.random()*8);
            queen_array[i] = 0;
        }
        return queen_array;
    }
    //实际函数的计算,参数position是针对该点前面的评价函数，进行评定，节省查找时间，进行优化
    public static int function_g(int[] one_geTi,int position){
        int flight_count = 0;
        for (int i = 0; i <= position-1; i++) {
            for (int j = i+1; j <= position; j++) {
                if (one_geTi[i]==one_geTi[j]|((j -i) == Math.abs(one_geTi[i]-one_geTi[j]))){
                    flight_count++;
                }
            }
        }
        return flight_count;
    }
    public static void print_queen(int[] queen){
        for (int i = 0; i < queen.length; i++) {
            System.out.print(queen[i]+"   ");
        }
        System.out.println();
    }
}

结语：共勉