Codevs_P1922 骑士共存问题(Dinic算法最大流+二分图匹配)

最新推荐文章于 2017-03-03 21:41:00 发布
最新推荐文章于 2017-03-03 21:41:00 发布
阅读量715 收藏
点赞数
分类专栏： Codevs 图论 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18455665/article/details/50470187
版权
Codevs 同时被 3 个专栏收录
84 篇文章 0 订阅
订阅专栏
图论
48 篇文章 0 订阅
订阅专栏
网络流
23 篇文章 0 订阅
订阅专栏

时间限制: 2 s
空间限制: 256000 KB
题目等级 : 大师 Master
题目描述 Description
在一个n*n个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘
上某些方格设置了障碍，骑士不得进入。

对于给定的n*n个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑
士，使得它们彼此互不攻击。

输入描述 Input Description
第一行有2 个正整数n 和m (1<=n<=200, 0<=m< n^2)，
分别表示棋盘的大小和障碍数。接下来的m 行给出障碍的位置。每行2 个正整数，表示障
碍的方格坐标。

输出描述 Output Description
将计算出的共存骑士数输出

样例输入 Sample Input
3 2
1 1
3 3

样例输出 Sample Output
5

友情提示:骑士与四周距离为“日” 型方格的棋不能共存

还是老思路，黑白染色，黑格与未被阻碍白格ri型相连,流量INF,超级源点与黑格相连流量为1，未被阻碍的白个与超级汇点相连，流量为1
Dinic算法:bfs将图分层，保证每次都是最短路，dfs求阻塞流；
ps：Dinic好快qwq，普通最大流SPFA会超时，第一个是Dinic的递归算法，第二个是非递归算法

#include<cstdio>
#include<climits>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
using namespace std;
#define N 205
#define INF INT_MAX/3*2
struct Min_Cut{
    struct Edge{
        int fr,to,cap,flow;
        Edge(int a,int b,int c,int d):fr(a),to(b),cap(c),flow(d){}
    };
    vector<Edge> edge;vector<int> g[N*N];
    int a[N*N],p[N*N],d[N*N],cur[N*N];bool b[N*N];
    int t,n,m,k,S,T,flow,ans;

    int hash(int i,int j){return (i-1)*n+j;}
    void in(int &x){
        x=0;char ch=getchar();
        while(ch>'9'||ch<'0') ch=getchar();
        while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
        return;
    }

    void Add_Edge(int fr,int to,int cap,int flow){
        edge.push_back(Edge(fr,to,cap,flow));
        edge.push_back(Edge(to,fr,0,0));
        t=edge.size();
        g[fr].push_back(t-2);g[to].push_back(t-1);return;
    }

    void init(){
        in(n),in(m);int x,y;
        S=0,T=n*n+1;ans=n*n-m;
        while(m--){
            in(x),in(y);
            b[hash(x,y)]=true;
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(!b[hash(i,j)]&&((i+j)&1)){
                    Add_Edge(S,hash(i,j),1,0);
                    if(i-2>0&&j-1>0&&!b[hash(i-2,j-1)]) Add_Edge(hash(i,j),hash(i-2,j-1),INF,0);
                    if(i-2>0&&j+1<=n&&!b[hash(i-2,j+1)])Add_Edge(hash(i,j),hash(i-2,j+1),INF,0);
                    if(i-1>0&&j-2>0&&!b[hash(i-1,j-2)]) Add_Edge(hash(i,j),hash(i-1,j-2),INF,0);
                    if(i-1>0&&j+2<=n&&!b[hash(i-1,j+2)])Add_Edge(hash(i,j),hash(i-1,j+2),INF,0);

                    if(i+2<=n&&j-1>0&&!b[hash(i+2,j-1)]) Add_Edge(hash(i,j),hash(i+2,j-1),INF,0);
                    if(i+2<=n&&j+1<=n&&!b[hash(i+2,j+1)])Add_Edge(hash(i,j),hash(i+2,j+1),INF,0);
                    if(i+1<=n&&j-2>0&&!b[hash(i+1,j-2)]) Add_Edge(hash(i,j),hash(i+1,j-2),INF,0);
                    if(i+1<=n&&j+2<=n&&!b[hash(i+1,j+2)])Add_Edge(hash(i,j),hash(i+1,j+2),INF,0);
                }
                if(!b[hash(i,j)]&&!((i+j)&1))   Add_Edge(hash(i,j),T,1,0);
            }

    }

