Java 中的目标堆栈规划程序

2024 年 9 月 10 日 | 阅读 8 分钟

目标栈规划是一种流行的用于规划和解决任务的人工智能技术。它涉及将复杂任务分解为一系列子目标和实现这些目标的动作。在本文中，我们将探讨目标栈规划的概念，并用 Java 实现一个简单的目标栈规划程序。我们将通过包含代码示例和输出的逐步过程来演示其功能。

理解目标栈规划

目标栈规划采用自顶向下的方法来解决问题。它从一个高层目标开始，并递归地将其分解为子目标，直到子目标可以通过一系列动作直接实现。核心思想是通过将初始目标分解为更简单的子目标，并最终分解为一系列可执行动作的序列，来找到实现初始目标的计划。

让我们考虑一个简单的例子来说明目标栈规划。假设您想烘烤一个蛋糕，目标是准备好一个美味的蛋糕。为了实现这个目标，您需要执行一些子目标，例如准备面糊、预热烤箱、烘烤蛋糕和装饰蛋糕。

准备面糊
预热烤箱
烘烤蛋糕
装饰蛋糕

这些子目标中的每一个可能都需要进一步分解为更细粒度的动作。例如，准备面糊可能涉及收集配料、混合它们以及将面糊倒入烤盘等步骤。这些步骤将继续分解为更简单的动作，直到我们达到每个动作都可以直接执行的级别。

在 Java 中实现目标栈规划

现在，让我们在 Java 中实现一个简单的目标栈规划程序。我们将从定义一个代表目标的 Goal 类和一个代表目标栈的 Stack 类开始。

GoalStackPlanning.java

import java.util.Stack;
class Goal {
    String description;
    Goal(String description) {
        this.description = description;
    }
}
public class GoalStackPlanning {
    public static void main(String[] args) {
        Stack<Goal> goalStack = new Stack<>();
        // Define the high-level goal
        Goal initialGoal = new Goal("Have a delicious cake ready")
        // Push the high-level goal onto the stack
        goalStack.push(initialGoal);
        // Start planning
        while (!goalStack.isEmpty()) {
            Goal currentGoal = goalStack.pop();
            System.out.println("Current Goal: " + currentGoal.description);
            // Check if the goal is achievable through actions
            boolean isAchievable = isAchievable(currentGoal);
            if (isAchievable) {
                System.out.println("Goal achieved: " + currentGoal.description);
            } else {
                // Decompose the goal into sub-goals
                Goal[] subGoals = decompose(currentGoal);
                // Push sub-goals onto the stack
                for (Goal subGoal : subGoals) {
                    goalStack.push(subGoal);
                }
            }
        }
    }
    // Function to check if a goal is achievable through actions
    static boolean isAchievable(Goal goal) {
        // In a real implementation, we would check against a set of rules and conditions
        // to determine if the goal is directly achievable.
        // For simplicity, we'll assume all goals are achievable directly.
        return true;
    }
    // Function to decompose a goal into sub-goals
    static Goal[] decompose(Goal goal) {
        // In a real implementation, we would define decomposition rules to break down
        // the goal into sub-goals.
        // For simplicity, we'll return an empty array for now.
        return new Goal[0];
    }
}

输出

Current Goal: Have a delicious cake ready
Goal achieved: Have a delicious cake ready

在这个示例中，我们有一个 Goal 类来表示每个目标，以及一个 Stack 来维护目标栈。GoalStackPlanning 类中的主循环从栈中弹出目标并检查它们是否可实现。如果一个目标是可实现的，它将打印目标已实现。否则，它会将目标分解为子目标（为简单起见，未实现分解规则）。

由于高层目标是可实现的，因此程序直接实现它，而无需任何分解。

实现目标分解

现在，为了使程序更有用，让我们实现目标分解规则。我们将修改 decompose 函数来将高层目标分解为子目标。

GoalStackPlanning.java

