[二分图博弈] BZOJ 1443 [JSOI2009]游戏Game & BZOJ 2437 [Noi2011]兔兔与蛋蛋

最新推荐文章于 2019-02-22 21:41:16 发布
最新推荐文章于 2019-02-22 21:41:16 发布
阅读量426 收藏
点赞数
分类专栏： 二分图 博弈论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014609452/article/details/59683643
版权

二分图博弈

考虑这样一类博弈问题

  • 博弈状态可分为两类 即状态空间可分为两个集合 对应二分图X集和Y集
  • 任意合法的决策使状态从一类跳转到另一类 可以用二分图描述
  • 不可以转移至已访问的状态
  • 无法转移者判负。

问题转化从二分图指定起点开始轮流沿着边移动 不可重复访问点 无法移动判负。

不妨设起点 s∈X 考虑该二分图的某个最大匹配

  • 若 s 不属于某个最大匹配 则先手所转移到的点y∈Y一定属于最大匹配 后手沿着最大匹配的边走即可 后手不可能无路可走 因为这样对应着找到一条增广链 这与最大匹配矛盾 后手必胜
  • 若任意最大匹配都包含 s 则先手沿着最大匹配的边走即可 因为s必属于最大匹配 所以不存在长度为偶数的链 先手必胜

所以

若起点 s <script type="math/tex" id="MathJax-Element-50">s</script>是二分图最大匹配必配点 那么先手必胜 否则后手必胜

1443

很裸的二分图博弈
我们用最大流求出任意最大匹配
再用找弱增广链（长为偶数的链）的方法求出最大匹配必配点即可

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
inline void read(char *s){
  char c=nc(); int len=0;
  for (;!(c=='.' || c=='#');c=nc());
  for (;c=='.' || c=='#';s[++len]=c,c=nc()); 
}

#define U G[p].u
#define V G[p].v
const int N=10005;
namespace DINIC{
  struct edge{
    int u,v,f,next;
  }G[N<<4];
  int head[N],inum=1;
  inline void add(int u,int v,int f,int p){
    G[p].u=u; G[p].v=v; G[p].f=f; G[p].next=head[u]; head[u]=p;
  }
  inline void link(int u,int v,int f){
    add(u,v,f,++inum); add(v,u,0,++inum);
  }
  int S,T;
  int Q[N],l,r;
  int dis[N];
  inline bool bfs(){
    for (int i=1;i<=T;i++) dis[i]=-1;
    l=r=-1; Q[++r]=S; dis[S]=0;
    while (l<r){
      int u=Q[++l];
      for (int p=head[u];p;p=G[p].next)
    if (G[p].f && dis[V]==-1){
      dis[V]=dis[u]+1; Q[++r]=V;
      if (V==T) return 1;
    }
    }
    return 0;            
  }
  int cur[N];
  inline int dfs(int u,int flow){
    if (u==T) return flow;
    int used=0;
    for (int p=cur[u];p;p=G[p].next){
      cur[u]=p;
      if (G[p].f && dis[V]==dis[u]+1){
    int d=dfs(V,min(flow-used,G[p].f));
    G[p].f-=d; G[p^1].f+=d;
    used+=d; if (used==flow) break;
      }
    }
    if (used==0) dis[u]=-1;
    return used;
  }
  inline void Dinic(){
    while (bfs())
      memcpy(cur,head,sizeof(head)),dfs(S,1<<30);
  }
}

const int dx[]={0,0,1,-1};
const int dy[]={1,-1,0,0};
int n,m;
#define P(x,y) (((x)-1)*m+y)
char Map[105][105];
int left[N],right[N];

inline void Build(){
  using namespace DINIC;
  int sx,sy; S=n*m+1; T=n*m+2;
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if ((i+j)&1){
    if (Map[i][j]=='#') continue;
    for (int k=0;k<4;k++){
      sx=i+dx[k],sy=j+dy[k];
      if (sx<1 || sy<1 || sx>n || sy>m || Map[sx][sy]=='#') continue;
      link(P(i,j),P(sx,sy),1);
    }
    link(S,P(i,j),1);
      }else
    link(P(i,j),T,1);
  Dinic();
  for (int p=2;p<=inum;p+=2)
    if (U!=S && V!=T && !G[p].f){
      left[V]=U,right[U]=V;
    }
}