    bool bfs(){
        memset(d,-1,sizeof(d));memset(b,0,sizeof(b));
        queue<int> q;int x;d[S]=0;b[S]=true;q.push(S);
        while(!q.empty()){
            x=q.front();q.pop();
            for(int i=0;i<g[x].size();i++){
                Edge &e=edge[g[x][i]];
                if(!b[e.to]&&e.cap>e.flow){
                    b[e.to]=true;d[e.to]=d[x]+1;q.push(e.to);
                }
            }
        }
        return b[T];
    }

    int dfs(int x,int a){
        if(x==T||a==0) return a;
        int flow=0,f;
        for(int &i=cur[x];i<g[x].size();i++){
            Edge &e=edge[g[x][i]];
            if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;edge[g[x][i]^1].flow-=f;
                flow+=f;a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }

    void Max_Flow(){
        flow=0;
        while(bfs()){
            memset(cur,0,sizeof(cur));
            flow+=dfs(S,INF);
        }
    /*  for(;;){
            memset(a,0,sizeof(a));a[S]=INF;int x;
            queue<int> q;q.push(S);
            while(!q.empty()){
                x=q.front();q.pop();
                for(int i=0;i<g[x].size();i++){
                    Edge &e=edge[g[x][i]];
                    if(!a[e.to]&&e.cap>e.flow){
                        a[e.to]=min(e.cap-e.flow,a[x]);
                        p[e.to]=g[x][i];
                        q.push(e.to);
                    }
                }
                if(a[T]) break;
            }
            if(!a[T]) break;
            flow+=a[T];
            for(x=T;x!=S;x=edge[p[x]].fr){
                edge[p[x]].flow+=a[T];edge[p[x]^1].flow-=a[T];
            }
        }*/
    }

    void solve(){
        init();Max_Flow();printf("%d\n",ans-flow);
    }

}s;
int main(){
    s.solve();return 0;
}

这是Dinic的非递归算法优化

#include<cstdio>
#include<climits>
#include<cstring>
#include<vector>
#include<queue>
#include<iostream>
using namespace std;
#define N 205
#define INF INT_MAX/3*2
struct Min_Cut{
    struct Edge{
        int fr,to,cap,flow;
        Edge(int a,int b,int c,int d):fr(a),to(b),cap(c),flow(d){}
    };
    vector<Edge> edge;vector<int> g[N*N];
    int a[N*N],p[N*N],d[N*N],cur[N*N];bool b[N*N];
    int t,n,m,S,T,flow,ans;

    int hash(int i,int j){return (i-1)*n+j;}
    void in(int &x){
        x=0;char ch=getchar();
        while(ch>'9'||ch<'0') ch=getchar();
        while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
        return;
    }

    void Add_Edge(int fr,int to,int cap,int flow){
        edge.push_back(Edge(fr,to,cap,flow));
        edge.push_back(Edge(to,fr,0,0));
        t=edge.size();
        g[fr].push_back(t-2);g[to].push_back(t-1);return;
    }