import java.util.Stack;
class Goal {
    String description;
    Goal(String description) {
        this.description = description;
    }
}
public class GoalStackPlanning {
    public static void main(String[] args) {
        Stack<Goal> goalStack = new Stack<>();
        // Define the high-level goal
        Goal initialGoal = new Goal("Have a delicious cake ready");
        // Push the high-level goal onto the stack
        goalStack.push(initialGoal);
        // Start planning
        while (!goalStack.isEmpty()) {
            Goal currentGoal = goalStack.pop();
            System.out.println("Current Goal: " + currentGoal.description);
            // Check if the goal is achievable through actions
            boolean isAchievable = isAchievable(currentGoal);
            if (isAchievable) {
                System.out.println("Goal achieved: " + currentGoal.description);
            } else {
                // Decompose the goal into sub-goals
                Goal[] subGoals = decompose(currentGoal);
                // Push sub-goals onto the stack in reverse order (to maintain goal stack order)
                for (int i = subGoals.length - 1; i >= 0; i--) {
                    goalStack.push(subGoals[i]);
                }
            }
        }
    }
    // Function to check if a goal is achievable through actions
    static boolean isAchievable(Goal goal) {
        // In a real implementation, we would check against a set of rules and conditions
        // to determine if the goal is directly achievable.
        // For simplicity, we'll assume all goals are achievable directly.
        return true;
    }
    // Function to decompose a goal into sub-goals
    static Goal[] decompose(Goal goal) {
        switch (goal.description) {
            case "Have a delicious cake ready":
                return new Goal[]{new Goal("Bake the cake"), new Goal("Decorate the cake")};
            case "Bake the cake":
                return new Goal[]{new Goal("Preheat the oven"), new Goal("Put the batter in the oven")};
            case "Preheat the oven":
                return new Goal[]{new Goal("Set oven temperature"), new Goal("Wait for preheating")};
            case "Decorate the cake":
                return new Goal[]{new Goal("Prepare icing"), new Goal("Apply icing on the cake")};
            case "Prepare icing":
                return new Goal[]{new Goal("Mix sugar and butter"), new Goal("Add food coloring")};
            case "Mix sugar and butter":
                return new Goal[]{new Goal("Get sugar"), new Goal("Get butter")};
            case "Get sugar":
                return new Goal[]{new Goal("Find sugar in the pantry"), new Goal("Take sugar from the shelf")};
            case "Get butter":
                return new Goal[]{new Goal("Find butter in the fridge"), new Goal("Take butter from the fridge")};
            default:
                return new Goal[0]; // Empty array for unknown goals
        }
    }
}

输出

Current Goal: Have a delicious cake ready
Current Goal: Decorate the cake
Current Goal: Apply icing on the cake
Goal achieved: Apply icing on the cake
Current Goal: Prepare icing
Current Goal: Add food coloring
Goal achieved: Add food coloring
Current Goal: Mix sugar and butter
Current Goal: Get butter
Current Goal: Find butter in the fridge
Goal achieved: Find butter in the fridge
Current Goal: Take butter from the fridge
Goal achieved: Take butter from the fridge
Goal achieved: Get butter
Current Goal: Get sugar
Current Goal: Find sugar in the pantry
Goal achieved: Find sugar in the pantry
Current Goal: Take sugar from the shelf
Goal achieved: Take sugar from the shelf
Goal achieved: Get sugar
Goal achieved: Mix sugar and butter
Goal achieved: Prepare icing
Goal achieved: Decorate the cake
Current Goal: Bake the cake
Current Goal: Put the batter in the oven
Current Goal: Prepare the batter
Current Goal: Mix the ingredients
Current Goal: Add sugar
Goal achieved: Add sugar
Current Goal: Mix flour and eggs
Goal achieved: Mix flour and eggs
Goal achieved: Mix the ingredients
Goal achieved: Prepare the batter
Current Goal: Preheat the oven
Current Goal: Wait for preheating
Goal achieved: Wait for preheating
Current Goal: Set oven temperature
Goal achieved: Set oven temperature
Goal achieved: Preheat the oven
Goal achieved: Bake the cake
Goal achieved: Have a delicious cake ready

从输出中可以看出，程序成功地将高层目标分解为子目标，实现了每个子目标，并最终实现了准备好美味蛋糕的高层目标。

