浙江大学 ACM 1002题 (三种解法·转载)

原创 2007年09月11日 16:40:00

①用C语言实现

#include<stdio.h>
#define MAX 4
#define WALL -1
char map[MAX+2][MAX+2];
int size,max,cur,depth;
void test(){
    int i =depth/size +1, j =depth%size +1,n;
    if(depth>=size*size){
        if(cur>max) max =cur;
        return;
    }
    if(!map[i][j]){
        map[i][j] =1;
        for(n=i+1;map[n][j]!=WALL;n++) map[n][j]++;
        for(n=i-1;map[n][j]!=WALL;n--) map[n][j]++;
        for(n=j+1;map[i][n]!=WALL;n++) map[i][n]++;
        for(n=j-1;map[i][n]!=WALL;n--) map[i][n]++;
        depth++;
        cur++;
        test();
        cur--;
        depth--;
        for(n=i+1;map[n][j]!=WALL;n++) map[n][j]--;
        for(n=i-1;map[n][j]!=WALL;n--) map[n][j]--;
        for(n=j+1;map[i][n]!=WALL;n++) map[i][n]--;
        for(n=j-1;map[i][n]!=WALL;n--) map[i][n]--;
        map[i][j] =0;
    }
    depth++;
    test();
    depth--;
}
void main(){
    int i,j;
    while(scanf_s("%d",&size)!=EOF&&size>0){
        getchar();
        for(i=0;i<=size+1;i++) 
           map[0][i] =map[size+1][i] =map[i][0] =map[i][size+1] =WALL;//四面都是墙
        for(i=1;i<=size;i++){
           for(j=1;j<=size;j++) map[i][j] = (getchar()=='X')?WALL:0;//输入内部构造
           getchar();
        }
        max =cur =depth =0;
        test();
        printf("%d/n",max);
    }
}

②用C++实现标准库实现

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


enum Tag
{
  STREET=0,
  VISITED=1,
  WALL=2,
  ERROR=-1
};
class Point
{
  public:
    int x;
    int y;
};
int Transfer(char ch)
{
  switch(ch)
  {
    case '.':
      return STREET;  //street
      break;
    case 'X':
      return WALL;  //wall
      break;
    default:
      return ERROR; //wrong input
    break;
  }
}
void Readin(vector< vector<int> > &map, int n)
{
  for(int row=0;row<n;row++)
  {
    vector<int> r(n);
    string line;
    cin>>line;
    for(int col=0;col<n;col++)
      r[col]=Transfer(line[col]);
    map.push_back(r);
  }
}
void Scan(vector< vector<int> >& map, int i, int j, vector<Point>& pvec)
{
  int size=map.size();
  //backward
  for(int b=j-1;b>=0;b--)
  {
    if(map[i][b]==WALL)
    {
      break;
    }
    else if(map[i][b]==STREET)
    {
      map[i][b]=VISITED;
      Point pt;
      pt.x=i;
      pt.y=b;
      pvec.push_back(pt);
    }
  }
  //forward
  for(int f=j+1;f<size;f++)
  {
    if(map[i][f]==WALL)
    {
      break;
    }
    else if(map[i][f]==STREET)
    {
      map[i][f]=VISITED;
      Point pt;
      pt.x=i;
      pt.y=f;
      pvec.push_back(pt);
    }
  }
 
  //up
  for(int u=i-1;u>=0;u--)
  {
    if(map[u][j]==WALL)
    {
      break;
    }
    else if(map[u][j]==STREET)
    {
      map[u][j]=VISITED;
      Point pt;
      pt.x=u;
      pt.y=j;
      pvec.push_back(pt);
    }
  }
  //down
  for(int d=i+1;d<size;d++)
  {
    if(map[d][j]==WALL)
    {
      break;
    }  
    else if(map[d][j]==STREET)
    {
      map[d][j]=VISITED;
      Point pt;
      pt.x=d;
      pt.y=j;
      pvec.push_back(pt);
    }
  }
}
void ResetScan(vector< vector<int> >& map, vector<Point>& pvec)
{
  for(int k=0;k<pvec.size();k++)
  {
    Point pt=pvec[k];
    map[pt.x][pt.y]=STREET;
  }
}
bool FindStreet(vector< vector<int> >& map)
{
  int size=map.size();
  for(int i=0;i<size;i++)
    for(int j=0;j<size;j++)
      if(map[i][j]==STREET)
        return true;
  return false;
}
void DFS(vector< vector<int> >& map, int& max, int& count)
{
  if(!FindStreet(map))
  {
    max=max>count?max:count;
    return;
  }
 
  int size=map.size();
  for(int i=0;i<size;i++)
  {
    for(int j=0;j<size;j++)
    {
      if(map[i][j]==STREET)
      {
        map[i][j]=VISITED;
        count++;
        vector<Point> pvec;
        Scan(map, i, j, pvec);
        DFS(map, max, count);
    
        map[i][j]=STREET;
        count--;
        ResetScan(map, pvec);
      }
    }
  }
}
 