    void init(){
        in(n),in(m);int x,y;
        S=0,T=n*n+1;ans=n*n-m;
        while(m--){
            in(x),in(y);
            b[hash(x,y)]=true;
        }
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++){
                if(!b[hash(i,j)]&&((i+j)&1)){
                    Add_Edge(S,hash(i,j),1,0);
                    if(i-2>0&&j-1>0&&!b[hash(i-2,j-1)]) Add_Edge(hash(i,j),hash(i-2,j-1),INF,0);
                    if(i-2>0&&j+1<=n&&!b[hash(i-2,j+1)])Add_Edge(hash(i,j),hash(i-2,j+1),INF,0);
                    if(i-1>0&&j-2>0&&!b[hash(i-1,j-2)]) Add_Edge(hash(i,j),hash(i-1,j-2),INF,0);
                    if(i-1>0&&j+2<=n&&!b[hash(i-1,j+2)])Add_Edge(hash(i,j),hash(i-1,j+2),INF,0);

                    if(i+2<=n&&j-1>0&&!b[hash(i+2,j-1)]) Add_Edge(hash(i,j),hash(i+2,j-1),INF,0);
                    if(i+2<=n&&j+1<=n&&!b[hash(i+2,j+1)])Add_Edge(hash(i,j),hash(i+2,j+1),INF,0);
                    if(i+1<=n&&j-2>0&&!b[hash(i+1,j-2)]) Add_Edge(hash(i,j),hash(i+1,j-2),INF,0);
                    if(i+1<=n&&j+2<=n&&!b[hash(i+1,j+2)])Add_Edge(hash(i,j),hash(i+1,j+2),INF,0);
                }
                if(!b[hash(i,j)]&&!((i+j)&1))   Add_Edge(hash(i,j),T,1,0);
            }

    }

    bool bfs(){
        memset(d,-1,sizeof(d));memset(b,0,sizeof(b));
        queue<int> q;int x;d[S]=0;b[S]=true;q.push(S);
        while(!q.empty()){
            x=q.front();q.pop();
            for(int i=0;i<g[x].size();i++){
                Edge &e=edge[g[x][i]];
                if(!b[e.to]&&e.cap>e.flow){
                    b[e.to]=true;d[e.to]=d[x]+1;q.push(e.to);
                }
            }
        }
        return b[T];
    }

/*  int dfs(int x,int a){
        if(x==T||a==0) return a;
        int flow=0,f;
        for(int &i=cur[x];i<g[x].size();i++){
            Edge &e=edge[g[x][i]];
            if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0){
                e.flow+=f;edge[g[x][i]^1].flow-=f;
                flow+=f;a-=f;
                if(a==0) break;
            }
        }
        return flow;
    }*/

    void Max_Flow(){
        flow=0;
        while(bfs()){
            int k=0,x=S;
            memset(cur,0,sizeof(cur));
            for(;;){
                if(x==T){
                    int mine=-1,minf=INF;
                    for(int i=0;i<k;i++)
                        if(edge[p[i]].cap-edge[p[i]].flow<minf){
                            minf=edge[p[i]].cap-edge[p[i]].flow;
                            mine=i;
                        }
                    for(int i=0;i<k;i++){
                        edge[p[i]].flow+=minf;
                        edge[p[i]^1].flow-=minf;
                    }
                    k=mine;x=edge[p[mine]].fr;flow+=minf;
                }
                for(int &i=cur[x];i<g[x].size();i++){
                    Edge &e=edge[g[x][i]];
                    if(e.cap>e.flow&&d[x]+1==d[e.to]) break;
                }
                if(cur[x]<g[x].size()){
                    p[k++]=g[x][cur[x]];
                    x=edge[g[x][cur[x]]].to;
                }
                else{
                    if(k==0) break;
                    d[x]=-1;k--;x=edge[p[k]].fr;
                }
            }
        }
    /*  for(;;){
            memset(a,0,sizeof(a));a[S]=INF;int x;
            queue<int> q;q.push(S);
            while(!q.empty()){
                x=q.front();q.pop();
                for(int i=0;i<g[x].size();i++){
                    Edge &e=edge[g[x][i]];
                    if(!a[e.to]&&e.cap>e.flow){
                        a[e.to]=min(e.cap-e.flow,a[x]);
                        p[e.to]=g[x][i];
                        q.push(e.to);
                    }
                }
                if(a[T]) break;
            }
            if(!a[T]) break;
            flow+=a[T];
            for(x=T;x!=S;x=edge[p[x]].fr){
                edge[p[x]].flow+=a[T];edge[p[x]^1].flow-=a[T];
            }
        }*/
    }

