BZOJ3519: [Zjoi2014]消棋子

最新推荐文章于 2020-09-26 21:29:57 发布
最新推荐文章于 2020-09-26 21:29:57 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： BZOJ 文章标签： C++ zjoi2014 bzoj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Array98/article/details/44346621
版权

【题目描述】
消棋子是一个有趣的游戏。游戏在一个r * c的棋盘上进行。棋盘的每个格子，要么是空，要么是一种颜色的棋子。同一种颜色的棋子恰好有两个。每一轮，玩家可以选择一个空格子(x, y)，并选择上下左右四个方向中的两个方向，如果在这两个方向上均存在有棋子的格子，而且沿着这两个方向上第一个遇到的棋子颜色相同，那么，我们将这两个棋子拿走，并称之为合法的操作。否则称这个操作不合法，游戏不会处理这个操作。游戏的目的是消除尽量多的棋子。
给出这样一个游戏和一个人的玩法。你需要：
z 指出此人能消去多少棋子。
z 给出一种能消去最多棋子的方案。

【输入格式】
在输入文件eliminate.in中，第一行给出了整数r, c。第二行给出了整数n，表示不同颜色数。接下来n行，第i行含4个整数a[i], b[i], c[i], d[i]，表示颜色

为i的两个格子分别是(a[i], b[i]), (c[i], d[i])。然后是一个整数m，表示此人的操作数。接下来m行，每行有2个整数和2个字母，代表了他选择的格子，以及两个方向。我们用“UDLR”分别表示上下左右。

【输出格式】
在输出文件eliminate.out中，第一行输出此人能消去多少棋子。第二行含一个整数k(0 ≤k ≤10^6)，表示你给出的方案的操作数。接下来k行，每行2个整数和2个字母，代表你选择的格子以及两个方向。

【样例输入】
4 4
4
1 1 1 4
1 2 3 4
1 3 3 2
4 1 2 3

6
2 3 U R
2 1 D R
2 2 L R
2 4 L D
3 1 L R
3 3 L U

【分析】
其实并不是特别难，也没有传说中的那么烦。
具体思路大概就是开两个Set维护行列相邻的状况，基于STL的二分查找。
第一问直接模拟就行了。
第二问大概也就是模拟= =，先把可以消掉的棋子先消掉，由于这可能影响到所在行所在列的其它棋子，所以我们要维护一个队列，每当有棋子被消掉就把他们加到队列里去。

当时我敲烦起来了，而且机房就要关门了TAT
于是就没有考虑效率直接暴力判断各个方向，具体实现就是在Set里查找当前结点（从队首取出来的）两个方向一共六种的棋子编号是否相同，相同就从Set里删除，入队。

这里是一个小例子和小BUG。

讲比较难讲清楚，这里是代码，比较偷懒直接复制粘贴了所以写的有些长= =
然后就是说还有个比较大的BUG……STL_Set不开-O2要超时……感谢BZOJ！

/**************************************************************
    Problem: 3519
    User: Array98
    Language: C++
    Result: Accepted
    Time:5784 ms
    Memory:35740 kb
****************************************************************/

#include <cstdio>
#include <algorithm>
#include <queue>
#include <set>
#define mk(a,b) make_pair(a,b)
using namespace std;
typedef pair<int,int> Pii;
const int MaxN=100010;
set <Pii> Line[MaxN],Row[MaxN];
Pii A1[MaxN],B1[MaxN],C1[MaxN],D1[MaxN];
const Pii NUL=mk(0,0);
int R,C,N,Ans=0;
int Delete[MaxN];
queue <int> Q;
struct Node { int X,Y; char D1,D2; } S[100010];

void Init()
{
    int a,b,c,d;
    scanf("%d%d",&R,&C);
    scanf("%d",&N);
    for (int i=1; i<=N; i++)
    {
        scanf("%d%d%d%d",&a,&b,&c,&d);
        A1[i].first=a;B1[i].first=b;C1[i].first=c;D1[i].first=d;
        A1[i].second= B1[i].second= C1[i].second= D1[i].second=i;
    }
}

void Clear()
{
    for (int i=0; i<=R; i++) { Line[i].clear(); Line[i].insert(mk(0,0)); Line[i].insert((mk(MaxN,0)));}
    for (int i=0; i<=C; i++) { Row[i].clear();  Row[i].insert(mk(0,0));  Row[i].insert((mk(MaxN,0)));}
    for (int i=1; i<=N; i++) 
    {
        Line[A1[i].first].insert(B1[i]);
        Line[C1[i].first].insert(D1[i]);
        Row[B1[i].first].insert(A1[i]);
        Row[D1[i].first].insert(C1[i]);
    }
}

