Sicily 1151. 魔板

原创 2013年12月03日 19:16:32

题目大意:

类似于华容道的按规则移动方块,达到预期状态。

算法思想及主要数据结构:

BFS(广搜)+ 康托展开 + Queue

1、BFS

I.   将初始状态放入队列,

II.  得到队列中的第一个状态,则从队列中pop

III. 得到pop出的状态与目标太进行比较,如果匹配则结束,否则对当前状态继续分别进行A、B、C三种操作,把得到的新状态依次放入队列。

IV.只要队列不为空,重复II操作。

 2、康托展开

康托展开是一种特殊的哈希函数,它的使用范围是对于n个数的排列进行状态的压缩和存储,例如要对9的全排列进行判重.没有必要开一个10^9的数组,同时内存也不允许开到那么大的数组.对此,有人提出了优化,即对于一个n的排列数,没有必要开到10^n,因为在一个排列中每个数只出现一次,所以只要前n-1位确定了,前N位就确定了。

但是以上的想法仍不是可行的,因为N可以很大,例如15,所以便引入了康托展开:只需要确定这个排列在总的排列情况中是第几小的就可以了。

例如: {1,2,3,4,...,n}表示1,2,3,...,n的排列如 {1,2,3} 按从小到大排列一共6个。123 132 213 231 312321 。

代表的数字 1 2 3 4 5 6 也就是把10进制数与一个排列对应起来。

他们间的对应关系可由康托展开来找到。

如我想知道321是{1,2,3}中第几个小的数可以这样考虑 :

第一位是3,当第一位的数小于3时,那排列数小于321 如 123、 213 ,小于3的数有1、2 。所以有2*2!个。再看小于第二位2的:小于2的数只有一个就是1 ,所以有1*1!=1 所以小于321的{1,2,3}排列数有2*2!+1*1!=5个。所以321是第6个小的数。 2*2!+1*1!+0*0!就是康托展开。

再举个例子:1324是{1,2,3,4}排列数中第几个大的数:第一位是1小于1的数没有,是0个 0*3! 第二位是3小于3的数有1和2,但1已经在第一位了,所以只有一个数2 1*2! 。第三位是2小于2的数是1,但1在第一位,所以有0个数 0*1! ,所以比1324小的排列有0*3!+1*2!+0*1!=2个,1324是第三个小数。

3、A、B、C操作的数学方法

A操作(结果存入m,n变量中)

after.x= curr.y;

after.y= curr.x;

B操作

after.x= after.x + curr.x[3]+curr.x[0]+curr.x[1]+curr.x[2]; 

after.y= after.y + curr.y[3]+curr.y[0]+curr.y[1]+curr.y[2]; 

C操作:

after.x = after.x +curr.x[0]+curr.y[1]+curr.x[1]+curr.x[3]; 

after.y = after.y +curr.y[0]+curr.y[2]+curr.x[2]+curr.y[3]; 

 

#include <iostream>
#include <cstring>
#include <queue> 

using namespace std;

struct Record{
    string x,y;
    string op;   
}start,target;

const int PermSize = 8;
int factory[] = { 1, 1, 2, 6, 24, 120,720, 5040 }; // 7的阶乘(n-1的阶乘) 
bool isVisited[50000];

void initial(){
    
    string tmp = ""; 
            
    // 初始化初态魔板 
    start.x = "1234";
    start.y = "8765";
    start.op = "";
    
    target.x = "";
    target.y = "";  
    
    for(int i = 0;i < 4;i++){  
       cin >> tmp; 
       target.x += tmp;  
    }  
    for(int j = 0;j < 4;j++){  
       cin >> tmp; 
       target.y += tmp;  
    }  
    
    memset(isVisited, false ,sizeof(isVisited)); 
}

int cantor( string buf ) 
{
    int i, j, counted;
    int result = 0;
    for ( i = 0; i < PermSize; ++i ) 
    {
        counted = 0;
        for( j = i + 1; j < PermSize + 1; ++j )
            if( buf[i] > buf[j] )
                ++counted;
        result = result + counted * factory[PermSize - i - 1];
    }
    return result;
}

bool isEqual(const Record &A,const Record &B){
    return ( A.x == B.x && A.y == B.y ); 
}

Record operate(Record curr, Record after,int operation)  
{  
    switch(operation){
        case 0: 
            after.x = curr.y; 
            after.y = curr.x;  
            after.op += "A";
            break;  
        case 1: 
            after.x = after.x + curr.x[3]+curr.x[0]+curr.x[1]+curr.x[2];  
            after.y = after.y + curr.y[3]+curr.y[0]+curr.y[1]+curr.y[2];  
            after.op += "B"; 
            break;
        case 2: 
            after.x = after.x + curr.x[0]+curr.y[1]+curr.x[1]+curr.x[3];  
            after.y = after.y + curr.y[0]+curr.y[2]+curr.x[2]+curr.y[3];  
            after.op += "C";
            break;  
    }
    return after;  
}  

// 广搜 
void bfs( int m ){
    if( isEqual(start,target) ){ 
        cout << 0 << endl;
        return;
    }
    queue<Record> records;
    records.push(start);
    
    // 队列不为空 
    while( !records.empty() ){
        Record curr = records.front();
        records.pop();
        
        // 如果操作次数大于要求次数则返回-1 
        if( curr.op.size() > m ) {
            cout << -1 << endl;  
            return;
        }
        
        // 当前态与目标太匹配则返回 
        if( isEqual(curr, target) ){
            cout << curr.op.size() << " " << curr.op << endl; 
            return;
        }
        
        // 循环进行A,B,C操作 
        for( int i = 0; i < 3; i++ ){
            Record after;
            after.x = ""; 
            after.y =""; 
            after.op = curr.op;
            
            after = operate(curr,after,i);     
                   
            int cn = cantor( after.x + after.y ); 
            if( !isVisited[ cn ]){
                isVisited[ cn ] = true;
                records.push(after);
            }    
        }                              
    }       
}
 
int main(){
    
    int m;
    
    while( cin >> m && m != -1 ){
        initial();
        bfs(m);
    }        
    
    return 0;
}




版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Sicily 1151 魔板 Another Thought

上课听到旁边同学在讨论这道题,说是要用康托展开,h

[sicily]1151. 魔板

1151. 魔板 Constraints Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge Description 题目和A题...

sicily1151魔板

sicily1151 魔板解题报告   1. 原题中文大意 由8个大小相同方块组成的魔板,初始状态是1 2 3 4               ...
  • liaoxr
  • liaoxr
  • 2011-10-31 21:35
  • 1204

[Sicily 1150 1151 1515 魔板] BFS+判重(康托展开)

1150、1151、1515都是魔板的题目,只是数据规模以及一些操作不同,1515的步数上限N最大会达到100。所以,我选择直接解决1515魔板C。这样就相当于同时解决了1150、1151、1515。...

sicily1151&魔板2

/* * main.cpp * * Created on: 2014年9月16日 */ #include #include #include #include #include ...

sicily 1151 魔板

1151. 魔板 Constraints Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge Description 题目和A题相同,在...

Sicily 1515. 魔版C

换汤不换药,还想用个N Run Time: 0.22sec Run Memory: 4528KB Code length: 1978Bytes SubmitTime: 2012-01-0...

sicily 1515. 魔版C[Special judge]

Description 魔板由8个大小相同方块组成,分别用涂上不同颜色,用1到8的数字表示。 其初始状态是 1 2 3 4 5 6 7 8 对魔板可进行三种基本操作: A操作(左右两列...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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