    void solve(){
        init();Max_Flow();printf("%d\n",ans-flow);
    }

}s;
int main(){
    s.solve();return 0;
}
北屿小智障
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络流初学整合
K键盘里的青春K
07-18 922
首先说明，此篇博客是我在初学网络流时将看到过的所有很好很经典博客里简单易懂或者精彩的部分摘取组合而成的。每一篇博客侧重点不同，有些讲的比较粗略但是另一些博客很详细，所以我觉得将这些精华聚合在一起还是很重要的，每篇博客我都会标明出处。另外有些地方我也会增加一些我自己的见解，如果有不对的地方，希望各位大佬指出。如果您觉得好的话欢迎转载，但请说明出处：http://blog.csdn.NET/qq_34
OI笔录
forto42的博客
03-26 438
文章目录二月一日 并查集+堆二月2日 BM & KMP & TRIE & AUTO_ACFebr,3rd——AUTO_AC2.4 RMQ / LCA / 树链剖分 / 线段树二月五日 RMQ & LCA / 树链剖分 / 线段树2/6/2020 线段树 / 树状数组 ----- 共 & 异2-7-2020 平衡树（划掉）treap元宵节AnKang 平...
codevs 1922 骑士共存问题||二分图||最大独立集||二分图匹配||Dinic与匈牙利算法的讨论||网络流
远方
11-26 2315
**1922 骑士共存问题** **题目描述 Description** 在一个n*n个方格的国际象棋棋盘上，马（骑士）可以攻击的棋盘方格如图所示。棋盘 上某些方格设置了障碍，骑士不得进入。对于给定的n*n个方格的国际象棋棋盘和障碍标志，计算棋盘上最多可以放置多少个骑 士，使得它们彼此互不攻击。**输入描述 Input Description** 第一行有2 个正整数n 和m (1<=n<
[codevs 1922] 骑士共存问题
ghy1953
02-01 732
[codevs 1922] 骑士共存问题 题解： 二分图最大独立集问题。 代码： 总时间耗费: 3172ms   总内存耗费: 11 kB #include #include #include #include #include #include #include using namespace
【CODEVS】1922 骑士共存问题
weixin_34258838的博客
03-03 59
【算法】二分图最大匹配(最大流) 【题解】按(i+j)奇偶性染色后，发现棋子跳到的地方刚好异色。 然后就是二分图了，对于每个奇点向可以跳到的地方连边，偶点不需连(可逆)。 所以题目要求转换为求二分图上最大独立集(对于每条边,至少有一个点不被选中)。 最大独立集=总点数-最小割 //代码略 //hzwer's code: #include<iostream&g...
【算法】网络流与二分图
weixin_33778778的博客
03-03 139
【最大流】Dinic ★推荐：Dinic入门。 本质：网络流本质上是为了解决一类取舍问题，这类取舍问题无法得知最优策略的模式（无法DP），因此通过构造一些带容量的路径表示原题目容量，模拟水流在这些容量之间的取舍，从而可以利用网络流来解决取舍问题。 Dinic算法：bfs得到分层图，然后严格按照分层图寻找增广路，重复至S-T断路。 当前弧优化：DFS过程中访问x点时一旦流入量=流出量就退出，...
【线性规划与网络流 24题】已完成(3道题因为某些奇怪的原因被抛弃了QAQ)
as2886089的博客
04-11 119
写在前面：SDOI2016 Round1滚粗后蒟蒻开始做网络流来自我拯救(2016-04-11再过几天就要考先修课，现在做网络流24题貌似没什么用←退役节奏) 做的题目将附上日期，见证我龟速刷题。 1.飞行员配对方案问题2016-04-11 　　二分图最大匹配问题，更新了一下$Dinic$模板，带上了当前弧优化和多路增广。这道题输出方案有很多种，可是没有special jud...
Dinic.rar_Dinif2.m_dinic_最大流_最大流算法_最大网络流
07-15
相比于其他最大流算法，如Ford-Fulkerson方法，Dinic算法在最坏情况下的时间复杂度可以达到O(V^2 * E)，其中V是节点数量，E是边的数量，这在很多情况下是可接受的。 总之，Dinic算法是一种强大的工具，用于解决网络...
最大网络流Dinic算法
09-01
最大网络流问题在图论和运筹学中占有重要地位，它主要研究在一个有向图中，从源点到汇点能通过的最大流量。Dinic算法是由苏联计算机科学家E. A. Dinic于1970年提出的，是一种解决此类问题的有效算法。该算法基于层的...
最大流dinic算法
12-06
Dinic算法的基本思路: 1.根据残量网络计算层次图。 2.在层次图中使用DFS进行增广直到不存在增广路 3.重复以上步骤直到无法增广
网络流最大流Dinic算法代码
10-16
最大流的Dinic算法，时间复杂度O(EV^2),代码简单而高效
cpp_zip_Dinic算法_
10-01
否则，说明网络已达到最大流状态，算法结束。 ### 3. 主要特点 - **层次化**：利用层次结构加快搜索速度，避免了回溯。 - **块技术**：通过将节点分为小块，减少每个增广步骤中的搜索复杂度。 - **预处理**：对图...
Codevs_P1087 麦森数(快速幂+分治)
BeiYu
11-03 3034
麦森数（Mason.cpp） 【问题描述】形如2P-1的素数称为麦森数，这时P一定也是个素数。但反过来不一定，即如果P是个素数，2P-1不一定也是素数。到1998年底，人们已找到了37个麦森数。最大的一个是P=3021377，它有909526位。麦森数有许多重要应用，它与完全数密切相关。 任务：从文件中输入P（1000< P <3100000），计算2P-1的位数和最后500位数字（用十进制高精
Codevs_P2185 最长公共上升子序列(LCIS)
BeiYu
12-05 1897
时间限制: 1 s 空间限制: 32000 KB 题目等级 : 钻石 Diamond 题目描述 Description 熊大妈的奶牛在小沐沐的熏陶下开始研究信息题目。小沐沐先让奶牛研究了最长上升子序列，再让他们研究了最长公共子序列，现在又让他们要研究最长公共上升子序列了。 小沐沐说，对于两个串A，B，如果它们都包含一段位置不一定连续的数字，且数字是严格递增的，那么称这一段数字是两个串的公共
BZOJ_P1008&Codevs_P1851 [HNOI2008]越狱(排列组合+快速幂)
BeiYu
12-19 1684
Time Limit: 1 Sec Memory Limit: 162 MB Submit: 6206 Solved: 2645 Description监狱有连续编号为1…N的N个房间，每个房间关押一个犯人，有M种宗教，每个犯人可能信仰其中一种。如果相邻房间的犯人的宗教相同，就可能发生越狱，求有多少种状态可能发生越狱Input 输入两个整数M，N.1<=M<=10^8,1<=N<=10^1
Codevs_P1425 最长公共子串(KMP)
BeiYu
12-05 1445
题目描述 Description 输入N（2<=N<=20）个字符串，输出最长公共子串。输入描述 Input Description 输入N再输入N个字符串输出描述 Output Description 输出最大公共子串。样例输入 Sample Input 3 abce cabk jaab样例输出 Sample Output ab简单KMP#include<cstdio> #incl
Codevs_P2825 危险的组合(DP)
BeiYu
12-19 1341
时间限制: 1 s 空间限制: 64000 KB 题目等级 : 钻石 Diamond 题目描述 Description 有一些装有铀(用U表示)和铅(用L表示)的盒子，数量均足够多。要求把N个盒子放成一行，但至少有3个U放在一起，有多少种方法？输入描述 Input Description 包含一个整数N输出描述 Output Description 输出一个整数表示方法数。样例输入 Sa
Codevs_P1021 玛丽卡(Dijkstra)
BeiYu
12-13 1134
时间限制: 2 s 空间限制: 128000 KB 题目等级 : 大师 Master题目描述 Description 麦克找了个新女朋友，玛丽卡对他非常恼火并伺机报复。因为她和他们不住在同一个城市，因此她开始准备她的长途旅行。在这个国家中每两个城市之间最多只有一条路相通，并且我们知道从一个城市到另一个城市路上所需花费的时间。麦克在车中无意中听到有一条路正在维修，并且那儿正堵车，但没听清楚到底是
最大流问题详解与Dinic算法
本资源详细介绍了最大流问题的基本概念、算法和解题策略，包括Dinic算法和最小费用最大流的解决方法。" 最大流问题是一个在计算机科学和运筹学中常见的网络优化问题，它涉及到在一个带权的有向图中，确定从单一源点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值