Coursera 算法二 week2 Seam Carving

这周作业设计到的算法是有向无环图的最短路径算法，只需要按照顶点的拓扑顺序去放松顶点即可。而在这个题目中拓扑顺序就是按照行的顺序或列的顺序。

用到的数据结构为一个二维数组picture同来存储每个像素的颜色，一个二维数组energy用来存储每个像素的能量。开始我是用一个Picture类的对象来存储图像，但是在讨论区里发现用二维数组存储图像，可以占用更小的存储，且计算能量、removeseam时更快更方便。

在检验各像素能量时发现计算结果不正确，后来发现是运算符优先级的问题，((rgbLeft >> 16) & 0xFF) - ((rgbRight >> 16) & 0xFF)，即‘ - ’的优先级大于‘ & ’的优先级，因此需要加括号。

在Checklist的Possible Progress Steps中发现计算seam以及removeseam时可以只写Horizontal和Vertical中的一个，然后另一个用矩阵转置的方法来完成。

第一次提交时memory没有通过，原因是把二维数组distTo和二维数组edgeTo放到了成员变量里，后来把这两个数组放到局部变量，就通过了memory测试。

 import edu.princeton.cs.algs4.Picture;

 public class SeamCarver {
   private int[][] picture;
   private double[][] energy;
   private int width;
   private int height;

   public SeamCarver(Picture picture)                // create a seam carver object based on the given picture
   {
       if (picture == null)
           throw new IllegalArgumentException();
       width = picture.width();
       height = picture.height();
       energy = new double[width][height];
       this.picture = new int[width][height];

       for (int i = 0; i < width(); i++)
       {
           for (int j = 0; j < height(); j++)
               this.picture[i][j] = picture.getRGB(i, j);
       }

       for (int i = 0; i < width(); i++)
       {
           for (int j = 0; j < height(); j++)
               energy[i][j] = computeEnergy(i, j);
       }
   }

   private double computeEnergy(int x, int y)
   {
       if (x == 0 || x == width() - 1 || y == 0 || y == height() - 1)
           return 1000.0;

       int rgbUp = picture[x][y - 1];
       int rgbDown = picture[x][y + 1];
       int rgbLeft = picture[x - 1][y];
       int rgbRight = picture[x + 1][y];
       double rx = Math.pow(((rgbLeft >> 16) & 0xFF) - ((rgbRight >> 16) & 0xFF), 2);
       double gx = Math.pow(((rgbLeft >> 8) & 0xFF) - ((rgbRight >> 8) & 0xFF), 2);
       double bx = Math.pow(((rgbLeft >> 0) & 0xFF) - ((rgbRight >> 0) & 0xFF), 2);

       double ry = Math.pow(((rgbUp >> 16) & 0xFF) - ((rgbDown >> 16) & 0xFF), 2);
       double gy = Math.pow(((rgbUp >> 8) & 0xFF) - ((rgbDown >> 8) & 0xFF), 2);
       double by = Math.pow(((rgbUp >> 0) & 0xFF) - ((rgbDown >> 0) & 0xFF), 2);

       return Math.sqrt(rx + gx + bx + ry + gy + by);
   }

   public Picture picture()                          // current picture
   {
       Picture pic = new Picture(width, height);
       for (int i = 0; i < width; i++)
           for (int j = 0; j < height; j++)
               pic.setRGB(i, j, picture[i][j]);

       return pic;
   }

   public int width()                            // width of current picture
   {
       return width;
   }

   public     int height()                           // height of current picture
   {
       return height;
   }

   public  double energy(int x, int y)               // energy of pixel at column x and row y
   {
       if (x < 0 || x > width - 1 || y < 0 || y > height - 1)
           throw new IllegalArgumentException();
       return energy[x][y];
   }

   private void relaxvertical(double[][] distTo, int[][] edgeTo, int x, int y)
   {
       if (distTo[x][y + 1] > distTo[x][y] + energy[x][y + 1])
       {
           distTo[x][y + 1] = distTo[x][y] + energy[x][y + 1];
           edgeTo[x][y + 1] = x;
       }
       if (x > 0 && distTo[x - 1][y + 1] > distTo[x][y] + energy[x - 1][y + 1])
       {
           distTo[x - 1][y + 1] = distTo[x][y] + energy[x - 1][y + 1];
           edgeTo[x - 1][y + 1] = x;
       }
       if (x < width() - 1 && distTo[x + 1][y + 1] > distTo[x][y] + energy[x + 1][y + 1])
       {
           distTo[x + 1][y + 1] = distTo[x][y] + energy[x + 1][y + 1];
           edgeTo[x + 1][y + 1] = x;
       }
   }

   private void transpose()
   {
       int temp = width;
       width = height;
       height = temp;

       double[][] energy2 = new double[width][height];
       int[][] picture2 = new int[width][height];

       for (int i = 0; i < width; i++)
       {
           for (int j = 0; j < height; j++)
           {
               energy2[i][j] = energy[j][i];
               picture2[i][j] = picture[j][i];
           }
       }

       energy = energy2;
       picture = picture2;
   }

   public int[] findHorizontalSeam()               // sequence of indices for horizontal seam
   {
       transpose();
       int[] array = findVerticalSeam();
       transpose();
       return array;
   }

   public int[] findVerticalSeam()                 // sequence of indices for vertical seam
   {
       int[] seam = new int[height];
       double[][] distTo = new double[width][height];
       int[][] edgeTo = new int[width][height];

       for (int i = 0; i < width; i++)
       {
           for (int j = 0; j < height; j++)
           {
               if (j == 0) distTo[i][j] = energy[i][j];
               else distTo[i][j] = Double.POSITIVE_INFINITY;
           }
       }
       for (int j = 0; j < height - 1; j++)
       {
           for (int i = 0; i < width; i++)
           {
               relaxvertical(distTo, edgeTo, i, j);
           }
       }

       double min = Double.MAX_VALUE;
       int minIndex = 0;
       for (int i = 0; i < width; i++)
       {
           if (distTo[i][height - 1] < min)
           {
               min = distTo[i][height - 1];
               minIndex = i;
           }
       }

       seam[height - 1] = minIndex;
       for (int j = height - 2; j >= 0; j--)
       {
           seam[j] = edgeTo[seam[j + 1]][j + 1];
       }

       return seam;
   }

   public void removeHorizontalSeam(int[] seam)   // remove horizontal seam from current picture
   {
       checkSeam(seam);

       int min = Integer.MAX_VALUE;
       int max = 0;

       for (int i = 0; i < width; i++)
       {
           if (seam[i] > max) max = seam[i];
           if (seam[i] < min) min = seam[i];

           for (int j = seam[i]; j < height - 1; j++)
           {
               picture[i][j] = picture[i][j + 1];
           }
       }

       height--;
       if (min > 0) min--;
       if (max > height - 1) max = height - 1;

       for (int i = 0; i < width; i++)
       {
           for (int j = min; j <= max; j++)
               energy[i][j] = computeEnergy(i, j);
           for (int j = max + 1; j < height - 1; j++)
               energy[i][j] = energy[i][j + 1];
       }

   }

   private void checkSeam(int[] seam)
   {
       if (height <= 1 || seam == null || seam.length != width)
           throw new IllegalArgumentException();
       for (int i = 0; i < width; i++)
       {
           if (seam[i] < 0 || seam[i] > height - 1)
               throw new IllegalArgumentException();
           if (i > 0 && Math.abs(seam[i] - seam[i - 1]) > 1)
               throw new IllegalArgumentException();
       }
   }
   public void removeVerticalSeam(int[] seam)     // remove vertical seam from current picture
   {
       transpose();
       removeHorizontalSeam(seam);
       transpose();
   }
 }