蓝桥杯——试题 算法训练 Bit Compressor

Java代码：

/**
 * @Author LZP
 * @Date 2021/2/28 10:45
 * @Version 1.0
 *
试题 算法训练 Bit Compressor


资源限制
时间限制：1.0s   内存限制：256.0MB
问题描述
　　数据压缩的目的是为了减少存储和交换数据时出现的冗余。这增加了有效数据的比重并提高了传输速率。有一种压缩二进制串的方法是这样的：
　　将连续的n个1替换为n的二进制表示（注：替换发生当且仅当这种替换减少了二进制串的总长度）
　　（译者注：连续的n个1的左右必须是0或者是串的开头、结尾）
　　比如：11111111001001111111111111110011会被压缩成10000010011110011。原串长为32,被压缩后串长为17.
　　这种方法的弊端在于，有时候解压缩算法会得到不止一个可能的原串，使得我们无法确定原串究竟是什么。请你写一个程序来判定我们能否利用压缩后的信息来确定原串。给出原串长L，原串中1的个数N，以及压缩后的串。
　　L<=16 Kbytes，压缩后的串长度<=40 bits。
输入格式
　　第一行两个整数L,N，含义同问题描述
　　第二行一个二进制串，表示压缩后的串
输出格式
　　输出"YES"或"NO"或"NOT UNIQUE"（不包含引号）
　　分别表示：
　　YES：原串唯一
　　NO：原串不存在
　　NOT UNIQUE：原串存在但不唯一
样例输入
样例1：
32 26
10000010011110011
样例2：
9 7
1010101
样例3：
14 14
111111
样例输出
样例1：YES
样例2：NOT UNIQUE
样例3：NO

 算法题型：类解压缩
 解题方法：递归求解
 解题思路：压缩后的字符串已知，可以对压缩后的字符串进行从头到尾遍历，用指针的移动（Java中就是数组的索引）
 来讨论所有情况。每当指针指向的字符为'1'时就可以展开进一步的遍历，即将当前索引作为字符串的开始索引，结束
 索引初始化为开始索引+1，然后依次递增到压缩后的字符串的长度，在这个过程中，如果发现结尾索引所指向的字符为
 '1'的话，就跳过当前循环，因为根据题意可知，前后都为1的字符串不符合压缩条件，所以解压缩时就不用考虑该情况。
 也就是说除了前后都为1的这种情况外，还剩下三种情况是我们需要写算法时需要考虑的：
    例如：
         1) 111110
         2) 011110
         3) 011111

 这里尤其要注意的一点就是当截取的字符串是“11”，也就是n = 3的时候，因为3这个数非常特别，又因为题目的要求，
 当n = 3时，原字符串可能为“111”，也可能为“11”，所以我们这里需要分两种情况讨论，而如果当指针指向的字符为
 '0'时则指针向后移动一位，当前字符串的总长度+1，当前字符串的含“1”个数不变继续向下递归。重复该过程，直到当前索引等于压
 缩后的字符串的总长度时，结束第一次递归，然后又继续下一次递归，直到所有情况都讨论完毕，程序停止。算法结果得
 到输出。
 */
public class Main {
    // 原字符串长
    private static int L;
    // 原字符串1的个数
    private static int N;
    // 压缩后的字符串
    private static String str;
    // 满足条件的原字符串个数
    private static int count;

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        L = input.nextInt();
        N = input.nextInt();
        str = input.next();
        division(0, 0, 0);
        if (count > 1) {
            System.out.println("NOT UNIQUE");
        } else if (count < 1) {
            System.out.println("NO");
        } else {
            System.out.println("YES");
        }
    }

    /**
     * 32 26
     * 10000010011110011
     * @param curIndex 当前压缩后字符串的索引
     * @param curStrLen 当前字符串的长度
     * @param curOneNum 当前字符串中1的个数
     */
    public static void division(int curIndex, int curStrLen, int curOneNum) {
        // 出口
        if (curIndex == str.length()) {
            if (curStrLen == L && curOneNum == N) {
                count++;
            }
            return;
        }
        if (curStrLen > L) {
            return;
        }
        if (curOneNum > N) {
            return;
        }

        // 第一个开始字符是1的话，那么就从这个1开始，向后依次遍历
        if (str.charAt(curIndex) == '1') {
            for (int i = curIndex; i < str.length(); i++) {
                // 如果是“1xxxx1”则不用判断，一定没有这种情况
                /*
                    根据题意：能压缩的只有三种情况
                        1、111110
                        2、011110
                        3、011111
                 */

                // 开头和结尾都是1那么就直接跳过这种情况
                if (i + 1 < str.length() && str.charAt(i + 1) == '1') {
                    continue;
                }
                int n = getD(str.substring(curIndex, i + 1));
                // 注意 “11” 的原字符串可能是 “111” 或者 “11” 所以n = 3时要多分一种情况
                /*
                  如果长度为3,原串可能是111
                  但如果原串是11,就不需要转换他
                  所以我们不清楚结果中的11是经过转换的,还是说原来就是这样的
                  所以分两种情况:
                 */
                if (n == 3) {
                    // 原串为“11”
                    division(i + 1, curStrLen + 2, curOneNum + 2);
                }
                division(i + 1, curStrLen + n, curOneNum + n);
            }
        } else {
            // 如果第一个字符不是1，而是零，则直接指针向后移一位，当前字符串的长度+1
            division(curIndex + 1, curStrLen + 1, curOneNum);
        }
    }

    /**
     * 返回对应二进制数的十进制数
     * @param binStr
     * @return
     */
    public static int getD(String binStr) {
        int total = 0;
        for (int i = 0; i < binStr.length(); i++) {
            if (binStr.charAt(i) == '1') {
                total += (long) Math.pow(2, (binStr.length() - 1 - i));
            }
        }
        return total;
    }
}