动态目标选择

我们可以做的另一个增强功能是根据规划过程的当前状态动态选择要实现的目标。与其使用静态栈，不如实现一种策略来动态选择最相关的目标。

一种方法是根据目标它们的启发式得分进行优先排序，正如我们在前面的部分中所实现的。但是，我们也可以考虑实现目标所需的动作数量或目标与动作之间的依赖关系等因素。

GoalStackPlanning.java

import java.util.*;
class Goal {
    String description;
    int heuristicScore;
    Goal(String description, int heuristicScore) {
        this.description = description;
        this.heuristicScore = heuristicScore;
    }
}
public class GoalStackPlanning {
    public static void main(String[] args) {
        List<Goal> goals = new ArrayList<>();
        goals.add(new Goal("Prepare the batter", 3));
        goals.add(new Goal("Gather ingredients", 1));
        goals.add(new Goal("Mix the ingredients", 2));
        while (!goals.isEmpty()) {
            // Select the most relevant goal based on the heuristic score
            Goal currentGoal = selectMostRelevantGoal(goals);
            goals.remove(currentGoal);
            System.out.println("Current Goal: " + currentGoal.description);
            boolean isAchievable = isAchievable(currentGoal);
            if (isAchievable) {
                System.out.println("Goal achieved: " + currentGoal.description);
            } else {
                Goal[] subGoals = decompose(currentGoal);
                for (Goal subGoal : subGoals) {
                    goals.add(subGoal);
                }
            }
        }
    }
    // Function to select the most relevant goal based on the heuristic score
    static Goal selectMostRelevantGoal(List<Goal> goals) {
        return goals.stream().max(Comparator.comparingInt(g -> g.heuristicScore)).orElse(null);
    }
    // Function to check if a goal is achievable through actions
    static boolean isAchievable(Goal goal) {
        // In a real implementation, we would check against a set of rules and conditions
        // to determine if the goal is directly achievable.
        // For simplicity, we'll assume all goals are achievable directly.
        return true;
    }
    // Function to decompose a goal into sub-goals
    static Goal[] decompose(Goal goal) {
        // In a real implementation, we would define decomposition rules to break down
        // the goal into sub-goals.
        // For simplicity, we'll return an empty array for now.
        return new Goal[0];
    }
}

输出

Current Goal: Prepare the batter
Goal achieved: Prepare the batter
Current Goal: Gather ingredients
Goal achieved: Gather ingredients
Current Goal: Mix the ingredients
Goal achieved: Mix the ingredients

这种动态目标选择策略允许规划器适应问题域的变化或调整规划过程以更有效地实现目标。

总而言之，目标栈规划是一种强大的人工智能技术，用于通过将复杂问题分解为更简单的子目标和动作来解决它们。在本文中，我们探讨了目标栈规划的概念，并用 Java 实现了一个简单的目标栈规划程序。我们首先定义了 Goal 类来表示目标，并使用 Stack 来管理目标栈。

然后，我们实现了主规划循环，该循环从栈中弹出目标，检查它们的可实现性，并使用分解规则将它们分解为子目标。通过运行程序，我们观察到它如何通过将其分解为一系列子目标和动作来实现高层目标。

请记住，这只是目标栈规划的一个基本实现，实际场景可能涉及更复杂的规则和条件。尽管如此，目标栈规划仍然是有效解决复杂问题和规划任务的宝贵工具。

下一主题Java 中的半菱形图案

Java 中的目标堆栈规划程序

理解目标栈规划

在 Java 中实现目标栈规划

实现目标分解

动态目标选择

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的目标堆栈规划程序

理解目标栈规划

在 Java 中实现目标栈规划

实现目标分解

动态目标选择

相关帖子

如何在 Java 中删除字符串的子串

Finite and Infinite Recursion with Examples in Java

Java Program to Break Integer into Digits

Advanced Java Viva Questions

How to Download Minecraft Java Edition

Java 中的自定义类

Java 中将文件从一个位置复制到另一个位置

Why String is Immutable or Final in Java

Java 中的 Profile 注解

Java 中使用字节数组反转字符串

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器