这个题是多个解法的题啦


题目中问：

删除多少个点，使得从起点1到终点n的最短路径大于K（到达不了算是INF）

如果用BFS+DFS就是搜索题


现在用网络流的思路来想这个题

删除点怎么和网络流量建立起来关系？！

拆点：把点拆成i，i+n，连接一条流量为1的边。意味着如果拆i点，在流量中等价于拆i->i+n的边

当然，由于题目中说了不能拆1和n这两个点，那么这两个点在拆点后的连边的权值为INF


然后，用floyd预处理任意两点的最短路

对m条边的任意边<u，v>，如果有mp【1】【u】+mp【u】【v】+mp【v】【n】<=k

就说明这条边是可以拆的，那么就有：

建边u+n->v，边权为1


最后建立超级源点S，S->1，边权INF

超级汇点T，2*n->T，边权INF


为什么？

割的定义是：把S和T拆开来，相当于题中的1和n拆开来，需要割断多少流量的边

所以我们重新构图，来匹配题意

花拆点为拆边来搞


#include<bits/stdc++.h>
using namespace std;

const int maxn=1000;
const int maxm=50050;
const int INF=0x3f3f3f3f;
int mp[maxn][maxn];
int n,m,k;
int s,t,tot;

struct Edge{
    int to,nxt,cap,flow;
}edge[maxm];
int tol,head[maxn],gap[maxn],dep[maxn],cur[maxn];

void init(){
    tol=0;
    memset(head,-1,sizeof(head));
}

void addedge(int u,int v,int w,int rw=0){
    edge[tol].to=v;
    edge[tol].cap=w;
    edge[tol].flow=0;
    edge[tol].nxt=head[u];
    head[u]=tol++;
    edge[tol].to=u;
    edge[tol].cap=rw;
    edge[tol].flow=0;
    edge[tol].nxt=head[v];
    head[v]=tol++;
}

int Q[maxn];
void BFS(int Start,int End){
    memset(dep,-1,sizeof(dep));
    memset(gap,0,sizeof(gap));
    gap[0]=1;
    int Front=0,Rear=0;
    dep[End]=0;
    Q[Rear++]=End;
    while(Front!=Rear){
        int u=Q[Front++];
        for(int i=head[u];i!=-1;i=edge[i].nxt){
            int v=edge[i].to;
            if (dep[v]!=-1) continue;
            Q[Rear++]=v;
            dep[v]=dep[u]+1;
            gap[dep[v]]++;
        }
    }
}

int S[maxn];
int sap(int Start,int End,int N){
    BFS(Start,End);
    memcpy(cur,head,sizeof(head));
    int top=0;
    int u=Start;
    int ans=0;
    while(dep[Start]<N){
        if (u==End){
            int Min=INF;
            int inser;
            for(int i=0;i<top;i++)
            if (Min>edge[S[i]].cap-edge[S[i]].flow){
                Min=edge[S[i]].cap-edge[S[i]].flow;
                inser=i;
            }
            for(int i=0;i<top;i++){
                edge[S[i]].flow+=Min;
                edge[S[i]^1].flow-=Min;
            }
            ans+=Min;
            top=inser;
            u=edge[S[top]^1].to;
            continue;
        }
        bool flag=false;
        int v;
        for(int i=cur[u];i!=-1;i=edge[i].nxt){
            v=edge[i].to;
            if (edge[i].cap-edge[i].flow&&dep[v]+1==dep[u]){
                flag=true;
                cur[u]=i;
                break;
            }
        }
        if (flag){
            S[top++]=cur[u];
            u=v;
            continue;
        }
        int Min=N;
        for(int i=head[u];i!=-1;i=edge[i].nxt)
        if (edge[i].cap-edge[i].flow&&dep[edge[i].to]<Min){
            Min=dep[edge[i].to];
            cur[u]=i;
        }
        gap[dep[u]]--;
        if (!gap[dep[u]]) return ans;
        dep[u]=Min+1;
        gap[dep[u]]++;
        if (u!=Start) u=edge[S[--top]^1].to;
    }
    return ans;
}

int a[maxm],b[maxm];

int main(){
    //freopen("input.txt","r",stdin);
    while(scanf("%d%d%d",&n,&m,&k)!=EOF){
        if (!n) break;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                mp[i][j]=(i==j)?0:INF;
        for(int i=1;i<=m;i++){
            scanf("%d%d",&a[i],&b[i]);
            mp[a[i]][b[i]]=mp[b[i]][a[i]]=1;
        }
        for(int l=1;l<=n;l++)
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if (mp[i][j]>mp[i][l]+mp[l][j])
                mp[i][j]=mp[i][l]+mp[l][j];
        //for(int i=1;i<=n;i++)
          //  for(int j=1;j<=n;j++)
            //    printf("%d%c",mp[i][j],j==n?'\n':' ');
        init();
        s=0;t=2*n+1;tot=t+1;
        addedge(s,1,INF);
        addedge(2*n,t,INF);
        addedge(1,n+1,INF);
        addedge(n,n+n,INF);
        for(int i=2;i<n;i++)
            addedge(i,i+n,1);
        for(int i=1;i<=m;i++)
                if (mp[1][a[i]]+mp[a[i]][b[i]]+mp[b[i]][n]<=k)
                    addedge(a[i]+n,b[i],1);
        printf("%d\n",sap(s,t,tot));
    }
    return 0;
}