QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#861412#9980. Boolean Function Reconstructionucup-team5234#WA 741ms10112kbC++232.6kb2025-01-18 17:22:192025-01-18 17:22:25

Judging History

你现在查看的是最新测评结果

  • [2025-01-18 17:22:25]
  • 评测
  • 测评结果:WA
  • 用时:741ms
  • 内存:10112kb
  • [2025-01-18 17:22:19]
  • 提交

answer

#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(),(v).end()
#define pb(a) push_back(a)
#define rep(i, n) for(int i=0;i<n;i++)
#define foa(e, v) for(auto&& e : v)
using ll = long long;
const ll MOD7 = 1000000007, MOD998 = 998244353, INF = (1LL << 60);
#define dout(a) cout<<fixed<<setprecision(10)<<a<<endl;

void solve() {
    int n;
    cin >> n;
    string s; cin >> s;
    bool ng = 0;
    rep(bit, 1 << n) {
        rep(i, n) {
            if(bit >> i & 1) continue;
            if(s[bit] == '1' and s[bit | (1 << i)] == '0') ng = 1;
        }
    }
    if(ng) {
        cout << "No" << endl;
        return ;
    }
    cout << "Yes" << endl;
    if(count(all(s), '0') == 0) {
        cout << "T" << endl;
        return;
    }
    if(count(all(s), '1') == 0) {
        cout << "F" << endl;
        return;
    }
    vector dp(1 << n, vector(n, 0)), dp1(1 << n, vector(n, 0));
    auto dfs = [&](auto dfs, int bits, int i) -> void {
        if(i == n - 1) {
            if(s[bits | (1 << i)] == s[bits]) dp[bits][i] = dp1[bits][i] = 0;
            else dp[bits][i] = dp1[bits][i] = 1;
            return; 
        }
        dfs(dfs, bits | (1 << i), i + 1);
        dfs(dfs, bits, i + 1);
        
        
        if(dp[bits | (1 << i)][i + 1] == 0 and dp[bits][i + 1] == 0) {
            if(s[bits] == s[bits | (1 << i)]) {
                dp[bits][i] = 0;
                return;
            }
        }
        int m = n - i - 1;
        bool f = 0;
        rep(bit, (1 << m)) {
            if(s[bits | (bit << (i + 1))] != s[bits | (bit << (i + 1)) | (1 << i)]) f = 1;
        }
        if(f) dp1[bits][i] = 1;
        
        dp[bits][i] = 1;
        return;
    };
    dfs(dfs, 0, 0);
    auto dfs1 = [&](auto dfs1, int bits, int i) -> void {
        if(i == n - 1) {
            cout << char('a' + i);
            return;
        }

        if(!dp1[bits][i]) {
            dfs1(dfs1, bits, i + 1);
            return;
        }


        if(dp[bits][i + 1]) cout << '(';
        if(dp[bits | (1 << i)][i + 1]) {
            cout << '(';
            cout << char('a' + i);
            cout << '&';
            dfs1(dfs1, bits | (1 << i), i + 1);
            cout << ')';
        } else {
            cout << char('a' + i);
        }
        
        if(dp[bits][i + 1]) {
            cout << '|';
            dfs1(dfs1, bits, i + 1);
            cout << ')';
        } 
    };
    dfs1(dfs1, 0, 0);
    cout << endl;
}
int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    int t;
    cin >> t;
    rep(i, t) solve();
    return 0;
}

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100
Accepted
time: 0ms
memory: 3712kb

input:

7
2
0001
2
0111
2
1111
3
00010111
1
10
2
0101
5
00000000000000000000000000000001

output:

Yes
(a&b)
Yes
(a|b)
Yes
T
Yes
((a&(b|c))|(b&c))
No
Yes
a
Yes
(a&(b&(c&(d&e))))

result:

ok 7 lines, tightest: 4 out of 14 (7 test cases)

Test #2:

score: 0
Accepted
time: 0ms
memory: 3584kb

input:

4
1
00
1
10
1
01
1
11

output:

Yes
F
No
Yes
a
Yes
T

result:

ok 4 lines, tightest: 0 out of 11 (4 test cases)

Test #3:

score: 0
Accepted
time: 1ms
memory: 3712kb

input:

