ZOJ 3316 Game 一般图最大匹配带花树
2014-11-05 17:01
525 查看
一般图最大匹配带花树:
建图后,计算最大匹配数.
如果有一个联通块不是完美匹配,先手就可以走那个没被匹配到的点,后手不论怎么走,都必然走到一个被匹配的点上,先手就可以顺着这个交错路走下去,最后一定是后手没有路可走,因为如果还有路可走,这一条交错路,就是一个增广路,必然有更大的匹配.
Game
Time Limit: 1 Second Memory Limit: 32768 KB
Fire and Lam are addicted to the game of Go recently. Go is one of the oldest board games. It is rich in strategy despite its simple rules. The game is played by two players who alternately
place black and white stones on the vacant intersections of a grid of 19*19 lines. Once placed on the board, stones cannot be moved elsewhere, unless they are surrounded and captured by the opponent's stones. The object of the game is to control (surround)
a larger portion of the board than the opponent.
Fire thinks it is too easy for him to beat Lam. So he thinks out a new game to play on the board. There are some stones on the board, and we don't need to care about the stones' color
in this new game. Fire and Lam take turns to remove one of the stones still on the board. But the Manhattan distance between the removed stone and the opponent's last removed stone must not be greater than L. And the one who can't remove any stone
loses the game.
The Manhattan distance between (xi, yi) and (xj, yj) is |xi - xj| + |yi - yj|.
To show the performance of grace, Fire lets Lam play first. In the beginning of the game, Lam can choose to remove any stone on the board.
Fire and Lam are clever, so they both use the best strategy to play this game. Now, Fire wants to know whether he can make sure to win the game.
Input
There are multiple cases (no more than 30).
In each case, the first line is a positive integer n (n <= 361) which indicates the number of stones left on the board. Following are n lines, each contains
a pair of integers x andy (0 <= x, y <= 18), which indicate a stone's location. All pairs are distinct. The last line is an integer L (1 <= L <= 36).
There is a blank line between cases.
Ouput
If Fire can win the game, output "YES"; otherwise, just output "NO".
Sample Input
Sample Output
Author: LIN, Yue
Source: The 10th Zhejiang University Programming Contest
Submit Status
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=500;
/*******************************************/
struct Edge
{
int to,next;
}edge[maxn*maxn];
int Adj[maxn],Size;
void init()
{
memset(Adj,-1,sizeof(Adj)); Size=0;
}
void add_edge(int u,int v)
{
edge[Size].to=v; edge[Size].next=Adj[u]; Adj[u]=Size++;
}
/*******************************************/
int n;
int Match[maxn];
int Start,Finish,NewBase;
int Father[maxn],Base[maxn];
bool InQueue[maxn],InPath[maxn],InBlossom[maxn];
int Count;
queue<int> q;
int FindCommonAncestor(int u,int v)
{
memset(InPath,false,sizeof(InPath));
while(true)
{
u=Base[u];
InPath[u]=true;
if(u==Start) break;
u=Father[Match[u]];
}
while(true)
{
v=Base[v];
if(InPath[v]) break;
v=Father[Match[v]];
}
return v;
}
void ResetTrace(int u)
{
int v;
while(Base[u]!=NewBase)
{
v=Match[u];
InBlossom[Base[u]]=InBlossom[Base[v]]=true;
u=Father[v];
if(Base[u]!=NewBase) Father[u]=v;
}
}
void BlossomContract(int u,int v)
{
NewBase=FindCommonAncestor(u,v);
memset(InBlossom,false,sizeof(InBlossom));
ResetTrace(u); ResetTrace(v);
if(Base[u]!=NewBase) Father[u]=v;
if(Base[v]!=NewBase) Father[v]=u;
for(int tu=1;tu<=n;tu++)
{
if(InBlossom[Base[tu]])
{
Base[tu]=NewBase;
if(!InQueue[tu])
{
q.push(tu);
InQueue[tu]=true;
}
}
}
}
void FindAugmentingPath()
{
memset(InQueue,false,sizeof(InQueue));
memset(Father,0,sizeof(Father));
for(int i=1;i<=n;i++) Base[i]=i;
while(!q.empty()) q.pop();
q.push(Start); InQueue[Start]=true;
Finish=0;
while(!q.empty())
{
int u=q.front(); InQueue[u]=false;
q.pop();
for(int i=Adj[u];~i;i=edge[i].next)
{
int v=edge[i].to;
if(Base[u]!=Base[v]&&Match[u]!=v)
{
if(v==Start||(Match[v]>0&&Father[Match[v]]>0))
BlossomContract(u,v);
else if(Father[v]==0)
{
Father[v]=u;
if(Match[v]>0)
{
q.push(Match[v]);
InQueue[Match[v]]=true;
}
else
{
Finish=v;
return ;
}
}
}
}
}
}
void AugmentPath()
{
int u,v,w;
u=Finish;
while(u>0)
{
v=Father[u];
w=Match[v];
Match[v]=u;
Match[u]=v;
u=w;
}
}
void Edmonds()
{
memset(Match,0,sizeof(Match));
for(int u=1;u<=n;u++)
{
if(Match[u]==0)
{
Start=u;
FindAugmentingPath();
if(Finish>0) AugmentPath();
}
}
}
struct Point
{
int x,y,id;
}p[maxn];
int L;
int MHD(Point a,Point b)
{
return abs(a.x-b.x)+abs(a.y-b.y);
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
p[i]=(Point){x,y,i};
}
scanf("%d",&L);
init();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j) continue;
if(MHD(p[i],p[j])<=L)
{
add_edge(i,j);
add_edge(j,i);
}
}
}
Edmonds();
Count=0;
for(int i=1;i<=n;i++)
{
if(Match[i]) Count++;
else break;
}
//cout<<"--> "<<Count<<endl;
if(Count==n) puts("YES");
else puts("NO");
}
return 0;
}
建图后,计算最大匹配数.
如果有一个联通块不是完美匹配,先手就可以走那个没被匹配到的点,后手不论怎么走,都必然走到一个被匹配的点上,先手就可以顺着这个交错路走下去,最后一定是后手没有路可走,因为如果还有路可走,这一条交错路,就是一个增广路,必然有更大的匹配.
Game
Time Limit: 1 Second Memory Limit: 32768 KB
Fire and Lam are addicted to the game of Go recently. Go is one of the oldest board games. It is rich in strategy despite its simple rules. The game is played by two players who alternately
place black and white stones on the vacant intersections of a grid of 19*19 lines. Once placed on the board, stones cannot be moved elsewhere, unless they are surrounded and captured by the opponent's stones. The object of the game is to control (surround)
a larger portion of the board than the opponent.
Fire thinks it is too easy for him to beat Lam. So he thinks out a new game to play on the board. There are some stones on the board, and we don't need to care about the stones' color
in this new game. Fire and Lam take turns to remove one of the stones still on the board. But the Manhattan distance between the removed stone and the opponent's last removed stone must not be greater than L. And the one who can't remove any stone
loses the game.
The Manhattan distance between (xi, yi) and (xj, yj) is |xi - xj| + |yi - yj|.
To show the performance of grace, Fire lets Lam play first. In the beginning of the game, Lam can choose to remove any stone on the board.
Fire and Lam are clever, so they both use the best strategy to play this game. Now, Fire wants to know whether he can make sure to win the game.
Input
There are multiple cases (no more than 30).
In each case, the first line is a positive integer n (n <= 361) which indicates the number of stones left on the board. Following are n lines, each contains
a pair of integers x andy (0 <= x, y <= 18), which indicate a stone's location. All pairs are distinct. The last line is an integer L (1 <= L <= 36).
There is a blank line between cases.
Ouput
If Fire can win the game, output "YES"; otherwise, just output "NO".
Sample Input
2 0 2 2 0 2 2 0 2 2 0 4
Sample Output
NO YES
Author: LIN, Yue
Source: The 10th Zhejiang University Programming Contest
Submit Status
#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=500;
/*******************************************/
struct Edge
{
int to,next;
}edge[maxn*maxn];
int Adj[maxn],Size;
void init()
{
memset(Adj,-1,sizeof(Adj)); Size=0;
}
void add_edge(int u,int v)
{
edge[Size].to=v; edge[Size].next=Adj[u]; Adj[u]=Size++;
}
/*******************************************/
int n;
int Match[maxn];
int Start,Finish,NewBase;
int Father[maxn],Base[maxn];
bool InQueue[maxn],InPath[maxn],InBlossom[maxn];
int Count;
queue<int> q;
int FindCommonAncestor(int u,int v)
{
memset(InPath,false,sizeof(InPath));
while(true)
{
u=Base[u];
InPath[u]=true;
if(u==Start) break;
u=Father[Match[u]];
}
while(true)
{
v=Base[v];
if(InPath[v]) break;
v=Father[Match[v]];
}
return v;
}
void ResetTrace(int u)
{
int v;
while(Base[u]!=NewBase)
{
v=Match[u];
InBlossom[Base[u]]=InBlossom[Base[v]]=true;
u=Father[v];
if(Base[u]!=NewBase) Father[u]=v;
}
}
void BlossomContract(int u,int v)
{
NewBase=FindCommonAncestor(u,v);
memset(InBlossom,false,sizeof(InBlossom));
ResetTrace(u); ResetTrace(v);
if(Base[u]!=NewBase) Father[u]=v;
if(Base[v]!=NewBase) Father[v]=u;
for(int tu=1;tu<=n;tu++)
{
if(InBlossom[Base[tu]])
{
Base[tu]=NewBase;
if(!InQueue[tu])
{
q.push(tu);
InQueue[tu]=true;
}
}
}
}
void FindAugmentingPath()
{
memset(InQueue,false,sizeof(InQueue));
memset(Father,0,sizeof(Father));
for(int i=1;i<=n;i++) Base[i]=i;
while(!q.empty()) q.pop();
q.push(Start); InQueue[Start]=true;
Finish=0;
while(!q.empty())
{
int u=q.front(); InQueue[u]=false;
q.pop();
for(int i=Adj[u];~i;i=edge[i].next)
{
int v=edge[i].to;
if(Base[u]!=Base[v]&&Match[u]!=v)
{
if(v==Start||(Match[v]>0&&Father[Match[v]]>0))
BlossomContract(u,v);
else if(Father[v]==0)
{
Father[v]=u;
if(Match[v]>0)
{
q.push(Match[v]);
InQueue[Match[v]]=true;
}
else
{
Finish=v;
return ;
}
}
}
}
}
}
void AugmentPath()
{
int u,v,w;
u=Finish;
while(u>0)
{
v=Father[u];
w=Match[v];
Match[v]=u;
Match[u]=v;
u=w;
}
}
void Edmonds()
{
memset(Match,0,sizeof(Match));
for(int u=1;u<=n;u++)
{
if(Match[u]==0)
{
Start=u;
FindAugmentingPath();
if(Finish>0) AugmentPath();
}
}
}
struct Point
{
int x,y,id;
}p[maxn];
int L;
int MHD(Point a,Point b)
{
return abs(a.x-b.x)+abs(a.y-b.y);
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
p[i]=(Point){x,y,i};
}
scanf("%d",&L);
init();
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(i==j) continue;
if(MHD(p[i],p[j])<=L)
{
add_edge(i,j);
add_edge(j,i);
}
}
}
Edmonds();
Count=0;
for(int i=1;i<=n;i++)
{
if(Match[i]) Count++;
else break;
}
//cout<<"--> "<<Count<<endl;
if(Count==n) puts("YES");
else puts("NO");
}
return 0;
}
相关文章推荐
- ZOJ 3316 Game 一般图最大匹配带花树
- zoj 3316 Game 一般图最大匹配+博弈 有N个棋子在棋盘上,2个人轮流拿走一个棋子,第一步可以拿任意一个,而之后每一步必须拿上一步拿走的棋子曼哈顿长度L以内的棋子,问,后手是否能赢
- 带花树(一般图最大匹配)详解 ZOJ 3316
- zoj 3316 Game (一般图匹配带花树)
- ZOJ 3316 Game 一般图匹配
- HDU 3551 Hard Problem 一般图的最大匹配(带花树)
- 带花树算法 UOJ#79. 一般图最大匹配
- uoj#79. 一般图最大匹配【带花树模板】
- 一般图最大匹配-带花树-带注释模板
- UOJ 一般图的最大匹配(带花树算法模板)
- 【转】带花树(一般无向图的最大匹配)
- uoj79 一般图最大匹配&【带花树】初学
- 一般图最大匹配——带花树算法
- [转]带花树,Edmonds's matching algorithm,一般图最大匹配
- #79. 一般图最大匹配(带花树算法)
- 【UOJ#97】一般图最大匹配【带花树开花】
- 【UOJ #79】一般图最大匹配 带花树模板
- uoj #79. 一般图最大匹配 带花树算法
- poj 3020 一般图最大匹配 带花树开花算法
- [模板]带花树算法(一般图最大匹配)