题意：给n (n≤5000) 个不同的数字，在这n个数字的集合中找到一个最大的子集使得这个子集中的元素满足如下的性质：子集中任何两个数字都至少有两个bit位不同（Hamming distance大于等于2）。输出一个最大的子集

题解：如果我们把这n个数字看成n个点，然后每两个数字之间距离大于等于2的连一条边。于是这个题就成了一个最大团问题。（和题目描述一样）又因为一个图的最大团等于他的补图的最大集， 于是我们可以考虑本题的补图：每两个bit位仅有一个不一样的连边。注意到一个点的所有邻居都不可能相连因为他的邻居之间的距离至少为2。这样就说明了这个图是一个二分图。虽然匈牙利算法可以正确算出独立集的大小，但是不能搞出每个元素。所以还是得网络流（注意dinic在单位图上跑的比香港记者还快

可以用残余网络的某个点到s的距离数组来判断每个点是属于S的还是属于T的，但是这种做法为什么是对的还是不太理解。。。。直接加到板子里面去吧

#include <iostream>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
const int maxn = 5005;
const int INF=0x3f3f3f3f;

struct E {
    int to, cp;
    E(int to, int cp): to(to), cp(cp) {}
};

struct Dinic {
    static const int M = 5005;
    int m, s, t;
    vector<E> edges;
    vector<int> G[M];
    int d[M];
    int cur[M];
    
    void init(int n, int s, int t) {
        this->s = s; this->t = t;
        for (int i = 0; i <= n; i++) G[i].clear();
        edges.clear(); m = 0;
    }
    
    void addedge(int u, int v, int cap) {
        edges.emplace_back(v, cap);
        edges.emplace_back(u, 0);
        G[u].push_back(m++);
        G[v].push_back(m++);
    }
    
    bool BFS() {
        memset(d, 0, sizeof d);
        queue<int> Q;
        Q.push(s); d[s] = 1;
        while (!Q.empty()) {
            int x = Q.front(); Q.pop();
            for (int& i: G[x]) {
                E &e = edges[i];
                if (!d[e.to] && e.cp > 0) {
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return d[t];
    }
    
    int DFS(int u, int cp) {
        if (u == t || !cp) return cp;
        int tmp = cp, f;
        for (int& i = cur[u]; i < G[u].size(); i++) {
            E& e = edges[G[u][i]];
            if (d[u] + 1 == d[e.to]) {
                f = DFS(e.to, min(cp, e.cp));
                e.cp -= f;
                edges[G[u][i] ^ 1].cp += f;
                cp -= f;
                if (!cp) break;
            }
        }
        return tmp - cp;
    }
    
    int go() {
        int flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof cur);
            flow += DFS(s, INF);
        }
        return flow;
    }
} DC;


int main()
{
    ios::sync_with_stdio(false);
    int n;
    cin >> n;
    DC.init(n+2, n, n+1);
    vector<int> a(n);
    for(int i=0;i<n;i++){
        cin>>a[i];
        if(__builtin_popcount(a[i])&1) DC.addedge(n, i, 1);
        else DC.addedge(i, n+1, 1);
    }

    for (int i = 0; i < n; i++)
    {
        for (int j = i+1; j < n; j++)
        {
            if (__builtin_popcount(a[i] ^ a[j]) == 1)
            {
                if (__builtin_popcount(a[i])&1)
                    DC.addedge(i, j, 1);
                else
                    DC.addedge(j, i, 1);
            }
        }
    }
    int ret = DC.go();
    cout << n - ret << endl;
    for(int i=0;i<n;i++){
        if(DC.d[i]){
            if(__builtin_popcount(a[i])%2){
                cout<<a[i]<<" ";
            }
        }
        else{
            if(__builtin_popcount(a[i])%2==0){
                cout<<a[i]<<" ";
            }
        }
    }
    
}

Dinic 算法来自 ECNU 退役队伍 F0RE1GNERS 的模板 https://github.com/zerolfx/template