8 câu đố c++

Chơi trò chơi 8 câu đố nổi tiếng với các mức độ không giới hạn bao gồm các hình ảnh vui nhộn và thú vị. Xem cách bạn chống lại các trạng thái tốt nhất có thể được thực hiện bởi AI bằng thuật toán Astar. Điểm của bạn được tính bằng cách chia số lần di chuyển để giải pháp tốt nhất có thể, được tạo bởi AI, cho số lần di chuyển của bạn để bạn giải câu đố. chúc vui vẻ

Dự án trò chơi này đã xuất hiện do hậu quả của một hướng dẫn mà tôi đã viết. "Giải quyết 8 vấn đề giải đố bằng cách sử dụng tìm kiếm sao A* trong C++" [ https. //faramira. com/solve-8-puheads-probols-USE-a-star -search-in-c /]. Điều này cuối cùng đã được chuyển đến Unity để chứng minh việc tìm đường của Astar để giải quyết 8 vấn đề giải câu đố

Trong giải pháp này, các nước đi liên tiếp có thể đưa chúng ta ra xa mục tiêu hơn là đưa chúng ta đến gần hơn. Việc tìm kiếm cây không gian trạng thái đi theo con đường ngoài cùng bên trái từ gốc bất kể trạng thái ban đầu. Một nút trả lời có thể không bao giờ được tìm thấy trong phương pháp này

2. BFS [Brute-Force] 
Chúng ta có thể thực hiện tìm kiếm theo chiều rộng trên cây không gian trạng thái. Điều này luôn tìm thấy trạng thái mục tiêu gần gốc nhất. Nhưng bất kể trạng thái ban đầu là gì, thuật toán sẽ thực hiện cùng một chuỗi các bước di chuyển như DFS.

3. Nhánh và Giới hạn 
Việc tìm kiếm nút trả lời thường có thể được tăng tốc bằng cách sử dụng hàm xếp hạng “thông minh”, còn được gọi là hàm chi phí gần đúng để tránh tìm kiếm trong các cây con không chứa câu trả lời . Nó tương tự như kỹ thuật quay lui nhưng sử dụng tìm kiếm giống như BFS.

Về cơ bản có ba loại nút liên quan đến Nhánh và Giới hạn 
1. Nút trực tiếp là nút đã được tạo nhưng nút con chưa được tạo.
2. Nút điện tử là nút trực tiếp có nút con hiện đang được khám phá. Nói cách khác, E-node là một nút hiện đang được mở rộng.
3. Nút chết là một nút được tạo không được mở rộng hoặc khám phá thêm nữa. Tất cả con của nút chết đã được mở rộng.

Hàm chi phí.
Mỗi nút X trong cây tìm kiếm được liên kết với một chi phí. Hàm chi phí rất hữu ích để xác định nút E tiếp theo. Nút điện tử tiếp theo là nút có chi phí thấp nhất. Hàm chi phí được định nghĩa là 

   C[X] = g[X] + h[X] where
   g[X] = cost of reaching the current node 
          from the root
   h[X] = cost of reaching an answer node from X.

Hàm Chi phí lý tưởng cho Thuật toán 8 câu đố.
Chúng tôi giả định rằng việc di chuyển một ô theo bất kỳ hướng nào sẽ có chi phí là 1 đơn vị. Ghi nhớ điều đó, chúng tôi xác định hàm chi phí cho thuật toán 8 câu đố như sau.

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

Một thuật toán có sẵn để lấy giá trị gần đúng của h[x] là một giá trị chưa biết

Thuật toán hoàn chỉnh.  

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

Sơ đồ dưới đây cho thấy con đường mà thuật toán trên theo sau để đạt được cấu hình cuối cùng từ cấu hình ban đầu đã cho của 8-Puzzle. Lưu ý rằng chỉ các nút có giá trị nhỏ nhất của hàm chi phí mới được mở rộng.
 

C++14

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

87

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

88

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

89

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

90

________ 791 ________ 792 ________ 10

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

1

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

2

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

3

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

4

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

7

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

1

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

3

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

6

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

8

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

41

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____243

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

46

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

48

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

871

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

873

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

875______25

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

877

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

883

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

890

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

892

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

894

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

895

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

892

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

899

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

904

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

905

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

907

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

911

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

913

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

914

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

916

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

918

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

921______7922

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

923

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

925

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

927

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

929

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

01____102

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

03

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

04

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

06

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

08

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

10

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

12

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

14

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

16

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

18

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

20

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

22

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

25

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

27

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

29

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

31

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

32

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

33

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

35

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

37

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

39

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

43

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

883

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

890

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

56

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

57

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

58

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

61

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

63

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

65

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

69

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

73

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

75

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

77

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

81

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

86

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

88

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

892

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

899

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

95

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

3

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

97

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

00

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

01

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

02

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

03

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

02

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

05

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

02

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

11

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

 

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

15

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

16

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

17

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

19

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

37

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

911

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

57

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

39

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

31

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____233

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

35

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

37

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

39

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

41

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____243

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

45

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

47

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

51

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

53

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

54

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

58

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

60

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

62

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

64

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

66

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

68

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

71

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

75

_______7891____277

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

86

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

91

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

96

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

400

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

402

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

404

________ 2405 ________ 2406

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

405

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

408

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

405

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

410

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

412

 

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

414

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

416

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

424

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

426

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

429

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

431

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

434

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

438

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

440

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

442

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____2446

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

431

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

451

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

438

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

457

_______7886____2459

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

463

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____2465

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

468

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

470

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

473

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

Java

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

475

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

88

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

89

________ 2478 ________ 2479

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

478

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

481

 

________ 2482 ________ 2483

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

484

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

489

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

482

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

4

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

7

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8705

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8708

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

922

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8711

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

3

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

41

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

8

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

46

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

43

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

871

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

48

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

873

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

875

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8736

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8741

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8743

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8748

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8750

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8752______78753

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8758

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8759

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

904

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8771

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8773

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

911

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8778

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

913

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

916

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8784

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8778

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8786

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8788

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

922

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8790

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8792

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

925

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

929

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8798

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

922

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8711

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8741

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8743

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8748

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8750

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8817

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

06

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8827

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8829

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8831

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8834

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

10

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8837

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

14

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

18

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8843

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8845

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

25

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

27

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8859

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8863

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8872

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8863

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

32

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

33

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

35

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8892

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8894

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8899

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8741

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8908

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8909

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8748

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8915

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8918

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8920

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8921

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

58

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

61

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8928

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

63

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

65

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

69

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8944

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8946

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8948

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8950

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

75

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8962

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55____78965

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8966

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8967

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8974

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8976

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8758

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8759

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

95

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

482

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

97

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8991

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8992

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8994

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8998

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9001

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9003

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

15

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

16

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

17

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

19

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8892

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

909

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9026

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

911

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8894

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9035

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9037______7922

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9039

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

922

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9041

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

37

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9046

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8966

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

900

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9052

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

43

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9057

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

47

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

51

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

53____79067

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

_______7891____79071____258

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9074

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9075

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

_______7891____268

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55____79081

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8967

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

77____275

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

84

_______7891____286

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8741

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9102

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9104

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9109

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9111

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

400

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

402

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9119

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9121

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9123

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8928

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

414

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9128

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

_______16____79139

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

486

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

487

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

76

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9144

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

49

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

429

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

431

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9154

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9161

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9164

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9167

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9169

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9164

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9175

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9177

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8928

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

446

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

431

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9190

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9161

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9164

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9167

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9177

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9169

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9164

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9175

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

872

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8928

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

463

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

465

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9226

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9228

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9161

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

84

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8928

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9233

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

902

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9237

Python3

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9238

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9239

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9240

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9241

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9242

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9243

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

478

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9245

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9246

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9247

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9248

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9249

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

478

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9251

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9252

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9253

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9254

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9255

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9258

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9259

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9261

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9266

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9271

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9261

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9266

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9283

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

482

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9285

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

_______16____79288

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9290

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9293

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9295

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9298

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

000

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

002

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

005

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

007

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

009

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

011

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

013

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

015

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

018

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9295

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

023

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

025

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

027

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

030

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9295

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

035

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

037

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

040

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

042

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8950

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

046

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

047

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

482

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

049

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9293

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

055

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

056

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

057

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

058

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

060

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

062

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

064

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

067

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

069

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

071

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

074

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

076

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

078

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

080

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

083

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

085

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

087

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

090

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

092

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

094

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

097

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

099

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

101

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____1103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

105

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

108

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

110

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9294

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

114

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

115

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

116

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

117

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

119

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9266

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

121

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

5

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8950

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

126______79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

131____1132

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

133

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

134

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

137

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

132

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

133

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

134

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

143

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

144

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

146

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

148

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

126____1151

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

126

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

159

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

161____79266

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

163

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

166

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

168

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

170

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

172

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

174

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

176

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

180______79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

176

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

186______79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

188

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

192____79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

188

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

198

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

200

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

202

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

092____79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

206

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

208

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

210

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9114

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

212

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

208

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

216

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

218

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

131____1132

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

133

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

134

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

137

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

132

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

133

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

134

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

233______7881

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

894

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

236

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

237

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8753

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9111

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

_______7886____1233____1244

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

245

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

246

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

248

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

252

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

144

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

144

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

258

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

144

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

262

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

263

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

265

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

269

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

272

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8950

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

278

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

280

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

233____1244

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

284

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

285

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

286

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9292

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

288

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

291

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

293

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

295

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

297

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

299

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

092____79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

303

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

269____79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

307

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

272

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

309

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

311____78742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9111

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

315

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

317

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____1319

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6____1321

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

323

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

325

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

6

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

53

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

035

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

329

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

331

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

333

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

335

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

337____79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

339

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

341

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

344

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8950

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

351

_______7891____1353

_______7891____1355

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

24

 

_______7886____1359

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

886

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

880

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

131

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

132

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

133

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

881

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9295

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

369______79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9261

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

373____78742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

151

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

377

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

373____78860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9270

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

151

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

383

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

55

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

387

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

389

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

391

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

394

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

396______79256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

398

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

399

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

400

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

399

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

402

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

399

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

404

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

151

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

399

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

409

 

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

411

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

99

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

413

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

414

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

415

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

416

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

417

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

419

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9161

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

425

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9261______79167

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9169

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8742

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

425

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

891

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9261____79175

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9177

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9103

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

441

 

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

442

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

416

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

444

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9256

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

419

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8860

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

9161

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

8861

/* Algorithm LCSearch uses c[x] to find an answer node
 * LCSearch uses Least[] and Add[] to maintain the list 
   of live nodes
 * Least[] finds a live node with least c[x], deletes
   it from the list and returns it
 * Add[x] adds x to the list of live nodes
 * Implement list of live nodes as a min-heap */

struct list_node
{
   list_node *next;

   // Helps in tracing path when answer is found
   list_node *parent; 
   float cost;
} 

algorithm LCSearch[list_node *t]
{
   // Search t for an answer node
   // Input: Root node of tree t
   // Output: Path from answer node to root
   if [*t is an answer node]
   {
       print[*t];
       return;
   }
   
   E = t; // E-node

   Initialize the list of live nodes to be empty;
   while [true]
   {
      for each child x of E
      {
          if x is an answer node
          {
             print the path from x to t;
             return;
          }
          Add [x]; // Add x to list of live nodes;
          x->parent = E; // Pointer for path to root
      }

      if there are no more live nodes
      {
         print ["No answer node"];
         return;
      }
       
      // Find a live node with least estimated cost
      E = Least[]; 

      // The found node is deleted from the list of 
      // live nodes
   }
}

490

   c[x] = f[x] + h[x] where
   f[x] is the length of the path from root to x 
        [the number of moves so far] and
   h[x] is the number of non-blank tiles not in 
        their goal position [the number of mis-
        -placed tiles]. There are at least h[x] 
        moves to transform state x to a goal state

425