例题 CF793G Oleg and chess
我们可以构造这样的矩阵，令白色矩阵为不可以走的矩阵，令有色矩阵为我们的匹配阵。
于是我们可以将每一个可以用作匹配的矩阵拆出来，就有它最远延伸到的点，以及延伸到的终点，每一个延伸到的终点，实际上就是每一个白色矩阵的起点的前一个位置（因为我们要保证矩阵没有相交面积）。这里我们的参考系选择是从左往右来看的，扫描也是从最左开始的。
所以，我们要知道每个点的最前面的到达的位置，然后我们就可以确定每一个有色矩阵的位置区间了，就譬如我们现在拿出一个有色矩阵块：
那么，我们实际上就是去处理这样的有色矩阵了来建立网络流边的话，会更加的快速了。
于是，我定义为y坐标为i时刻时候最远到达的位置（最远指的是x坐标最小），当我们需要处理的时候，实际上就是要引入一个白色点的左端了，于是，这一段实际上就是到了一个极限了，矩阵就这样被造出来了。
处理：
根据这个，我们可以确定连续段了，至于怎么写的话，八仙过海各显神通吧！
根据这样的性质，我们可以构造扫描线来进行处理，然后利用线段树进行建图，将边数从变成
。
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 4e5 + 7, maxM = 1e6 + 7;
int N, Q, head[maxN], cnt;
struct Eddge
{
int nex, to; ll flow;
Eddge(int a=-1, int b=0, ll c=0):nex(a), to(b), flow(c) {}
}edge[maxM];
inline void addEddge(int u, int v, ll w)
{
edge[cnt] = Eddge(head[u], v, w);
head[u] = cnt++;
}
inline void _add(int u, int v, ll w) { addEddge(u, v, w); addEddge(v, u, 0); }
struct Dinic
{
int S, T, cur[maxN], node;
int deep[maxN], que[maxN], top, tail;
inline bool bfs()
{
for(int i=0; i<=node; i++) deep[i] = 0;
top = tail = 0; que[tail++] = S; deep[S] = 1;
while(top < tail)
{
int u = que[top++];
for(int i=head[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to; ll f = edge[i].flow;
if(!deep[v] && f)
{
deep[v] = deep[u] + 1;
que[tail++] = v;
}
}
}
return deep[T];
}
ll dfs(int u, ll dist)
{
if(u == T) return dist;
for(int &i = cur[u], v; ~i; i=edge[i].nex)
{
v = edge[i].to;
ll f = edge[i].flow;
if(deep[v] == deep[u] + 1 && f)
{
ll flow = dfs(v, min(f, dist));
if(flow)
{
edge[i].flow -= flow;
edge[i ^ 1].flow += flow;
return flow;
}
}
}
return 0;
}
inline ll Max_Flow()
{
ll ans = 0, tmp;
while(bfs())
{
for(int i=0; i<=node; i++) cur[i] = head[i];
while((tmp = dfs(S, INF))) ans += tmp;
}
return ans;
}
} mf;
namespace Segemeng
{
int lc[maxN], rc[maxN], tot, rt1, rt2, pos[maxN][2];
vector<int> a;
void build(int &rt, int fa, int l, int r, int op)
{
rt = ++tot;
if(fa)
{
if(op) _add(fa, rt, INF);
else _add(rt, fa, INF);
}
if(l == r) { pos[l][op] = rt; return; }
int mid = HalF;
build(lc[rt], rt, l, mid, op);
build(rc[rt], rt, mid + 1, r, op);
}
void query(int rt, int l, int r, int ql, int qr, int point, int op)
{
if(ql <= l && qr >= r)
{
if(op) _add(point, rt, INF);
else _add(rt, point, INF);
return;
}
int mid = HalF;
if(qr <= mid) query(lc[rt], l, mid, ql, qr, point, op);
else if(ql > mid) query(rc[rt], mid + 1, r, ql, qr, point, op);
else { query(lc[rt], l, mid, ql, qr, point, op); query(rc[rt], mid + 1, r, ql, qr, point, op); }
}
void solve(int x, int l, int r)
{
int pos = -1, las = -1;
for(int i=l; i<=r + 1; i++)
{
if(i == r + 1 || las != a[i])
{
if(~pos && las <= x)
{
int new_point = ++tot;
query(rt1, 1, N, pos, i - 1, new_point, 0);
query(rt2, 1, N, las, x, new_point, 1);
}
pos = i;
las = a[i];
}
if(i <= r) a[i] = INF;
}
}
};
using namespace Segemeng;
inline void init()
{
cnt = tot = 0;
memset(head, -1, sizeof(head));
}
struct node
{
int x, l, r, op;
node(int a=0, int b=0, int c=0, int d=0):x(a), l(b), r(c), op(d) {}
friend bool operator < (node e1, node e2) { return e1.x == e2.x ? e1.op < e2.op : e1.x < e2.x; }
};
vector<node> qvt;
int main()
{
scanf("%d%d", &N, &Q);
init();
build(rt1, 0, 1, N, 0);
build(rt2, 0, 1, N, 1);
a.clear();
a.resize(N + 2);
for(int i=1; i<=N; i++) a[i] = 1;
for(int i=1, xl, yl, xr, yr; i<=Q; i++)
{
scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
qvt.push_back(node(xl - 1, yl, yr, 1));
qvt.push_back(node(xr, yl, yr, -1));
}
sort(qvt.begin(), qvt.end());
int len = (int)qvt.size();
for(int i=0; i<len; i++)
{
switch (qvt[i].op)
{
case -1:
{
for(int j=qvt[i].l; j<=qvt[i].r; j++) a[j] = qvt[i].x + 1;
break;
}
default:
{
solve(qvt[i].x, qvt[i].l, qvt[i].r);
break;
}
}
}
solve(N, 1, N);
mf.S = 0; mf.T = ++tot; mf.node = tot;
for(int i=1; i<=N; i++)
{
_add(mf.S, pos[i][0], 1);
_add(pos[i][1], mf.T, 1);
}
printf("%lld\n", mf.Max_Flow());
return 0;
}