int main()
{
  int n;
  cin>>n;
  while(n!=0)
  {
    vector< vector<int> > Map;
    Readin(Map,n);
    int count=0;
    int max=0;
    DFS(Map, max, count);
    cout<<max<<endl;
    cin>>n;
  }
  return 0;
}
 
这个问题本质上是约束条件下的搜索问题。
这里使用DFS来做。只适合于问题规模不大的情况。
另外也可以使用二分图的匹配方法来做,时间复杂度要低。

③用C++队列实现

#i nclude<iostream>
#i nclude<math.h>
using std::cout;
using std::endl;
using std::cin;
//0 空格 1 被射击 2 房子 3 墙
struct  CiteSite
{
 int x,y;     //方格中的位置
    CiteSite(){}
 CiteSite(int i,int j){x=i;y=j;}
};
struct CityPic
{
 unsigned long Buf[2]; //用来压缩方格
 CityPic(){};
 CityPic(const CityPic &item){Buf[0]=item.Buf[0];Buf[1]=item.Buf[1];}
};
struct CityPics
{
int M;            //M*M
CityPic citypic;
};
template<class NodeEntry>
struct Node
{
 Node():Next(NULL){}
 Node(const NodeEntry &entry):Entry(entry){}
 NodeEntry Entry;
 Node *Next;
};
template<class NodeEntry>
class Queue 
{
public:
 Queue();                                      //构造函数
 ~Queue();                                     //析构函数
 bool         IsEmpty() const;                 //队列是否为空
 NodeEntry    Server();                        //返回并去掉队首元素
    void         Append(const NodeEntry &item);   //添加一个队尾元素
    void         Retrieve(NodeEntry &item) const; //取得队首元素
 int          Size()const;                     //队列现有元素个数   
 void         Clear();                         //队列清空
 int iCount;
    Node<NodeEntry> *Front,*Rear;
};
void GetCity(char Buf[][4],int M);                 //读取输入的方格
void InCode(CityPic& citypic,char Buf[][4]);       //方格编码
void OutCode(CityPic &citypic,char Buf[][4]);      //方格解码
void CopyBuf(char Buf[][4],char OldBuf[][4]);      //复制方格
int  SeachCity(char Buf[][4],int M,Queue<CiteSite> &CitySiteQueue);//将可建房的位置装入CitySiteQueue
bool IsCityPicInQueue(CityPic& citypic,Queue<CityPic> &queue);     //队列中是否存在该方格的编码
bool IsCityPicCanBeExpand(char Buf[][4],int M);                    //该方格是否可扩展
void ExpandCityPic(char Buf[][4],int x,int y,int M);               //扩展方格
int  CountHouse(char Buf[][4],int M);                              //计算方格中的房子数量
/***************************************************************************************/
/****************************************************************************************/
int main()
{
 CityPic citypic;              //方格编码
 Queue<CityPic> queue;         //方格编码队列
 CityPics citypics;            //带M的方格编码
 Queue<CityPics> CityPicsQueue;//带M的方格编码队列
    CiteSite citysite;            //方格中的位置坐标
 Queue<CiteSite> CitySiteQueue;//坐标队列
 bool bWorking=true;           //是否进行方格处理
 char   OldCityBuf[4][4]={0}; 
 char   CityBuf[4][4]={0};
 int M;
 cin>>M;
    while(M!=0)
 {
  GetCity(OldCityBuf,M);
        InCode(citypics.citypic,OldCityBuf);
        citypics.M=M;   //输入  带M的方格编码到CityPicsQueue             
     CityPicsQueue.Append(citypics);
  cin>>M;
 }
 while(CityPicsQueue.iCount>0)
 {
     citypics=CityPicsQueue.Server();
        M=citypics.M;
  OutCode(citypics.citypic,OldCityBuf);  //取得原始方格
  if(!IsCityPicCanBeExpand(OldCityBuf,M))
  {
   cout<<0<<endl;
   continue;
  }
  bWorking=true;
  while(bWorking)
  {
   SeachCity(OldCityBuf,M,CitySiteQueue);//装入坐标队列
   while(CitySiteQueue.iCount>0)
   {
   citysite=CitySiteQueue.Server();
    CopyBuf(CityBuf,OldCityBuf);
    ExpandCityPic(CityBuf,citysite.x,citysite.y,M);//扩展
    if(!IsCityPicCanBeExpand(CityBuf,M))
    {
     if(queue.iCount==0&&CitySiteQueue.iCount<=0)    
     {
      bWorking=false;
     cout<<CountHouse(CityBuf,M)<<endl;
     break;
     }
     else continue;
    }   
    InCode(citypic,CityBuf);//编码
    if(IsCityPicInQueue(citypic,queue))
    {
     continue;
    }
    queue.Append(citypic); //编码入队
   }
   if(bWorking)
   {
   citypic=queue.Server();  //取新编码
   OutCode(citypic,OldCityBuf);//解码
   }
  }
 }
 return 0;
}
/**************************************************************************************/
/**************************************************************************************/
void GetCity(char Buf[][4],int M)
{
 char c;
 memset(Buf,16,0);
 for(int i=0;i<M;i++)
  for(int j=0;j<M;j++)
  {
   cin>>c;
   if(c=='.') Buf[i][j]=0;
   else Buf[i][j]=3;
  }
}
void InCode(CityPic& citypic,char Buf[][4])
{
 memset(&citypic,sizeof(CityPic),0);
 citypic.Buf[0]=Buf[0][0]+
  Buf[0][1]*10+
  Buf[0][2]*100+
  Buf[0][3]*1000+
  Buf[1][0]*10000+
  Buf[1][1]*100000+
  Buf[1][2]*1000000+
  Buf[1][3]*10000000+
  Buf[2][0]*100000000;
 citypic.Buf[1]=Buf[2][1]+
  Buf[2][2]*10+
  Buf[2][3]*100+
  Buf[3][0]*1000+
  Buf[3][1]*10000+
  Buf[3][2]*100000+
  Buf[3][3]*1000000;
}
void OutCode(CityPic &citypic,char Buf[][4])
{
 memset(Buf,16,0);
 Buf[0][0]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[0][1]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[0][2]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[0][3]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[1][0]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[1][1]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[1][2]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[1][3]=citypic.Buf[0]%10;
 citypic.Buf[0]/=10;
 Buf[2][0]=citypic.Buf[0]%10;
 
 Buf[2][1]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[2][2]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[2][3]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[3][0]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[3][1]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[3][2]=citypic.Buf[1]%10;
 citypic.Buf[1]/=10;
 Buf[3][3]=citypic.Buf[1]%10;
}
void CopyBuf(char Buf[][4],char OldBuf[][4])
{
 for(int i=0;i<4;i++)
  for(int j=0;j<4;j++)
   Buf[i][j]=OldBuf[i][j];
}
int  SeachCity(char Buf[][4],int M,Queue<CiteSite> &CitySiteQueue)
{
 int r=0;
 for(int i=0;i<M;i++)
  for(int j=0;j<M;j++)
  {
   if(Buf[i][j]==0)
   {
    r++;
            CitySiteQueue.Append(CiteSite(i,j));
   }
  }
  return r;
}
bool IsCityPicInQueue(CityPic& citypic,Queue<CityPic>&queue)
{
 Node<CityPic> *pNode=queue.Front;
 int i=queue.iCount;
 while(i>0)
 {
  if((citypic.Buf[0]==pNode->Entry.Buf[0])&&(citypic.Buf[1]==pNode->Entry.Buf[1]))
   return true;
  pNode=pNode->Next;
  i--;
 }
 return false;
}
bool IsCityPicCanBeExpand(char Buf[][4],int M)
{
 for(int i=0;i<M;i++)
  for(int j=0;j<M;j++)
  {
   if(Buf[i][j]==0)
    return true;
  }
  return false;
}
void ExpandCityPic(char Buf[][4],int x,int y,int M)
{
 int i=x,j=y;
 Buf[x][y]=2;
 while(i>0)
 {
  if(Buf[i-1][y]!=3)
   Buf[i-1][y]=1;
  else break;
  i--;
 }
 i=x;
 while(i<M-1)
 {
  if(Buf[i+1][y]!=3)
   Buf[i+1][y]=1;
  else break;
  i++;
 }
 j=y;
 while(j>0)
 {
  if(Buf[x][j-1]!=3)
   Buf[x][j-1]=1;
  else break;
  j--;
 }
 j=y;
 while(j<M-1)
 {
  if(Buf[x][j+1]!=3)
   Buf[x][j+1]=1;
  else break;
  j++;
 }
}
int  CountHouse(char Buf[][4],int M)
{
 int r=0;
 for(int i=0;i<M;i++)
  for(int j=0;j<M;j++)
  {
   if(Buf[i][j]==2)
    r++;
  }
  return r;
}
/***********************************构造函数*******************************************/
template<class NodeEntry>
Queue<NodeEntry>::Queue()
{
 iCount=0;
 Front=Rear=NULL;
}
/***********************************析构函数*******************************************/
template<class NodeEntry>
Queue<NodeEntry>::~Queue()
{
 Clear();
}
/***********************************队列是否为空***************************************/
template<class NodeEntry>
bool Queue<NodeEntry>::IsEmpty() const
{
 return (iCount==0);
}
/*********************************返回并去掉队首元素**********************************/
template<class NodeEntry>
NodeEntry  Queue<NodeEntry>::Server()
{
 NodeEntry entry;
 if(Front==NULL)cout<<"The Queue is empty!/n";
    Node<NodeEntry> *pNode=Front;
    Front=Front->Next;
 entry=pNode->Entry;
 delete pNode;
 iCount--;
 if(iCount<=0) Front=Rear=NULL;
 return entry;
}
/*********************************添加一个队尾元素************************************/
template<class NodeEntry>
void  Queue<NodeEntry>::Append(const NodeEntry &item)
{
 Node<NodeEntry> *pNode=new Node<NodeEntry>(item);
 if(Rear==NULL) Front=Rear=pNode;
 else
 {
  Rear->Next=pNode;
  Rear=pNode;
 }
 iCount++;
}
/********************************取得队首元素*****************************************/
template<class NodeEntry>
void  Queue<NodeEntry>::Retrieve(NodeEntry &item) const
{
 item=Front->Entry;
}
/*******************************队列现有元素个数***************************************/
template<class NodeEntry>
int   Queue<NodeEntry>::Size()const
{
 return iCount;
}
/*******************************队列清空***********************************************/
template<class NodeEntry>
void  Queue<NodeEntry>::Clear()
{
 Node<NodeEntry> *pNode;
 while(iCount>0)
 {
  pNode=Front;
  Front=Front->Next;
  delete pNode;
  iCount--;
 }
 Front=Rear=NULL;
}

 