void Solve_ZZY()
{
    Clear();
    int M,X,Y,Ans=0; char D_X,D_Y; Pii Find1,Find2;
    set<Pii>::iterator It;
    scanf("%d",&M);
    for (int i=0; i<M; i++)
    {

        int flag1=0,flag2=0;
        scanf("%d %d %c %c\n",&X,&Y,&D_X,&D_Y);
        Find1=*Line[X].lower_bound(mk(Y,0));
        if (Find1.first==Y) continue;
        Find1=Find2=NUL;
        if (D_X=='U') { Find1=*(--Row[Y].lower_bound(mk(X,0)));   flag1=(Find1.second==0)?0:1;}
        if (D_X=='D') { Find1=*(Row[Y].upper_bound(mk(X,MaxN)));  flag1=(Find1.second==0)?0:1;}
        if (D_X=='L') { Find1=*(--Line[X].lower_bound(mk(Y,0)));  flag1=(Find1.second==0)?0:2;}
        if (D_X=='R') { Find1=*(Line[X].upper_bound(mk(Y,MaxN))); flag1=(Find1.second==0)?0:2;}

        if (D_Y=='U') { Find2=*(--Row[Y].lower_bound(mk(X,0)));   flag2=(Find2.second==0)?0:1;}
        if (D_Y=='D') { Find2=*(Row[Y].upper_bound(mk(X,MaxN)));  flag2=(Find2.second==0)?0:1;}
        if (D_Y=='L') { Find2=*(--Line[X].lower_bound(mk(Y,0)));  flag2=(Find2.second==0)?0:2;}
        if (D_Y=='R') { Find2=*(Line[X].upper_bound(mk(Y,MaxN))); flag2=(Find2.second==0)?0:2;}     

        if (flag1 && flag2 && Find1.second==Find2.second)
        {
            Ans+=1;
            if (flag1==1) { Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second)); }
            if (flag1==2) { Line[X].erase(Find1); Row[Find1.first].erase(mk(X,Find1.second));  }
            if (flag2==1) { Row[Y].erase(Find2);  Line[Find2.first].erase(mk(Y,Find2.second)); }
            if (flag2==2) { Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second));  }
        }
    }
    printf("%d ",Ans);  
}

inline void Print(int X, int Y, char D1, char D2) { S[Ans]=(Node){X,Y,D1,D2}; }

inline void Recheck(int X, int Y, int Id)
{
    Pii Find1,Find2;
    Find1=*Line[X].lower_bound(mk(Y,0));
    if (Find1.first==Y) return;

    //UD
    Find1=*(--Row[Y].lower_bound(mk(X,0))); 
    Find2=*(Row[Y].upper_bound(mk(X,MaxN)));
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Delete[Id]=1; Ans++; Q.push(Id); Print(X,Y,'U','D');
        Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second));
        Row[Y].erase(Find2);  Line[Find2.first].erase(mk(Y,Find2.second));
        return;
    }

    //LR
    Find1=*(--Line[X].lower_bound(mk(Y,0)));
    Find2=*(Line[X].upper_bound(mk(Y,MaxN)));
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Delete[Id]=1; Ans++; Q.push(Id); Print(X,Y,'L','R');
        Line[X].erase(Find1); Row[Find1.first].erase(mk(X,Find1.second)); 
        Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second)); 
        return;
    }

    //UR
    Find1=*(--Row[Y].lower_bound(mk(X,0))); 
    Find2=*(Line[X].upper_bound(mk(Y,MaxN)));
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Delete[Id]=1; Ans++; Q.push(Id); Print(X,Y,'U','R');
        Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second));
        Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second));
        return;
    }

    //UL
    Find1=*(--Row[Y].lower_bound(mk(X,0))); 
    Find2=*(--Line[X].lower_bound(mk(Y,0)));
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Delete[Id]=1; Ans++; Q.push(Id); Print(X,Y,'U','L');
        Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second));
        Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second));
        return;
    }

    //DR
    Find1=*(Row[Y].upper_bound(mk(X,MaxN))); 
    Find2=*(Line[X].upper_bound(mk(Y,MaxN)));
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Q.push(Id); Delete[Id]=1; Ans++; Print(X,Y,'D','R');
        Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second));
        Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second));
        return;
    }

    //DL
    Find1=*(Row[Y].upper_bound(mk(X,MaxN)));
    Find2=*(--Line[X].lower_bound(mk(Y,0))); 
    if (Find1.second && Find1.second==Id && Find1.second==Find2.second  && !Delete[Id])
    {
        Delete[Id]=1; Ans++; Q.push(Id); Print(X,Y,'D','L');
        Row[Y].erase(Find1);  Line[Find1.first].erase(mk(Y,Find1.second)); 
        Line[X].erase(Find2); Row[Find2.first].erase(mk(X,Find2.second));
        return;
    }
}

