Problem A. Seven-segment Display - APAC Test Round A（暴力枚举）

链接

https://code.google.com/codejam/contest/3214486/dashboard

题意

一个7段数码管，有未知的几段坏掉了。

现在给出一个长度为N的序列，开始的一个数x，然后每一个数依次递减，但是显示出来的是破损后的结果。

求问：数码管下一个显示的状态能够唯一确定？

思路

比较暴力的一个思路，直接暴力枚举可能破损掉的位置（一共127种可能），然后判断是否合法即可。

在判断合法的时候，需要注意：

1. 枚举出的破损掉的位置一定不能出现：某一个状态下该位置是亮的
2. 显示出的状态拼凑上破损的位置后（注意假如我们A, B, E段破损，此时拼凑上破损位置可能拼凑A, B, E的任一子集）应为一个7段数码管能表示的阿拉伯数字
3. 最后拼凑出的完整序列应为循环的

最后，能得到的可能是多种破损的合法状态，每一个破损状态有唯一的下一个数，然后需要判断的即为：对于所有的破损状态，其对应的数在该破损状态下显示的结果应相同，此时结果是合法的。

代码

#include <bits/stdc++.h>

using namespace std;

inline int in() {int x; scanf("%d", &x); return x;}
#define pr(x) {cout << #x << ' ' << x << endl;}

const int maxn = 105;
int basic[10] = {0b1111110, 0b0110000, 0b1101101, 0b1111001, 0b0110011, 0b1011011, 0b1011111, 0b1110000, 0b1111111, 0b1111011};
int seq[maxn], n, final_ans;
vector<int> ans[maxn];

void main_init() {
    final_ans = -1;
}

void init(int n) {
    for (int i = 0; i < n; i++) {
        while (ans[i].size()) {
            ans[i].pop_back();
        }
    }
}

int string_to_int(char s[]) {
    int n = strlen(s);
    int t = 0;
    for (int i = 0; i < n; i++) {
        t <<= 1;
        t += s[i] - '0';
    }
    return t;
}

void read() {
    char s[maxn][8];
    n = in();
    for (int i = 0; i < n; i++) {
        scanf("%s", s[i]);
        seq[i] = string_to_int(s[i]);
    }
}

bool judge(int off, int j) {
    bool flag = false;
    if (seq[j] & off) return false;
    for (int i = 0; i < (1 << 7); i++) {
        if ((off | i) != off) continue;
        int y = seq[j] | i;
        for (int k = 0; k < 10; k++) {
            if (y == basic[k]) {
               ans[j].push_back(k);
               flag = true;
            }
        }
    }
    return flag;
}

int get_next(int x) {
    return x == 0 ? 9 : x - 1;
}

vector<int> next_num_v;

void dfs(int pre, int i) {
    if (i == n) {
        next_num_v.push_back(get_next(pre));
        return;
    }
    if (i == 0) {
        for (auto x : ans[i]) {
            dfs(x, i + 1);
        }
    } else {
        for (auto x : ans[i]) {
            if (x == get_next(pre)) {
                dfs(x, i + 1);
            }
        }
    }
}

int break_num(int x, int off) {
    return ~off & x;
}

void judge_seq() {
    while (next_num_v.size()) next_num_v.pop_back();
    dfs(-1, 0);
}

bool solve() {
    for (int i = 0; i < (1 << 7); i++) {
        bool flag = false;
        init(n);
        for (int j = 0; j < n; j++) {
            if (!judge(i, j)) {
                flag = true;
                break;
            }
        }
        if (!flag) {
            judge_seq();
            for (auto x : next_num_v) {
                if (final_ans == -1) {
                    final_ans = break_num(basic[x], i);
                } else {
                    int t = break_num(basic[x], i);
                    if (final_ans != t) return false;
                }
            }
        }
    }
    return true;
}

int main() {
    int T = in(), kase = 0;
    while (T--) {
        main_init();
        read();
        if (!solve())
            cout << "Case #" << ++kase << ": " << "ERROR!" << endl;
        else {
            cout << "Case #" << ++kase << ": " << bitset<7>(final_ans) << endl;
        }
    }
    return 0;
}