相关文章推荐

浙江大学ACM1002题

  • 2009年11月01日 22:46
  • 2KB
  • 下载

题目1002:Grading 2011年浙江大学计算机及软件工程研究生机试真题

Grading 2011年浙江大学计算机及软件工程研究生机试真题 Grading hundreds of thousands of Graduate Entrance Exams is a hard ...
  • ZJFCLH
  • ZJFCLH
  • 2014年03月16日 22:27
  • 1053

1002 Grading(2011年浙江大学计算机及软件工程研究生机试真题)

题目描述:     Grading hundreds of thousands of Graduate Entrance Exams is a hard work. It is even har...

浙江大学ZOJ 1002题 详解

欢迎来看一个小新手的博客 前几天第一次代表内蒙古大学参加了在上海大学举办的ec-final 被狠虐了一顿之后发现了自己不足,和真正的一流大学相比天差地别,于是回来打算尽自己努力练一下自己的算法,起码要...

浙江大学ACM俱乐部 1028:行车路程

1.说白了,读取输入就两种可能,一种是一个变量一个变量读取,另一种就是读取字符串,读取一个文件的话,也是按照字符串处理,所以说白了,其实还是在读字符串。 2.为了读懂题目,最好自己把测试数据好好看看...

浙江大学ACM俱乐部 1011:软件版本

这个题要考虑一下,版本号未必是个位数,故想把三个版本号用1,10,100加权再比较的同学是行不通的。 题目描述 相信大家一定有过在网上下载软件而碰到多个不同版本的情况。一般来说,软...

浙江大学ACM俱乐部 1025:统计硬币

题目描述 假设一堆由1分、2分、5分组成的n个硬币总面值为m分,求一共有多少种可能的组合方式(某种面值的硬币可以数量可以为0)。 输入格式 输入数据第一行有一个正整数T,表示有T组测...

浙江大学ACM俱乐部 2029:欧拉回路

说实话,看到这道题我还不懂什么叫“欧拉回路”、、、

浙江大学 ACM俱乐部 1990:Grading abs和fabs函数的用法和头文件

这道题目很简单,不

ZOJ acm 大大牛们的 牛逼语录~O(∩_∩)O~摘自浙江大学ACM网站

特地转过来,激励一下自己!! 转自:http://hi.baidu.com/sunnyykn/blog/item/f972f60841ad59c73bc76382.html 于某天摘自...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:浙江大学 ACM 1002题 (三种解法·转载)
举报原因:
原因补充:

(最多只允许输入30个字)