中级实训扩展任务

　　刚刚实训答辩结束，在答辩上说了一句“我是C++的忠实粉丝”，于是TA们就都问我问题了。

　　这次实训很水，基础部分几乎不需要让人了解底层，所以格外轻松。扩展部分设计的不大合适，所以经常会出现各种问题。写点东西，贴点代码，让后人乘荫吧。

　　

第三部分扩展部分第一天：

实验要求
1． 利用二进制流读取Bitmap位图文件。注意，这里要求不能使用Java提供的API直接读取图像，根据二进制数据创建Image时可以使用API；
2． 把读取彩色图像转换成灰度图像；
3． 提取并且显示彩色图像各个色彩通道；
4． 把处理完的图像保存为bmp格式图像。注意，这里可以使用Java提供的API完成，但本文档不提供，希望各位同学自行上网查找资料自学。如果学有余力的同学，可以实现按照二进制流输出保存bmp图像；

5. 编写Junit测试程序，测试输出的图片是否与goal文件夹下的图片一致。（比较位图宽度、位图高度以及像素值）

    个人补充：Bitmap是windows下的格式，比较无聊地被拿到Linux下去读取，wiki上给的链接介绍Bitmap的格式，网上再稍微搜一下就对它有更深的理解了。我对bitmap有点了解后，就到MSDN搜索bitmap的数据结构，模仿其数据结构去保存数据。代码如下：

　　 

package ImageIOImplement;
import java.awt.*;  
import java.awt.image.*;  
import javax.imageio.*;  
import java.io.*;  
import java.lang.String;
import imagereader.IImageIO;

public class ImageIOImplement implements IImageIO
{
    /* 位图文件头，模仿windows下的结构体，
     * 详细见：http://msdn.microsoft.com/en-us/library/windows/desktop/dd183374(v=vs.85).aspx
     */
    public class BITMAPFILEHEADER
    {
        public int bfType; // 位图文件的类型，必须为BM
        public int bfSize; // 位图文件的大小，以字节为单位
        public int bfReserved1; // 位图文件保留字，必须为0
        public int bfReserved2; // 位图文件保留字，必须为0
        public int bfOffBits; // 位图数据的起始位置，以相对于位图
        
        /*保存位图头
        * 字节 #0-1    保存位图文件的标识符，这两个字节的典型数据是BM。
        * 字节 #2-5    使用一个dword保存位图文件大小。
        * 字节 #6-9    是保留部分，留做以后的扩展使用,对实际的解码格式没有影响。
        * 字节 #10-13    保存位图数据位置的地址偏移，也就是起始地址。
        * 注：由以上可知，只有字节#2-5是需要保存的。
        */
        public BITMAPFILEHEADER(FileInputStream pFile)
        {
            int BitMapHeadRSize = 14;
            byte pBITMAPFILEHEADER[] = new byte[BitMapHeadRSize];
            try
            {
                pFile.read(pBITMAPFILEHEADER, 0, BitMapHeadRSize);
                bfType = 16973;         //ox424D, BM
                //为何要&呢？因为byte(8位)转int(32位)时，需要补24位，当byte数据是无符号数时，则补0,有符号时，则补1
                bfSize = (((int)pBITMAPFILEHEADER[5] & 0xff) << 24)  
                          | (((int)pBITMAPFILEHEADER[4] & 0xff) << 16)  
                          | (((int)pBITMAPFILEHEADER[3] & 0xff) << 8)  
                          | ((int)pBITMAPFILEHEADER[2] & 0xff);  
                bfReserved1 = 0;
                bfReserved2 = 0;
                //bfOffBits暂时不进行处理 
            }
            //IO读取异常，FileInputStream和FileOutStream必须使用异常处理，略无奈
            catch(IOException e)
            { 
                e.printStackTrace(); 
            }
        }
        
    }
    
    /* 位图信息头，模仿windows下的结构体
     * 详细见：http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376(v=vs.85).aspx
     */
    public class  BITMAPINFOHEADER
    {
        public int biSize; // 本结构所占用字节数
        public int biWidth; // 位图的宽度，以像素为单位
        public int biHeight; // 位图的高度，以像素为单位
        public int biPlanes; // 目标设备的级别，必须为1
        public int biBitCount;// 每个像素所需的位数，必须是1(双色),
        // 4(16色)，8(256色)或24(真彩色)之一
        public int biCompression; // 位图压缩类型，必须是 0(不压缩),
        // 1(BI_RLE8压缩类型)或2(BI_RLE4压缩类型)之一
        public int biSizeImage; // 位图的大小，以字节为单位
        public int biXPelsPerMeter; // 位图水平分辨率，每米像素数
        public int biYPelsPerMeter; // 位图垂直分辨率，每米像素数
        public int biClrUsed;// 位图实际使用的颜色表中的颜色数
        public int biClrImportant;// 位图显示过程中重要的颜色数
        