inline void GotoCheck(int Id)
{
    int X1=A1[Id].first,Y1=B1[Id].first,X2=C1[Id].first,Y2=D1[Id].first;
    if (X1==X2) { Recheck(X1,(Y1+Y2)/2,Id); return; }
    if (Y1==Y2) { Recheck((X1+X2)/2,Y1,Id); return; }
    Recheck(X1,Y2,Id);
    Recheck(X2,Y1,Id);
}

inline void Check(int X, int Y)
{
    Pii Find;   
    Find=*(--Row[Y].lower_bound(mk(X,0)));  if (Find.second) GotoCheck(Find.second);
    Find=*(Row[Y].upper_bound(mk(X,MaxN))); if (Find.second) GotoCheck(Find.second);
    Find=*(--Line[X].lower_bound(mk(Y,0))); if (Find.second) GotoCheck(Find.second); 
    Find=*(Line[X].upper_bound(mk(Y,MaxN)));if (Find.second) GotoCheck(Find.second); 
}

inline void Get_Start()
{
    for (int i=1; i<=N; i++)
    {
        int X1=A1[i].first,Y1=B1[i].first,X2=C1[i].first,Y2=D1[i].first;
        if (X1==X2) { Recheck(X1,(Y1+Y2)/2,i); continue; }
        if (Y1==Y2) { Recheck((X1+X2)/2,Y1,i); continue; }
        Recheck(X1,Y2,i);
        Recheck(X2,Y1,i);
    }
}

void Solve_YPC()
{   
    Clear();
    Get_Start();
    while(!Q.empty())
    {
        int i=Q.front(); Q.pop();
        int X1=A1[i].first,Y1=B1[i].first,X2=C1[i].first,Y2=D1[i].first;
        Check(X1,Y1);
        Check(X2,Y2);
    }
    printf("%d\n",Ans);
    for (int i=1; i<=Ans; i++) printf("%d %d %c %c\n",S[i].X,S[i].Y,S[i].D1,S[i].D2);
}

int main()
{
    Init();
    Solve_ZZY();
    Solve_YPC();
    return 0;
}

谢郭嘉！