16
2
0000
2
1000
2
0100
2
1100
2
0010
2
1010
2
0110
2
1110
2
0001
2
1001
2
0101
2
1101
2
0011
2
1011
2
0111
2
1111

output:

Yes
F
No
No
No
No
No
No
No
Yes
(a&b)
No
Yes
a
No
Yes
b
No
Yes
(a|b)
Yes
T

result:

ok 16 lines, tightest: 1 out of 12 (16 test cases)

Test #4:

score: 0
Accepted
time: 0ms
memory: 3712kb

input:

256
3
00000000
3
10000000
3
01000000
3
11000000
3
00100000
3
10100000
3
01100000
3
11100000
3
00010000
3
10010000
3
01010000
3
11010000
3
00110000
3
10110000
3
01110000
3
11110000
3
00001000
3
10001000
3
01001000
3
11001000
3
00101000
3
10101000
3
01101000
3
11101000
3
00011000
3
10011000
3
01011000...

output:

Yes
F
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
...

result:

ok 256 lines, tightest: 4 out of 14 (256 test cases)

Test #5:

score: 0
Accepted
time: 23ms
memory: 3584kb

input:

65536
4
0000000000000000
4
1000000000000000
4
0100000000000000
4
1100000000000000
4
0010000000000000
4
1010000000000000
4
0110000000000000
4
1110000000000000
4
0001000000000000
4
1001000000000000
4
0101000000000000
4
1101000000000000
4
0011000000000000
4
1011000000000000
4
0111000000000000
4
1111000...

output:

Yes
F
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
No
...

result:

ok 65536 lines, tightest: 9 out of 18 (65536 test cases)

Test #6:

score: 0
Accepted
time: 0ms
memory: 3712kb

input:

168
4
0000000000000000
4
0000000000000001
4
0000000000000011
4
0000000000000101
4
0000000000000111
4
0000000000001111
4
0000000000010001
4
0000000000010011
4
0000000000010101
4
0000000000010111
4
0000000000011111
4
0000000000110011
4
0000000000110111
4
0000000000111111
4
0000000001010101
4
000000000...

output:

