leetcode:Surrounded Regions

最新推荐文章于 2014-05-03 16:52:26 发布
最新推荐文章于 2014-05-03 16:52:26 发布
阅读量1.2k 收藏
点赞数
分类专栏： C/C++ Algorithm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/binary_search/article/details/8965914
版权

Problem：

Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region .

For example,

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

Solution:

因为学过一段时间的《数字图像处理》，所以一看到这个题目就想起来了数图中的边缘检测。于是就顺着这个给走下来了，把背景（在board边界之外的）全部看成'O'，检测出来'X'的边缘，然后找出一个'X'围起来的圈中的一个内点，然后根据这个内点把圈内的点全部变成'X'，然后就得到了结果。

于是：

  1. 在边界上找出来一个'X'
  2. 根据这个'X'，沿着他的8-邻居（就是上、下、左、右、右上、右下、左上、左下相邻的点都是邻居，相对比的有一个4-邻居，就是只有上、下、左、右相邻的点是邻居）走，找出来一个封闭的曲线
  3. 然后找出一个内点
  4. 同样根据这个内点的4-邻居，把圈内的点全部变成'X'
  5. 达到目的

事实上，在第4步找内点的时候，费了很大的劲，因为没法判断一个点是不是内点（从一个点走向无穷远穿过边界的次数），因为这个边界有点奇葩。最后想到了反射，就是在找这个边界的时候，其实是知道他外面一圈的点的，于是就上、下、45度以边界上的点反射，找到一个内点。这个结论到现在还不清楚对不对。最后写出来了程序如下，在程序中的测试例子是可以通过的。

#include <iostream>
#include <vector>
using namespace std;


class Solution
{
public:
    void solve(vector<vector<char> > &board)
    {
        int On=-1;
        pair<int,int> cur=get_firstX(board,On); 

        vector<pair<int,int> > path;
        vector<pair<int,int> > Opath;
        get_boundary(cur.first,cur.second,On,board,path,Opath);

        pair<int,int> inner_point=get_inner_point(board,path,Opath);
        vfill(board,path,inner_point);
    }

    pair<int,int> get_inner_point(vector<vector<char> > &board,vector<pair<int,int> > &path, vector<pair<int,int> > &Opath)
    {
        int Onum=Opath.size();
        int nrows=board.size();
        int ncols=board[0].size();
        for(int i=0;i<Onum;i++)
        {
            pair<int,int> tmp;
            if (board[Opath[i].second-1][Opath[i].first+1]=='X' &&
                board[Opath[i].second][Opath[i].first+1]=='X' &&
                board[Opath[i].second+1][Opath[i].first+1]=='X')
            {
               tmp=make_pair(Opath[i].first+2,Opath[i].second); 
            }
            else if(board[Opath[i].second-1][Opath[i].first-1]=='X' &&
                board[Opath[i].second][Opath[i].first-1]=='X' &&
                board[Opath[i].second+1][Opath[i].first-1]=='X')
            {
                tmp=make_pair(Opath[i].first-2,Opath[i].second);
            }
            else if(board[Opath[i].second-1][Opath[i].first+1]=='X' &&
                board[Opath[i].second-1][Opath[i].first]=='X' &&
                board[Opath[i].second-1][Opath[i].first-1]=='X')
            {
                tmp=make_pair(Opath[i].first,Opath[i].second-2);
            }
            else if(board[Opath[i].second+1][Opath[i].first+1]=='X' &&
                board[Opath[i].second+1][Opath[i].first]=='X' &&
                board[Opath[i].second+1][Opath[i].first-1]=='X')
            {
                tmp=make_pair(Opath[i].first,Opath[i].second+2);
            }
            else if(board[Opath[i].second+1][Opath[i].first]=='X' &&
                board[Opath[i].second][Opath[i].first+1]=='X')
            {
                tmp=make_pair(Opath[i].first+1,Opath[i].second+1);
            }
            else if(board[Opath[i].second-1][Opath[i].first]=='X' &&
                board[Opath[i].second][Opath[i].first+1]=='X')
            {
                tmp=make_pair(Opath[i].first-1,Opath[i].second-1);
            }
            else if(board[Opath[i].second+1][Opath[i].first]=='X' &&
                board[Opath[i].second][Opath[i].first-1]=='X')
            {
                tmp=make_pair(Opath[i].first-1,Opath[i].second+1);
            }
            else if(board[Opath[i].second-1][Opath[i].first]=='X' &&
                board[Opath[i].second][Opath[i].first-1]=='X')
            {
                tmp=make_pair(Opath[i].first-1,Opath[i].second-1);
            }
            else
                continue;

            if (tmp.first<ncols-1 && tmp.first>0 && tmp.second<nrows-1 && tmp.second>0 && !on_path(tmp.first,tmp.second,path))
            {
                return tmp;
            }
            else
                continue;
        }


    }
    pair<int,int> get_firstX(vector<vector<char> > &board,int &On)
    {
        //find the first X
        int nrows=board.size();
        int ncols=board[0].size();

        for (int i=0;i<nrows;i++)
            for(int j=0;j<ncols;j++)
            {
                if (i==0 || i==nrows-1 || j==0 || j==ncols-1)
                    if (board[i][j]=='X')
                    {
                        if (i==0) On=2;
                        if (j==0) On=4;
                        if (i==nrows-1) On=0;
                        if (j==ncols-1) On=6;
                        return make_pair(i,j);
                    }
            }
        return make_pair(-1,-1);
    }

