Acwing.4672 布料排序(排序)

题目

每块布料包含三种属性：

颜色（C），一个由小写英文字母组成的字符串，表示布料的颜色。
耐久性（D），一个整数，表示布料的耐久性。
唯一标识符（U），一个整数，表示布料的 ID。
给定 N 块布料，阿达和查尔斯需要对布料进行排序。

阿达按照颜色（C）字典序升序的顺序对布料进行排序，颜色相同的布料按唯一标识符（U）升序的顺序进行排序。

查尔斯按照耐久性（D）升序的顺序对布料进行排序，耐久性相同的布料按唯一标识符（U）升序的顺序进行排序。

请你计算，有多少块布料满足，无论是阿达还是查尔斯对布料进行排序，其最终顺位排名都相同。

输入格式

第一行包含整数 T，表示共有 T 组测试数据。

每组数据第一行包含整数 N。

接下来 N 行，每行包含一个字符串 Ci，一个整数 Di，一个整数 Ui。

输出格式

每组数据输出一个结果，每个结果占一行。

结果表示为 Case #x: y，其中 x 为组别编号（从 1 开始），y 为满足条件的布料数量。

数据范围

1≤T≤100,
1≤N≤103,
1≤|Ci|≤10,
1≤Di≤100,
1≤Ui≤103,
Ci 只包含小写英文字母。
Ui 两两不同。

• 输入样例1：

3
2
blue 2 1
yellow 1 2
2
blue 2 1
brown 2 2
1
red 1 1

• 输出样例1：

Case #1: 0
Case #2: 2
Case #3: 1

样例1解释

在 Case 1 中，按颜色排序时，布料（用唯一标识符表示）顺序为 1,2；按耐久性排序时，布料顺序为 2,1，所以 0 块布料具有相同的排名。

在 Case 2 中，按颜色排序时，布料（用唯一标识符表示）顺序为 1,2；按耐久性排序时，布料顺序为 1,2，所以 2 块布料具有相同的排名，这里需要注意，两块布料具有相同的耐久性，所以在查尔斯进行排序时，他将具有更小 ID 的 1 号布料排在前面。

在 Case 3 中，只有 1 块布料，所以无论如何其排名都不会有变化。

• 输入样例2：

1
5
blue 1 2
green 1 4
orange 2 5
red 3 6
yellow 3 7

• 输出样例2：

Case #1: 5

题解

import java.util.*;

/**
 * @author akuya
 * @create 2023-10-16-16:35
 */
public class Main {
    static int t,tt,ttt;
    static int n;
    static int N=1010;
    static int ans;
    static PriorityQueue<clo> pq1=new PriorityQueue<>(new Comparator<clo>() {
        @Override
        public int compare(clo o1, clo o2) {
            if(o1.color.compareTo(o2.color)!=0){
                return o1.color.compareTo(o2.color);
            }else{
                return o1.Uid-o2.Uid;
            }
        }
    });

    static PriorityQueue<clo> pq2=new PriorityQueue<>(new Comparator<clo>() {
        @Override
        public int compare(clo o1, clo o2) {
            if(o1.endurance!=o2.endurance){
                return o1.endurance-o2.endurance;
            }else{
                return o1.Uid-o2.Uid;
            }
        }
    });
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        t=scanner.nextInt();
        tt=t;

        while(t--!=0){
            ans=0;
            n=scanner.nextInt();
            for(int i=0;i<n;i++){
                String color=scanner.next();
                int endurance=scanner.nextInt();
                int uid=scanner.nextInt();
                pq1.add(new clo(color,endurance,uid));
                pq2.add(new clo(color,endurance,uid));
            }
            while(!pq1.isEmpty()){
                clo c1=pq1.poll();
                clo c2=pq2.poll();
                if(c1.color.equals(c2.color)&&c1.endurance==c2.endurance&&c1.Uid==c2.Uid){
                    ans++;
                }
            }

            ttt=tt-t;
            System.out.println("Case #"+ttt+": "+ans);


        }
    }

    public static class clo{
        private String color;
        private int endurance;
        private int Uid;

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public int getEndurance() {
            return endurance;
        }

        public void setEndurance(int endurance) {
            this.endurance = endurance;
        }

        public int getUid() {
            return Uid;
        }

        public void setUid(int uid) {
            Uid = uid;
        }

        public clo(String color, int endurance, int uid) {
            this.color = color;
            this.endurance = endurance;
            Uid = uid;
        }
    }
}

思路

按照两种排序的规则创建优先队列，然后遍历一次优先队列，进行判断即可。