题目

分析

要点：在排队的基础上移动学生位置，实现要求的分组，分组的顺序不做要求，求移动学生次数的最小值。

实现方案：考虑Map

参考

解题思路：
1.建立索引字典:将学生目前排队情况转换成索引字典,其中键为学生编号,值为该学生在队伍中的索引位置。
2.遍历每个小组:对于每个小组,遍历其中的学生。
3.计算目标位置:对于每个小组的学生,计算其目标位置。
目标位置是该学生在小组中的相对位置乘以3再加上该小组在整个队伍中的位置。
4,调整位置:如果当前位置不是目标位置,则需要进行调整。
通过交换当前位置和目标位置的学生,使得小组内的学生在队伍中是连续排列。
5,更新索引字典:调整后更新索引字典,确保索引字典中的信息是最新的。
6.累计调整次数:统计每次调整,最终得到最少调整次数。

通过以上步骤,可以确保同组成员在队伍中是彼此相连的。在代码中,需要注意索引的计算以及列表中的元素交换。这个思路的关键在于通过交换操作，逐步调整队伍中学生的位置，使得每个小组的学生都连续排列。

import java.util.Scanner;
import java.util.*;
import java.util.stream.Stream;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
 
public class Main {
    public static List<Integer> cur_order = new ArrayList<>();
    public static List<Integer> final_order= new ArrayList<>();
    public static List<Integer> order_flags= new ArrayList<>();
    public static int n=0;
    //map<学生编号, 组号>
    public static Map<Integer, Integer> relations=new HashMap<>(); 
    public static int result = 0;
    
    //判断每一位同学是否都在对应组内
    public static boolean check_order(){
        for (int i = 0; i < cur_order.size(); i += 3) {
            if (!(relations.get(cur_order.get(i)) == relations.get(cur_order.get(i + 1)) && 
                relations.get(cur_order.get(i)) == relations.get(cur_order.get(i + 2)))){
                return false;
            }
        }
        return true;
    }
    
    public static void move(int cur_student, int remove_index, int append_index){
        if (relations.get(cur_order.get(remove_index)) == relations.get(cur_student)) {
            int remove_element = cur_order.get(remove_index);
            cur_order.remove(remove_index);
            cur_order.add(append_index, remove_element);
        }
    }
    
    public static void two_step_move(){
        for (int i = 0; i < n; i++) {
            int cur_student = cur_order.get(i);
            if (order_flags.get(relations.get(cur_student))==0) {
                result += 2;
                for (int j = 0; j < n; j++) {
                    if (cur_order.get(j) != cur_student) {
                        move(cur_student,j,i);
                    }
                }
            }
        }
    }
    
    //以当前学生为准，判断他后面的两个学生是否与其同组
    public static int get_cur_order_cnt(int index, int cur_student){
        int count = 0; 
        int cur_stu_order = relations.get(cur_student);
        if (index + 1 < n && relations.get(cur_order.get(index + 1)) == cur_stu_order) {
            order_flags.set(relations.get(cur_student), 1);
            count+=1;
            if(index + 2 < n && relations.get(cur_order.get(index + 2)) == cur_stu_order){
                count+=1;
            }
        }
        return count;
    }
 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] tmp1 = in.nextLine().split(" ");
        for (int i = 0; i < tmp1.length; i++) {  
            cur_order.add(Integer.parseInt(tmp1[i]));
        }
        String[] tmp2 = in.nextLine().split(" ");
        for (int i = 0; i < tmp2.length; i++) {  
            final_order.add(Integer.parseInt(tmp2[i]));
        }
        n = cur_order.size();
        for (int j = 0; j < n; j++) {
            order_flags.add(0);
        }
        
        int k=0;
        while(true){
            if(k>=n){
                break;
            } else {
                for (int j = 0; j < 3; j++) {
                    relations.put((final_order.get(k + j)) , k / 3 + 1);
                }
            }
            k+=3;
        }
    
     
        while (!check_order()) {
            int operation_flag = 0;  
    
            int i=0;
            while(true){
                if(i>=n){
                    break;
                } else {
                    int cur_student = cur_order.get(i);
                    if (order_flags.get(relations.get(cur_student))==0){
                        //后面有一个学生与其同组，那么需要操作1次
                        //后面有两个学生与其同组，那么需要操作0次,无需操作
                        if (get_cur_order_cnt(i, relations.get(cur_student)) == 1) {
                            result += 1;
                            operation_flag = 1; 
                            for (int j = 0; j < n; j++) {
                                if (j != i && j != i + 1) {
                                    move(cur_student,j,i);
                                }
                            }
                        }
                    } 
     
                }
                i+=1;
            }
    
            // 若每一个学生后面两个学生都没有与其同组的情况
            // 需要操作2次，将其后面两位都移动,然后再循环的去遍历,判读是否满足分组情况
            if (operation_flag==0) {
                two_step_move();
            }
        }
        System.out.println(result);
    }
 
    public static int[] split(String input_str){
        String[] tmp2 = input_str.split(",");
        int[] nums = new int[tmp2.length];
        for (int i = 0; i < tmp2.length; i++) {  
            nums[i] = Integer.parseInt(tmp2[i]);
        }
        return nums;
    }
}

https://blog.csdn.net/weixin_52908342/article/details/136288646