    int get_boundary(int seedx,int seedy,int Orin,vector<vector<char> > &board,
                    vector<pair<int,int> > &path,vector<pair<int,int> > &Opath)
    {
        int testx=seedx,testy=seedy;
        int curx=seedx,cury=seedy;
        int On;
        do
        {
            int testn=(Orin+1)%8;
            while(testn%8!=Orin)
            {
                pair<int,int> tmp=get_by_direction(curx,cury,testn);
                testx=tmp.first;
                testy=tmp.second;
                On=((testn/2)*2+6)%8;
                
                int testc=get_color(testx,testy,board);
                if (testc==0)
                {
                    testn=(++testn)%8;
                    Opath.push_back(make_pair(testx,testy));
                }
                else if(testc==1)
                {
                    path.push_back(make_pair(curx,cury));
                    curx=testx;
                    cury=testy;
                    Orin=On;
                    break;
                }
            }
            if (testn%8==Orin)
            {
                //isolated X
                board[curx][cury]='O';
            }
        }while (curx!=seedx || cury!=seedy);

        return 0;
    }

    pair<int,int> get_by_direction(int curx,int cury,int direction)
    {
        int testx,testy;
        switch(direction)
        {
            case 0:
                testx=curx+1;
                testy=cury;
                break;
            case 1:
                testx=curx+1;
                testy=cury-1;
                break;
            case 2:
                testx=curx;
                testy=cury-1;
                break;
            case 3:
                testx=curx-1;
                testy=cury-1;
                break;
            case 4:
                testx=curx-1;
                testy=cury;
                break;
            case 5:
                testx=curx-1;
                testy=cury+1;
                break;
            case 6:
                testx=curx;
                testy=cury+1;
                break;
            case 7:
                testx=curx+1;
                testy=cury+1;
                break;
        }
        return make_pair(testx,testy);
    }

    int get_color(int x,int y,vector<vector<char> > &board)
    {
        //regard the background as 'O'
        int maxx=board[0].size();
        int maxy=board.size();
        if (x>=maxx || x<0)
            return 0;
        if (y>=maxy || y<0)
            return 0;
        return char2int(board[y][x]);
    }
   
    int char2int(char x)
    {
        int res=0;
        switch(x)
        {
            case 'X':
                res=1;
                break;
            case 'O':
                res=0;
                break;
            default:
                res=0;
        }

        return res;
    }

    void vfill(vector<vector<char> > &board,vector<pair<int,int> > &path,pair<int,int> inner_point)
    {
        vector<pair<int,int> > Opoint;
        pair<int,int> cur=inner_point;
        Opoint.push_back(inner_point);
        do
        {   
            cur.first=Opoint.back().first;
            cur.second=Opoint.back().second;
            board[cur.second][cur.first]='Y';
            Opoint.pop_back();
            
            for(int d=0;d<8;d+=2)
            {
                pair<int,int> tmp=get_by_direction(cur.first,cur.second,d);
                if (!on_path(tmp.first,tmp.second,path) && board[tmp.second][tmp.first]!='Y')
                {
                    Opoint.push_back(tmp);
                }
            }
        } while(Opoint.size()!=0);

        int nrows=board.size();
        int ncols=board[0].size();
        for(int i=0;i<nrows;i++)
        {
            for(int j=0;j<ncols;j++)
            {
                if (board[i][j]=='Y')
                {
                    board[i][j]='X';
                }
            }
        }
    }

    bool on_path(int x,int y, vector<pair<int,int> > &path)
    {
        int num=path.size();
        for(int i=0;i<num;i++)
        {
            if (path[i].first== x && path[i].second==y)
                return true;
        }
        return false;
    }
};

