Description
这是一道经典傻逼题，对经典题很熟悉的人也不要激动，希望大家不要傻逼。
考虑一张N个点的带权无向图，点的编号为1到N。 对于图中的任意一个点集
（可以为空或者全集），所有恰好有一个端点在这个点集中的边组成的集合被称
为割。 一个割的权值被定义为所有在这个割上的边的异或和。
一开始这张图是空图， 现在，考虑给这张无向图不断的加边， 加入每条边之
后，你都要求出当前权值最大的割的权值， 注意加入的边永远都不会消失。
Input
输入的第一行包括一个数ID表示数据编号， 如第一组数据中的ID = 1。注意
样例数据中的ID = 0。
接下来的第一行包括两个整数N,M表示图的点数和总共加的边。
接下来M行，每行三个正整数x,y,w表示在点x和点y之间加入一条权值为w的边。
注意x和y可能相同，两条不同的边也可能连接了同一对点。
此外， w将以二进制形式从高位向低位给出，比如， 6 = 110(2)，因此如果边
权为 6，那么w将会是110。
1 ≤ N≤ 500， 1 ≤ M ≤ 1000， 0 ≤ L < 1000， 1 ≤ x,y≤ N
Output
输出M行，按顺序输出每一条边加入之后权值最大的割的权值。
同样，你也要以二进制形式输出，形式和输入格式中描述的形式一样。
Sample Input
0
3
6
1 2 1
1 2 1
3 3 111
1 3 101101
1 2 1011
2 3 111011
Sample Output
1
0
0
101101
101101
110000
HINT
前三条边加入之后的答案较为显然，考虑后三条边，加入第六条边之前， 考
虑点集{1,2}，它对应的割只有第四条边， 因此答案就是第四条边的权值，考虑加
入最后一条边以后的情况，此时点集{1,2}对应的割变成了第四条边和第六条边组
成的集合，权值也发生了相应的改变。 点集{2}对应的割是第五条边和第六条边
组成的集合， 可以证明这就是权值最大的割，权值为\(1011(2)\bigoplus111011(2) =110000(2)\)
要是不知道啥是线段树分治，啥是线性基，这题这辈子不可能会做出来的
但是身为一个菜鸡，就算知道了我也照样做不出来
毕竟还是一道很好的题
很巧妙地运用了线段树分治这个方法，也让我对模型的转化有了更加深刻的认识
思路
因为直接维护边的权值非常的不方便
而且异或又有一些神奇的性质吗，所以可以考虑把边的权值转移到点上
如果一条边的两个端点都被选择了那么显然是这条边没有贡献
那就让每个点的权值等于连接到这个点上的所有边的权值的异或和
这样显然选出来点集和割的贡献就是点集权值的异或和
所以就只需要考虑点了
那么因为会像图中加入新的边，所以每个点在每个时间的权值可能是不一样的，所以就考虑用线段树分治来实现
这样就只需要算出每个时间对应的最大值就可以了
这个东西可以维护一个线性基来做
然后就做完了
我真是个傻逼
//Author: dream_maker
#include<bits/stdc++.h>
using namespace std;
//----------------------------------------------
//typename
typedef long long ll;
//convenient for
#define fu(a, b, c) for (int a = b; a <= c; ++a)
#define fd(a, b, c) for (int a = b; a >= c; --a)
#define fv(a, b) for (int a = 0; a < (signed)b.size(); ++a)
//inf of different typename
const int INF_of_int = 1e9;
const ll INF_of_ll = 1e18;
//fast read and write
template <typename T>
void Read(T &x) {
bool w = 1;x = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') w = 0, c = getchar();
while (isdigit(c)) {
x = (x<<1) + (x<<3) + c -'0';
c = getchar();
}
if (!w) x = -x;
}
template <typename T>
void Write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) Write(x / 10);
putchar(x % 10 + '0');
}
//----------------------------------------------
const int N = 1e3 + 10;
const int LEN = 1e3;
typedef bitset<N> bittyp;
void Read(bittyp &x) {
static char s[N];
scanf("%s", s);
int len = strlen(s);
reverse(s, s + len);
x.reset();
fu(i, 0, len - 1) x[i] = s[i] - '0';
}
void Write(bittyp x) {
if (!x.any()) {
putchar('0');
return;
}
int pos;
fd(i, LEN, 0) if (x.test(i)) {
pos = i;
break;
}
fd(i, pos, 0) {
if (x.test(i)) putchar('1');
else putchar('0');
}
}
struct Basis {
bittyp b[N];
void clear() {
fu(i, 0, LEN) b[i].reset();
}
void insert(bittyp x) {
fd(i, LEN, 0) {
if (x[i]) {
if (!b[i].any()) {
b[i] = x;
break;
}
x ^= b[i];
}
}
}
bittyp query_max() {
bittyp res;
fd(i, LEN, 0) {
if (!res[i] && b[i].any()) {
res ^= b[i];
}
}
return res;
}
};
#define LD (t << 1)
#define RD (t << 1 | 1)
vector<bittyp> g[N << 2];
void modify(int t, int l, int r, int ql, int qr, bittyp vl) {
if (ql <= l && r <= qr) {
g[t].push_back(vl);
return;
}
int mid = (l + r) >> 1;
if (qr <= mid) modify(LD, l, mid, ql, qr, vl);
else if (ql > mid) modify(RD, mid + 1, r, ql, qr, vl);
else {
modify(LD, l, mid, ql, mid, vl);
modify(RD, mid + 1, r, mid + 1, qr, vl);
}
}
void dfs(int t, int l, int r, Basis now) {
fv(i, g[t]) now.insert(g[t][i]);
if (l == r) {
Write(now.query_max());
putchar('\n');
return;
}
int mid = (l + r) >> 1;
dfs(LD, l, mid, now);
dfs(RD, mid + 1, r, now);
}
int n, m;
int las[N];
bittyp val[N];
int main() {
int ID; Read(ID);
Read(n), Read(m);
fu(i, 1, m) {
int u, v; bittyp w;
Read(u), Read(v), Read(w);
if (u == v) continue;
if (las[u]) modify(1, 1, m, las[u], i - 1, val[u]);
las[u] = i, val[u] ^= w;
if (las[v]) modify(1, 1, m, las[v], i - 1, val[v]);
las[v] = i, val[v] ^= w;
}
fu(i, 1, n) modify(1, 1, m, las[i], m, val[i]);
Basis rt;
rt.clear();
dfs(1, 1, m, rt);
return 0;
}