struct edge{
  int u,v,next;
}G[N<<2];
int head[N],inum;
inline void add(int u,int v,int p){
  G[p].u=u; G[p].v=v; G[p].next=head[u]; head[u]=p;
}

int vst[N];
inline void dfs(int u){
  if (vst[u]) return;
  vst[u]=1;
  for (int p=head[u];p;p=G[p].next)
    dfs(V);
}

typedef pair<int,int> abcd;
int pnt;
abcd ans[N];

int main(){
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<=n;i++) read(Map[i]);
  Build();int sx,sy;
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if ((i+j)&1){
    if (Map[i][j]=='#') continue;
    for (int k=0;k<4;k++){
      sx=i+dx[k],sy=j+dy[k];
      if (sx<1 || sy<1 || sx>n || sy>m || Map[sx][sy]=='#') continue;
      if (right[P(i,j)]==P(sx,sy))
        add(P(sx,sy),P(i,j),++inum);
      else
        add(P(i,j),P(sx,sy),++inum);
    }
      }
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if (((i+j)&1) && !right[P(i,j)])
    dfs(P(i,j));
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if (((i+j)&1) && vst[P(i,j)] && Map[i][j]!='#')
    ans[++pnt]=abcd(i,j);
  cl(head); inum=0; cl(vst);
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if (~(i+j)&1){
    if (Map[i][j]=='#') continue;
    for (int k=0;k<4;k++){
      sx=i+dx[k],sy=j+dy[k];
      if (sx<1 || sy<1 || sx>n || sy>m || Map[sx][sy]=='#') continue;
      if (left[P(i,j)]==P(sx,sy))
        add(P(sx,sy),P(i,j),++inum);
      else
        add(P(i,j),P(sx,sy),++inum);
    }
      }
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if ((~(i+j)&1) && !left[P(i,j)])
    dfs(P(i,j));
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if ((~(i+j)&1) && vst[P(i,j)] && Map[i][j]!='#')
    ans[++pnt]=abcd(i,j);
  sort(ans+1,ans+pnt+1);
  if (pnt==0)
    printf("LOSE\n");
  else{
    printf("WIN\n");
    for (int i=1;i<=pnt;i++)
      printf("%d %d\n",ans[i].first,ans[i].second);
  }
  return 0;
}

2437

首先空格的移动不可能出现环
因为先手是白方 我们把空格当作黑格
那么空格的移动 对应一条黑白相间的简单路径
我们只要建出二分图 判断这一路径是否唯一即可
因为这道题多次询问 需要删点操作 所以不能直接处理出必配点
只要每次删点后再增广一遍 看看最大匹配是否减小就能知道是否是先手必胜

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define cl(x) memset(x,0,sizeof(x))
using namespace std;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline void read(int &x){
  char c=nc(),b=1;
  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;
  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;
}
inline void read(char *s){
  char c=nc(); int len=0;
  for (;!(c=='O' || c=='X' || c=='.');c=nc());
  for (;c=='O' || c=='X' || c=='.';s[++len]=c,c=nc()); 
}

#define U G[p].u
#define V G[p].v

const int N=1605;
const int dx[]={0,0,1,-1};
const int dy[]={1,-1,0,0};

int n,m;
#define P(x,y) (((x)-1)*m+y)
char Map[105][105];
int left[N],right[N];

struct edge{
  int u,v,next;
}G[N<<2];
int head[N],inum;
inline void add(int u,int v,int p){
  G[p].u=u; G[p].v=v; G[p].next=head[u]; head[u]=p;
}
inline void link(int u,int v){
  add(u,v,++inum),add(v,u,++inum);
}

