Go Running（二分图最小点覆盖 网络流）

题目传送门

Go Running

题目大意

视跑道为轴，有若干学生在上面跑步
学生的跑步起止时间和方向和起始位置均未知，速度为 $1m/s$
有n个监控，监控会给出 t 和 x，表示当时间为t 的时候，x位置上至少有一个学生
求当前跑道最少有多少学生

思路

可以将学生视为点，每次监控到的学生可以有两种来源（x-t）或者（x+t），每个学生都可以用一条斜率为1或者-1的直线去覆盖，则问题可以转化为直线最少有多少条，可以用二分图将（x-t）和（x+t）分别放在两边，再用网络流求一下最小覆盖

AC Code

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
const int N=2e6 +10;
int a, b, x, t, l, r, n, sp, ep;
int cnt;
int head[N];
int dis[N];
struct node
{
    int e;
    int v;
    int nxt;
}edge[N<<1];
inline int read(){
   int ans=0;char r=getchar();
   while(r<'0'||r>'9')r=getchar();
   while(r>='0'&&r<='9'){ans=ans*10+r-'0';r=getchar();}
   return ans;
}
inline void addl(int u,int v,int w)
{
    edge[cnt].e=v;
    edge[cnt].v=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt++;
}

bool bfs()//bfs找深度
{
    memset(dis,-1,sizeof(dis));//注意！不要忘了这句
    dis[sp]=0;//起点深度为0，从源向汇bfs
    queue<int>q;
    q.push(sp);
    while(!q.empty())
    {
        int r=q.front();q.pop();
        for(int i=head[r];i!=-1;i=edge[i].nxt)
        {
            int j=edge[i].e;
            if(dis[j]==-1&&edge[i].v)//如果这个点还没有被bfs且这条边的流量不为0
            {
                dis[j]=dis[r]+1;
                q.push(j);
            }
        }
    }
    return dis[ep]!=-1;//若不可以到终点（起点）就返回false 
}
int dfs(int u,int flo)//dfs就是求节点u及其子树在残量为flo时的最大增量 
{
    if(u==ep)return flo;//如果是汇，直接返回flo
    int detla=flo;//用一个变量来保存flo，以方便更新其剩余残量
    for(int i=head[u];i!=-1;i=edge[i].nxt)
    {
        int v=edge[i].e;
        if(dis[v]==(dis[u]+1)&&(edge[i].v)>0)//如果满足深度条件且边可以走
        {
            int d=dfs(v,min(detla,edge[i].v));//向下递归
            //求v及其后续节点在残量为min(detla,edge[i].v)时的最大流量
            edge[i].v-=d;edge[i ^ 1].v+=d;//边的处理
            //注意，编号为i的边的反向边的编号为i^1,这是根据存边时的cnt决定的
            detla-=d;//将本节点的剩余残量值更新
            if(detla==0)break;//如果本节点已经没有残量可消耗了，就返回
        }
    }
    return flo-detla;//返回这个点已经被允许流过的流量
}
int dini()//求最大流量
{
    int ans=0, t;
    while(bfs())
    {
        while(t=dfs(sp, INF))   ans+=t;
    }
    return ans;
}


void solve()
{
    memset(head,-1,sizeof(head)); cnt=0;
    cin>>n;
    unordered_map<int,int>L;                //分别离散化二分图的两边
    unordered_map<int,int>R;
    int cntL=0, cntR=0;
    for(int i=1; i<=n; i++){
        cin>>t>>x;
        if(L.count(x+t))  l=L[x+t];
        else    L[x+t]=++cntL, l=cntL;

        if(R.count(x-t))    r=R[x-t];
        else    R[x-t]=++cntR, r=cntR;

        addl(l, r+n, 1);                    //加边
        addl(r+n, l, 0);    
    }
    sp=2*n+1, ep=2*n+2;                     //sp为源点，ep为汇点
    for(int i=1; i<=n; i++) addl(sp,i,1), addl(i,sp,0);
    for(int i=1+n; i<=2*n; i++) addl(i,ep,1), addl(ep,i,0);
    cout<<dini()<<endl;
}

int main()
{
    int T;
    cin>>T;
    while(T--)  solve();
    return 0;
}