        //
        public int ColorModel[];
        /* 保存位图信息
         * 字节 #14-17    定义以下用来描述影像的区块（BitmapInfoHeader）的大小。它的值是：40 - Windows 3.2、95、NT、12 - OS/2 1.x、240 - OS/2 2.x
         * 字节 #18-21    保存位图宽度（以像素个数表示）。
         * 字节 #22-25    保存位图高度（以像素个数表示）。
         * 字节 #26-27    保存所用彩色位面的个数。不经常使用。
          * 字节 #28-29    保存每个像素的位数，它是图像的颜色深度。常用值是1、4、8（灰阶）和24（彩色）。
         * 字节 #30-33    定义所用的压缩算法。允许的值是0、1、2、3、4、5。
         *                     0 - 没有压缩（也用BI_RGB表示）
         *                     1 - 行程长度编码 8位/像素（也用BI_RLE8表示）
         *                     2 - 行程长度编码4位/像素（也用BI_RLE4表示）
         *                     3 - Bit field（也用BI_BITFIELDS表示）
         *                     4 - JPEG图像（也用BI_JPEG表示）
         *                     5 - PNG图像（也用BI_PNG表示）
         *                    然而，由于大多数位图文件都是不压缩的，所以最常用的值是0。
         * 字节 #34-37    保存图像大小。这是原始（:en:raw）位图数据的大小，不要与文件大小混淆。
         * 字节 #38-41    保存图像水平方向分辨率。
         * 字节 #42-45    保存图像竖值方向分辨率。
         * 字节 #46-49    保存所用颜色数目。
         * 字节 #50-53    保存所用重要颜色数目。当每个颜色都重要时这个值与颜色数目相等。
         * */
        public BITMAPINFOHEADER(FileInputStream pFile)
        {
            int bitMapInfoHeaderSize = 40;
            byte pBITMAPINFOHEADER[] = new byte[bitMapInfoHeaderSize];
            try
            {
                pFile.read(pBITMAPINFOHEADER, 0, bitMapInfoHeaderSize);
                
                biSize = (((int)pBITMAPINFOHEADER[3] & 0xff) << 24)  
                         | (((int)pBITMAPINFOHEADER[2] & 0xff) << 16)  
                         | (((int)pBITMAPINFOHEADER[1] & 0xff) << 8)  
                         | (int)pBITMAPINFOHEADER[0] & 0xff;  
            
                biWidth = (((int)pBITMAPINFOHEADER[7] & 0xff) << 24)  
                        | (((int)pBITMAPINFOHEADER[6] & 0xff) << 16)  
                        | (((int)pBITMAPINFOHEADER[5] & 0xff) << 8)  
                        | (int)pBITMAPINFOHEADER[4] & 0xff;  

                biHeight = (((int)pBITMAPINFOHEADER[11] & 0xff) << 24)  
                        | (((int)pBITMAPINFOHEADER[10] & 0xff) << 16)  
                        | (((int)pBITMAPINFOHEADER[9] & 0xff) << 8)  
                        | (int)pBITMAPINFOHEADER[8] & 0xff;  


                biPlanes = (((int)pBITMAPINFOHEADER[13] & 0xff) << 8) 
                           | (int)pBITMAPINFOHEADER[12] & 0xff;  


                biBitCount = (((int)pBITMAPINFOHEADER[15] & 0xff) << 8) 
                            | (int)pBITMAPINFOHEADER[14] & 0xff;  

              
                biCompression = (((int)pBITMAPINFOHEADER[19]) << 24)  
                              | (((int)pBITMAPINFOHEADER[18]) << 16)  
                              | (((int)pBITMAPINFOHEADER[17]) << 8)  
                              | (int)pBITMAPINFOHEADER[16];  

                biSizeImage = (((int)pBITMAPINFOHEADER[23] & 0xff) << 24)  
                            | (((int)pBITMAPINFOHEADER[22] & 0xff) << 16)  
                            | (((int)pBITMAPINFOHEADER[21] & 0xff) << 8)  
                            | (int)pBITMAPINFOHEADER[20] & 0xff;  

                biXPelsPerMeter = (((int)pBITMAPINFOHEADER[27] & 0xff) << 24)  
                                  | (((int)pBITMAPINFOHEADER[26] & 0xff) << 16)  
                                  | (((int)pBITMAPINFOHEADER[25] & 0xff) << 8)  
                                  | (int)pBITMAPINFOHEADER[24] & 0xff;  
      

                biYPelsPerMeter = (((int)pBITMAPINFOHEADER[31] & 0xff) << 24)  
                                | (((int)pBITMAPINFOHEADER[30] & 0xff) << 16)  
                                | (((int)pBITMAPINFOHEADER[29] & 0xff) << 8)  
                                | (int)pBITMAPINFOHEADER[28] & 0xff;  

                biClrUsed = (((int)pBITMAPINFOHEADER[35] & 0xff) << 24)  
                          | (((int)pBITMAPINFOHEADER[34] & 0xff) << 16)  
                          | (((int)pBITMAPINFOHEADER[33] & 0xff) << 8)  
                          | (int)pBITMAPINFOHEADER[32] & 0xff;  

                biClrImportant = (((int)pBITMAPINFOHEADER[39] & 0xff) << 24)  
                               | (((int)pBITMAPINFOHEADER[38] & 0xff) << 16)  
                               | (((int)pBITMAPINFOHEADER[37] & 0xff) << 8)  
                               | (int)pBITMAPINFOHEADER[36] & 0xff; 
                
                if(biBitCount == 24)
                {
                    //构建位数组
                    //由于像素使用的字节若不是4的倍数，则会自动扩大，由此产生空白。因此我们需要在一开始计算出空白的大小
                    int biPad = (biSizeImage / biHeight) - biWidth * 3; 
                    if(biPad == 4)
                    {  
                        biPad = 0;  
                    }  
                    ColorModel = new int[biHeight * biWidth];  
                    //由此构建数组  
                    byte brgb[] = new byte[biSizeImage];  
                    pFile.read(brgb, 0, biSizeImage);  
                    
                    int index = 0;  
                    for(int j = 0; j < biHeight; j++)
                    {  
                        for(int i = 0; i < biWidth; i++)
                        {  
                            //为何要&255?透明度呀卧槽...
                            ColorModel[biWidth * (biHeight - j - 1) + i] =  
                                                            (255 & 0xff) << 24  
                                                        | (((int)brgb[index + 2] & 0xff) << 16)  
                                                        | (((int)brgb[index + 1] & 0xff) << 8)  
                                                        | (int)brgb[index] & 0xff;  
                            index += 3;  
                        }  
                        index += biPad;  
                    }
                }
                else
                {
                    //抛出异常或打印提醒
                    System.out.println("不是24bit，暂时不能处理");
                }
            }
            //IO读取异常，FileInputStream和FileOutStream必须使用异常处理，略无奈
            catch(IOException e)
            { 
                e.printStackTrace(); 
            }
        }  
         
        public Image getImage()
        {
            //MemoryImageSouce来自ImageProducer
            Image pImage = null;
            pImage = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(
                                        this.biWidth, this.biHeight, 
                                        this.ColorModel, 0, this.biWidth));
            return pImage;
        }
    }
    
    public Image myRead(String bmpFileName)
    {
        //我们要读取到Image
        Image pImage = null;
        try
        {
            //读取文件
            FileInputStream pFile = new FileInputStream(bmpFileName);
                
            //保存位图头,弱弱地说这个暂时没用到,在保存文件时用了API
            BITMAPFILEHEADER pBITMAPFILEHEADER = new BITMAPFILEHEADER(pFile);
                
            // 保存位图信息
            BITMAPINFOHEADER pBITMAPINFOHEADER = new BITMAPINFOHEADER(pFile);
                
            pImage = pBITMAPINFOHEADER.getImage();
            
            pFile.close();
            
            return pImage;
        }
        //IO读取异常，FileInputStream和FileOutStream必须使用异常处理，略无奈
        catch(IOException e)
        { 
            e.printStackTrace(); 
        }
        return null;
    }
    
    //根据二进制数据创建Image时可以使用API
    public Image myWrite(Image pImage, String saveFileName)
    {
        try  
        {  
            File pImgFile = new File(saveFileName + ".bmp");
            BufferedImage pBufferedImage = new BufferedImage(pImage.getWidth(null), 
                                                    pImage.getHeight(null), 
                                                    BufferedImage.TYPE_INT_RGB);
            Graphics pGraphics = pBufferedImage.getGraphics();
            pGraphics.drawImage(pImage, 0, 0, null); 
            pGraphics.dispose();
            ImageIO.write(pBufferedImage, "bmp", pImgFile); 
        }  
        catch (Exception e)  
        {  
            e.printStackTrace(System.out);  
        }  
        
        return pImage;
    }
}

