SRM 550 DIV2

 

 

250pt

题意：

给定两个只有两种字符组成的字符串，把一个字符变成另一个字符称为一次变换，求是否能从第一个字符串经过k次变换后变成第二个字符串。

 

分析：

首先求出至少需要多少次变换m，若k不小于m且k和m的差是偶数（1个字符通过两次变换后值不变），则能，否则不能. 

class EasyConversionMachine 
{ 
        public: 
        string isItPossible(string ow, string fw, int k) 
        { 
                int i,j,n=ow.size();
                for(i=j=0;i<n;i++)
                    if(ow[i]!=fw[i])
                        j++;
                if(k>=j&&(k-j)%2==0)
                    return "POSSIBLE";
                return "IMPOSSIBLE";
        } 
        
 
}; 

 

 

500pt

题意：

在一个长宽未知的网格图里，一个机器人开始面朝东方，两个移动规则：

1，它会一直往前走直到碰到墙壁或已经走过的格子，之后会往左转。

2，重复1直到停止。

给定一个机器人的移动步数序列，求面积最小的网格图

 

分析：

因为序列数和步长都小于50，直接模拟，之后再求出已访问过的格点的行和列的最小值和最大值，差即为所求长和宽的值，构造网格图的边界，再验证每步步长是否符合规则1。

 

class RotatingBot 
{ 
        public: 
        int minArea(vector <int> a) 
        {
            bool map[150][150]={false};
            int i,j,k,t,li,lj,ri,rj,v,n=a.size();
            int d[4][2]={{0,1},{-1,0},{0,-1},{1,0}};

            map[60][60]=true;
            for(k=t=0,i=j=60;k<n;k++)
            {
                for(v=0;v<a[k];v++)
                {
                    i+=d[t][0];
                    j+=d[t][1];
                    if(map[i][j])
                        return -1;
                    map[i][j]=true;
                }
                t=(t+1)%4;
            }
            li=lj=111;
            ri=rj=0;
            for(i=0;i<150;i++)
                for(j=0;j<150;j++)
                    if(map[i][j])
                    {
                        if(i<li)
                            li=i;
                        if(i>ri)
                            ri=i;
                        if(j<lj)
                            lj=j;
                        if(j>rj)
                            rj=j;
                    }
            int w=rj-lj+1,h=ri-li+1;

            memset(map,false,sizeof(map));
            map[60][60]=true;
            for(i=li-1,j=lj;j<=rj;j++)
                map[li-1][j]=map[ri+1][j]=true;
            for(i=li;i<=ri;i++)
                map[i][lj-1]=map[i][rj+1]=true;
            //for(i=li-1;i<=ri+1;i++,puts(""))
            //    for(j=lj-1;j<=rj+1;j++)
            //        printf("%d ",map[i][j]?1:0);
            for(k=t=0,i=j=60;k<n;k++)
            {
                for(v=0;;v++)
                {
                    i+=d[t][0];
                    j+=d[t][1];
                    if(map[i][j])
                    {
                        i-=d[t][0];
                        j-=d[t][1];
                        break;
                    }
                    map[i][j]=true;
                }
                if(k+1<n&&v!=a[k])
                    return -1;
                t=(t+1)%4;
            }
            return w*h;
        } 
        

}; 

 

 

1000pt

题意：

给定至多62个颜色唯一的矩形，把它们按照一定顺序放到网格图内，后放的矩形会覆盖前面所放的，所有矩形都没有被完全覆盖，求矩形的放置顺序（若有多个解，字典序最小）

 

分析：

看了半天,终于看出是拓扑排序。

覆盖是单向关系，即只能是后放的覆盖已放的，这种关系和拓扑很类似，解又是一个顺序，很容易想到是拓扑排序。

　　先求出每个矩形长和宽的至少值（与500分题行和列最小值和最大值的求法相同），再求它被哪些矩形所覆盖，构造拓扑边，剩下的就是拓扑排序了。

char L[]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

class TopView 
{ 
        public:
        int toVex(char c)
        {
            int k;
            for(k=0;L[k]!=c;k++);
            return k;
        }
        string findOrder(vector <string> grid) 
        {
            bool covered[66][66],has[66]={false},flag=true;
            string ret;
            int i,j,k,li,lj,ri,rj,n,m,v,w,to[66];
            memset(covered,0,sizeof(covered));
            memset(to,0,sizeof(to));
            n=grid.size();
            m=grid[0].size();
            for(v=0;v<62;v++)
            {
                li=lj=100;
                ri=rj=0;
                for(i=0;i<n;i++)
                {
                    for(j=0;j<m;j++)
                        if(grid[i][j]==L[v])
                        {
                            li=min(li,i);
                            ri=max(ri,i);
                            lj=min(lj,j);
                            rj=max(rj,j);
                        }
                }
                for(i=li;i<=ri;i++)
                    for(j=lj;j<=rj;j++)
                    {
                        has[v]=true;
                        if(grid[i][j]=='.')
                            return "ERROR!";
                        w=toVex(grid[i][j]);
                        if(v!=w)
                            covered[v][w]=true;
                    }
            }
            for(v=0;v<62;v++)
                for(w=0;w<62;w++)
                    if(covered[v][w])
                        to[w]++;
            for(;flag;)
            {
                flag=false;
                for(v=0;v<62;v++)
                    if(has[v]&&to[v]==0)
                    {
                        flag=true;
                        has[v]=false;
                        ret.push_back(L[v]);
                        for(w=0;w<62;w++)
                            if(covered[v][w])
                                to[w]--;
                        break;
                    }
            }
            for(v=0;v<62;v++)
                if(has[v])
                    return "ERROR!";
            return ret;
        } 
        
 
};