QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#591907#8058. Binary vs TernaryhcywoiWA 1ms3652kbC++231.5kb2024-09-26 19:01:012024-09-26 19:01:02

Judging History

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

  • [2024-09-26 19:01:02]
  • 评测
  • 测评结果:WA
  • 用时:1ms
  • 内存:3652kb
  • [2024-09-26 19:01:01]
  • 提交

answer

#include <bits/stdc++.h>

using i64 = long long;

void solve() {
    std::string A, B;
    std::cin >> A >> B;

    if (A == B) {
        std::cout << 0 << "\n";
        return;
    }
    if (A.size() == 1 || B.size() == 1) {
        std::cout << -1 << "\n";
        return;
    }

    int a = A.size(), b = B.size();
    std::vector<std::pair<int, int>> ans;
    for (int i = a - 1; i >= 0; i -- ) {
        if (A[i] == '0') {
            int j = i;
            while (j >= 0 && A[j] == '0') {
                j -- ;
            }
            a -= i - j - 1;
            ans.emplace_back(j + 1, i);
            ans.emplace_back(j, j + 1);
            i = j + 1;
        }
    }

    while (a > b) {
        ans.emplace_back(a - 2, a - 1);
        ans.emplace_back(a - 3, a - 2);
        ans.emplace_back(a - 2, a + 1);
        a -- ;
    }
    while (a < b) {
        ans.emplace_back(a - 2, a - 1);
        ans.emplace_back(a - 2, a - 1);
        ans.emplace_back(a - 1, a);
        a ++ ;
    }

    for (int i = b - 1; i; i -- ) {
        if (B[i] == '0') {
            ans.emplace_back(i - 1, i);
            ans.emplace_back(i, i + 1);
        }
    }

    std::cout << ans.size() << "\n";
    for (auto [x, y] : ans) {
        std::cout << x + 1 << " " << y + 1 << "\n";
    }    
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;

    while (t -- ) {
        solve();
    }

    return 0;
}

詳細信息

Test #1:

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

input:

3
1
111
110110
1101010
1111
111111

output:

-1
13
6 6
5 6
3 3
2 3
5 6
5 6
6 7
6 7
7 8
4 5
5 6
2 3
3 4
6
3 4
3 4
4 5
4 5
4 5
5 6

result:

ok Haitang Suki (3 test cases)

Test #2:

score: -100
Wrong Answer
time: 1ms
memory: 3652kb

input:

1000
11100
111
1
11110
10001
10
1011
1111
10
1110
1100
11
11010
11
110
11
1
10001
10110
10
10
11111
10000
1001
10
1
11
10111
11
10
1
100
11
10100
1
10
101
11
1100
110
11
1110
1
1001
1
11111
10
10010
10
11001
110
1010
10011
1110
10100
1001
1001
101
100
1
1001
11
101
11
101
1001
1
1
1011
1
10
10
1011
...

output:

5
4 5
3 4
3 4
2 3
3 6
-1
7
2 4
1 2
2 3
1 2
2 5
1 2
2 3
2
2 2
1 2
10
2 2
1 2
1 2
1 2
2 3
2 3
2 3
3 4
3 4
4 5
5
3 4
2 3
2 3
1 2
2 5
13
5 5
4 5
3 3
2 3
4 5
3 4
4 7
3 4
2 3
3 6
2 3
1 2
2 5
5
3 3
2 3
2 3
1 2
2 5
-1
15
5 5
4 5
2 2
1 2
4 5
3 4
4 7
3 4
2 3
3 6
2 3
1 2
2 5
1 2
2 3
11
2 2
1 2
1 2
1 2
2 3
2 3
...

result:

wrong answer S!=T after all operations (test case 1)