题目链接

混合图+欧拉回路+最大流

1，双向边也只能走一次。 2，不需要判断是否连通

Kuangbin博客

#include <iostream>
#include <cstdio>
#include <cstring>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;

const int Maxn = 200+10;
const int INF = 0x3f3f3f3f;
const long long LINF = 1e18;

struct Edge {
    int v, cap, flow, next;
} edge[Maxn*Maxn*2];

int h[Maxn], edge_cnt;
int indx[Maxn], deep[Maxn], qu[Maxn];
int out[Maxn], in[Maxn], D[Maxn];

void add(int u, int v, int c) {
    edge[edge_cnt].v = v;
    edge[edge_cnt].cap = c;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[u];
    h[u] = edge_cnt++;

    edge[edge_cnt].v = u;
    edge[edge_cnt].cap = 0;
    edge[edge_cnt].flow = 0;
    edge[edge_cnt].next = h[v];
    h[v] = edge_cnt++;
}

bool bfs(int s, int t) {
    int head = 0, tail = 0;
    memset(deep, 0, sizeof(deep));
    deep[s] = 1; qu[tail++] = s;
    while(head < tail) {
        int u = qu[head++];
        for(int i = h[u]; i != -2; i = edge[i].next) {
            Edge &e = edge[i];
            if(deep[e.v] == 0 && e.cap-e.flow > 0) {
                deep[e.v] = deep[u]+1;
                qu[tail++] = e.v;
            }
        }
    }
    if(deep[t] > 0) return true;
    else return false;
}

int dfs(int cur, int t, int a) {
    if(cur == t || a == 0) return a;
    int flow = 0, f;
    if(indx[cur] == -1) indx[cur] = h[cur];
    for(int &i = indx[cur]; i != -2; i = edge[i].next) {
        Edge &e = edge[i];
        if(deep[e.v] == deep[cur]+1) {
            f = dfs(e.v, t, min(a, e.cap-e.flow));
            if(f > 0) {
                e.flow += f;
                edge[i^1].flow -= f;
                flow += f;
                a -= f;
                if(a == 0) break;
            }
        }
    }
    return flow;
}

void dinic(int s, int t) {
    int ans = 0;
    while(bfs(s, t)) {
        memset(indx, -1, sizeof(indx));
        ans += dfs(s, t, INF);
    }
    return;
}

int main(void)
{
	int T;
	scanf("%d", &T);
	while(T--) {
        int N, M, u, v, c;
        scanf("%d%d", &N, &M);
        memset(out, 0, sizeof(out));
        memset(in, 0, sizeof(in));
        for(int i = 0; i < Maxn; ++i) h[i] = -2;
        edge_cnt = 0;
        for(int i = 0; i < M; ++i) {
            scanf("%d%d%d", &u, &v, &c);
            in[v]++; out[u]++;
            if(c == 1) add(u, v, 0);
            else add(u, v, 1);
        }
        bool ok = true;
        for(int i = 1; i <= N; ++i) {
            D[i] = in[i]-out[i];
            if(abs(D[i])%2 == 1) {
                ok = false; break;
            }
            if(D[i] < 0) {
                add(0, i, -D[i]/2);
            }
            if(D[i] > 0) {
                add(i, N+1, D[i]/2);
            }
        }
        if(ok) {
            dinic(0, N+1);
            for(int i = h[0]; i != -2; i = edge[i].next) {
                if(edge[i].flow != edge[i].cap) {
                    ok = false; break;
                }
            }
        }
        if(ok) printf("possible\n");
        else printf("impossible\n");
	}
	return 0;
}