The Castle chapter 2.1

  看到题目介绍我就虚了，看到问题我更虚了，结果写了堆又臭又长的代码，提交了几次，改了几个错误，想着最后肯定超时，没想到竟然过了...

/*
ID: hubiao cave
PROG: castle
LANG: C++
*/


#include <iostream>
#include <fstream>
#include <cstring>
#include <set>
#include <deque>
#include <algorithm>
using namespace std;

#define EDGE 9999 

struct ROOM
{ 
    int wnes[4];
    ROOM()
    {
        memset(wnes,0,4*4);
    }
};

struct WALL
{
    int row;
    int col;
    char ch;
};

struct TWOPTR
{
    set<int>*p1;
    set<int>*p2;
};

ROOM rooms[2502];
bool visited[2502]={0};

void restore(int row,int column,ifstream* fin);
void dfs(int,set<int>*);

bool lesssize(set<int>*, set<int>*);
bool canmerge(set<int>*,set<int>*);
bool operator < (const WALL&,const WALL&);


ifstream* pfin;
deque<set<int>* >liset;
set<WALL> sw;
deque<TWOPTR> dt;

int grow,gcolumn;


int main()
{
     pfin=new ifstream("castle.in");
     ofstream fout("castle.out");

    int row,column;
    int count=0;
    *pfin>>column>>row;
    grow=row;
    gcolumn=column;

    restore(row,column,pfin);
    for(int i=1;i<=row*column;i++)
    {
        if(!visited[i])
        {
            set<int>*pset=new set<int>;
            dfs(i,pset);
            liset.push_back(pset);
            count++;
        }
    }
    fout<<count<<endl;
    int maxsize=0;
    for(deque<set<int>*>::iterator it=liset.begin();it!=liset.end();it++)
    {
        if((*it)->size()>maxsize)
        {
            maxsize=(*it)->size();
        }

    }
    fout<<maxsize<<endl;
    sort(liset.begin(),liset.end(),lesssize);

    
    set<int>*p1,*p2;
    int maxsum=0;
    for(int i=liset.size()-1;i>=0;i--)
    {

        for(int j=i-1;j>=0;j--)
        {
            if(canmerge(liset[j],liset[i]))
            {

                if(maxsum==liset[j]->size()+liset[i]->size())
                {
                TWOPTR tp;
                tp.p1=liset[j];
                tp.p2=liset[i];
                dt.push_back(tp);
                }
                if(maxsum<liset[j]->size()+liset[i]->size())
                {
                p1=liset[j];
                p2=liset[i];
                TWOPTR tp;
                tp.p1=p1;
                tp.p2=p2;
                dt.clear();
                dt.push_back(tp);
                maxsum=liset[j]->size()+liset[i]->size();
                }


            }

        }

    }
    fout<<maxsum<<endl;

    for(deque<TWOPTR>::iterator it=dt.begin();it!=dt.end();it++)
    {
        p1=(*it).p1;
        p2=(*it).p2;


    for(set<int>::iterator it=p1->begin();it!=p1->end();it++)
    {
        int number=*it;
        if(number%gcolumn!=1)
        {
            if(p2->count(number-1))
            {
                WALL wa;
                if(number%column!=0)
                wa.row=number/column+1;
                else
                    wa.row=number/column;
                if(number%column!=0)
                    wa.col=number%column-1;
                else
                    wa.col=column-1;

                wa.ch='E';
                sw.insert(wa);
            }
                
        }
        if(number>gcolumn)
        {
            if(p2->count(number-gcolumn))
            {
                WALL wa;
                if(number%column!=0)
                wa.row=number/column+1;
                else
                    wa.row=number/column;
                if(number%column!=0)
                    wa.col=number%column;
                else
                    wa.col=column;
                wa.ch='N';
                sw.insert(wa);
            }
                
        }
        if(number%gcolumn!=0)
        {
            if(p2->count(number+1))
            {
                WALL wa;
                wa.row=number/column+1;
                wa.col=number%column;
                wa.ch='E';
                sw.insert(wa);
            }
        }
        if(number<=(grow-1)*gcolumn)
        {
            if(p2->count(number+gcolumn))
            {
                WALL wa;
               if(number%column!=0)
                wa.row=number/column+2;
                else
                    wa.row=number/column+1;
                if(number%column!=0)
                   wa.col=number%column;
                else
                    wa.col=column;
                wa.ch='N';
                sw.insert(wa);
            }
        }
    }
    }
    fout<<(*sw.begin()).row<<" "<<(*sw.begin()).col<<" "<<(*sw.begin()).ch<<endl;

    return 0;
}

void restore(int row,int column,ifstream* fin)
{
    for(int i=1;i<=row;i++)
        for(int j=1;j<=column;j++)
        {
            int t;
            *fin>>t;
    
            if(!(t&1))//西面没墙
            {
                if(j!=1)
                    rooms[(i-1)*column+j].wnes[0]=(i-1)*column+j-1;
                else
                    rooms[(i-1)*column+j].wnes[0]=EDGE;
            }

            if(!(t&2))
            {
                if(i!=1)
                    rooms[(i-1)*column+j].wnes[1]=(i-2)*column+j;
                else
                    rooms[(i-1)*column+j].wnes[1]=EDGE;

            }
            if(!(t&4))
            {
                if(j!=column)
                    rooms[(i-1)*column+j].wnes[2]=(i-1)*column+j+1;
                else
                    rooms[(i-1)*column+j].wnes[2]=EDGE;
            }
            if(!(t&8))
            {
                if(i!=row)
                    rooms[(i-1)*column+j].wnes[3]=i*column+j;
                else
                    rooms[(i-1)*column+j].wnes[3]=EDGE;
            }
        }
}
void dfs(int index,set<int>* pset)
{

    if(!visited[index])
    {
        visited[index]=1;
        pset->insert(index);
        for(int i=0;i<4;i++)
        {
            if(rooms[index].wnes[i]!=0&&rooms[index].wnes[i]!=EDGE)
            {
                dfs(rooms[index].wnes[i],pset);
            }
        }
    }
    else
        return;
}
bool lesssize( set<int>* s1, set<int>* s2)
{
    return s1->size()<s2->size();
}
bool canmerge(set<int>* s1,set<int>* s2)
{
    for(set<int>::iterator it=s1->begin();it!=s1->end();it++)
    {
        int number=*it;
        if(number%gcolumn!=1)
        {
            if(s2->count(number-1))
                return true;
        }
        if(number>gcolumn)
        {
            if(s2->count(number-gcolumn))
                return true;
        }
        if(number%gcolumn!=0)
        {
            if(s2->count(number+1))
                return true;
        }
        if(number<=(grow-1)*gcolumn)
        {
            if(s2->count(number+gcolumn))
                return true;
        }
    }
    return false;
}
bool operator < (const WALL& w1,const WALL& w2)
{
    if(w1.col!=w2.col)
        return w1.col<w2.col;
    if(w1.row!=w2.row)
        return w1.row>w2.row;
    return w1.ch>w2.ch;

}