Yes
F
Yes
(a&(b&(c&d)))
Yes
(b&(c&d))
Yes
(a&(c&d))
Yes
((a&(c&d))|(b&(c&d)))
Yes
(c&d)
Yes
(a&(b&d))
Yes
((a&(b&d))|(b&(c&d)))
Yes
(a&((b&d)|(c&d)))
Yes
((a&((b&d)|(c&d)))|(b&(c&d)))
Yes
((a&((b&d)|(c&d)))|(c&d))
Yes
(b&d)
Yes
((a&((b&d)|(c&d)))|(b&d))
Yes
((b&d)|(c&d))
Yes
(a&d)
Yes
((a&d)|(b&(c&d...

result:

ok 168 lines, tightest: 9 out of 18 (168 test cases)

Test #7:

score: 0
Accepted
time: 18ms
memory: 3712kb

input:

7581
5
00000000000000000000000000000000
5
00000000000000000000000000000001
5
00000000000000000000000000000011
5
00000000000000000000000000000101
5
00000000000000000000000000000111
5
00000000000000000000000000001111
5
00000000000000000000000000010001
5
00000000000000000000000000010011
5
0000000000000...

output:

Yes
F
Yes
(a&(b&(c&(d&e))))
Yes
(b&(c&(d&e)))
Yes
(a&(c&(d&e)))
Yes
((a&(c&(d&e)))|(b&(c&(d&e))))
Yes
(c&(d&e))
Yes
(a&(b&(d&e)))
Yes
((a&(b&(d&e)))|(b&(c&(d&e))))
Yes
(a&((b&(d&e))|(c&(d&e))))
Yes
((a&((b&(d&e))|(c&(d&e))))|(b&(c&(d&e))))
Yes
((a&((b&(d&e))|(c&(d&e))))|(c&(d&e)))
Yes
(b&(d&e))
Yes
...

result:

ok 7581 lines, tightest: 20 out of 26 (7581 test cases)

Test #8:

score: 0
Accepted
time: 6ms
memory: 6208kb

input:

14
1
01
2
0111
3
00010111
4
0001011101111111
5
00000001000101110001011101111111
6
0000000100010111000101110111111100010111011111110111111111111111
7
00000000000000010000000100010111000000010001011100010111011111110000000100010111000101110111111100010111011111110111111111111111
8
00000000000000010000...

output:

Yes
a
Yes
(a|b)
Yes
((a&(b|c))|(b&c))
Yes
((a&(b|(c|d)))|((b&(c|d))|(c&d)))
Yes
((a&((b&(c|(d|e)))|((c&(d|e))|(d&e))))|((b&((c&(d|e))|(d&e)))|(c&(d&e))))
Yes
((a&((b&(c|(d|(e|f))))|((c&(d|(e|f)))|((d&(e|f))|(e&f)))))|((b&((c&(d|(e|f)))|((d&(e|f))|(e&f))))|((c&((d&(e|f))|(e&f)))|(d&(e&f)))))
Yes
((a&...

result:

ok 14 lines, tightest: 68 out of 74 (14 test cases)

Test #9:

score: 0
Accepted
time: 4ms
memory: 6152kb

input:

14
1
01
2
0001
3
00010111
4
0000000100010111
5
00000001000101110001011101111111
6
0000000000000001000000010001011100000001000101110001011101111111
7
00000000000000010000000100010111000000010001011100010111011111110000000100010111000101110111111100010111011111110111111111111111
8
00000000000000000000...

output:

Yes
a
Yes
(a&b)
Yes
((a&(b|c))|(b&c))
Yes
((a&((b&(c|d))|(c&d)))|(b&(c&d)))
Yes
((a&((b&(c|(d|e)))|((c&(d|e))|(d&e))))|((b&((c&(d|e))|(d&e)))|(c&(d&e))))
Yes
((a&((b&((c&(d|(e|f)))|((d&(e|f))|(e&f))))|((c&((d&(e|f))|(e&f)))|(d&(e&f)))))|((b&((c&((d&(e|f))|(e&f)))|(d&(e&f))))|(c&(d&(e&f)))))
Yes
((a&...

result:

ok 14 lines, tightest: 68 out of 74 (14 test cases)

Test #10:

score: 0
Accepted
time: 6ms
memory: 6180kb

input:

14
1
00
2
0001
3
00000001
4
0000000100010111
5
00000000000000010000000100010111
6
0000000000000001000000010001011100000001000101110001011101111111
7
00000000000000000000000000000001000000000000000100000001000101110000000000000001000000010001011100000001000101110001011101111111
8
00000000000000000000...

output:

Yes
F
Yes
(a&b)
Yes
(a&(b&c))
Yes
((a&((b&(c|d))|(c&d)))|(b&(c&d)))
Yes
((a&((b&((c&(d|e))|(d&e)))|(c&(d&e))))|(b&(c&(d&e))))
Yes
((a&((b&((c&(d|(e|f)))|((d&(e|f))|(e&f))))|((c&((d&(e|f))|(e&f)))|(d&(e&f)))))|((b&((c&((d&(e|f))|(e&f)))|(d&(e&f))))|(c&(d&(e&f)))))
Yes
((a&((b&((c&((d&(e|(f|g)))|((e&(...

result:

ok 14 lines, tightest: 33 out of 42 (14 test cases)

Test #11:

score: 0
Accepted
time: 5ms
memory: 6204kb

input:

14
1
00
2
0000
3
00000001
4
0000000000000001
5
00000000000000010000000100010111
6
0000000000000000000000000000000100000000000000010000000100010111
7
00000000000000000000000000000001000000000000000100000001000101110000000000000001000000010001011100000001000101110001011101111111
8
00000000000000000000...

output:

Yes
F
Yes
F
Yes
(a&(b&c))
Yes
(a&(b&(c&d)))
Yes
((a&((b&((c&(d|e))|(d&e)))|(c&(d&e))))|(b&(c&(d&e))))
Yes
((a&((b&((c&((d&(e|f))|(e&f)))|(d&(e&f))))|(c&(d&(e&f)))))|(b&(c&(d&(e&f)))))
Yes
((a&((b&((c&((d&(e|(f|g)))|((e&(f|g))|(f&g))))|((d&((e&(f|g))|(f&g)))|(e&(f&g)))))|((c&((d&((e&(f|g))|(f&g)))|(e...

result:

ok 14 lines, tightest: 0 out of 11 (14 test cases)

Test #12:

score: 0
Accepted
time: 5ms
memory: 10112kb

input:

1
15
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000...

output:

Yes
((a&((b&((c&((d&((e&((f&((g&(h|(i|(j|(k|(l|(m|(n|o))))))))|((h&(i|(j|(k|(l|(m|(n|o)))))))|((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o)))))))))|((g&((h&(i|(j|(k|(l|(m|(n|o)))))))|((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n...

result:

ok 1 lines, tightest: 12868 out of 16394 (1 test case)

Test #13:

score: 0
Accepted
time: 5ms
memory: 10112kb

input:

1
15
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000100000000000000010000000100010111000000000000000000000000000000000000000...

output:

Yes
((a&((b&((c&((d&((e&((f&(g|(h|(i|(j|(k|(l|(m|(n|o)))))))))|((g&(h|(i|(j|(k|(l|(m|(n|o))))))))|((h&(i|(j|(k|(l|(m|(n|o)))))))|((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o))))))))))|((f&((g&(h|(i|(j|(k|(l|(m|(n|o))))))))|((h&(i|(j|(k|(l|(m|(n|...

result:

ok 1 lines, tightest: 11438 out of 16394 (1 test case)

Test #14:

score: 0
Accepted
time: 5ms
memory: 9984kb

input:

1
15
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

output:

Yes
((a&((b&((c&((d&((e&((f&((g&((h&(i|(j|(k|(l|(m|(n|o)))))))|((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o))))))))|((h&((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o)))))))|((i&((j&(k|(l|(m|(...

result:

ok 1 lines, tightest: 11438 out of 16394 (1 test case)

Test #15:

score: 0
Accepted
time: 4ms
memory: 9984kb

input:

1
15
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000...

output:

Yes
((a&((b&((c&((d&((e&((f&((g&((h&((i&(j|(k|(l|(m|(n|o))))))|((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o)))))))|((i&((j&(k|(l|(m|(n|o)))))|((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o))))))|((j&((k&(l|(m|(n|o))))|((l&(m|(n|o)))|((m&(n|o))|(n&o)))))|((k&((l&(m|(n|o...

result:

ok 1 lines, tightest: 8006 out of 16394 (1 test case)

Test #16:

score: 0
Accepted
time: 386ms
memory: 3584kb

input:

65536
6
0000001101111111000111111111111101111111111111111111111111111111
6
0000000000000000000100110011011100000000000000000001001100111111
6
0101010101110111011101111111111101110111111111111111111111111111
6
0000001100000011000000110001011100011111001111110011111100111111
6
000000010001011100000001...

output:

Yes
((a&((b&(c|(d|(e|f))))|((c&(d|(e|f)))|(d|f))))|((b&(c|(d|f)))|((c&(d|(e|f)))|((d&(e|f))|(e&f)))))
Yes
((a&((b&e)|(c&(d&e))))|((b&((c&e)|(d&e)))|(c&(d&(e&f)))))
Yes
(a|((b&(d|(e|f)))|((d&(e|f))|(e&f))))
Yes
((a&((b&(c|((d&(e|f))|f)))|(c&((d&(e|f))|f))))|((b&(c|((d&f)|(e&f))))|(c&f)))
Yes
((a&((b&...

result:

ok 65536 lines, tightest: 40 out of 42 (65536 test cases)

Test #17:

score: -100
Wrong Answer
time: 741ms
memory: 3712kb

input:

65536
7
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
7
00000001000100010001000101110111000100010111011101110111011111110001000101110111011101110111111100010001011101110111011111111111
7
000000010001001100000001001101...

output:

Yes
(a&(b&(c&(d&(e&(f&g))))))
Yes
((a&((b&(c|(d|(e|(f|g)))))|((d&(e|(f|g)))|(e&(f|g)))))|((b&((d&(e|(f|g)))|(e&(f|g))))|((c&(d&(e&(f|g))))|(d&(e&(f&g))))))
Yes
((a&((b&(c|(d|f)))|((c&((d&(e|f))|(e&f)))|(d&f))))|((b&((c&(d|((e&(f|g))|f)))|((d&(e|f))|(e&f))))|((c&(d&f))|(d&(e&(f&g))))))
Yes
((a&((b&((...

result:

wrong answer 78 operations, you can't use more than 74 operations (test case 822)