基礎知識
歐拉回路是圖G中的一個迴路，經過每條邊有且僅一次，稱該回路為歐拉回路。具有歐拉回路的圖稱為尤拉圖，簡稱E圖。
無向圖中存在歐拉回路的條件：每個點的度數均為偶數。
有向圖中存在歐拉回路的條件：每個點的入度=出度。
尤拉路徑比歐拉回路要求少一點：
無向圖中存在尤拉路徑的條件：每個點的度數均為偶數或者有且僅有2個度數為奇數的點。
有向圖中存在尤拉路徑的條件：除了2個點外，其餘的點入度=出度，且在這2個點中，一個點的入度比出度大1，另一個出度比入度大1。
尤拉路徑的輸出：經典的套圈演算法。

下面來重點講講混合圖的歐拉回路問題。
混合圖就是邊集中有有向邊和無向邊同時存在。這時候需要用網路流建模求解。
建模：

把該圖的無向邊隨便定向，計算每個點的入度和出度。如果有某個點出入度之差為奇數，那麼肯定不存在歐拉回路。 因為歐拉回路要求每點入度 = 出度，也就是總度數為偶數，存在奇數度點必不能有歐拉回路。
好了，現在每個點入度和出度之差均為偶數。那麼將這個偶數除以2，得x。也就是說，對於每一個點，只要將x條邊改變方向（入>出就是變入，出>入就是變出），就能保證出 = 入。如果每個點都是出 = 入，那麼很明顯，該圖就存在歐拉回路。
現在的問題就變成了：我該改變哪些邊，可以讓每個點出 = 入？構造網路流模型。
首先，有向邊是不能改變方向的，要之無用，刪。一開始不是把無向邊定向了嗎？定的是什麼向，就把網路構建成什麼樣，邊長容量上限1。另新建s和t。對於入 > 出的點u，連線邊(u, t)、容量為x，對於出 > 入的點v，連線邊(s, v)，容量為x（注意對不同的點x不同）。
之後，察看從S發出的所有邊是否滿流。有就是能有歐拉回路，沒有就是沒有。歐拉回路是哪個？察看流值分配，將所有流量非 0（上限是1，流值不是0就是1）的邊反向，就能得到每點入度 = 出度的尤拉圖。
由於是滿流，所以每個入 > 出的點，都有x條邊進來，將這些進來的邊反向，OK，入 = 出了。對於出 > 入的點亦然。那麼，沒和s、t連線的點怎麼辦？和s連線的條件是出 > 入，和t連線的條件是入 > 出，那麼這個既沒和s也沒和t連線的點，自然早在開始就已經滿足入 = 出了。那麼在網路流過程中，這些點屬於“中間點”。我們知道中間點流量不允許有累積的，這樣，進去多少就出來多少，反向之後，自然仍保持平衡。
所以，就這樣，混合圖歐拉回路問題，解了。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
const int inf=0x3ffffff;
const int MAXN = 333;
const int MAXM = 100008;
const double eps = 1e-6;
struct Edge{
    int data, next, cap, flow, oppo;
    Edge(){
    }
    Edge(int
 
 data, int next, int cap, int flow, int oppo):data(data)
        , next(next), cap(cap), flow(flow), oppo(oppo){
    }
}edge[MAXM];
int link[MAXM][3];
int list[MAXN];
int degree[MAXN];
int queue[MAXN], path[MAXN], add[MAXN];
int n, m, e, v;

void Add_Link(int a, int b, int c) {
    edge[e] = Edge(b, list[a], c, 0, e+1);
    edge[e+1] = Edge(a, list[b], 0, 0, e);
    list[a] = e;
    list[b] = e+1;
    e += 2;
}

void Init() {
    int i;
    v = n + 2;
    for (i = 0; i < v; i++) {
        list[i] = -1;
        degree[i] = 0;
    }
    e = 0;
    for (i = 0; i < m; i++) {
        degree[link[i][0]]--;
        degree[link[i][1]]++;
        if (!link[i][2]) {
            Add_Link(link[i][0], link[i][1], 1);
        }
    }
}

int Max_Flow() {
    int ans = 0, head, tail, curr, succ, i, j, k;
    bool flag = true;
    while(flag) {
        flag = false;
        for (i = 0; i < v; i++) {
            path[i] = -1;
        }
        path[n] = -2;
        queue[0] = n;
        add[n] = inf;
        for (head = tail = 0; !flag && head <= tail; head++) {
            curr = queue[head];
            for (i = list[curr]; i != -1; i = edge[i].next) {
                if (path[succ = edge[i].data] == -1 && edge[i].flow < edge[i].cap) {
                    queue[++tail] = succ;
                    path[succ] = i;
                    add[succ] = min(add[curr], edge[i].cap-edge[i].flow);
                    if (succ == n+1) {
                        ans += add[succ];
                        flag = true;
                        for (j = succ; path[j] >= 0; j = edge[k].data) {
                            k = edge[path[j]].oppo;
                            edge[path[j]].flow += add[succ];
                            edge[k].flow -= add[succ];
                        }
                        break;
                    }
                }
            }
        }
    }
    return ans;
}

bool Work() {
    Init();
    int i, ans = 0;
    for (i = 0; i < n; i++) {
        if (degree[i] & 1) {
            return false;
        }
    }
    for (i = 0; i < n; i++) {
        if (degree[i] < 0) {
            Add_Link(n, i, -degree[i]/2);
            ans += -degree[i]/2;
        }
        if (degree[i] > 0) {
            Add_Link(i, n+1, degree[i]/2);
        }
    }
    if (Max_Flow() < ans) {
        return false;
    }
    return true;
}

int main() {
//#ifndef ONLINE_JUDGE
//  freopen("1.txt", "r", stdin);
//#endif
    int i, j, k; 
    int T;
    cin >> T;
    while(T--)  {
        cin >> n >> m;
        for (i = 0; i < m; i++) {
            scanf("%d%d%d", &link[i][0], &link[i][1], &link[i][2]);
            link[i][0]--;
            link[i][1]--;
        }
        if (Work()) {
            cout << "possible" << endl;
        } else {
            cout << "impossible" << endl;
        }
    }
    return 0;
}