11:潜伏者

一、题目链接

http://noi.openjudge.cn/ch0107/11/

二、解题思路

三、实施步骤

四、Java程序

import java.util.Scanner;

public class Main {
    /**
     * 判断给定字符串是否包含26个大写字母
     *
     * @param text String类型的对象，代表给定字符串
     * @return true当且仅当text包含26个大写字母，否则false
     */
    public boolean isAllUpperLettersOccurred(String text) {
        char[] chars = text.toCharArray(); // 将text的内容转存为字符数组处理
        boolean[] isOccurred = new boolean[128]; // 标记text是否包含某个字符，默认false
        /* 通过foreach循环遍历chars数组的每个字符e */
        for (char e : chars) {
            isOccurred[e] = true; // 标记text包含当前字符e
        }
        /* 标记ch代表每个大写字母，ch从A开始，到Z为止，更新步长为1 */
        for (char ch = 'A'; ch <= 'Z'; ch++) {
            if (!isOccurred[ch]) { // 如果text不包含当前大写字母ch
                return false; // 返回false
            }
        }
        return true; // 以上没有返回false，说明text包含26个大写字母
    }

    /**
     * 判断给定的加密信息和原信息是否存在唯一编码关系
     *
     * @param encryption String类型的对象，代表给定的加密信息
     * @param source     String类型的对象，代表给定的原信息
     * @return true当且仅当encryption和source存在唯一编码关系，否则false
     */
    public boolean isUniqueCoded(String encryption, String source) {
        int n = encryption.length(); // 给定的加密信息和原信息的长度
        char[] code = new char[128]; // 编码表，下标对应加密信息字符，内容对应原信息字符
        boolean[] isCoded = new boolean[128]; // 标记加密信息字符是否已经编码，默认false
        /* 标记i代表每个字符的位置，i从0开始，到n-1为止，更新步长为1 */
        for (int i = 0; i < n; i++) {
            if (!isCoded[encryption.charAt(i)]) { // 如果当前加密信息字符尚未编码
                code[encryption.charAt(i)] = source.charAt(i); // 通过编码表为其编码
                isCoded[encryption.charAt(i)] = true; // 标记当前加密信息字符完成编码
            }
            else { // 否则，当前加密信息字符已经编码
                if (code[encryption.charAt(i)] != source.charAt(i)) { // 如果该编码不是当前原信息字符
                    return false; // 说明加密信息和原信息不存在唯一编码关系
                }
            }
        }
        return true; // 以上没有返回false，说明加密信息和原信息存在唯一编码关系
    }

    /**
     * 根据给定的加密信息和原信息，对指定信息进行解密
     *
     * @param encryption String类型的对象，代表给定的加密信息
     * @param source     String类型的对象，代表给定的原信息
     * @param required   String类型的对象，代表指定信息
     * @return String类型的对象，根据encryption和source的编码关系，对required进行解密
     */
    public String decryption(String encryption, String source, String required) {
        // 如果给定的原信息不包含26个大写字母，或者给定的加密信息和原信息不存在唯一编码关系
        if (!isAllUpperLettersOccurred(source) || !isUniqueCoded(encryption, source)) {
            return "Failed"; // 返回Failed
        }
        int n = encryption.length(); // 给定的加密信息和原信息的长度
        int m = required.length(); // 指定信息的长度
        char[] code = new char[128]; // 编码表，下标对应加密信息字符，内容对应原信息字符
        char[] ans = new char[m]; // 指定信息的解密信息
        /* 标记i代表每个字符的位置，i从0开始，到n-1为止，更新步长为1 */
        for (int i = 0; i < n; i++) {
            code[encryption.charAt(i)] = source.charAt(i); // 利用原信息字符对加密信息字符进行编码
        }
        /* 标记i代表每个字符的位置，i从0开始，到m-1为止，更新步长为1 */
        for (int i = 0; i < m; i++) {
            ans[i] = code[required.charAt(i)]; // 利用编码表对required字符进行解密
        }
        return String.valueOf(ans); // 返回ans的字符串形式
    }

    public static void main(String[] args) {
        Main test = new Main();
        Scanner input = new Scanner(System.in);
        String encryption = input.next();
        String source = input.next();
        String required = input.next();
        System.out.print(test.decryption(encryption, source, required));
    }
}