【系列】网络流

bzoj 1934 善意的投票

题目大意：

每个人可以选择睡不睡午觉 给出他们原本的意愿 以及m对朋友表示他们之间应当选择相同 求好朋友之间发生冲突的总数加上和所有和自己本来意愿发生冲突的人数

思路：

每个意愿不同的人分别连向源和汇 对于一对朋友之间连边 这样最小割即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<complex>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define Cd complex<double>
#define inf 2139062143
#define MOD 998244353
#define MAXN 310
#define MAXM 90100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T;
struct Dinic
{
    int fst[MAXN],cur[MAXN],nxt[MAXM<<1],to[MAXM<<1],val[MAXM<<1];
    int vis[MAXN],dep[MAXN],tot,cnt,q[MAXN],l,r;
    void mem(){memset(fst,0,sizeof(fst));cnt=1;}
    void add(int u,int v,int w){nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,int w){add(u,v,w);add(v,u,0);}
    int bfs()
    {
        q[l=r=1]=T,vis[T]=++tot,dep[T]=0;int x;
        while(l<=r)
        {
             x=q[l++];
             ren if(val[i^1]&&vis[to[i]]!=tot) {vis[to[i]]=tot,dep[to[i]]=dep[x]+1,q[++r]=to[i];if(to[i]==S)return 1;}
        }
        return vis[S]==tot;
    }
    int dfs(int x,int now)
    {
        if(x==T||!now) return now;
        int flow=0,f;
        for(int& i=cur[x];i;i=nxt[i])
            if(val[i]&&dep[to[i]]==dep[x]-1&&(f=dfs(to[i],min(now,val[i]))))
                {now-=f,flow+=f,val[i]-=f,val[i^1]+=f;if(!now) break;}
        return flow;
    }
    int solve()
    {
        int ans=0,f;
        while(bfs()) {memcpy(cur,fst,sizeof(cur));while(f=dfs(S,inf)) ans+=f;}
        return ans;
    }
}D;
int main()
{
    n=read(),m=read(),S=0,T=n+1;D.mem();int a,b;rep(i,1,n) {a=read();if(a) D.ins(S,i,1);else D.ins(i,T,1);}
    rep(i,1,m) a=read(),b=read(),D.ins(a,b,1),D.ins(b,a,1);
    printf("%d
",D.solve());
}

bzoj 1066 蜥蜴

题目大意：

一个网格图，一开始有一些蜥蜴，一些网格上有石柱，每个石柱在被一个蜥蜴离开之后高度会减一 ，减为0后就不能被跳了

每只蜥蜴只能从一个石柱跳到不超过d的距离的石柱上去 求最少不能出去的蜥蜴数量

思路：

对于每个石柱拆成两个点 中间连一条边来满足这个石柱的限制

其余的就从每个石柱的第二个点连向可以跳到石柱的第一个点 最后用总数-最大流即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<complex>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define Cd complex<double>
#define inf 2139062143
#define MOD 998244353
#define MAXN 510
#define MAXM 320100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,d,S,T,all;
struct Dinic
{
    int fst[MAXN],cur[MAXN],nxt[MAXM<<1],to[MAXM<<1],val[MAXM<<1];
    int vis[MAXN],dep[MAXN],tot,cnt,q[MAXN],l,r;
    void mem(){memset(fst,0,sizeof(fst));cnt=1;}
    void add(int u,int v,int w){nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,int w){add(u,v,w);add(v,u,0);}
    int bfs()
    {
        q[l=r=1]=T,vis[T]=++tot,dep[T]=0;int x;
        while(l<=r)
        {
             x=q[l++];
             ren if(val[i^1]&&vis[to[i]]!=tot) {vis[to[i]]=tot,dep[to[i]]=dep[x]+1,q[++r]=to[i];if(to[i]==S)return 1;}
        }
        return vis[S]==tot;
    }
    int dfs(int x,int now)
    {
        if(x==T||!now) return now;
        int flow=0,f;
        for(int& i=cur[x];i;i=nxt[i])
            if(val[i]&&dep[to[i]]==dep[x]-1&&(f=dfs(to[i],min(now,val[i]))))
                {now-=f,flow+=f,val[i]-=f,val[i^1]+=f;if(!now) break;}
        return flow;
    }
    int solve()
    {
        int ans=0,f;
        while(bfs()) {memcpy(cur,fst,sizeof(cur));while(f=dfs(S,inf)) ans+=f;}
        return ans;
    }
}D;
char mp[25][25],ch[25];
int cur[25][25];
void srch(int x,int y)
{
    if(mp[x][y]=='0') return ;
    if((x-d<1||x+d>n||y-d<1||y+d>m)) D.ins(cur[x][y]+1,T,inf);
    rep(i,x-d,x+d) if(i<1||i>n) continue;
    else rep(j,y-d,y+d) if(j<1||j>m) continue;
    else if(abs(x-i)+abs(y-j)<=d) D.ins(cur[x][y]+1,cur[i][j],inf);
}
int main()
{
    n=read(),m=read(),d=read(),S=0,T=(n*m+2)<<1,all=1;int num=0;D.mem();
    rep(i,1,n) {scanf("%s",mp[i]+1);rep(j,1,m) {if(mp[i][j]!='0') D.ins(all,all+1,mp[i][j]-'0');cur[i][j]=all,all+=2;}}
    rep(i,1,n) {scanf("%s",ch+1);rep(j,1,m) {srch(i,j);if(ch[j]=='L') D.ins(S,cur[i][j],1),num++;}}
    printf("%d",num-D.solve());
}

bzoj 4625 水晶

题目大意：

地图由密铺的六边形单元组成，每个单元与其他

六个单元相邻。为了方便起见，我们用坐标(x,y,z)描述一个单元的位置，表示从原点开始按如图所示的x,y,z方向

各走若干步之后到达的地方。有可能有两个坐标描述同一个单元，比如(1,1,1)和(0,0,0)描述的都是原点

显然(x,y,z)单元和(x+1, y,z)，(x-1,y,z)，(x,y+1,z)，(x,y-1,z)，(x, y, z+1)，(x,y, z-1)相邻。有N块水晶

位于地图的单元内，第i块水晶位于坐标(xi, yi, zi)所表示的单元中，并拥有ci的价值。每个单元内部可能会有

多块水晶。地图中，有一些单元安装有能量源。如下图，任何满足x+y+z是3的整数倍的坐标所描述的单元内都安装

有能量源。

 

有能量源的单元中的水晶价值将会额外增加10%.如果三块水晶所在的单元满足特定排列，那么它们将会引发共振。

共振分两种，a共振和b共振。a共振：如果三块水晶所在的单元两两相邻地排成一个三角形，那么会引起a共振。

图中每一个三角形表示这三个单元各有一块水晶将会发生一个a共振。b共振：如果三块水晶所在的单元依次相邻地

排成一条长度为2的直线段，且正中间的单元恰好有能量源，那么会引起b共振。

 

图中粉红色线段表示这三个单元各有一块水晶将会发生一个b共振，黑色线段表示即使这三个单元有水晶也不会发

生b共振。现在你要炸掉一部分水晶，使得任何共振都不会发生的前提下，剩余水晶的价值总和最大

思路：

首先根据题意发现题为一个三分图 由于b共振的条件 

因此把坐标和%3位0的放在中间 剩下两个顺序随意 通过拆点来满足价值 用总数-最小割即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<complex>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define Cd complex<double>
#define inf 2139062143
#define MOD 998244353
#define MAXN 100100
#define MAXM 400100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T,x[MAXN],y[MAXN],z[MAXN];
double all,d[MAXN];
int calc(int x,int y) {return 4000*(x+2000)+y+6000;}
map <int,int> hsh;
struct Dinic
{
    int fst[MAXN],cur[MAXN],nxt[MAXM<<1],to[MAXM<<1];double val[MAXM<<1];
    int vis[MAXN],dep[MAXN],tot,cnt,q[MAXN],l,r;
    void mem(){memset(fst,0,sizeof(fst));cnt=1;}
    void add(int u,int v,double w){nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,double w){add(u,v,w);add(v,u,0.0);}
    int bfs()
    {
        q[l=r=1]=T,vis[T]=++tot,dep[T]=0;int x;
        while(l<=r)
        {
             x=q[l++];
             ren if(val[i^1]>0.0&&vis[to[i]]!=tot) {vis[to[i]]=tot,dep[to[i]]=dep[x]+1,q[++r]=to[i];if(to[i]==S)return 1;}
        }
        return vis[S]==tot;
    }
    double dfs(int x,double now)
    {
        if(x==T||now==0.0) return now;
        double flow=0,f;
        for(int& i=cur[x];i;i=nxt[i])
            if(val[i]>0.0&&dep[to[i]]==dep[x]-1&&((f=dfs(to[i],min(now,val[i])))!=0.0))
                {now-=f,flow+=f,val[i]-=f,val[i^1]+=f;if(!now) break;}
        return flow;
    }
    double solve()
    {
        double ans=0,f;
        while(bfs()) {memcpy(cur,fst,sizeof(cur));while((f=dfs(S,inf))!=0.0) ans+=f;}
        return ans;
    }
}D;
int main()
{
    n=read(),S=(n+3)<<1,T=((n+3)<<1|1);D.mem();int tmp,to;rep(i,1,n)
    {
        x[i]=read(),y[i]=read(),z[i]=read(),d[i]=read();
        if((x[i]+y[i]+z[i])%3==0) d[i]*=1.1;all+=d[i];
        tmp=hsh[to=calc(x[i]-=z[i],y[i]-=z[i])];
        if(!tmp) hsh[to]=tmp=i;D.ins(tmp<<1,tmp<<1|1,d[i]);
    }
    rep(i,1,n)
    {
        tmp=hsh[to=calc(x[i],y[i])];if(tmp!=i) continue;
        if((x[i]+y[i]+33333)%3==1) D.ins(i<<1|1,T,inf);
        else 
        {
            if((x[i]+y[i]+33333)%3==2) D.ins(S,i<<1,inf);
            D.ins(i<<1|1,hsh[calc(x[i],y[i]+1)]<<1,inf);
            D.ins(i<<1|1,hsh[calc(x[i]+1,y[i])]<<1,inf);
            D.ins(i<<1|1,hsh[calc(x[i]-1,y[i]-1)]<<1,inf);
        }
    }
    printf("%.1lf
",all-D.solve());
}

bzoj 1391 order

题目大意：

n个任务 m个机器 每个任务都需要一些机器 一个机器可以租借或购买 具有不同的价格

每个机器对不同的任务租借费用不同 任务的利润和机器的购买价格相等

思路：

若不考虑租借 则为最大权闭合子图 考虑修改这个图 对于原来流量为inf的边修改为相应的租借费用

这样对于一条$S ightarrow T$的路径，总会有一条边被割掉，即为买机器或租借某一个机器或者不要这个收益

用总收益减去最小割即为答案

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<complex>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define Cd complex<double>
#define inf 2139062143
#define MOD 998244353
#define MAXN 2510
#define MAXM 1500100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T,all;
struct Dinic
{
    int fst[MAXN],cur[MAXN],nxt[MAXM<<1],to[MAXM<<1],val[MAXM<<1];
    int vis[MAXN],dep[MAXN],tot,cnt,q[MAXN],l,r;
    void mem(){memset(fst,0,sizeof(fst));cnt=1;}
    void add(int u,int v,int w){nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,int w){add(u,v,w);add(v,u,0);}
    int bfs()
    {
        q[l=r=1]=T,vis[T]=++tot,dep[T]=0;int x;
        while(l<=r)
        {
             x=q[l++];
             ren if(val[i^1]&&vis[to[i]]!=tot){vis[to[i]]=tot,dep[to[i]]=dep[x]+1,q[++r]=to[i];if(to[i]==S)return 1;}
        }
        return vis[S]==tot;
    }
    int dfs(int x,int now)
    {
        if(x==T||!now) return now;int flow=0,f;
        for(int& i=cur[x];i;i=nxt[i])
            if(val[i]&&dep[to[i]]==dep[x]-1&&(f=dfs(to[i],min(now,val[i]))))
                {now-=f,flow+=f,val[i]-=f,val[i^1]+=f;if(!now) break;}
        return flow;
    }
    int solve()
    {
        int ans=0,f;
        while(bfs()) {memcpy(cur,fst,sizeof(cur));while(f=dfs(S,inf)) ans+=f;}
        return ans;
    }
}D;
int main()
{
    n=read(),m=read(),S=n+m+5,T=S+1;D.mem();int a,b,c;rep(i,1,n) 
    {
        a=read(),all+=a;D.ins(S,i,a);a=read();rep(j,1,a)
            b=read(),c=read(),D.ins(i,b+n,c);
    }
    rep(i,1,m) a=read(),D.ins(i+n,T,a);
    printf("%d
",all-D.solve());
}

bzoj 1070 修车

题目大意：

m个人修n辆车，不同的人修不同的车需要不同的时间，求所有人最短修完车的时间（包含等待时间）

思路：

把每个人拆成n个点，表示第$i$个倒数第$j$个修哪辆车

这样倒数第$j$个的影响就是$j$倍的影响（会影响加上自己的$j$个人的等待时间）

// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<complex>
#include<iomanip>
#define Fill(a,x) memset(a,x,sizeof(a))
#define rep(i,s,t) for(register int i=(s),i__end=(t);i<=i__end;++i)
#define dwn(i,s,t) for(register int i=(s),i__end=(t);i>=i__end;--i)
#define ren for(int i=fst[x];i;i=nxt[i])
#define inf 2139062143
#define ll long long
#define ull unsigned long long
#define MAXN 710
#define MAXM 40010
#define MOD 998244353 
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int S,T,n,m,g[70][70];
struct zkw
{
    int fst[MAXN],nxt[MAXM<<1],to[MAXM<<1],cst[MAXM<<1],val[MAXM<<1],cnt;
    int q[MAXN<<4],hd,tl,vis[MAXN],tot,dis[MAXN];ll ans;
    zkw(){Fill(fst,0);cnt=1,ans=0LL;}
    void add(int u,int v,int w,int c) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,cst[cnt]=c,val[cnt]=w;}
    void ins(int u,int v,int w,int c) {add(u,v,w,c);add(v,u,0,-c);}
    int spfa()
    {
        Fill(vis,0);Fill(dis,127);q[hd=tl=1]=T,dis[T]=0;int x;
        while(hd<=tl)
        {
            x=q[hd++],vis[x]=0;
            ren if(val[i^1]&&dis[to[i]]>dis[x]-cst[i]) 
                {dis[to[i]]=dis[x]-cst[i];if(!vis[to[i]]) vis[to[i]]=1,q[++tl]=to[i];}
        }
        return dis[S]!=inf;
    }
    int dfs(int x,int a)
    {
        if(x==T||!a) {ans+=dis[S]*a;return a;}
        if(vis[x]) return 0;vis[x]=1;int f,flw=0;
        ren if(val[i]&&dis[to[i]]==dis[x]-cst[i]&&(f=dfs(to[i],min(a,val[i]))))
            {flw+=f,val[i]-=f,val[i^1]+=f,a-=f;if(!a) break;}
        return flw;
    }
    int solve(int res=0)
    {
        while(spfa()) res+=dfs(S,inf);return res;
    }
}Z;
int main()
{
    n=read(),m=read();S=n*m+m+1,T=S+1;rep(i,1,n*m) Z.ins(S,i,1,0);
    rep(i,1,m) Z.ins(i+n*m,T,1,0);rep(i,1,m) rep(j,1,n) g[i][j]=read();
    rep(i,1,n) rep(j,1,m) rep(k,1,m) Z.ins((i-1)*m+j,n*m+k,1,j*g[k][i]);
    Z.solve();printf("%.2lf
",1.0*Z.ans/m);
}

bzoj 3894 文理分科

题目大意：

每个人可以选文理科分别得到两种价值$a$或$b$

若这个人的四连块中的人选课都与他一样则会得到附加的$c$或$d$

思路：

每个人拆成三个点 第一个点表示自己 分别与源汇点连边表示选文或理

第二个点连向包括自己和相邻的五个点的第一个点 容量为inf（因为不能被割） 从源向该点连边容量为附加的文科值

第三个点与第二个点类似表示理科

这样的话使用总代价-最小割即为答案

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<set>
#define ll long long
#define inf 2139062143
#define MAXN 30500
#define MAXM 300100
#define MOD 998244353
#define rep(i,s,t) for(register int i=(s),i##__end=(t);i<=i##__end;++i)
#define dwn(i,s,t) for(register int i=(s),i##__end=(t);i>=i##__end;--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define pb(i,x) vec[i].push_back(x)
#define pls(a,b) (a+b)%MOD
#define mns(a,b) (a-b+MOD)%MOD
#define mul(a,b) (1LL*(a)*(b))%MOD
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T,sum,dx[5]={1,-1,0,0,0},dy[5]={0,0,1,-1,0};
struct Dinic
{
    int fst[MAXN],nxt[MAXM<<1],to[MAXM<<1],val[MAXM<<1],cnt;
    int q[MAXN],l,r,vis[MAXN],dep[MAXN],cur[MAXN],tot;
    Dinic(){memset(fst,0,sizeof(fst));memset(vis,0,sizeof(vis));cnt=1,tot=0;}
    void add(int u,int v,int w) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,int w) {add(u,v,w);add(v,u,0);}
    int bfs()
    {
        vis[T]=++tot,q[l=r=1]=T,dep[T]=0;int x;
        while(l<=r)
        {
            x=q[l++];ren if(vis[to[i]]!=tot&&val[i^1])
                vis[to[i]]=tot,dep[to[i]]=dep[x]+1,q[++r]=to[i];
        }
        return vis[S]==tot;
    }
    int dfs(int x,int a)
    {
        if(x==T||!a) return a;int flw=0,f;
        for(int& i=cur[x];i&&a;i=nxt[i])
            if(val[i]&&dep[to[i]]==dep[x]-1&&(f=dfs(to[i],min(a,val[i]))))
                flw+=f,a-=f,val[i]-=f,val[i^1]+=f;
        return flw;
    }
    int solve()
    {
        int ans=0,f;
        while(bfs()){memcpy(cur,fst,sizeof(cur));while(f=dfs(S,inf)) ans+=f;}
        return ans;
    }
}D;
int ok(int x,int y) {return x>=0&&x<=n&&y>=0&&y<=m;}
int calc(int k,int x,int y) {return k*(n+1)*(m+1)+x*(m+1)+y;}
int main()
{
    n=read()-1,m=read()-1,S=3*(n+1)*(m+1)+1,T=S+1;int x,nx,ny;
    rep(i,0,n) rep(j,0,m) {x=read(),sum+=x;D.ins(S,calc(0,i,j),x);}
    rep(i,0,n) rep(j,0,m) {x=read(),sum+=x;D.ins(calc(0,i,j),T,x);}
    rep(i,0,n) rep(j,0,m)
    {
        x=read(),sum+=x;rep(k,0,4) if(ok(nx=(i+dx[k]),(ny=j+dy[k])))
            D.ins(calc(1,i,j),calc(0,nx,ny),inf);
        D.ins(S,calc(1,i,j),x);
    }
    rep(i,0,n) rep(j,0,m)
    {
        x=read(),sum+=x;rep(k,0,4) if(ok(nx=(i+dx[k]),(ny=j+dy[k])))
            D.ins(calc(0,nx,ny),calc(2,i,j),inf);
        D.ins(calc(2,i,j),T,x);
    }
    printf("%d
",sum-D.solve());
}

bzoj 1143 祭祀

题目大意：

求DAG的最长反链（一个点集使其两两不可达

思路：

最长反链=最小链覆盖

求最小链覆盖需要把每个点拆成两个，每个能到达的点对，由左边的$u$连向右边的$v$ ，求最大点独立集

最大点独立集=$n$-最大匹配

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<map>
#include<set>
#define ll long long
#define db double
#define inf 2139062143
#define MAXN 510
#define MAXM 100300
#define rep(i,s,t) for(register int i=(s),i##__end=(t);i<=i##__end;++i)
#define dwn(i,s,t) for(register int i=(s),i##__end=(t);i>=i##__end;--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define pb(i,x) vec[i].push_back(x)
#define pls(a,b) (a+b)%MOD
#define mns(a,b) (a-b+MOD)%MOD
#define mul(a,b) (1LL*(a)*(b))%MOD
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,S,T,mp[110][110];
struct Dinic
{
    int fst[MAXN],nxt[MAXM<<1],to[MAXM<<1],val[MAXM<<1],cnt,cur[MAXN];
    int vis[MAXN],dis[MAXN],tot,q[MAXN],l,r;
    Dinic(){memset(fst,0,sizeof(fst));cnt=1;}
    void add(int u,int v,int w) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v,val[cnt]=w;}
    void ins(int u,int v,int w) {add(u,v,w);add(v,u,0);}
    int bfs()
    {
        q[l=r=1]=T,vis[T]=++tot,dis[T]=0;int x;
        while(l<=r)
        {
            x=q[l++];ren if(vis[to[i]]!=tot&&val[i^1]) 
                dis[to[i]]=dis[x]+1,vis[to[i]]=tot,q[++r]=to[i];
        }
        return vis[S]==tot;
    }
    int dfs(int x,int a)
    {
        if(x==T||!a) return a;int flw=0,f;
        for(int& i=cur[x];i&&a;i=nxt[i]) 
            if(dis[to[i]]==dis[x]-1&&val[i]&&(f=dfs(to[i],min(a,val[i]))))
                a-=f,flw+=f,val[i]-=f,val[i^1]+=f;
        return flw;
    }
    int solve(int res=0)
    {
        int f;while(bfs())
            {rep(i,1,T) cur[i]=fst[i];while(f=dfs(S,inf)) res+=f;}
        return res;
    }
}D;
int main()
{
    n=read(),m=read();int a,b;S=n<<1|1,T=S+1;
    while(m--) a=read(),b=read(),mp[a][b]=1;
    rep(k,1,n) rep(i,1,n) rep(j,1,n) mp[i][j]|=(mp[i][k]&mp[k][j]);
    rep(i,1,n) rep(j,1,n) if(mp[i][j]) D.ins(i,j+n,1);
    rep(i,1,n) D.ins(S,i,1),D.ins(i+n,T,1);
    printf("%d
",n-D.solve());
}