至于如何提取不同颜色通道，看下面的代码注释就了解了。如果大家学完第一第二部分，能够去看一下GridWorld的WorldFrame，看看GUIController和Grid如何分离，我记得里面有一个转灰色的方法，就可以模仿他的实现。

package ImageIOImplement;
import imagereader.IImageProcessor;  

import java.awt.*;  
import java.awt.image.*; 

/*
 * 根据不同颜色通道的提取实现不同的filterRGB方法。到处查看声明发现filterRGB是一个abstract方法。
 * 查看调用发现是在filterIndexColorModel和filterRGBPixels中调用。
 * 查看setColorModel，发现这个条件canFilterIndexColorModel && (model instanceof IndexColorModel)决定了是否调用自己实现的提取色彩通道的方法。
 * 貌似必须这样做,所以就
 *  */
public class ImageProcessor implements IImageProcessor  
{
    //R
    public Image showChanelR(Image sourceImage)
    {
        RedFilter filter = new RedFilter();
        Toolkit kit = Toolkit.getDefaultToolkit();
        Image newimg = kit.createImage(new FilteredImageSource(sourceImage.getSource(), filter));
        return newimg;
    }
    //G
    public Image showChanelG(Image sourceImage)
    {
        GreenFilter filter = new GreenFilter();
        Toolkit kit = Toolkit.getDefaultToolkit();
        Image newimg = kit.createImage(new FilteredImageSource(sourceImage.getSource(), filter));
        return newimg;
    }
    //B
    public Image showChanelB(Image sourceImage)
    {
        BlueFilter filter = new BlueFilter();
        Toolkit kit = Toolkit.getDefaultToolkit();
        Image newimg = kit.createImage(new FilteredImageSource(sourceImage.getSource(), filter));
        return newimg;
    }
    //Gray
    public Image showGray(Image sourceImage)
    {
        GrayFilter filter = new GrayFilter();
        Toolkit kit = Toolkit.getDefaultToolkit();
        Image newimg = kit.createImage(new FilteredImageSource(sourceImage.getSource(), filter));
        return newimg;
    }
    //实现自己的红色通道提取
    class RedFilter extends RGBImageFilter
    {
        public RedFilter()
        {
            //查看RGBImageFilter的setColorModel方法，发现
            //这个条件canFilterIndexColorModel && (model instanceof IndexColorModel)
            //决定着是否调用自己的提取方法，所以将canFilterIndexColorModel设置为true
            canFilterIndexColorModel = true;    
        }
        public int filterRGB(int x, int y, int rgb)
        {
            return (rgb & 0xffff0000);
        }
    }
    //Green通道提取
    class GreenFilter extends RGBImageFilter
    {
        public GreenFilter()
        {
            canFilterIndexColorModel = true;
        }
        public int filterRGB(int x, int y, int rgb)
        {
            return (rgb & 0xff00ff00);
        }
    }
    //Blue提取
    class BlueFilter extends RGBImageFilter
    {
        public BlueFilter()
        {
            canFilterIndexColorModel = true;
        }
        public int filterRGB(int x, int y, int rgb)
        {
            return (rgb & 0xff0000ff);
        }
    }
    //Gray提取
    class GrayFilter extends RGBImageFilter
    {
        public GrayFilter()
        {
            canFilterIndexColorModel = true;
        }
        public int filterRGB(int x, int y, int rgb)
        {
            int gray = (int)(((rgb & 0x00ff0000)>>16)*0.299 + 
                            ((rgb & 0x0000ff00)>>8)*0.587 + 
                            (rgb & 0x000000ff)*0.114);
            return (rgb & 0xff000000)+(gray<<16)+(gray<<8)+gray;
        } 
    }
}

Runner：

package ImageIOImplement;
import imagereader.Runner;  