int main()
{
    char bd[][4]={{'X','X','X','X'},{'X','O','O','X'},{'X','X','O','X'},{'X','O','X','X'}};
    vector<vector<char> > board(4,vector<char>(4));
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            board[i][j]=bd[i][j];
    Solution s;
    s.solve(board);
    return 0;
}

可是在leetcode上测试的时候，发现总是runtime error，感觉很无力，于是就懒得调试了。到网上看了看别人的代码，原来这么简单，主要的点都在我上面的代码上体现了，就是现在边界上找到一个'O'，然后把沿着这个'O'的4-邻居，把它以及与它相连的所有的'O'变成另外一个字母（随便怎么选），然后把剩下的'O'都变成'X'，然后把前面的'O'再变回来了，然后结束。


网上的代码的遍历邻居不少是使用的递归实现的，我上面（vfill）的相当于是使用了一个栈。下面是重新整理的代码：


class Solution {
public:
    void solve(vector<vector<char>> &board) {
        if (board.size()==0) return;
        if (board[0].size()==0) return;
        pair<int,int> cur=get_firstO(board); 

        while(cur.first!=-1 || cur.second!=-1)
        {
            flip_openO(board,cur,'Y');
            cur=get_firstO(board);
        }
        flip_from_to(board,'O','X');
        flip_from_to(board,'Y','O');
    }

    pair<int,int> get_firstO(vector<vector<char> > &board)
    {
        //find the first X
        int nrows=board.size();
        int ncols=board[0].size();

        for (int i=0;i<nrows;i++)
            for(int j=0;j<ncols;j++)
            {
                if (i==0 || i==nrows-1 || j==0 || j==ncols-1)
                    if (board[i][j]=='O')
                    {
                        return make_pair(j,i);
                    }
            }
        return make_pair(-1,-1);
    }

    void flip_openO(vector<vector<char> > &board,pair<int,int> &start,char to)
    {
        vector<pair<int,int> > Opoint;
        Opoint.push_back(start);
        pair<int,int> cur=start;
        int nrows=board.size();
        int ncols=board[0].size();
        do
        {   
            cur.first=Opoint.back().first;
            cur.second=Opoint.back().second;
            board[cur.second][cur.first]=to;
            Opoint.pop_back();
            
            for(int d=0;d<8;d+=2)
            {
                pair<int,int> tmp=get_by_direction(cur.first,cur.second,d);
                if (tmp.first>=0 && tmp.first<ncols &&
                    tmp.second>=0 && tmp.second<nrows)
                {
                    if (board[tmp.second][tmp.first]=='O')
                    {
                        Opoint.push_back(tmp);
                    }
                }
            }
        } while(Opoint.size()!=0);
    }

    void flip_from_to(vector<vector<char> > &board,char from, char to)
    {
        int nrows=board.size();
        int ncols=board[0].size();
        for(int i=0;i<nrows;i++)
        {
            for(int j=0;j<ncols;j++)
            {
                if (board[i][j]==from)
                    board[i][j]=to;
            }
        }
    }

    pair<int,int> get_by_direction(int curx,int cury,int direction)
    {
        int testx,testy;
        switch(direction)
        {
            case 0:
                testx=curx+1;
                testy=cury;
                break;
            case 1:
                testx=curx+1;
                testy=cury-1;
                break;
            case 2:
                testx=curx;
                testy=cury-1;
                break;
            case 3:
                testx=curx-1;
                testy=cury-1;
                break;
            case 4:
                testx=curx-1;
                testy=cury;
                break;
            case 5:
                testx=curx-1;
                testy=cury+1;
                break;
            case 6:
                testx=curx;
                testy=cury+1;
                break;
            case 7:
                testx=curx+1;
                testy=cury+1;
                break;
        }
        return make_pair(testx,testy);
    }
};

在leetcode上测试，全部通过。微笑

其实在上面写自己的代码的时候，学长看到了说我怎么写这么多。现在看来果然是掉坑里了。艾，碰到问题还是不要想那么复杂为好~

