Compartilhamento de tecnologia

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

1.algoritmo gananciosointroduzir

1. Ideia de algoritmo

A ideia básica do algoritmo ganancioso é proceder passo a passo a partir de uma solução inicial para o problema. De acordo com uma medida de otimização, cada etapa deve garantir que uma solução ótima local possa ser obtida. Apenas um dado é considerado em cada etapa, e sua seleção deve atender às condições de otimização local. Se os próximos dados e a solução parcial ótima estiverem conectados e não for mais uma solução viável, os dados não serão adicionados à solução parcial até que todos os dados sejam enumerados ou o algoritmo não possa mais ser adicionado e o algoritmo pare.

O algoritmo ganancioso geralmente procede da seguinte forma:

①Estabelecermodelo matemáticopara descrever o problema.

② Divida o problema a ser resolvido em vários subproblemas.

③ Resolva cada subproblema e obtenha a solução ótima local do subproblema.

④ Combine a solução ótima local do subproblema em uma solução para o problema original.

O algoritmo guloso é uma técnica de projeto mais simples e rápida para determinados problemas de solução ótima. A característica do algoritmo ganancioso é que ele avança passo a passo, muitas vezes fazendo escolhas ótimas com base na situação atual e com base em uma medida de otimização, sem considerar todas as situações globais possíveis, eliminando a necessidade de esgotar todas as possibilidades para encontrar a solução ótima. Muito tempo gasto.Algoritmo ganancioso usacareca , faça escolhas gananciosas sucessivas em um método iterativo. Cada vez que uma escolha gananciosa é feita, o problema desejado é simplificado em um subproblema menor. Através de cada etapa da escolha gananciosa, uma solução ótima para o problema pode ser obtida. Embora seja necessário garantir que a solução ótima local possa ser obtida em cada etapa, a solução global resultante às vezes não é necessariamente ótima, de modo que algoritmos gananciosos não retrocedem [2].

2. Introdução ao código

 
    /**
     * 为指定学生推荐最合适的课程。
     * @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. Use um algoritmo ganancioso para recomendar o curso mais adequado para um aluno específico

1. Definição do método:
- `recommendBestCourse` é um método estático que recebe um objeto `Scanner` para entrada do usuário e objetos da camada de serviço `StudentService` e `CourseService` para obter informações do aluno e do curso.

2. Processamento de entrada do usuário:
- O programa primeiro solicita que o usuário insira uma ID de aluno e, em seguida, usa um objeto `Scanner` para ler esse valor de entrada.

3. Aquisição de informações dos alunos:
- Use o método `studentService.getStudentById(studentID)` para obter informações do aluno com base na carteira do aluno. Caso o aluno não exista, imprima a mensagem de prompt e finalize a execução do método.

4. Obtenha a lista de cursos:
- Chame `courseService.listAllCourses()` para obter uma lista de todos os cursos disponíveis. Caso não haja informações do curso, as informações do prompt também serão impressas e a execução do método será encerrada.

5. Lógica de recomendação:
- Use um algoritmo ganancioso para recomendar o curso mais adequado para os alunos chamando o método `findBestCourse`.

6. Implementação de algoritmo ganancioso:
- O método `findBestCourse` percorre todos os cursos e calcula uma pontuação para cada curso através do método `calculateCourseScore`. O curso com maior pontuação é selecionado como a melhor recomendação.

7. Cálculo da pontuação:
- O método `calculateCourseScore` define a lógica de cálculo das notas dos cursos. Neste exemplo, a pontuação é baseada em dois fatores: a quantidade de créditos do curso e se o aluno realizou o curso. Quanto mais créditos maior será a pontuação, sendo atribuídos pontos adicionais caso o aluno não tenha realizado o curso.

8. Saída de resultado recomendada:
- Se o melhor curso for encontrado, imprima o nome do curso, ID do curso e informações de crédito. Se não houver um curso adequado, imprima a mensagem de prompt correspondente.