Condivisione della tecnologia

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

1.algoritmo avidointrodurre

1. Idea di algoritmo

L’idea di base dell’algoritmo greedy è quella di procedere passo dopo passo partendo da una soluzione iniziale del problema. Secondo una misura di ottimizzazione, ogni passo deve garantire che si possa ottenere una soluzione ottima locale. In ogni passaggio viene considerato un solo dato e la sua selezione deve soddisfare le condizioni di ottimizzazione locale. Se i dati successivi e la soluzione ottima parziale sono collegati tra loro e non è più una soluzione fattibile, i dati non verranno aggiunti alla soluzione parziale finché tutti i dati non saranno enumerati o finché l'algoritmo non potrà più essere aggiunto e l'algoritmo si arresterà.

L’algoritmo greedy generalmente procede nel modo seguente:

①Stabiliremodello matematicoper descrivere il problema.

② Dividere il problema da risolvere in più sottoproblemi.

③ Risolvi ogni sottoproblema e ottieni la soluzione ottima locale del sottoproblema.

④ Combina la soluzione ottima locale del sottoproblema in una soluzione del problema originale.

L'algoritmo greedy è una tecnica di progettazione più semplice e veloce per alcuni problemi di soluzione ottima. La caratteristica dell'algoritmo greedy è che procede passo dopo passo, spesso facendo scelte ottimali basate sulla situazione attuale e sulla base di una misura di ottimizzazione, senza considerare tutte le possibili situazioni complessive, eliminando la necessità di esaurire tutte le possibilità per trovare la soluzione ottimale. Trascorso molto tempo.Utilizza l'algoritmo golosodall'alto al basso , effettuare scelte avide successive in un metodo iterativo. Ogni volta che viene effettuata una scelta avida, il problema desiderato viene semplificato in un sottoproblema più piccolo. Attraverso ogni passaggio della scelta avida, è possibile ottenere una soluzione ottimale al problema. Sebbene sia necessario garantire che la soluzione ottima locale possa essere ottenuta in ogni passaggio, la soluzione globale risultante a volte non è necessariamente ottimale, quindi gli algoritmi greedy non tornano sui propri passi [2].

2. Introduzione al codice

 
    /**
     * 为指定学生推荐最合适的课程。
     * @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. Utilizza un algoritmo goloso per consigliare il corso più appropriato per uno studente specifico

1. Definizione del metodo:
- "recommendBestCourse" è un metodo statico che riceve un oggetto "Scanner" per l'input dell'utente e oggetti del livello di servizio "StudentService" e "CourseService" per ottenere informazioni sugli studenti e sul corso.

2. Elaborazione dell'input dell'utente:
- Il programma richiede innanzitutto all'utente di inserire un ID studente, quindi utilizza un oggetto "Scanner" per leggere questo valore di input.

3. Acquisizione delle informazioni sugli studenti:
- Utilizza il metodo `studentService.getStudentById(studentID)` per ottenere informazioni sugli studenti in base all'ID studente. Se lo studente non esiste, stampa il messaggio di richiesta e termina l'esecuzione del metodo.

4. Ottieni l'elenco dei corsi:
- Chiama `courseService.listAllCourses()` per ottenere un elenco di tutti i corsi disponibili. Se non sono presenti informazioni sul corso, verranno stampate anche le informazioni sul prompt e l'esecuzione del metodo terminerà.

5. Logica della raccomandazione:
- Utilizza un algoritmo goloso per consigliare il corso più adatto agli studenti chiamando il metodo `findBestCourse`.

6. Implementazione dell'algoritmo greedy:
- Il metodo "findBestCourse" ripete tutti i corsi e calcola un punteggio per ciascun corso tramite il metodo "calculateCourseScore". Il corso con il punteggio più alto viene selezionato come migliore raccomandazione.

7. Calcolo del punteggio:
- Il metodo `calculateCourseScore` definisce la logica di calcolo dei punteggi del corso. In questo esempio il punteggio si basa su due fattori: il numero di crediti del corso e se lo studente ha frequentato il corso. Maggiore è il numero di crediti, maggiore è il punteggio e vengono assegnati punti aggiuntivi se lo studente non ha seguito il corso.

8. Risultati consigliati:
- Se viene trovato il corso migliore, stampa il nome del corso, l'ID del corso e le informazioni sul credito. Se non esiste un corso adatto, stampare il messaggio di richiesta corrispondente.