Question

Solver.java

package hw7;

import java.util.Iterator;
import edu.princeton.cs.algs4.Graph;
import edu.princeton.cs.algs4.BreadthFirstPaths;

public class Solver {
   public static String solve(char[][] grid) {
       // TODO
       /*
       * 1. Construct a graph using grid
       * 2. Use BFS to find shortest path from start to finish
       * 3. Return the sequence of moves to get from start to finish
       */
      
       // Hardcoded solution to toyTest
       return "RRRDDDDDDDDDRRRRRR";
   }
}

ToyTest.java

package hw7;

import static org.junit.Assert.*;

import org.junit.Test;

public class ToyTest {
  
   private void checkSol(char[][] grid, String path, int distance) {
       int size = grid.length;
       int row = -1;
       int col = -1;
      
       // Start at s;
       for(int i = 0; i < size; i++) {
           for(int j = 0; j < size; j++) {
               if (grid[i][j] == 's') {
                   row = i;
                   col = j;
               }
           }
       }
      
       // Move according to path
       for(char c : path.toCharArray()) {
           switch(c) {
           case 'U':
               row -= 1;
               break;
           case 'D':
               row += 1;
               break;
           case 'R':
               col += 1;
               break;
           case 'L':
               col -= 1;
               break;
           default:
               fail("Illegal character in solution: " + c);
           }
           // Make sure you haven't moved outside the grid.
           assertTrue(row >= 0 && row < size && col >= 0 && col < size);
           // Make sure you haven't moved into a '*'
           assertTrue(grid[row][col] != '*');
       }
       // Make sure you end at 'f'
       assertTrue(grid[row][col] == 'f');
      
       // Make sure it is not longer than shortest distance.
       assertTrue(path.length() <= distance);
   }

   @Test
   public void toyTest() {
       String[] data =
           {
                   "s ",
                   " ",
                   " * ",
                   " * *****",
                   " * ",
                   " * ",
                   " * ",
                   " * ",
                   " * ",
                   " * f"
           };
       char[][] grid;
       /* Solution to this grid is hardcoded */
       grid = GridUtilities.fromStringArray(data);
       String solution = Solver.solve(grid);
      
       checkSol(grid, solution, 18);
      
       /* Hardcoded solution does not solve this grid */
       grid = GridUtilities.rotateClockwise(grid);
       solution = Solver.solve(grid);
       checkSol(grid, solution, 18);
   }

}

GridUtilties.java

package hw7;

import java.io.*;
import java.util.ArrayList;

public class GridUtilities {
   public static char[][] fromStringArray(String[] in) {
       int size = in.length;
       char[][] result = new char[size][];
       for(int i = 0; i < size; i++) {
           String row = in[i];
           if (row.length() != size)
               throw new RuntimeException(String.format("Row %d and col 0 have different sizes", i));
           result[i] = row.toCharArray();
       }
       return result;
   }
  
  
   public static char[][] fromFile(String filename) throws IOException {
       try (BufferedReader in = new BufferedReader(new FileReader(filename))) {
           String row = in.readLine();
           ArrayList<String> temp = new ArrayList<String>(row.length());
           while (row != null) {
               temp.add(row);
               row = in.readLine();
           }
           String[] table = temp.toArray(new String[0]);
           return fromStringArray(table);
       }
   }
  
   public static char[][] rotateClockwise(char[][] in) {
       int size = in.length;
       char[][] out = new char[size][size];
       for(int row = 0; row < size; row++)
           for(int col = 0; col < size; col++)
               out[row][col] = in[size-1-col][row];
       return out;
   }
  
   public static String toString(char[][] grid) {
       StringBuilder sb = new StringBuilder(grid.length * (grid.length+5));
       for(char[] row : grid) {
           sb.append(new String(row));
           sb.append('\n');
       }
       return sb.toString();
   }
}

Answer 1

I have implemented source code :

I just implemented Source-code it will work based on that u can write code