P2156 [SDOI2009]细胞探索

最新推荐文章于 2024-11-05 15:38:36 发布
最新推荐文章于 2024-11-05 15:38:36 发布
阅读量159 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/olinr/p/10445464.html
版权

$ \color{#0066ff}{ 题目描述 }$

生物课上，老师开始为同学们介绍细胞。为了加深同学们的印象，老师在一张N×M的矩阵中定义了一种细胞，矩阵中仅有井号“#”和点“.”：

细胞由细胞核、细胞质及细胞膜构成。细胞核是一个4连通（上下左右相连）的全为“#”的连通块，它必须实心，即不能存在一个4连通的“.”连通块被其完全包围（所谓完全包围指的是，这个“.”连通块不能位于矩阵边界相邻，且它的4相邻格子均属于包含它的“#”连通块）。细胞膜是一个8连通（上下左右，以及4个对角方向）的全为“#”的非实心连通块。细胞膜仅包围一个4连通的区域，且这个区域内有且仅有一个细胞核，这个区域剩下的位置全为“.”。

所有连通块必须极大化，即一个8连通块周围不能找到一个“#”与这个连通块的任意一个“#”8连通；同样，对于一个4连通块周围不能找到一个“#”与这个连通块的任意一个“#”4连通。

现在，老师画了一幅图画，并让小E回答图画中一共有几个细胞，并把图画中不属于任何一个细胞的“#”改成“.”。

\(\color{#0066ff}{输入格式}\)

输入文件explore.in的第一行包含两个用空格分隔的正整数N和M，表示矩阵的高和长。

接下来一个N行M列的矩阵，矩阵中仅含井号“#”和点“.”，保证没有多余字符。

\(\color{#0066ff}{输出格式}\)

输出文件explore.out第一行包含一个整数，表示输入的矩阵中的细胞数。

接下来一个N行M列的矩阵，矩阵中仅含井号“#”和点“.”，表示更改后的图画。

\(\color{#0066ff}{输入样例}\)

12 13
.###..#####..
#...#.#....#.
#.#.#.#..#.#.
#...#..#...#.
.###.#..###..
....#..##...#
..........###
##########..#
#...........#
#.###...###.#
#...........#
#############


9 14
#########.....
#.......#....#
#.#####.#...#.
#.#...#.#..#..
#.#.#.#.#.#..#
#.#...#.#..#..
#.#####.#...#.
#.......#....#
#########.....


7 15
#######.#######
#.....#.#.....#
#.###.#.#.###.#
#.#.#.#.#.#...#
#.###.#.#.###.#
#.....#.#.....#
#######.#######

\(\color{#0066ff}{输出样例}\)

1
......#####..
......#....#.
......#..#.#.
.......#...#.
........###..
.......##....
.............
.............
.............
.............
.............
.............

    
1
..............
..............
..#####.......
..#...#.......
..#.#.#.......
..#...#.......
..#####.......
..............
..............

    
1
........#######
........#.....#
........#.###.#
........#.#...#
........#.###.#
........#.....#
........#######

\(\color{#0066ff}{数据范围与提示}\)

对于20%的数据，满足1 ≤ N, M ≤ 20。

另有20%的数据，满足所有“#”都属于某一个正确的细胞。

对于100%的数据，满足1 ≤ N, M ≤ 1,000。

\(\color{#0066ff}{题解}\)

看起来很难下手，如果搜井号的话，还要考虑内外，肯定很麻烦的
那么我们不如从点入手
不难发现，一个合法的细胞，细胞质连接且仅连接两个联通块
所以可以先预处理出所有井号联通块，然后。。。过程见代码。。
#include<bits/stdc++.h>
#define LL long long
LL in() {
    char ch; LL x = 0, f = 1;
    while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
    for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
    return x * f;
}
const int maxn = 1050;
const int inf = 0x7fffffff;
int bel[maxn][maxn], n, m, mp[maxn][maxn], num, siz[maxn * maxn], cnt[maxn * maxn];
int up[maxn * maxn], bj[maxn * maxn], ls, fa[maxn * maxn], must[maxn * maxn];
std::pair<int, int> spe[maxn * maxn];
char sss[maxn];
int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int rx[] = {1, -1, 0, 0};
int ry[] = {0, 0, 1, -1};
bool vis[maxn][maxn], flag, have;
std::set<int> v;
void dfs(int x, int y, int id) {
    siz[id]++;
    up[id] = std::min(up[id], x);
    bel[x][y] = id;
    vis[x][y] = true;
    for(int i = 0; i < 8; i++) {
        int xx = x + dx[i];
        int yy = y + dy[i];
        if(xx >= 1 && xx <= n && yy >= 1 && yy <= m && !vis[xx][yy] && mp[xx][yy]) dfs(xx, yy, id);
    }
}
void expand(int x, int y) {
    if(x == 1 || x == n || y == 1 || y == m) flag = true;
    vis[x][y] = true;
    for(int i = 0; i < 4; i++) {
        int xx = x + rx[i];
        int yy = y + ry[i];
        if(xx >= 1 && yy >= 1 && xx <= n && yy <= m) {
            if(mp[xx][yy]) v.insert(bel[xx][yy]);
            if(!mp[xx][yy] && !vis[xx][yy]) expand(xx, yy);
        }
    }
}
void init(int x, int y) {
#ifdef olinr
    printf("init %d %d\n", x, y);
#endif
    ls++;
    vis[x][y] = true;
    for(int i = 0; i < 4; i++) {
        int xx = x + rx[i];
        int yy = y + ry[i];
        if(xx >= 1 && xx <= n && yy >= 1 && yy <= m) {
#ifdef olinr
            printf("in");
#endif
            if(!mp[xx][yy] && !vis[xx][yy]) have = true;
#ifdef olinr
            if(mp[xx][yy]) printf("!");
            if(!vis[xx][yy]) printf("$");
#endif
            if(mp[xx][yy] && !vis[xx][yy]) init(xx, yy);
        }
    }
}


void work(int x, int y) {
    v.clear();
    flag = false;
    have = false;
    ls = 0;
    expand(x, y);
    if(flag) {
#ifdef olinr
        //搜索到边界一定不是细胞质
    printf("break at 1\n");
#endif
        return;
    }
    if(v.size() != 2) {
        //一个膜里面一大堆不知道什么玩意
        int pos = 0, mx = inf;
        for(std::set<int>::iterator it = v.begin(); it != v.end(); it++)
            if(mx > up[*it]) mx = up[*it], pos = *it;
        //这个膜肯定没用了
        bj[pos] = true, cnt[pos] += v.size() - 1, must[pos] = true;
        for(std::set<int>::iterator it = v.begin(); it != v.end(); it++)
            if(*it != pos) fa[*it] = pos;
#ifdef olinr
        printf("vis: ");
        for(std::set<int>::iterator it = v.begin(); it != v.end(); it++) printf("%d ", *it);
        puts("");
        printf("break at 2\n");
#endif
        return;
    }
    std::set<int>::iterator it = v.begin();
    int aa = *it;
    it++;
    int bb = *it; 
    if(up[aa] > up[bb]) std::swap(aa, bb);
    if(bj[aa]) {
#ifdef olinr
        printf("break at 3\n");
#endif
        //已经用过了，就是两个粘在一起的细胞，然而在本题是不合法的
        must[aa] = true;
        return;
    }
    init(spe[bb].first, spe[bb].second);
    if(have) {
        //细胞核里有TM细胞质！！！我去
        must[aa] = true;
#ifdef olilnr
        printf("break at 4\n");
#endif
        return;
    }
    if(ls != siz[bb]) {
        //因为搜井号联通块是8联通的，这里要4联通搜一下，看是不是完整
#ifdef olinr
        printf("%d %d\n", ls, siz[bb]), printf("break at 5\n");
#endif
        must[aa] = true;
        return;
    }
    fa[aa] = 0, fa[bb] = aa;
    cnt[aa]++;
}
//must：是否一定不合法，bj是否曾经被作为细胞膜，fa，细胞核属于哪个细胞膜， cnt，作为细胞膜的次数
int main() {
    n = in(), m = in();
    for(int i = 1; i <= n; i++) {
        scanf("%s", sss);
        for(int j = 1; j <= m; j++)
            mp[i][j] = sss[j - 1] == '#';
    }
    //处理井号联通块
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            if(mp[i][j] && !vis[i][j]) {
                num++;
                up[num] = inf;
                spe[num] = std::make_pair(i, j);
                dfs(i, j, num);
#ifdef olinr
                printf("id: %d, siz = %d\n", num, siz[num]);
#endif
            }
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) 
            vis[i][j] = 0;
    //对于每个点的联通块，处理
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++)
            if(!mp[i][j] && !vis[i][j]) {
#ifdef olinr
                printf("now dfs %d %d\n", i, j);
#endif
                work(i, j);
            }
    int ans = 0;
    for(int i = 1; i <= num; i++) {
        bj[i] = false;
        if(!must[i] && !fa[i] && cnt[i] == 1) ans++, bj[i] = true;
    }
    printf("%d\n", ans);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            if(!mp[i][j]) putchar('.');
            else {
                if(bj[bel[i][j]] || bj[fa[bel[i][j]]]) putchar('#');
                else putchar('.');
            }
        }
        puts("");
    }
    return 0;
}

转载于:https://www.cnblogs.com/olinr/p/10445464.html

weixin_30376453
关注
LUOGU P2156 [SDOI2009]细胞探索
REWINE
03-19 302
题目描述 生物课上，老师开始为同学们介绍细胞。为了加深同学们的印象，老师在一张N×M的矩阵中定义了一种细胞，矩阵中仅有井号“#”和点“.”： 细胞由细胞核、细胞质及细胞膜构成。细胞核是一个4连通（上下左右相连）的全为“#”的连通块，它必须实心，即不能存在一个4连通的“.”连通块被其完全包围（所谓完全包围指的是，这个“.”连通块不能位于矩阵边界相邻，且它的4相邻格子均属于包含它的“#”连通块）...
P2148 [SDOI2009]E&D （Ferguson游戏的sg函数）
_Griefs
08-25 155
题目链接 题面： 题解： 每一组可以看作一个Ferguson游戏。 重点在怎么求Ferguson游戏的sg值上。 代码： #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<bitset> #include<algorithm> #define ll long long #define pr make_pair #define p
【SDOI2009】解题汇总
weixin_30813225的博客
03-20 119
又开了波专题，感觉就和炉石开冒险一样...（说的好像我有金币开冒险似的） /—————————————————————————————————————————————/ BZOJ-1226 【SDOI2009】学校食堂Dining 状态压缩DP f【i】【j】【k】表示前i-1人都吃过饭，j表示i与i之后7人的吃饭情况，k表示上一个吃饭的人与i的相对位置 转移如...
[luogu]P2152 [SDOI2009]SuperGCD
Hardict的算法日记
09-14 241
题目 计算两个大整数的 数据范围: 分析 即写高精形式的 即是更相损减术的优化,对于首先提取其公共的幂次,即. 由更相损减术,,但这种直接计算若两者差值太大则时间复杂度逼近(n为最大整数的值).注意到值为奇数,则可以通过对中的2的倍数减半规模. 若则,否则,并对进行可能的折半操作 PS:一开始写的函数(*,&amp;)形式,莫名其妙TLE. ﾍ(;′Д｀ﾍ)  #include...
P2156 [SDOI2009] 细胞探索
m0_71227570的博客
03-11 433
细胞核是一个4连通（上下左右相连）的全为“#”的连通块，它必须实心，即不能存在一个4连通的“.”连通块被其完全包围（所谓完全包围指的是，这个“.”连通块不能位于矩阵边界相邻，且它的4相邻格子均属于包含它的“#”连通块）。所有连通块必须极大化，即一个8连通块周围不能找到一个“#”与这个连通块的任意一个“#”8连通；同样，对于一个4连通块周围不能找到一个“#”与这个连通块的任意一个“#”4连通。接下来一个N行M列的矩阵，矩阵中仅含井号“#”和点“.”，表示更改后的图画。### 样例输入 #1。
P1972 [SDOI2009]HH的项链
Ajwallet
07-09 466
莫队
P2152 [SDOI2009]SuperGCD
qq_35975367的博客
08-11 180
P2152 [SDOI2009]SuperGCD 题意： 求a和b的最大公约数 a,b<=101000010^{10000}1010000 题解： 高精度，java高精度直接有模板，c++高精度结合gcd的辗转相减法 对于：a,b的gcd(a,b)有： 若a为奇数，b为偶数，gcd(a,b)=gcd(a,b/2) 若a为偶数，b为奇数，gcd(a,b)=gcd(a/2,b) 若a为偶数，b为偶数，gcd(a,b)=2gcd(a,b) 若a为奇数，b为奇数，gcd(a,b)=gcd(a-b,b)（a&
洛谷P2152 [SDOI2009] SuperGCD
puvakyOK的博客
08-26 287
P2152 [SDOI2009] SuperGCD
P1972 [SDOI2009] HH的项链 题解
luogu_553625的博客
05-05 1125
补一个扫描线题解。
【洛谷】P2149[SDOI2009]Elaxia的路线
谭思博的博客
10-07 288
又一道省选题。又是在学校模拟赛上考过的。#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<queue> #include<algorithm> using namespace std; #define Max(a,b) (a)>(b)?(a):(b) const int MAXN=1500+1
[SDOI2009]学校食堂
蒟蒻QMQ
11-26 186
题目 题目 做法 f[i][j][k]f[i][j][k]f[i][j][k]表示第iii个数字，jjj表示最后一个数字在j+kj+kj+k的位置，然后kkk用二进制表示后面的情况，对于f[i][j][k]f[i][j][k]f[i][j][k]，设xxx为包括他以内往后b[i]+1b[i]+1b[i]+1位第一个没有做菜的位置，然后用f[i][j][k]f[i][j][k]f[i][j][k]贡献给f[x]f[x]f[x]即可。 当然，需要提前处理每个位置的哪些二进制合法。 #include<cst
[SDOI2009]HH去散步
StaroForgin的博客
04-21 337
HH去散步 题解 很明显的一道矩阵加速呀！ 我们可以将图的连通性用矩阵给表示出来，矩阵的t次方就是跑t秒的结果。 好吧，虽然思路是没问题的但我们很快就发现这样是行不通的，它不能像这样去走，我们又该怎样去处理呢？ 之前我们是通过点去建的矩阵，要求不能走回头边，是很难处理的，如果我们用边来建矩阵不就很好处理了吗。 于是我们将边像点一样连起来，只是不把回头的边连着，就可以用矩阵来处理了。 ...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 718
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
DFS求解迷宫最长移动路线
安祝老师的博客
11-05 1272
来源：十四届蓝桥杯STEMA考试Python真题试卷第二套第五题。本文给出了C++实现代码，介绍了 STL 中容器`vector`，`pair`，`unordered_set` 的应用，供信奥选手参考。**迷宫类问题**适合用**DFS算法**解决，本文最后总结了DFS算法的两种常见实现方式——**递归实现、栈实现**，应用场景——**迷宫类问题、图的连通性、树的遍历、拓朴排序、排列组合**，以及主要优缺点。
链表交集相关算法题|AB链表公共元素生成链表C|AB链表交集存放于A|连续子序列|相交链表求交点位置(C)
ChoSeitaku的博客
11-04 1107
表A，B都有序，可从第一个元素起依次比较A、B两表的元素，若元素值不等，则值小的值往后移，若元素值相等，则创建一个值等于两节点的元素值的新节点，使用尾插法插入到新的链表中，并将两个原表指针后移一位，直到其中一个链表遍历到表尾。一个工作指针cura用来遍历链表A，一个工作指针curb用来遍历链表B，一个工作指针curc用来建立链表C，一个指针new用来创建共同节点的新节点尾插到C链表上。循环结束后，如果curb指向NULL，表示链表B的curb都等于对应的cura，链表B是链表A的连续子序列。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 1041
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
实习冲刺Day11
2301_78814687的博客
11-02 320
c++中字符串有两种存储方式，一种是存储在char[]数组中，一种是存储在c++封装的string类中。在C中也可以使用字符指针来访问一个字符串,通过字符指针指向存放字符串数组的首元素地址来进行访问.在C中，并没有字符串这个数据类型，而是使用。char[]来保存字符串。二叉树的先序遍历根左右。二叉树的后序遍历左右根。
模拟退火算法求解TSP问题
m0_56408077的博客
11-04 367
模拟退火算法（Simulated Annealing, SA）是一种通用的随机优化算法，适合解决组合优化问题，如旅行商问题（TSP）。TSP 问题的目标是给定一组城市，找到一条闭合路径，使得旅行商从一个城市出发，访问每个城市恰好一次并最终返回起点，同时路径总长度最短。
二叉树(一)
最新发布
m0_74340589的博客
11-05 430
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
洛谷精选：树形数据结构实战题目及模板
8. **SDOI2009**（HH的项链）： 一道经典的算法竞赛题目，涉及链表操作或其他数据结构，可以用来检验对复杂问题的理解和解决能力。 这份资料为学习者提供了一个全面且深入的树形数据结构学习路径，通过解决这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值