binary_search
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode:LeetCode题解
04-20
LeetCode题解 小萌新正在刷题中···
leetcode:leetcode去
04-05
LeetCode问题 编码...
leetcode:leetcode实践
03-30
密码 我的leetcode代码 个人资料链接
leetcode:Leetcode解决方案
04-28
:fire: Leetcode :fire: 实践使完美 :party_popper: 开玩笑的单元测试 :sparkles: 简单的代码 :artist_palette: 可读代码 入门指南 git clone https: //github.com/tangweikun/leetcode.git cd leetcode npm ...
leetcode：leetcode问题
02-15
密码
使用MySQLpp访问MySQL
binary_search的专栏
11-20 5025
昨天忘了在看什么的时候发现了在/usr/include/中有个mysql++的文件夹，google之发现原来这个是mysqlpp，一个C++的用来访问MySQL的第三方的库。google到的提供支持的是这个网站http://tangentsoft.net/mysql++/。上面有详细的文档。貌似这个也是有官方支持的，在mysql的官网的emaillist中发现好多关于这个库的。 之前也有弄过官网
leetcode:Palindrome Partitioning II
binary_search的专栏
03-29 2217
谨遵学长教导，开始刷算法题，从leetcode开始做起。可惜第一次就碰到了两个dp的问题Palindrome Partitioning II。。。第一次搞了半天，感觉像是可以建模为最短路径问题，思路不清晰，乱写竟然通过了judge small，在judge large的时候，最后一个测试例子没有通过，显示超时。不懂为什么，后来google了一下，发现原来是判断是不是回文也要用dp，艾。。后来就没有
C/C++与Python字符串处理比较
binary_search的专栏
11-13 1784
本文比较了C，C++和Python中关于字符串处理的一些库函数。这里你可能会奇怪，Python和C/C++本来就不是同一层次上的语言，为什么要放在一起比较。这里就是参照Python来看看C++的字符串处理目前是一种什么情况。Python现在也属于一种很热门的脚本语言，它以其容易上手著称。它的库中提供了众多的函数、类和模块支持对字符串的处理。本文期望能够为使用C++的人提供一定的帮助。 在比较值钱
leetcode:Palindrome Partitioning
binary_search的专栏
03-29 1456
Given a string s, partition s such that every substring of the partition is a palindrome. Return all possible palindrome partitioning of s. For example, given s = "aab", Return [ ["a
windows socket端口监听和多线程任务处理
binary_search的专栏
11-05 1050
本文本应该是和上一篇在一起的一个程序，但是由于是不同的内容，所以分开来写了。 整体思路是将端口监听程序写成一个服务，然后如果遇到服务请求就创建一个新的线程来处理这个请求，在原线程中用一个数组来记录当前所有的请求。本程序在VS2010下测试通过。下面是监听程序，使用非阻塞式socket，使用select来检查是否有请求到来。 DWORD CSampleService::ListenThrea
leetcode:Sqrt(x)
binary_search的专栏
04-03 1036
题目： Implement int sqrt(int x). Compute and return the square root of x. 做这道题目，做的真拙计。一开始想到了《最优化理论》里面的类似于二分法的方法，结果竟然超时。十分不解，后来换成了牛顿切线法，表示貌似我实现的是有问题的，我实现没有使用浮点数，在某些输入的情况下是有死循环的。google了之后，结果让
虚函数：从入门到精通
binary_search的专栏
05-03 979
什么是虚函数 C++2011标准（草稿）第10章第3小节给的描述为 Virtual functions support dynamic binding and object-oriented programming. A class that declares or inherits a virtual function is called a polymorphic class. If
leetcode: Regular Expression Matching
binary_search的专栏
11-22 967
Implement regular expression matching with support for '.' and '*'. '.' Matches any single character. '*' Matches zero or more of the preceding element. The matching should cover the entire input
leetcode: ZigZag Conversion
binary_search的专栏
11-17 838
The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility) P A H N A P L S I
windows service程序编写及原理
binary_search的专栏
11-05 829
一个windows服务由三部分组成:服务控制管理器，服务本身和服务控制调度器。 第一部分是服务控制管理器Service Control Manager(SCM)。每个Windows NT/2000系统都有一个SCM，SCM存在于Service.exe中，在Windows启动的时候会自动运行，伴随着操作系统的启动和关闭而产生和终止。这个进程以系统特权运行，并且提供一个统一的、安全的手段去控制服
leetcode: String to Integer (atoi)
binary_search的专栏
11-17 771
Implement atoi to convert a string to an integer. Hint: Carefully consider all possible input cases. If you want a challenge, please do not see below and ask yourself what are the possible input ca
leetcode: Longest Substring Without Repeating Characters
binary_search的专栏
11-16 749
Given a string, find the length of the longest substring without repeating characters. For example, the longest substring without repeating letters for "abcabcbb" is "abc", which the length is 3. Fo
leetcode: Reverse Integer
binary_search的专栏
11-17 717
Reverse digits of an integer. Example1: x = 123, return 321 Example2: x = -123, return -321 click to show spoilers. Have you thought about this? Here are some good questions to ask before c
Leetcode:63题不同路径||
最新发布
09-27
根据给出的参考代码，Leetcode第63题的题目是不同路径II。这道题目给定了一个包含障碍物的网格，机器人只能向右或向下移动，需要计算从左上角到右下角的不同路径数。如果有障碍物，那么该位置将被视为不可通过。 该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值