Trình chấm tùy chỉnh (Custom Checker)

#include "testlib.h"
using namespace std;

int main(int argc, char* argv[]) {
    registerTestlibCmd(argc, argv);

    // Đọc dữ liệu từ 3 stream:
    // inf  — file input gốc (.in)
    // ouf  — output của thí sinh
    // ans  — output chuẩn (.out)

    // Kiểm tra và trả verdict
    quitf(_ok, "correct");   // AC
    quitf(_wa, "wrong");     // WA
}

int n = inf.readInt();                    // đọc một int
long long x = inf.readLong();             // đọc một long long
double d = ouf.readDouble();              // đọc một double
string s = ouf.readToken();               // đọc một token (không khoảng trắng)
string line = ouf.readLine();             // đọc cả dòng
int v = ouf.readInt(1, n, "vertex");      // đọc int trong [1, n], tên biến cho thông báo lỗi

quitf(_ok, "message");     // Accepted
quitf(_wa, "message");     // Wrong Answer
quitf(_pe, "message");     // Presentation Error (hiếm dùng)
quitf(_fail, "message");   // Judge Error — dùng khi phát hiện lỗi trong test/checker

#include "testlib.h"
#include <string>
#include <map>
#include <algorithm>
using namespace std;

int main(int argc, char* argv[]) {
    registerTestlibCmd(argc, argv);

    int n = inf.readInt();
    string s = inf.readToken();

    string out = ouf.readToken();

    // Kiểm tra có khả thi không
    map<char,int> cnt;
    for (char c : s) cnt[c]++;
    int maxf = 0;
    for (auto& [k, v] : cnt) maxf = max(maxf, v);
    bool possible = maxf <= (n + 1) / 2;

    // Xử lý IMPOSSIBLE
    string up = out;
    for (auto& ch : up) ch = toupper(ch);

    if (up == "IMPOSSIBLE") {
        if (possible)
            quitf(_wa, "printed IMPOSSIBLE but a valid arrangement exists");
        quitf(_ok, "correctly reported infeasible");
    }

    if (!possible)
        quitf(_wa, "no valid arrangement exists but contestant printed %s",
              out.c_str());

    // Kiểm tra output hợp lệ
    if ((int)out.length() != n)
        quitf(_wa, "output length %d != expected %d",
              (int)out.length(), n);

    map<char,int> ac;
    for (char c : out) ac[c]++;
    if (ac != cnt)
        quitf(_wa, "output is not a permutation of input");

    for (int i = 1; i < n; i++)
        if (out[i] == out[i-1])
            quitf(_wa, "adjacent duplicate at position %d", i);

    quitf(_ok, "valid rearrangement");
}

#include "testlib.h"
#include <cmath>
using namespace std;

int main(int argc, char* argv[]) {
    registerTestlibCmd(argc, argv);

    double expected = ans.readDouble();
    double got = ouf.readDouble();

    // So sánh với sai số tuyệt đối và tương đối
    if (abs(expected - got) <= 1e-6 ||
        abs(expected - got) <= 1e-6 * abs(expected)) {
        quitf(_ok, "answer %.10f, expected %.10f", got, expected);
    }

    quitf(_wa, "answer %.10f, expected %.10f, diff %.10f",
          got, expected, abs(expected - got));
}

#include "testlib.h"
#include <vector>
using namespace std;

int main(int argc, char* argv[]) {
    registerTestlibCmd(argc, argv);

    int n = inf.readInt();
    int m = inf.readInt();

    // Đọc đồ thị từ input
    vector<vector<pair<int,int>>> adj(n + 1);
    for (int i = 0; i < m; i++) {
        int u = inf.readInt(), v = inf.readInt(), w = inf.readInt();
        adj[u].push_back({v, w});
        adj[v].push_back({u, w});
    }

    long long expected_dist = ans.readLong();
    long long got_dist = ouf.readLong();

    // Kiểm tra giá trị tối ưu
    if (got_dist != expected_dist)
        quitf(_wa, "distance %lld != expected %lld", got_dist, expected_dist);

    // Kiểm tra đường đi hợp lệ
    int k = ouf.readInt();
    vector<int> path(k);
    for (int i = 0; i < k; i++)
        path[i] = ouf.readInt(1, n, "node");

    if (path[0] != 1 || path[k-1] != n)
        quitf(_wa, "path must start at 1 and end at %d", n);

    long long total = 0;
    for (int i = 1; i < k; i++) {
        bool found = false;
        for (auto [v, w] : adj[path[i-1]]) {
            if (v == path[i]) {
                total += w;
                found = true;
                break;
            }
        }
        if (!found)
            quitf(_wa, "no edge between %d and %d", path[i-1], path[i]);
    }

    if (total != got_dist)
        quitf(_wa, "path cost %lld != claimed distance %lld", total, got_dist);

    quitf(_ok, "valid shortest path of length %lld", got_dist);
}

if ((int)s.length() != n)
    quitf(_fail, "judge input malformed: string length %d != n=%d",
          (int)s.length(), n);

// Sau khi đọc xong output cần thiết
if (ouf.seekEof()) {
    quitf(_ok, "correct");
} else {
    quitf(_wa, "extra output after answer");
}