public class MyRunner 
{
    public static void main(String[] args)
    {  
        ImageIOImplement imgIO = new ImageIOImplement();  
        ImageProcessor processor = new ImageProcessor();  
        Runner.run(imgIO, processor);  
    }  
}

    单元测试嘛，我从开始学Junit的时候就去GitHub上查看官方文档(刚开始查到一个乱七八糟的文档然后被坑了)，查看里面的参数化测试方法(链接：https://github.com/junit-team/junit/wiki/Parameterized-tests)，里面给了个例子，非常容易懂，有一个方法定义了不同情境下的数据，然后在构造函数里面获取数据，然后有几组数据就会测试几次。

    下面的代码也写得很清楚了，不过记得在读取图片的时候，要使用绝对地址。想要使用相对地址的貌似需要改点东西～

package ImageIOImplement;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;

import java.io.FileInputStream;
import java.util.Collection;
import java.util.Arrays;  

import java.awt.*;
import javax.imageio.*;
import java.lang.String;
import org.junit.runner.RunWith;  
import org.junit.runners.Parameterized;  
import org.junit.runners.Parameterized.Parameters;  

@RunWith(Parameterized.class)
public class ImageReaderTest
{
    //private String filePath0;
    //private String filePath1;
    private FileInputStream pFile0;
    private FileInputStream pFile1;
    private Image pImage0;
    private Image pImage1;

    
    @Parameters   
    public static Collection<Object[]> prepareData()
    {  
         return Arrays.asList(new Object[][]{
                 {"/home/gumc/Bitmap/bmptest/my/1_blue_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/1_blue_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/1_red_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/1_red_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/1_green_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/1_green_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/1_gray_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/1_gray_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/2_blue_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/2_blue_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/2_red_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/2_red_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/2_green_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/2_green_goal.bmp"},
                 {"/home/gumc/Bitmap/bmptest/my/2_gray_goal.bmp", "/home/gumc/Bitmap/bmptest/goal/2_gray_goal.bmp"}});
    }  
    
    public ImageReaderTest(String file1, String file2) throws Exception 
    {
        //this.filePath0 = file1;
        //this.filePath1 = file2;
        this.pFile0 = new FileInputStream(file1);
        this.pFile1 = new FileInputStream(file2);
        this.pImage0 = ImageIO.read(pFile0);
        this.pImage1 = ImageIO.read(pFile1);
    }
    
    @Before
    public void setUp() throws Exception {
    }

    //比较分辨率（长宽像素值都相等）
    @Test
    public void testResolution()
    {
        assertEquals(pImage0.getHeight(null), pImage1.getHeight(null));
        assertEquals(pImage0.getWidth(null), pImage1.getWidth(null));
    }
    
    //比较像素值
    @Test
    public void testPixValue() throws Exception 
    {
        int sizeImage = pImage0.getHeight(null) * pImage1.getWidth(null);
            
        //将两个图片的位图数据部分全部读出，比较。
        byte imageColor0[] = new byte[sizeImage];
        byte imageColor1[] = new byte[sizeImage];
            
        //跳过不属于位图信息的部分
        pFile0.skip(54);
        pFile1.skip(54);
            
        pFile0.read(imageColor0, 0, sizeImage);
        pFile1.read(imageColor1, 0, sizeImage);
        //是否相等
        assertEquals(imageColor1, imageColor1);    
    }

}

 

第三部分扩展部分第二天：

 

    1. 无环路迷宫在数据结构上表现为一棵树，采用深度优先搜索算法就可以走出迷宫。本实验的目的是让同学们学习、理解和应用深度优先搜索算法。本实验要求同学们在改进的Grid World软件装置中实现深度优先搜索算法，从而使虫子走出迷宫。

　 就是用栈实现深搜嘛，刚开始一直纠结为何是Stack<ArrayList<Location>>来保存状态，而不是Stack<Location>来保存状态。想了很久才知道，原来他在栈里面就实现了保存路径和剪枝，这样的话就不用再去记录是否走过可否再走。例如我下面用栈的变化来解释为何要使用ArrayList<Location>：

　　0:　(0, 0)　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//栈的初始状态

      1:   (0, 0),  (0, 1)    |     (0,1) 　　　　　　　　　　　　　　　　　　　   //走到(0，1)是的栈状态，我用|分割不同的ArrayList<Location>

      2:   (0, 0),  (0, 1)    |     (0, 1),  (0, 2) |  (0, 2)　　　　　　　　　　　　//走到(0，2)是的栈状态

　　3:   (0, 0),  (0, 1)    |     (0, 1),  (0, 2)　　　　　　　　　　　　　　　　//假如不能再走，则pop一下

　　4:   (0, 0),  (0, 1)    |     (0, 1),  (0, 2), (1, 1) |  (1, 1)　　　　　　　　//取出(0, 1)即栈顶链表的第一个元素,找到可以走的点(1, 1),为何不是(0, 2)了呢？因为已经在链表中，证明已经走过了。

　　这样就对为何使用ArrayList有所理解了。

　　下面是我实现的代码，写得很丑，非常丑，因为那天状态挺糟糕的，所以几乎写不出代码来。

package info.gridworld.maze;

import info.gridworld.actor.Actor;

/**
 * A <code>MazeBug</code> can find its way in a maze. <br />
 * The implementation of this class is testable on the AP CS A and AB exams.
 */
public class MazeBug extends Bug 
{
    //public Location next;
    ///public Location last;
    //public Location last;
    public boolean isEnd = false;
    public Stack<ArrayList<Location>> crossLocation = new Stack<ArrayList<Location>>();
    public Integer stepCount = 0;
    boolean hasShown = false;//final message has been shown
    
    private int direction[] = {Location.NORTH, Location.EAST, Location.SOUTH, Location.WEST};
    class Probability
    {
        //North, East, South, West
        public int dire[] = {1, 1, 1, 1};
        public Location getNextLocation(ArrayList<Location> array, Location nowLoc)
        {
            int size = array.size();
            int k = nowLoc.getDirectionToward(array.get(0)) / 90;
            int max = dire[k];
            
            for (int i = 1; i < size; i++)
            {
                int j = nowLoc.getDirectionToward(array.get(i)) / 90;
                int tmp = dire[j];
                if (max < tmp)
                {
                    max = tmp;
                    k = j;
                }
            }
            return nowLoc.getAdjacentLocation(direction[k]);
        }
        
        public void increase(int oneDirection)
        {
            if (oneDirection < 0)
                throw new IllegalArgumentException("Direction " + oneDirection + " is not valid");
            dire[oneDirection / 90]++; 
        }
        public void descrease(int oneDirection)
        {
            if (oneDirection < 0)
                throw new IllegalArgumentException("Direction " + oneDirection + " is not valid");
            dire[oneDirection / 90]--; 
        }
    }
    //四个方向的概率
    Probability prob = new Probability();
    
    /**
     * Constructs a box bug that traces a square of a given side length
     * 
     * @param length
     *            the side length
     */
    public MazeBug() 
    {
        setColor(Color.GREEN);
    }

    /**
     * Moves to the next location of the square.
     */
    public void act() 
    {
        if (stepCount == 0)
        {
            ArrayList<Location> pLocs = new ArrayList<Location>();
            pLocs.add(this.getLocation());
            crossLocation.push(pLocs);
        }
        boolean willMove = canMove();
        if (isEnd == true)
        {
            //结束
            if (hasShown == false) 
            {
                String msg = stepCount.toString() + " steps";
                JOptionPane.showMessageDialog(null, msg);
                hasShown = true;
            }
        } 
        else if (willMove)
        {    
            //移动
            move();
            stepCount++;
        }
        else
        {
            //回溯
            backtracking();
            stepCount++;
        }
    }

    /**
     * Find all positions that can be move to.
     * 
     * @param loc
     *            the location to detect.
     * @return List of positions.
     */
    //取得除了来时的Location外的所有下一步可走的Location
    public ArrayList<Location> getValid(Location loc) 
    {
        Grid<Actor> gr = getGrid();
        if (gr == null)
            return null;
        
        ArrayList<Location> valid = new ArrayList<Location>();
        if (crossLocation.size() > 0)
        {
            ArrayList<Location> first = crossLocation.pop();
            ArrayList<Location> second = null;
            if (crossLocation.size() > 0)
                second = crossLocation.peek();
            for (int i = 0; i < 4; i++)
            {
                Location next = loc.getAdjacentLocation(direction[i]);
                Actor pActor = null;
                if (gr.isValid(next))
                {
                    pActor = (Actor)gr.get(next);
                    if (pActor instanceof Rock && pActor.getColor().equals(new Color(255, 0, 0)))
                    {
                        isEnd = true;
                        valid.add(next);
                        this.setDirection(this.getLocation().getDirectionToward(next));
                        this.moveTo(next);
                    }    
                    else if (pActor == null)
                    {
                        if (!first.contains(next))
                        {
                            valid.add(next);
                        }
                    }
                }
            }
            if (valid.size() == 0)
            {
                
                for (int i = 0; i < 4; i++)
                {
                    Location next = loc.getAdjacentLocation(direction[i]);
                    if (gr.isValid(next))
                    {
                        Actor pActor = (Actor)gr.get(next);
                        if (pActor instanceof Flower)
                        {
                            if (second != null && !second.contains(next) && !first.contains(next))
                            {
                                valid.add(next);
                            }
                            else if (second == null && !first.contains(next))
                            {
                                valid.add(next);
                            }
                        }
                    }
                }
            }
            crossLocation.add(first);
        }
        
        return valid;
    }

    /**
     * Tests whether this bug can move forward into a location that is empty or
     * contains a flower.
     * 
     * @return true if this bug can move.
     */
    public boolean canMove() 
    {
        if (this.getValid(this.getLocation()).size() > 0)
            return true;
        return false;
    }
    /**
     * Moves the bug forward, putting a flower into the location it previously
     * occupied.
     */
    public void move() 
    {
        Grid gr = this.getGrid();
        if (gr == null)
            return;
        //保存原来的位置
        Location loc = this.getLocation();
        //获取所有可移动的点
        ArrayList<Location>pLocs = this.getValid(this.getLocation());
        //根据概率获取概率最大的点
        Location next = prob.getNextLocation(pLocs, this.getLocation());
        //移动到该点
        if (gr.isValid(next))
        {
            this.setDirection(this.getLocation().getDirectionToward(next));
            this.moveTo(next);
            prob.increase(this.getDirection());
        }
        else
        {
            removeSelfFromGrid();
            return;
        }
        
        Flower flower = new Flower(getColor());
        flower.putSelfInGrid(gr, loc);
        
        pLocs = crossLocation.pop();
        pLocs.add(next);
        crossLocation.push(pLocs);
        
        pLocs = new ArrayList<Location>();
        pLocs.add(next);
        crossLocation.push(pLocs);
    }
    
    private void backtracking()
    {
        Grid gr = this.getGrid();
        if (gr == null)
            return ;
        if (crossLocation.size() > 0)
        {
            crossLocation.pop();
            if (crossLocation.size() > 0)
            {
                Location loc = this.getLocation();
                ArrayList<Location> pLocs = crossLocation.peek();
                Location next = pLocs.get(0);
                if (gr.isValid(next))
                {
                    this.setDirection(loc.getDirectionToward(next));
                    this.moveTo(next);
                }
                else
                {
                    removeSelfFromGrid();
                    return;
                }
                Flower flower = new Flower(getColor());
                flower.putSelfInGrid(gr, loc);
            }
        }
    }
}

 

    2. 参考已实现的MazeBug，定义一个继承Bug类的MazeDigBug类，需要实现以下功能。

    （1）MazeDigBug能在一张N*N的布满石头的grid中挖出一个迷宫。注意虫子每次只能前进一步，不能出现闪烁飞行的情况。

    （2）参考FinalMaze01.txt中的格式，自行学习Java的文件IO，定义好迷宫的终点并将迷宫输出到文件。然后将迷宫加载，并使用第一部分的MazeBug走出迷宫。

    输出可以在地图生成时IO将文件地图输出（不需要GUI参与）；也可以修改WorldFrame.java，仿造其中Load Map的实现添加Save Map按钮（保存地图时可以借助其中的saveMap方法将地图输出）。

注：因为状态太差了，所以几乎写不出代码。所以我就随意实现了一个只能挖奇数迷宫的代码，也就是一次走两格。本来想继续改成能挖出偶数的，但是好困...每个月总有那么一些天不想突然像来大姨爸一样。

　　

package info.gridworld.maze;

import javax.swing.JOptionPane;

//迷宫生成虫，把石头当作路径，所以每次应该尝试走两步。一步是穿过墙，一步是到达新可能开辟通道的地方
public class MazeDigBug extends Bug
{
    private Location next;
    private boolean isEnd = false;
    boolean hasShown = false;
    private Stack<Location> pathLocation = new Stack();
    private boolean isContinuing = false;
    private boolean isBacktracing = false;
    private int direction[] = {Location.NORTH, Location.EAST, Location.SOUTH, Location.WEST};
    
    public MazeDigBug()
    {
        setColor(Color.green);
    }

    public void act()
    {
        boolean willMove = canMove();
        if (this.isEnd)
        {
            if (!this.hasShown) 
            {
                String msg = "OK";
                JOptionPane.showMessageDialog(null, msg);
                this.hasShown = true;
            }
        } 
        else if (willMove) 
        {
            move();
        }
    }

    public ArrayList<Integer> getValid(Location loc)
    {
        Grid gr = getGrid();
        if (gr == null)
            return null;
        ArrayList valid = new ArrayList();
        for (int i = 0; i < 4; i++)
        {
            Location nextLoc0 = loc.getAdjacentLocation(direction[i]);
            Location nextLoc1 = nextLoc0.getAdjacentLocation(direction[i]);
            if (gr.isValid(nextLoc0) && gr.isValid(nextLoc1))
            {
                Actor pActor0 = (Actor)gr.get(nextLoc0);
                Actor pActor1 = (Actor)gr.get(nextLoc1);
                if (pActor1 != null && pActor0 instanceof Rock && pActor1.getColor().equals(Color.black))
                {
                    valid.add(new Integer(direction[i]));
                }
            }
        }
        return valid;
    }

    public boolean canMove()
    {
        if (this.isContinuing == true)
        {
            this.isContinuing = false;
            this.next = this.getLocation().getAdjacentLocation(this.getDirection());
            if (this.isBacktracing)
            {
                  this.pathLocation.pop();
            }
            return true;
        }
      
        ArrayList directions = this.getValid(this.getLocation());
        if (directions.size() >= 1)
        {
            this.isContinuing = true;
            this.isBacktracing = false;
            Random rand = new Random();
            int randNum = rand.nextInt(directions.size());
            int nextDir = ((Integer)directions.get(randNum)).intValue();
            next = this.getLocation().getAdjacentLocation(nextDir);

        }
        else if (!this.pathLocation.empty())
        {
            this.isContinuing = true;
            this.isBacktracing = true;
            this.next = (Location)this.pathLocation.pop();
        }
        else
        {
            this.isEnd = true;
            return false;
        }
        return true;
    }

    public void move()
    {
        Grid gr = getGrid();
        if (gr == null)
            return;
        Location loc = getLocation();
        if (gr.isValid(this.next)) 
        {
            setDirection(getLocation().getDirectionToward(this.next));
            moveTo(this.next);
            if (!this.isBacktracing)
                this.pathLocation.push(loc);
        }
        else 
        {
            removeSelfFromGrid();
        }
    }
}

弱弱地说一句，wiki上给了一个挖迷宫的jar包，可以去下载一下然后找些工具打开..因为java是翻译成字节码，然后再由jvm解释，所以想从class转成java是非常容易的。

 

 

第三天：

　　拼图部分很无聊，就是让我们写广搜和启发式搜索的估值函数，而且是照着伪代码去写。答辩的时候，我跟TA建议，这部分就不要给代码，直接给文档，里面说明一下各种数据结构及设计，然后由我们自己去编码。不要让我们在别人写的半个类中改代码，并且运用到别人写的另外的类。这样不小心就非常蛋疼。

　　直接上代码吧：

package jigsaw;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Iterator;
import java.util.Vector;

/** 在此类中填充算法，完成重拼图游戏（N-数码问题）
 * @author abe
 *
 */
public class Jigsaw {
    JigsawNode beginJNode;        // 拼图的起始状态节点
    JigsawNode endJNode;        // 拼图的目标状态节点
    JigsawNode currentJNode;    // 拼图的当前状态节点
    private Vector<JigsawNode> openList;    // open表 ：用以保存已发现但未访问的节点
    private Vector<JigsawNode> closeList;    // close表：用以保存已访问的节点
    private Vector<JigsawNode> solutionPath;// 解路径  ：用以保存从起始状态到达目标状态的移动路径中的每一个状态节点
    private boolean isCompleted;    // 完成标记：初始为false;当求解成功时，将该标记至为true
    private int searchedNodesNum;    // 已访问节点数： 用以记录所有访问过的节点的数量

    /**拼图构造函数
     * @param bNode - 初始状态节点
     * @param eNode - 目标状态节点
     */
    public Jigsaw(JigsawNode bNode, JigsawNode eNode) {
        this.beginJNode = new JigsawNode(bNode);
        this.endJNode = new JigsawNode(eNode);
        this.currentJNode = new JigsawNode(bNode);
        this.openList = new Vector<JigsawNode>();
        this.closeList = new Vector<JigsawNode>();
        this.solutionPath = null;
        this.isCompleted = false;
        this.searchedNodesNum = 0;
    }

    /**此函数用于打散拼图：将输入的初始状态节点jNode随机移动len步，返回其打散后的状态节点
     * @param jNode - 初始状态节点
     * @param len - 随机移动的步数
     * @return 打散后的状态节点
     */
    public static JigsawNode scatter(JigsawNode jNode, int len) {
        int randomDirection;
        len += (int) (Math.random() * 2);
        JigsawNode jigsawNode = new JigsawNode(jNode);
        for (int t = 0; t < len; t++) {
            int[] movable = jigsawNode.canMove();
            do{randomDirection = (int) (Math.random() * 4);}
            while(0 == movable[randomDirection]);
            jigsawNode.move(randomDirection);
        }
        jigsawNode.setInitial();
        return jigsawNode;
    }

    /**获取拼图的当前状态节点
     * @return currentJNode -  拼图的当前状态节点
     */
    public JigsawNode getCurrentJNode() {
        return currentJNode;
    }

    /**设置拼图的初始状态节点
     * @param jNode - 拼图的初始状态节点
     */
    public void setBeginJNode(JigsawNode jNode) {
        beginJNode = jNode;
    }

    /**获取拼图的初始状态节点
     * @return beginJNode - 拼图的初始状态节点
     */
    public JigsawNode getBeginJNode() {
        return beginJNode;
    }

    /**设置拼图的目标状态节点
     * @param jNode - 拼图的目标状态节点
     */
    public void setEndJNode(JigsawNode jNode) {
        this.endJNode = jNode;
    }

    /**获取拼图的目标状态节点
     * @return endJNode - 拼图的目标状态节点
     */
    public JigsawNode getEndJNode() {
        return endJNode;
    }

    /**获取拼图的求解状态
     * @return isCompleted - 拼图已解为true；拼图未解为false
     */
    public boolean isCompleted() {
        return isCompleted;
    }

    /**计算解的路劲
     * @return 若有解，则将结果保存在solutionPath中，返回true; 若无解，则返回false
     */
    private boolean calSolutionPath() {
        if (!this.isCompleted()) {
            return false;
        } else {
            JigsawNode jNode = this.currentJNode;
            solutionPath = new Vector<JigsawNode>();
            while (jNode != null) {
                solutionPath.addElement(jNode);
                jNode = jNode.getParent();
            }
            return true;
        }
    }

    /**获取解路径文本
     * @return 解路径solutionPath的字符串，若有解，则分行记录从初始状态到达目标状态的移动路径中的每一个状态节点；
     * 若未解或无解，则返回提示信息。
     */
    public String getSolutionPath() {
        String str = new String();
        str += "Begin->";
        if (this.isCompleted) {
            for (int i = solutionPath.size()-1; i>=0; i--) {
                str += solutionPath.elementAt(i).toString() + "->";
            }
            str+="End";
        } else
            str = "Jigsaw Not Completed.";
        return str;
    }

    /**获取访问过的节点数searchedNodesNum
     * @return 返回所有已访问过的节点总数
     */
    public int getSearchedNodesNum() {
        return searchedNodesNum;
    }
    
    /**将搜索结果写入文件中，同时显示在控制台
     * 若搜索失败，则提示问题无解，输出已访问节点数；
     * 若搜索成功，则输出初始状态beginJnode，目标状态endJNode，已访问节点数searchedNodesNum，路径深度nodeDepth和解路径solutionPath。
     * @param pw - 文件输出PrintWriter类对象，如果pw为null，则写入到D://Result.txt
     * @throws IOException
     */
    public void printResult(PrintWriter pw) throws IOException{
        boolean flag = false;
        if(pw == null){
            pw = new PrintWriter(new FileWriter("Result.txt"));// 将搜索过程写入D://BFSearchDialog.txt
            flag = true;
        }
        if (this.isCompleted == true) {
            // 写入文件
            pw.println("Jigsaw Completed");
            pw.println("Begin state:" + this.getBeginJNode().toString());
            pw.println("End state:" + this.getEndJNode().toString());
            pw.println("Solution Path: ");
            pw.println(this.getSolutionPath());
            pw.println("Total number of searched nodes:" + this.getSearchedNodesNum());
            pw.println("Length of the solution path is:" + this.getCurrentJNode().getNodeDepth());

            
            // 输出到控制台
            System.out.println("Jigsaw Completed");
            System.out.println("Begin state:" + this.getBeginJNode().toString());
            System.out.println("End state:" + this.getEndJNode().toString());
            System.out.println("Solution Path: ");
            System.out.println(this.getSolutionPath());
            System.out.println("Total number of searched nodes:" + this.getSearchedNodesNum());
            System.out.println("Length of the solution path is:" + this.getCurrentJNode().getNodeDepth());

            
        } 
        else {
            // 写入文件
            pw.println("No solution. Jigsaw Not Completed");
            pw.println("Begin state:" + this.getBeginJNode().toString());
            pw.println("End state:" + this.getEndJNode().toString());
            pw.println("Total number of searched nodes:"
                    + this.getSearchedNodesNum());
            
            // 输出到控制台
            System.out.println("No solution. Jigsaw Not Completed");
            System.out.println("Begin state:" + this.getBeginJNode().toString());
            System.out.println("End state:" + this.getEndJNode().toString());
            System.out.println("Total number of searched nodes:"
                    + this.getSearchedNodesNum());
        }
        if(flag)
            pw.close();
    }

    /**探索所有与jNode邻接(上、下、左、右)且未曾被访问的节点
     * @param jNode - 要探索的节点
     * @return 包含所有与jNode邻接且未曾被访问的节点的Vector<JigsawNode>对象
     */
    private Vector<JigsawNode> findFollowJNodes(JigsawNode jNode) {
        Vector<JigsawNode> followJNodes = new Vector<JigsawNode>();
        JigsawNode tempJNode;
        for(int i=0; i<4; i++){
            tempJNode = new JigsawNode(jNode);
            if(tempJNode.move(i) && !this.closeList.contains(tempJNode) && !this.openList.contains(tempJNode))
                followJNodes.addElement(tempJNode);
        }
        return followJNodes;
    }

    /**排序插入openList：按照节点的代价估值（estimatedValue）将节点插入openList中，估值小的靠前。
     * @param jNode - 要插入的状态节点
     */
    private void sortedInsertOpenList(JigsawNode jNode) {
        this.estimateValue(jNode);
        for (int i = 0; i < this.openList.size(); i++) {
            if (jNode.getEstimatedValue() < this.openList.elementAt(i)
                    .getEstimatedValue()) {
                this.openList.insertElementAt(jNode, i);
                return;
            }
        }
        this.openList.addElement(jNode);
    }
    
    
    
    // ****************************************************************
    // *************************实验任务************************
    /**实验任务一：广度优先搜索算法，求指定3*3拼图（8-数码问题）的最优解
     * 要求：填充广度优先搜索算法BFSearch()，执行测试脚本RunnerPart1
     * 主要涉及函数：BFSearch()
     */
    /**实验任务二：启发式搜索算法，求解随机5*5拼图（24-数码问题）
     * 要求：1.修改启发式搜索算法ASearch()和代价估计函数estimateValue()，执行测试脚本RunnerPart2
     *      2.访问节点总数不超过25000个
     * 主要涉及函数：ASearch()，estimateValue()
     */
    // ****************************************************************
    
    /**（实验一）广度优先搜索算法，求解指定3*3拼图（8-数码问题）的最优解。
     * 要求函数结束后：1,isCompleted记录了求解完成状态；
     *              2,closeList记录了所有访问过的节点；
     *                 3,searchedNodesNum记录了访问过的节点数；
     *              4,solutionPath记录了解路径。
     * @return isCompleted, 搜索成功时为true,失败为false
     * @throws IOException
     */
    public boolean BFSearch() throws IOException {
        // 将搜索过程写入D://BFSearchDialog.txt
        String filePath = "BFSearchDialog.txt";
        PrintWriter pw = new PrintWriter(new FileWriter(filePath));
        // *************************************

        // Write your code here.
        //（1）将起始节点放入一个open列表中。
        this.openList.add(this.beginJNode);

        //（2）如果open列表为空，则搜索失败，问题无解；否则重复以下步骤:
        while (openList.size() > 0)
        {
            // 1.访问open列表中的第一个节点v，若v为目标节点，则搜索成功，退出。
            this.currentJNode = openList.firstElement();
            if (currentJNode.equals(this.endJNode))
            {
                this.isCompleted = true;
                this.calSolutionPath();
                break;
            }
            
            // 2.从open列表中删除节点v，放入close列表中。
            this.openList.removeElementAt(0);
            closeList.add(currentJNode);
            searchedNodesNum++;
            
            // 3.将所有与v邻接且未曾被访问的节点放入open列表中。
            Vector<JigsawNode>v = this.findFollowJNodes(currentJNode);
            int size = v.size();
            for (int i = 0; i < size; i++)
            {
                openList.add(v.get(i));
            }
        }
        
        // *************************************
        this.printResult(pw);
        pw.close();
        System.out.println("Record into " + filePath);
        return isCompleted;
    }
    
    /**（Demo+实验二）启发式搜索。访问节点数大于30000个则认为搜索失败。
     * 函数结束后：isCompleted记录了求解完成状态；
     *           closeList记录了所有访问过的节点；
     *           searchedNodesNum记录了访问过的节点数；
     *           solutionPath记录了解路径。
     *  搜索过程和结果会记录在D://DemoASearchDialog.txt中。
     * @return 搜索成功返回true,失败返回false
     * @throws IOException
     */
    
    /*修改Jigsaw类中的启发式搜索算法ASearch()和代价估计函数estimateValue()，
     * 对随机生成的5*5拼图初始状态进行求解。
     * 具体要求：
     * 1，修改Jigsaw类中的ASearch()和estimateValue()两个函数，可添加其他函数；
     * 2，要求访问节点总数不超过25000个；
     * 3，要求算法结束后：
     *     1.isCompleted记录了求解完成状态；
     *     2.closeList记录了所有访问过的节点；
     *     3.searchedNodesNum记录了访问过的节点数；
     *     4.solutionPath记录了解路径。
     *     4，必须通过测试脚本RunnerPart2的测试检查。
     *     注意：解此题前必须先把JigsawNode中的拼图维度dimension改为5。
     *     5，进行多次测试（次数>=20），画出频率分布折线图，在文档中提交。如图6所示，
     *     X轴表示步数(<5000, <10000, ... , <25000, >25000)，Y轴为步数在该范围内的频率。
     *     TA会对程序进行抽查，因此不要捏造数据或故意选取跑的好的结果。
     * */
    /*   估价函数f(n)用来估计节点n的重要性，表示为：从起始节点，经过节点n，到达目标节点的代价。
     *   f(n)越小，表示节点n越优良，应该优先访问它的邻接节点。可参考的估价方法有：
        1） 所有 放错位的数码 个数
        2） 所有 放错位的数码与其正确位置的距离 之和
        3） 后续节点不正确的数码个数
        4） .....
        可以同时使用多个估价方法，f(n) = a*f1(n) + b*f2(n) „„,通过适当调整权重（a、b、„„），
        能够加快搜索速度。
     * */
    public boolean ASearch() throws IOException{
        // 将搜索过程写入ASearchDialog.txt
        String filePath = "ASearchDialog.txt";
        PrintWriter pw = new PrintWriter(new FileWriter(filePath));
        
        // 访问节点数大于30000个则认为搜索失败
        int maxNodesNum = 25000;  
        
        // 用以存放某一节点的邻接节点
        Vector<JigsawNode> followJNodes = new Vector<JigsawNode>(); 
        
        // 重置求解完成标记为false
        isCompleted = false;           
        
        // (1)将起始节点放入openList中
        this.sortedInsertOpenList(this.beginJNode);
        
        // (2) 如果openList为空，或者访问节点数大于maxNodesNum个，则搜索失败，问题无解;否则循环直到求解成功
        while (this.openList.isEmpty() != true && searchedNodesNum <= maxNodesNum) {
            
            // (2-1)访问openList的第一个节点N，置为当前节点currentJNode
            //      若currentJNode为目标节点，则搜索成功，设置完成标记isCompleted为true，计算解路径，退出。
            this.currentJNode = this.openList.elementAt(0);
            if (this.currentJNode.equals(this.endJNode)){
                isCompleted = true;
                this.calSolutionPath();
                break;
            }
            
            // (2-2)从openList中删除节点N,并将其放入closeList中，表示以访问节点            
            this.openList.removeElementAt(0);
            this.closeList.addElement(this.currentJNode);
            searchedNodesNum++;
            
                // 记录并显示搜索过程
                pw.println("Searching.....Number of searched nodes:" + this.closeList.size() + "   Current state:" + this.currentJNode.toString());
                System.out.println("Searching.....Number of searched nodes:" + this.closeList.size() + "   Current state:" + this.currentJNode.toString());            

            // (2-3)寻找所有与currentJNode邻接且未曾被访问的节点，将它们按代价估值从小到大排序插入openList中
            followJNodes = this.findFollowJNodes(this.currentJNode);
            while (!followJNodes.isEmpty()) {
                this.sortedInsertOpenList(followJNodes.elementAt(0));
                followJNodes.removeElementAt(0);
            }
        }
        
        this.printResult(pw);    // 记录搜索结果
        pw.close();             // 关闭输出文件
        System.out.println("Record into " + filePath);
        return isCompleted;
    }
    
    /**（Demo+实验二）
     * @param jNode - 要计算代价估计值的节点；此函数会改变该节点的estimatedValue属性值。
     */
    private void estimateValue(JigsawNode jNode)
    {
        int s = 0 * getEstimateValue0(jNode) + 
                1 * getEstimateValue1(jNode) +
                1 * getEstimateValue2(jNode);
        jNode.setEstimatedValue(s);
    }
    //所有 放错位的数码 个数
    private int getEstimateValue0(JigsawNode jNode)
    {
        int s = 0;
        int dimension = JigsawNode.getDimension();
        int currentNodeState[] = jNode.getNodesState();
        int endNodeState[] = endJNode.getNodesState();
        for (int i = 1; i <= dimension * dimension; i++)
        {
            if (currentNodeState[i] != endNodeState[i])    
                s++;
        }
        return s;
    }
    //所有 放错位的数码与其正确位置的距离 之和
    private int getEstimateValue1(JigsawNode jNode)
    {
        int s = 0;
        int col0, row0, col1, row1;
        
        int dimension = JigsawNode.getDimension();
        int currentNodeState[] = jNode.getNodesState();
        int endNodeState[] = endJNode.getNodesState();
        
        for (int i = 1; i <= dimension * dimension; i++)
        {
            if (currentNodeState[i] != 0 && currentNodeState[i] != endNodeState[i])
            {
                row0 = (int) (i - 1) / dimension;
                col0 = (int) (i + 4) % dimension;
                for (int j = 0; j <= dimension * dimension; j++)
                {
                    if (currentNodeState[i] == endNodeState[j])
                    {
                        row1 = (int) (j - 1) / dimension;
                        col1 = (int) (j + 4) % dimension;
                        s += (Math.abs(row1 - row0) + Math.abs(col1 - col0));
                        break;
                    }
                }
            }
        }
        return s;
    }
    // 后续节点不正确的数码个数
    //计算并修改状态节点jNode的代价估计值:f(n)=s(n)。
    // s(n)代表后续节点不正确的数码个数
    private int getEstimateValue2(JigsawNode jNode)
    {
        int s = 0; 
        int dimension = JigsawNode.getDimension();
        for(int index =1 ; index<dimension*dimension; index++){
            if(jNode.getNodesState()[index]+1!=jNode.getNodesState()[index+1])
                s++;
        }
        return s;
    }
}

 

第四天：

　　

　　答辩呀，感谢我们有一个做得了学霸写得了代码，写得了文档做得了ppt的队友～

 

　　有问题欢迎提问。看到这篇文章的各位，希望大家还是专心写点代码，不要总想着找一些可以参考的，这样会养成自己非常不严谨和不擅长思考的习惯，渐渐地就会变成菜鸟。前两部分有时间的话，记得多看一下WorkFrame，GUI，Grid这三大块(其实就只有数据和UI两块)。如果大家对写游戏有兴趣，欢迎联系我，发邮件给我。