int vst[N],del[N],boy[N];
inline bool dfs(int u){
  for (int p=head[u];p;p=G[p].next)
    if (!vst[V] && !del[V]){
      vst[V]=1;
      if (!boy[V] || dfs(boy[V]))
    return boy[V]=u,boy[u]=V,1;
    }
  return 0;
}

inline void Build(){
  int sx,sy;
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if ((i+j)&1)
    for (int k=0;k<4;k++){
      sx=i+dx[k],sy=j+dy[k];
      if (sx<1 || sy<1 || sx>n || sy>m) continue;
      if (Map[sx][sy]!=Map[i][j])
        link(P(i,j),P(sx,sy));
    }
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if (!boy[P(i,j)]){
    cl(vst);
    dfs(P(i,j));
      }
}

inline bool Jud(int x,int y){
  int u=P(x,y);
  del[u]=1;
  if (boy[u]){
    int tmp=boy[u];
    boy[u]=boy[tmp]=0;
    cl(vst);
    return !dfs(tmp);
  }else
    return 0;
}

int pnt,ans[N];

int main(){
  int Q,nx,ny,_x,_y;
  freopen("t.in","r",stdin);
  freopen("t.out","w",stdout);
  read(n); read(m);
  for (int i=1;i<=n;i++) read(Map[i]);
  for (int i=1;i<=n;i++)
    for (int j=1;j<=m;j++)
      if (Map[i][j]=='.') Map[i][j]='X',nx=i,ny=j;
  Build();
  read(Q);
  for (int i=1;i<=Q;i++){
    read(_x); read(_y);
    int t1=Jud(nx,ny),t2=Jud(_x,_y);
    if (t1 && t2)
      ans[++pnt]=i;
    read(nx); read(ny);
  }
  printf("%d\n",pnt);
  for (int i=1;i<=pnt;i++)
    printf("%d\n",ans[i]);
  return 0;
}
里阿奴摩西
关注
专栏目录
bzoj 1443: [JSOI2009]游戏Game 二分图博弈
beginend
02-22 594
题意给出一个n*m的地图，有的格子不能走。先手可以选择某个格子开始，然后到后手走，再到先手走。每个格子只能走一次，不能走的那方算输。问对于哪些格子，先手有必胜策略。 n,m<=100分析首先考虑黑白染色，那么这就变成了一个二分图，然后求出这个二分图的最大匹配。 假设先手选择了一个非匹配点，那么后手就只能走匹配点，然后先手沿着匹配走。若某一次后手走到了一个非匹配点，那么就出现了一条增广路，与最大匹
NOI模拟（5.19） JSOID2T2 扫地机器人 （bzoj5318）
scarlyw的博客
05-22 489
结论 + DP
【博弈+二分图匹配】[NOI2011]兔兔与蛋蛋游戏
weixin_30951231的博客
07-12 186
题目描述 Description Input输入的第一行包含两个正整数 n、m。 接下来 n行描述初始棋盘。其中第i 行包含 m个字符，每个字符都是大写英文字母"X"、大写英文字母"O"或点号"."之一，分别表示对应的棋盘格中有黑色棋子、有白色棋子和没有棋子。其中点号"."恰好出现一次。 接下来一行包含一个整数 k（1≤k≤1000） ，表示兔兔和蛋蛋各进行了k次操...
bzoj2437 [Noi2011]兔兔与蛋蛋
MustImproved的博客
09-08 672
题解：我们将棋盘分成黑白格子（相邻格子颜色不同），将空格染成黑色，那么我们可以知道X为合法棋子当且仅当X在黑色格子，而O为合法棋子当且仅当O在白色格子。 相邻合法棋子(空格也为合法)连边，则我们得到无向图，而它也是二部图，当空格一定是在最大匹配中时，则先手必胜；否则先手必败。若不一定在，则空格可能在偶数条交错路，或者有点可以代替空格（此时空格可不在最大匹配中），那么此时后手总有办法走到先手所在的
BZOJ2437: [Noi2011]兔兔与蛋蛋
L_0_Forever_LF的专栏
09-12 420
1443的强化版，黑白染色后，节点颜色若和染色不同，因为永远不会到达，可以视为障碍，每次移动空格到一个位置，那个位置的颜色交换到空格处，也变成障碍，所以可视为不能重复经过一点，判断每次操作前是不是必胜态只需判所处的点是否是必经点#include<set> #include<map> #include<deque> #include<queue> #include<stack> #include<cm
【BZOJ2437】【NOI2011】兔兔与蛋蛋
cz_xuyixuan的博客
04-19 327
【题目链接】点击打开链接【思路要点】补档博客，无题解。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; #define MAXN 45 #define MAXK 1005 #define MAXP 1605 #define INF 1e9 struct edge {int dest, flow; unsigned pos; }; vect...
BZOJ 题目整理
喵~
08-31 2342
现在要写一些题目。 现在已经做了：157题
蒟蒻的做题录(时间)
aoanping0730的博客
10-07 1104
总计：672道 [SCOI2016]萌萌哒 [HAOI2018]苹果树 [CTSC2008]网络管理 [HNOI/AHOI2018]转盘 [HAOI2015]树上染色 [CTSC2017]吉夫特 [CTSC2011]幸福路径 [TJOI2015]组合数学 [CTSC2008]祭祀 [APIO2007]风铃 [APIO2011]方格染色 [APIO2016]烟火...
网络流专题——基本模型与技巧
LittlePrincess Pick room
02-26 597
该博客整理网络流的常见模型，不建议初学者食用 感谢：本文例题即部分解释来自THU 胡泽聪授课pdf 流量表示变迁 eg1 给定一张的无向图，每条边有长度。点i处有ai头牛，以及一个能容纳bi头 牛的牛棚。牛可以沿边移动，每条边上可以同时有任意头牛经过。一头牛经过 一条边所需时间即为道路长度。 给出一个将牛分配到牛棚的方案，并最小化所需移动时间T。 hint：我们发现这是一个最小...
做题记录
slongle的专栏
06-21 2113
6.158 数学 [Beijing wc2012]算不出的算式 动态规划 三角形牧场 线性筛 素数个数 最短路 [Usaco2004 Nov]Til the Cows Come Home 带奶牛回家 最短路 [Usaco2007 Feb]Cow Party奶牛派对 DP [RQNOJ 3822]选择题 数学 [TYVJ 1020]寻找质因数 模拟 [NOIP 2013]花匠
bzoj 2437 [Noi2011]兔兔与蛋蛋 [二分图匹配]
Shion的专栏
06-03 1734
描述这些天，兔兔和蛋蛋喜欢上了一种新的棋类游戏。 这个游戏是在一个 n 行 m 列的棋盘上进行的。游戏开始之前，棋盘上有一 个格子是空的，其它的格子中都放置了一枚棋子，棋子或者是黑色，或者是白色。 每一局游戏总是兔兔先操作，之后双方轮流操作，具体操作为： 兔兔每次操作时，选择一枚与空格相邻的白色棋子，将它移进空格。 蛋蛋每次操作时，选择一枚与空格相邻的黑色棋子，将它移进空格。 第一个不能按照规则操作
[BZOJ 2437][NOI 2011]兔兔与蛋蛋(二分图匹配)
某沙茶的OI代码库
04-29 1971
题目链接http://www.lydsy.com/JudgeOnline/problem.php?id=2437思路很容易发现整个游戏过程就是两个人依次移动棋盘上的唯一的那个空格。对整个棋盘进行黑白染色，假设空格是黑色格子(如下图中的被蓝色框出的’X’格子)，并把空格看作’X’棋子，可以发现空格的移动轨迹是由黑格子上的’X’、白格子上的’O’交错的，如下图 我们定义黑白染色后，起点空格为黑格子
[BZOJ]2437 [NOI2011] 兔兔与蛋蛋 二分图博弈
Le Petit Prince
09-22 395
2437: [Noi2011]兔兔与蛋蛋 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 771  Solved: 493 [Submit][Status][Discuss] Description Input 输入的第一行包含两个正整数 n、m。  接下来 n行描述初始棋盘。其中第i 行包含 m个字符，每个字符都是大
bzoj2437: [Noi2011]兔兔与蛋蛋 二分图博弈
Twin Automata的博客
12-25 342
题目链接：戳这里 2437: [Noi2011]兔兔与蛋蛋 Time Limit: 10 Sec  Memory Limit: 128 MB Submit: 788  Solved: 500 [Submit][Status][Discuss] Description Input 输入的第一行包含两个正整数 n、m。  接下来 n行描述初始棋盘。其中第i 行包
[BZOJ2437]-[Noi2011]兔兔与蛋蛋-博弈+二分图必匹配点
泉華子的OI足迹
06-10 414
说在前面 终于把这个史前巨坑填了emmmm 题目 BZOJ24373传送门 看题可进传送门 解法 首先是个网格图 根据我们做 BZOJ1443 以及 BZOJ2463 的经验 我们把相邻的 黑白棋子 连边，然后跑一个最大匹配 （对于兔兔）可以发现，如果空格旁边有一个非匹配白棋子，那么挪动这个棋子之后，蛋蛋只能寻找非匹配边，然后挪动一个黑棋子。由于是最大匹配，这个黑棋子...
bzoj1443
weixin_33913377的博客
07-06 128
首先要思考的问题肯定是，什么点可以是ans， 不难想到对图黑白染色，假如一个棋子不管怎么走，都只能走到和它同色的点上时，这就是一个ans 再考虑，每次棋子的移动都是黑白相间的 再考虑，黑白染色是可以构成一个二分图的 不难想到，二分图上的增广路。 于是第一问就很好解决，我们构建二分图做最大匹配， 如果所有的黑点和白点都匹配了，那么一定不存在，否则一定存在。 为什么呢？ 我们知道，如果...
bzoj1443 [JSOI2009]游戏Game
aida9573的博客
01-25 85
二分图上的博弈游戏。 我们把二分图上的点分成两类，一类是一定在最大匹配中的，一类是不一定在里面的。 如果我把棋子放到了必经点上，那么对手就可以一直走匹配边，我只能在找非匹配边，因为最大匹配没有增广路，所以我必输 那么反过来，我把棋子放到了非必经点上，我们可以发现对手无论怎么走，走到的都是必经点上，我就可以像上面他玩我一样玩他。 所以我们把棋子放到非必经点上必胜，否则必败 这是为...
BZOJ1443 DINIC
Gipsy
02-22 176
水 #include&lt;bits/stdc++.h&gt; using namespace std; const int N=2e4+10,M=2e4+10,inf=1&lt;&lt;30; int ans,A[N],B[N]; struct DINIC{ int Next[M],d[N],head[N],ver[M],edge[M],tot,S,T; queue&lt;i...
【BZOJ1443】游戏（二分图匹配，博弈论）
weixin_30695195的博客
06-30 106
【BZOJ1443】游戏（二分图匹配，博弈论） 题面 BZOJ 题解 很明显的二分图博弈问题。 发现每次移动一定是从一个黑点到达一个白点，或者反过来。 所以可以对于棋盘进行染色然后连边。 考虑一下必胜策略。 如果选择从一个匹配点开始走， 另外一个人沿着匹配点走，那么就输了，因为匹配点不一定有出边了。 如果选择从一个非匹配点开始走， 另外一个人无论怎么走都只能走到一个匹配点（或者无路可走） 如果另外...
平面图与对偶图关系深度解析：最大最小定理竞赛应用实例
平面图G与它的对偶图G*之间存在密切联系，具体表现为： 1. **面数与点数**：G的面数（即内部区域的数量）等于G*的点数，而G*的点数则等于G的面数。这体现了两者结构上的相互转换。 2. **边数**：G与G*的边数相同，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值