挑战程序设计竞赛（算法和数据结构）——7.7最小成本排序的JAVA实现

Posted 2022-12-05 小乖乖的臭坏坏

题目&思路：



代码：

import java.util.*;

public class MinimumCostSort 
    public static final int MAX = 1000;

    public static void main(String[] args) 
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int A[] = new int[n+1];
        boolean T[] = new boolean[n+1];//用于判断数组中的元素是否已经被处理过了
        int min_val = Integer.MAX_VALUE;
        for (int i=1;i<=n;i++)
            A[i] = cin.nextInt();
            T[i] = false;
            min_val = Math.min(min_val, A[i]);
        

        int[] B = getPosition(A);//获取位置排序

        ArrayList<ArrayList<Integer>> Group = new ArrayList<>();//用于存放每一个组
        for (int i =1;i<=n;i++)
            ArrayList<Integer> S = new ArrayList<>();
            int u = i;
            while (!T[u])//如果当前值没有处理过，才进入循环进行处理
                T[u] = true;//当前数字设置为已被处理
                S.add(A[u]);//将当前节点添加到集合S中
                u = B[u];//该数字作为新的索引
            
            //集合S构建完后，添加到Group里
            if(S.size()!=0)
                Group.add(S);
            
        

        int cost = 0;
        for (int i=0;i<Group.size();i++)
            int sub_cost = subCost(Group.get(i), min_val);
            cost += sub_cost;
        

        System.out.println(cost);

    

    public static int[] getPosition(int[] A)
        int n = A.length-1;
        ArrayList<Integer> C = new ArrayList<>();
        for (int i=0;i<=n;i++)
            C.add(A[i]);
        
        Collections.sort(C);

        int[] B = new int[n+1];

        for (int i=0;i<=n;i++)
            B[i] = C.indexOf(A[i]);
        
        return B;
    
    public static int subCost(ArrayList<Integer> S, int min_val)
        int sub_cost = 0;
        int w = 0;
        int n = S.size();
        int min_w = Integer.MAX_VALUE;
        for (int i=0;i<n;i++)
            w = w + S.get(i);
            min_w = Math.min(min_w, S.get(i));
        
        if (S.indexOf(min_val)!=-1)//最小是在集合内
            sub_cost = w + (n-2)*min_w;
        
        else 
            sub_cost = Math.min(w + min_w + (n+1) * min_val, w + (n-2)*min_w);
        
        return sub_cost;
    

输入1：

7
4 3 2 7 1 6 5

输出1：

24

输入2：

5
1 5 3 4 2

输出2：

5

输入3：

6
2 1 8 10 7 9

输出3：

49