网络流 + 欧拉回路 = B

B - Sightseeing tour POJ - 1637 

https://blog.csdn.net/qq_36551189/article/details/80905345

首先要了解一下欧拉回路的基本思路。

欧拉回路：如果是无向图，那么每一个点连的边的数量为偶数，如果是有向图，那么每一个点的入度要等于出度。

欧拉路径：这个欧拉路径是没有成环的，如果是无向图，那么除了两个点连的边是奇数，其他都是偶数，

如果是有向图，那么除了有一个点入度比出度大1，有一个点的出度比入度大1 ，其他都是入度等于出度。

这个题目的基本思路就涉及到了欧拉回路。

这个地方难处理的就是有无向和有向边的混合，这个无向很难处理，但是这个无向最后都要转化成有向。

根据欧拉回路的一些基本性质我们可以知道，有向图每一个点的入度要等于出度。

所以我们可以先给无向图随意定一个方向然后我们用 d=出度-入度 因为我们随意改变一条边的方向这个d的变化量为2 

所以就说明之后改变边的方向并不会改变改变这个d的奇偶性。

根据欧拉回路我们就可以知道我们需要的是这个d==0

这个时候就需要用到最大流，怎么用最大流解决这个问题呢，

就是把d大于0的部分和源点相连，因为d大于0如果是欧拉回路那么就肯定是由其他边d小于0，

其他边d<0说明出度小于入度，也就是说有点的入度会小于出度，就是说在任意给定边的时候有点把边连到了这个d<0的点上面，

说到这里其实这个图就建的差不多了。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <vector>
#include <algorithm>
#include <cstring>
#include <iostream>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 10;
const int INF = 0x3f3f3f3f;
struct edge {
    int u, v, c, f;
    edge(int u, int v, int c, int f) :u(u), v(v), c(c), f(f) {}
};
vector<edge>e;
vector<int>G[maxn];
int level[maxn];//BFS分层，表示每个点的层数
int iter[maxn];//当前弧优化
int m;
void init(int n) {
    for (int i = 0; i <= n; i++)G[i].clear();
    e.clear();
}
void addedge(int u, int v, int c) {
    e.push_back(edge(u, v, c, 0));
    e.push_back(edge(v, u, 0, 0));
    m = e.size();
    G[u].push_back(m - 2);
    G[v].push_back(m - 1);
}
void BFS(int s)//预处理出level数组
//直接BFS到每个点
{
    memset(level, -1, sizeof(level));
    queue<int>q;
    level[s] = 0;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int v = 0; v < G[u].size(); v++) {
            edge& now = e[G[u][v]];
            if (now.c > now.f && level[now.v] < 0) {
                level[now.v] = level[u] + 1;
                q.push(now.v);
            }
        }
    }
}
int dfs(int u, int t, int f)//DFS寻找增广路
{
    if (u == t)return f;//已经到达源点，返回流量f
    for (int &v = iter[u]; v < G[u].size(); v++)
        //这里用iter数组表示每个点目前的弧，这是为了防止在一次寻找增广路的时候，对一些边多次遍历
        //在每次找增广路的时候，数组要清空
    {
        edge &now = e[G[u][v]];
        if (now.c - now.f > 0 && level[u] < level[now.v])
            //now.c - now.f > 0表示这条路还未满
            //level[u] < level[now.v]表示这条路是最短路，一定到达下一层，这就是Dinic算法的思想
        {
            int d = dfs(now.v, t, min(f, now.c - now.f));
            if (d > 0) {
                now.f += d;//正向边流量加d
                e[G[u][v] ^ 1].f -= d;
                //反向边减d，此处在存储边的时候两条反向边可以通过^操作直接找到
                return d;
            }
        }
    }
    return 0;
}
int Maxflow(int s, int t) {
    int flow = 0;
    for (;;) {
        BFS(s);
        if (level[t] < 0)return flow;//残余网络中到达不了t，增广路不存在
        memset(iter, 0, sizeof(iter));//清空当前弧数组
        int f;//记录增广路的可增加的流量
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
    return flow;
}
int in[maxn], out[maxn];

int main()
{
    int k;
    scanf("%d", &k);
    while(k--)
    {
        int n, m;
        scanf("%d%d", &n, &m);
        init(n + m);
        memset(in, 0, sizeof(in));
        memset(out, 0, sizeof(out));
        int s = 0, t = n + 1;
        for(int i=1;i<=m;i++)
        {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            out[u]++; in[v]++;
            if (w == 0) addedge(u, v, 1);
        }
        bool flag = false;
        for(int i=1;i<=n;i++)
        {
            if ((out[i] - in[i]) & 1) flag = true;
            else if (out[i] > in[i]) addedge(s, i, (out[i] - in[i]) / 2);
            else if (in[i] > out[i]) addedge(i, t, (in[i] - out[i]) / 2);
        }
        if (flag) {
            printf("impossible
");
            continue;
        }
        int ans = Maxflow(s, t);
        for(int i=0;i<G[0].size();i++)
        {
            edge now = e[G[0][i]];
            if (now.c != now.f) flag = true;
        }
        if (flag) printf("impossible
");
        else printf("possible
");
    }
    return 0;
}