Array98
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ JOI 2013~2014 春季training合宿 系列题解1
08-04
BZOJ JOI 2013~2014 春季training合宿 系列题解1 本文主要讲述哈希算法在OJ系统中的应用，通过对BZOJ JOI 2013~2014 春季training合宿 系列题解1的分析，来阐述哈希算法的原理和实现。 首先，我们来看一下哈希算法...
CSP 201512-2 消除类游戏（C++）
qq_45405490的博客
09-10 219
#include<bits/stdc++.h> using namespace std; int main() { int n,m; cin>>n>>m; int old_square[n][m]; int new_square[n][m]; for(int i=0; i<n; i++) { for(int j=0; j<m; j++) { cin&gt
bzoj 3519: [Zjoi2014] 消棋子 题解
aofan9566的博客
12-28 162
【序言】在大家怀疑的眼光下，我做了一个中午和半个下午、调了一个晚上的题目总算A了！ 【原题】 消棋子是一个有趣的游戏。游戏在一个r * c的棋盘上进行。棋盘的每一个格 子。要么是空，要么是一种颜色的棋子。同一种颜色的棋子恰好有两个。每一轮， 玩家能够选择一个空格子(x, y)，并选择上下左右四个方向中的两个方向，假设 在这两个方向上均存在有棋子的格子，并且沿着这两个方向...
【ZJOI2014】【BZOJ3519】消棋子
CaptainChen的博客
03-25 567
题目大意：消棋子是一个有趣的游戏。游戏在一个r∗c r * c 的棋盘上进行。棋盘的每个格 子，要么是空，要么是一种颜色的棋子。同一种颜色的棋子恰好有两个。每一轮， 玩家可以选择一个空格子(x,y)(x, y)，并选择上下左右四个方向中的两个方向，如果 在这两个方向上均存在有棋子的格子，而且沿着这两个方向上第一个遇到的棋子 颜色相同，那么，我们将这两个棋子拿走，并称之为合法的操作。否则称这个操 作不
【模拟】ZJOI2014&BZOJ3519消棋子
氧化钠的博客
03-25 478
传送门 注： 图的方向要注意！如果你把方向看反了，样例仍然可以过（然而几乎所有测试数据都过不了）。 样例图例如下： 题目中给出，每种颜色只有2个，而且最多有100000种颜色。 那么很容易想到暴力算法。 用set分每行每列储存所有的点： 如一点坐标为(x,y) 那么就在y列插入x，同时在x行插入y 这样就可以通过迭代器，快速找到某个点每行每列相邻的的点。对于1问，主要通过set的l
BZOJ_problem_rank:BZOJ问题等级按交流比排序
05-25
#BZOJ Problem Rankrank.cpp 程序文件data.dat bzoj题库数据done.dat AC过的题，初始可以把所有A过的题粘进去，正常退出的话自动维护。black.dat 黑名单。选题时会跳过。错题、神题、没题面、不想做等等。//Thank ...
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
[BZOJ3519][Zjoi2014][模拟]消棋子
CE玩家
02-01 609
巨烦的模拟。 差不多算是第一次用set，发现set是个好东西。对于第一个询问，用set记录每行每列放棋子的情况，那么对于这个人的每次操作，直接在set上模拟就好了 第二问贪心，每次把能消掉的棋子消掉就可以了。代码长，思路乱，还跑得慢……#include <cstdio> #include <iostream> #include <algorithm> #include <set> #define
C++ CCF真题----消除类游戏
程序猿的养成
12-21 7726
问题描述　　消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。 　　请注意：一个棋子可能在某一行和某一列同时被
消除类游戏（C++）
LG.田猿的博客
01-25 2005
消除类游戏 【问题描述】消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。 　　请注意：一个棋子可能在某一行和某...
2015-12-2消除类游戏
weixin_43922093的博客
09-26 373
问题描述 　　消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。 　　请注意：一个棋子可能在某一行和某一列同时被消除。 输入格式 　　输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。 　　接下来n行.
BZOJ3619 : [Zjoi2014]璀灿光华
weixin_33895604的博客
10-13 92
终于把省选时的遗憾补上了… 对于构造立方体： 首先BFS构出底层，然后再逐层构造立方体 对于计算： $O(n^6)$爆搜即可。   #include&lt;cstdio&gt; #include&lt;cstring&gt; const int N=75,M=343010; char ch[N]; int n,m,i,j,k,tmp,q[M],t,l,r; int cnt...
CCF计算机软件能力认证试题练习：201512-2 消除类游戏
WINGREZ‘S BLOG
09-10 1999
消除类游戏 来源： 标签： 参考资料： 相似题目： 题目 消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 现在给你一个n行m列的棋盘，棋盘中的每一...
【ZJOI2014】【BZOJ3527】 力 (FFT)
დ♂Hany01's Blog Space♂ღ
11-28 316
Description给出序列{qi}\{q_i\}，求Ei=∑j<iqj(i−j)2−∑j>iqj(i−j)2E_i = \sum_{j<i}\frac{q_j}{(i-j)^2}-\sum_{j>i}\frac{q_j}{(i-j)^2}Solution考虑： 令t=n−it = n - i , pn−i=qip_{n - i} = q_i Ei=∑j=1i−1qjgi−j−∑j=i+1nq
BZOJ2839:集合计数(容斥,组合数学)
最新发布
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合的个数，以此类推，直到加上包含所有特定元素的集合的个数。 对于一个大小为n的集合，其子集的个数为2^n。因此，所有集合的个数为2^n。现在我们考虑如何计算至少包含一个特定元素的集合的个数。我们可以将这个特定元素看作是一个元素，然后考虑其余n-1个元素组成的集合的个数，即2^(n-1)。因此，至少包含一个特定元素的集合的个数为2^(n-1)。同理，至少包含两个特定元素的集合的个数为C(2,n)*2^(n-2)，其中C(2,n)表示从n个元素中选取2个元素的组合数。 将以上结果代入容斥原理的公式中，即可得到最终的计数公式： sum((-1)^k*C(k,n)*2^(n-k),k=0,1,...,n) 其中，sum表示对k从0到n进行求和，C(k,n)表示从n个元素中选取k个元素的组合数，2^(n-k)表示剩余元素组成集合的个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值