Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1.algorithme gourmandintroduire

1. Idée d'algorithme

L'idée de base de l'algorithme glouton est de procéder étape par étape à partir d'une solution initiale au problème. Selon une mesure d'optimisation, chaque étape doit garantir qu'une solution optimale locale peut être obtenue. Une seule donnée est considérée à chaque étape, et sa sélection doit répondre aux conditions d'optimisation locale. Si les données suivantes et la solution optimale partielle sont connectées ensemble et que ce n'est plus une solution réalisable, les données ne seront pas ajoutées à la solution partielle jusqu'à ce que toutes les données soient énumérées ou que l'algorithme ne puisse plus être ajouté et que l'algorithme s'arrête.

L’algorithme glouton procède généralement de la manière suivante :

①Établirmodèle mathématiquepour décrire le problème.

② Divisez le problème à résoudre en plusieurs sous-problèmes.

③ Résolvez chaque sous-problème et obtenez la solution optimale locale du sous-problème.

④ Combiner la solution optimale locale du sous-problème en une solution au problème d'origine.

L'algorithme glouton est une technique de conception plus simple et plus rapide pour certains problèmes de solution optimale. La caractéristique de l'algorithme glouton est qu'il procède étape par étape, en faisant souvent des choix optimaux basés sur la situation actuelle et sur la base d'une mesure d'optimisation, sans considérer toutes les situations globales possibles, éliminant ainsi le besoin d'épuiser toutes les possibilités pour trouver la solution optimale. Beaucoup de temps passé.L'algorithme gourmand utilisede haut en bas , faites des choix gloutons successifs dans une méthode itérative. Chaque fois qu'un choix glouton est fait, le problème souhaité est simplifié en un sous-problème plus petit. À chaque étape du choix glouton, une solution optimale au problème peut être obtenue. Bien qu’il soit nécessaire de s’assurer que la solution optimale locale puisse être obtenue à chaque étape, la solution globale résultante n’est parfois pas nécessairement optimale, donc les algorithmes gloutons ne reviennent pas en arrière [2].

2. Présentation du code

 
    /**
     * 为指定学生推荐最合适的课程。
     * @param scanner 用于接收用户输入的Scanner对象。
     * @param studentService 用于获取学生信息的服务。
     * @param courseService 用于获取课程列表的服务。
     */
    public static void recommendBestCourse(Scanner scanner, StudentService studentService, CourseService courseService) {
        // 提示用户输入学生ID并接收输入
        System.out.print("输入学生ID：");
        int studentID = scanner.nextInt();
        scanner.nextLine(); // 消耗换行符
 
        // 根据学生ID获取学生信息，如果学生不存在则返回
        Student student = studentService.getStudentById(studentID);
        if (student == null) {
            System.out.println("未找到该学生。");
            return;
        }
 
        // 获取所有课程的列表，如果没有课程信息则返回
        List<Course> courses = courseService.listAllCourses();
        if (courses.isEmpty()) {
            System.out.println("当前没有课程信息。");
            return;
        }
 
        // 使用贪心算法推荐最合适的课程
        Course bestCourse = findBestCourse(student, courses);
        if (bestCourse != null) {
            // 如果找到最佳课程，打印课程信息
            System.out.println("推荐的最合适课程是：" + bestCourse.getCourseName());
            System.out.println("课程ID: " + bestCourse.getCourseID());
            System.out.println("学分: " + bestCourse.getCreditHours());
        } else {
            System.out.println("没有找到合适的课程。");
        }
    }
 
    /**
     * 使用贪心算法找到最合适的课程。
     * @param student 需要推荐课程的学生。
     * @param courses 可供选择的所有课程列表。
     * @return 最佳课程对象。
     */
    private static Course findBestCourse(Student student, List<Course> courses) {
        Course bestCourse = null; // 用于存储当前找到的最佳课程
        int maxScore = Integer.MIN_VALUE; // 用于存储当前最高分数
 
        // 遍历所有课程
        for (Course course : courses) {
            // 计算每个课程的得分
            int score = calculateCourseScore(student, course);
            // 如果当前课程的得分高于已知最高分数，则更新最佳课程和最高分数
            if (score > maxScore) {
                maxScore = score;
                bestCourse = course;
            }
        }
 
        // 返回得分最高的课程作为最佳课程推荐
        return bestCourse;
    }
 
    /**
     * 计算单个课程的得分，用于评估课程的适宜性。
     * @param student 学生对象。
     * @param course 课程对象。
     * @return 计算得到的课程得分。
     */
    private static int calculateCourseScore(Student student, Course course) {
        int score = 0; // 初始化得分
 
        // 学分越高，得分越高，这里假设每1学分得10分
        score += course.getCreditHours() * 10;
 
        // 如果学生未修过该课程，额外加分，这里假设额外加50分
        List<Grade> grades = student.getGrades(new GradeService()); // 获取学生已修课程的列表
        boolean isTaken = grades.stream().anyMatch(grade -> grade.getCourseID() == course.getCourseID());
        if (!isTaken) {
            score += 50;
        }
 
        // 返回计算得到的得分
        return score;
    }

3. Utilisez un algorithme glouton pour recommander le cours le plus approprié pour un étudiant spécifique

1. Définition de la méthode :
- `recommendBestCourse` est une méthode statique qui reçoit un objet `Scanner` pour la saisie de l'utilisateur, ainsi que des objets de couche de service `StudentService` et `CourseService` pour obtenir des informations sur les étudiants et les cours.

2. Traitement des entrées utilisateur :
- Le programme invite d'abord l'utilisateur à saisir un identifiant d'étudiant, puis utilise un objet « Scanner » pour lire cette valeur d'entrée.

3. Acquisition d'informations sur les étudiants :
- Utilisez la méthode `studentService.getStudentById(studentID)` pour obtenir des informations sur les étudiants en fonction de leur carte d'étudiant. Si l'étudiant n'existe pas, imprimez le message d'invite et terminez l'exécution de la méthode.

4. Obtenez la liste des cours :
- Appelez `courseService.listAllCourses()` pour obtenir une liste de tous les cours disponibles. S'il n'y a aucune information sur le cours, les informations d'invite seront également imprimées et l'exécution de la méthode prendra fin.

5. Logique de recommandation :
- Utilisez un algorithme glouton pour recommander le cours le plus adapté aux étudiants en appelant la méthode `findBestCourse`.

6. Implémentation d'un algorithme glouton :
- La méthode « findBestCourse » parcourt tous les cours et calcule un score pour chaque cours via la méthode « calculateCourseScore ». Le cours ayant obtenu le score le plus élevé est sélectionné comme meilleure recommandation.

7. Calcul des scores :
- La méthode `calculateCourseScore` définit la logique de calcul des scores des cours. Dans cet exemple, le score est basé sur deux facteurs : le nombre de crédits pour le cours et si l'étudiant a suivi le cours. Plus il y a de crédits, plus le score est élevé et des points supplémentaires sont attribués si l'étudiant n'a pas suivi le cours.

8. Résultat recommandé :
- Si le meilleur cours est trouvé, imprimez le nom du cours, l'identifiant du cours et les informations de crédit. S'il n'y a pas de cours approprié, imprimez le message d'invite correspondant.