【ZJOI2014】【BZOJ3519】消棋子

最新推荐文章于 2022-02-17 17:58:49 发布
最新推荐文章于 2022-02-17 17:58:49 发布
阅读量579 收藏
点赞数 1
分类专栏： OI题解 文章标签： set stl ZJOI BZOJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/can919/article/details/65935116
版权

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

题解：给每行每列开一个set，然后模拟。

代码极致恶心，（不要看我的代码，超长）

犯得错误：
1.set迭代器到处都要判断是否到begin或end；
2.check颜色是否可以连接有两种情况：有拐弯，在同一行或列；
……

#include<cstdio>
#include<set>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
const int MAXN=100005;
int R,C,N;
struct Point
{
    int x,y;
    Point(){}
    Point(int _x,int _y):x(_x),y(_y){}
    void Read(){scanf("%d%d",&x,&y);}
    bool operator < (Point t)const
    {return x<t.x||(x==t.x&&y<t.y);}
}P[MAXN][2];
struct ID
{
    int pri,c,i;
    ID(){}
    ID(int _p,int _c,int _i):pri(_p),c(_c),i(_i){}
    bool operator < (ID t)const
    {return pri<t.pri;}
};
set<ID> row[MAXN],col[MAXN];
map<Point,bool> has;
void Read()
{
    scanf("%d%d",&R,&C);
    scanf("%d",&N);
    for(int i=1;i<=N;i++)
        P[i][0].Read(),P[i][1].Read();
}
void Init()
{
    for(int i=1;i<=R;i++)row[i].clear();
    for(int i=1;i<=C;i++)col[i].clear();
    has.clear();
    for(int i=1;i<=N;i++)
    {
        has[P[i][0]]=1;
        has[P[i][1]]=1;
        row[P[i][0].x].insert(ID(P[i][0].y,i,0));
        row[P[i][1].x].insert(ID(P[i][1].y,i,1));
        col[P[i][0].y].insert(ID(P[i][0].x,i,0));
        col[P[i][1].y].insert(ID(P[i][1].x,i,1));
    }
}
void erase(int color)
{
    row[P[color][0].x].erase(ID(P[color][0].y,color,0));
    row[P[color][1].x].erase(ID(P[color][1].y,color,1));
    col[P[color][0].y].erase(ID(P[color][0].x,color,0));
    col[P[color][1].y].erase(ID(P[color][1].x,color,1));
    has[P[color][0]]=0;
    has[P[color][1]]=0;
}
void solve1()
{
    int M;
    scanf("%d",&M);
    int x,y;
    char d1,d2;
    set<ID>::iterator it;
    int color=-1,ans=0;
    for(int i=1;i<=M;i++)
    {
        scanf("%d %d %c %c",&x,&y,&d1,&d2);
        if(has[Point(x,y)])
            continue;
        color=-1;
        if(d1=='U'||d2=='U')
        {
            it=col[y].lower_bound(ID(x,0,0));
            if(it==col[y].begin())continue;
            it--;
            if(~color&&it->c!=color)
                continue;
            else if(~color&&it->c==color)
            {
                erase(color);
                ans++;
                continue;
            }
            else if(color==-1)
                color=it->c;
        }
        if(d1=='D'||d2=='D')
        {
            it=col[y].upper_bound(ID(x,0,0));
            if(it==col[y].end())continue;
            if(~color&&it->c!=color)
                continue;
            else if(~color&&it->c==color)
            {
                erase(color);
                ans++;
                continue;
            }
            else if(color==-1)
                color=it->c;
        }
        if(d1=='L'||d2=='L')
        {
            it=row[x].lower_bound(ID(y,0,0));
            if(it==row[x].begin())continue;
            it--;
            if(~color&&it->c!=color)
                continue;
            else if(~color&&it->c==color)
            {
                erase(color);
                ans++;
                continue;
            }
            else if(color==-1)
                color=it->c;
        }
        if(d1=='R'||d2=='R')
        {
            it=row[x].upper_bound(ID(y,0,0));
            if(it==row[x].end())continue;
            if(~color&&it->c!=color)
                continue;
            else if(~color&&it->c==color)
            {
                erase(color);
                ans++;
                continue;
            } 
            else if(color==-1)
                color=it->c;
        }
    }
    printf("%d\n",ans);
}
queue<int>Q;
int output[MAXN][4],cnt;
bool check(int color)
{
    if(P[color][0].x==P[color][1].x&&(P[color][0].y==P[color][1].y-1||P[color][0].y==P[color][1].y+1))return 0;
    if(P[color][0].y==P[color][1].y&&(P[color][0].x==P[color][1].x-1||P[color][0].x==P[color][1].x+1))return 0;
    set<ID>::iterator it;
    bool flag=1;
    int x1=P[color][0].x,x2=P[color][1].x,y1=P[color][0].y,y2=P[color][1].y;
    if(x1==x2)
    {
        it=row[x1].find(ID(y1,color,0));
        if(y1<y2)
        {
            it++;
            if(it!=row[x1].end()&&it->c==color)
            {
                cnt++;
                output[cnt][0]=x1;output[cnt][1]=y1+1;
                output[cnt][2]='L';output[cnt][3]='R';
                return 1;
            }
        }
        if(y2<y1&&it!=row[x1].begin())
        {
            it--;
            if(it->c==color)
            {
                cnt++;
                output[cnt][0]=x1;output[cnt][1]=y1-1;
                output[cnt][2]='L';output[cnt][3]='R';
                return 1;
            }
        }
        return 0;
    }
    if(y1==y2)
    {
        it=col[y1].find(ID(x1,color,0));
        if(x1<x2)
        {
            it++;
            if(it!=col[y1].end()&&it->c==color)
            {
                cnt++;
                output[cnt][0]=x1+1;output[cnt][1]=y1;
                output[cnt][2]='U';output[cnt][3]='D';
                return 1;
            }
        }
        if(x2<x1&&it!=col[y1].begin())
        {
            it--;
            if(it->c==color)
            {
                cnt++;
                output[cnt][0]=x1-1;output[cnt][1]=y1;
                output[cnt][2]='U';output[cnt][3]='D';
                return 1;
            }
        }
        return 0;
    }
    it=row[x1].find(ID(y1,color,0));
    if(y1<y2)
    {
        it++;
        if(it!=row[x1].end()&&it->pri<=y2)
            flag=0;
    }
    else if(y2<y1)
    {
        if(it!=row[x1].begin())
        {
            it--;
            if(it->pri>=y2)
                flag=0;
        }
    }
    if(flag)
    {
        it=col[y2].find(ID(x2,color,1));
        if(x2<x1)
        {
            it++;
            if(it!=col[y2].end()&&it->pri<=x1)
                flag=0;
        }
        else if(x1<x2)
        {
            if(it!=col[y2].begin())
            {
                it--;
                if(it->pri>=x1)
                    flag=0;
            }
        }
    }
    if(flag)
    {
        cnt++;
        output[cnt][0]=x1;output[cnt][1]=y2;
        if(x1>x2)output[cnt][2]='U';
        else output[cnt][2]='D';
        if(y1>y2)output[cnt][3]='R';
        else output[cnt][3]='L';
        return 1;
    }
    flag=1;
    it=row[x2].find(ID(y2,color,1));
    if(y2<y1)
    {
        it++;
        if(it!=row[x2].end()&&it->pri<=y1)
            flag=0;
    }
    else if(y1<y2)
    {
        if(it!=row[x2].begin())
        {
            it--;
            if(it->pri>=y1)
                flag=0;
        }
    }
    if(flag)
    {
        it=col[y1].find(ID(x1,color,0));
        if(x1<x2)
        {
            it++;
            if(it!=col[y1].end()&&it->pri<=x2)
                flag=0;
        }
        else if(x2<x1)
        {
            if(it!=col[y1].begin())
            {
                it--;
                if(it->pri>=x2)
                    flag=0;
            }
        }
    }
    if(flag)
    {
        cnt++;
        output[cnt][0]=x2;output[cnt][1]=y1;
        if(x1<x2)output[cnt][2]='U';
        else output[cnt][2]='D';
        if(y1<y2)output[cnt][3]='R';
        else output[cnt][3]='L';
        return 1;
    }
    return 0;
}
int que[10],h;
void update(const Point &p,int color)
{
    set<ID>::iterator it,tt;
    it=row[p.x].find(ID(p.y,color,0));
    tt=it;
    if(tt!=row[p.x].begin())
    {
        tt--;
        que[++h]=tt->c;
    }
    tt=it;
    tt++;
    if(tt!=row[p.x].end())
        que[++h]=tt->c;
    it=col[p.y].find(ID(p.x,color,0));
    tt=it;
    if(tt!=col[p.y].begin())
    {
        tt--;
        que[++h]=tt->c;
    }
    tt=it;
    tt++;
    if(tt!=col[p.y].end())
        que[++h]=tt->c;
}
bool vis[MAXN];
void solve2()
{
    for(int i=1;i<=N;i++)
        if(check(i))
        {
            Q.push(i);
            vis[i]=1;
        }
    while(!Q.empty())
    {
        int t=Q.front();
        Q.pop();
        h=0;
        update(P[t][0],t);
        update(P[t][1],t);
        sort(que+1,que+h+1);
        h=unique(que+1,que+h+1)-que-1;
        erase(t);
        for(int i=1;i<=h;i++)
            if(!vis[que[i]]&&check(que[i]))
            {
                Q.push(que[i]);
                vis[que[i]]=1;
            }
    }
    printf("%d\n",cnt);
    for(int i=1;i<=cnt;i++)
        printf("%d %d %c %c\n",output[i][0],output[i][1],output[i][2],output[i][3]);
}
int main()
{
    Read();
    Init();
    solve1();
    Init();
    solve2();
    return 0;
}
CaptainHarryChen
关注
专栏目录
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
bzoj 3519: [Zjoi2014] 消棋子 题解
aofan9566的博客
12-28 169
【序言】在大家怀疑的眼光下，我做了一个中午和半个下午、调了一个晚上的题目总算A了！ 【原题】 消棋子是一个有趣的游戏。游戏在一个r * c的棋盘上进行。棋盘的每一个格 子。要么是空，要么是一种颜色的棋子。同一种颜色的棋子恰好有两个。每一轮， 玩家能够选择一个空格子(x, y)，并选择上下左右四个方向中的两个方向，假设 在这两个方向上均存在有棋子的格子，并且沿着这两个方向...
【BZOJ1457】棋盘游戏
cz_xuyixuan的博客
04-12 279
【题目链接】点击打开链接【思路要点】补档博客，无题解。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; #define MAXN 105 #define MAXV 405 int sg[MAXN][MAXN], mark[MAXV]; int n, T, num; bool func(int x, int y) { return x =...
【模拟】ZJOI2014&BZOJ3519消棋子
氧化钠的博客
03-25 484
传送门 注： 图的方向要注意！如果你把方向看反了，样例仍然可以过（然而几乎所有测试数据都过不了）。 样例图例如下： 题目中给出，每种颜色只有2个，而且最多有100000种颜色。 那么很容易想到暴力算法。 用set分每行每列储存所有的点： 如一点坐标为(x,y) 那么就在y列插入x，同时在x行插入y 这样就可以通过迭代器，快速找到某个点每行每列相邻的的点。对于1问，主要通过set的l
BZOJ3519: [Zjoi2014]消棋子
03-17 1313
【题目描述】 消棋子是一个有趣的游戏。游戏在一个r * c的棋盘上进行。棋盘的每个格子，要么是空，要么是一种颜色的棋子。同一种颜色的棋子恰好有两个。每一轮，玩家可以选择一个空格子(x, y)，并选择上下左右四个方向中的两个方向，如果在这两个方向上均存在有棋子的格子，而且沿着这两个方向上第一个遇到的棋子颜色相同，那么，我们将这两个棋子拿走，并称之为合法的操作。否则称这个操作不合法，游戏不会处理这个操
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
BZOJ上面的题目以及数据
10-13
【BZOJ】全称是“北京邮电大学在线评测系统”，它是一个为编程爱好者和参赛者提供在线编程练习和比赛的平台。该平台涵盖了多种算法和编程问题，旨在提升用户的编程技能和解决复杂问题的能力。BZOJ支持C、C++、Java等...
BZOJ题目镜像
09-14
【BZOJ题目镜像】是为了解决BZOJ（Blue Zoo Online Judge）系统因服务器问题时常出现访问不稳定或无法访问的情况而设立的一个备份资源。BZOJ是中国早期的在线编程竞赛平台，提供了大量的算法题目供编程爱好者进行...
[BZOJ3519][Zjoi2014][模拟]消棋子
CE玩家
02-01 616
巨烦的模拟。 差不多算是第一次用set，发现set是个好东西。对于第一个询问，用set记录每行每列放棋子的情况，那么对于这个人的每次操作，直接在set上模拟就好了 第二问贪心，每次把能消掉的棋子消掉就可以了。代码长，思路乱，还跑得慢……#include <cstdio> #include <iostream> #include <algorithm> #include <set> #define
python实现三消游戏(消消乐)算法--简单案例
大蛇王的博客
02-17 8441
前言： 三消算法首要实现的就是找到所有三个或三个以上的同样颜色，所以我们思路是：判断每个点进行上下左右四个方向移动后，能得到三个及以上的相连。 经过分析，当我们向一个方向移动时，会有四种情况符合条件，所以当一个点符合消除时，需要判断周围点的情况共有16种！ 例如：当红色圈向右移动一格能消除时，他周围的情况必然时图下四种状态： 1.与右边两个绿圈消除 2.与右上方两个蓝圈消除 3.与右下方两个黄圈消除 4.与右边上下各一个绿色正方形消除。 所以，我们的要做的是： 第一步： 将图片.
bzoj 3519 线段树
make_it_for_good的博客
03-11 579
题意说的什么jb玩意 写完之后我都开始怀疑人生了。。。每行每列开个线段树，维护加点删点找前驱后继（好像可以set） 第一问找询问的点两个方向的第一个点，看是不是相同颜色。 第二问把一开始能选的放进一个队列，然后每删除一个点只会影响到上下左右第一个点的答案。 一坨判断#include <bits/stdc++.h> using namespace std; #define N 110000 #
【ZJOI2014】【BZOJ3527】 力 (FFT)
დ♂Hany01's Blog Space♂ღ
11-28 322
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
消消乐游戏原理（附部分代码）
热门推荐
MaxLykoS的博客
03-17 1万+
在vs里看见一些方法上次修改是501天以前，乖乖，为了复试我也算是把陈谷子烂芝麻都翻出来读了。 一.存储 格子+格子哈希表[id]，格子的属性：x，y，id，type 其中id=x*10+y x=id/10 y=id%10 type代表格子属于什么类型，相同的3个相连可以消除 比如一个9*9的棋盘，x横轴，y是纵轴 8 18 28 38 48 58 ...
BZOJ3619 : [Zjoi2014]璀灿光华
weixin_33895604的博客
10-13 97
终于把省选时的遗憾补上了… 对于构造立方体： 首先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系列题解--2015年12月第二题 棋类消除
Jing Sir的博客
04-01 3818
问题描述 　　消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。 　　请注意：一个棋子可能在某一行和某一列同时被消除。 输入格式 　　输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。 　　接下来
Python入门习题----消除游戏
不祈求 ~ ~
11-10 2563
【问题描述】 消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。 现在给定一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子（用数字1-9表示各种颜色的棋子），请给出经过消除后的棋盘。 请注意：一个棋...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值