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ẻ

Show

    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.
     

    8 câu đố c++

    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