康拓展开

http://baike.baidu.com/item/%E5%BA%B7%E6%89%98%E5%B1%95%E5%BC%80?force=1

就是百度百科的康拓展开解决魔板问题的代码 打了一遍 调试了一下 长了一下姿势

感觉就是和状压一样 展开就是为了标记？

一共只有8格 即8!=40320个状态 

用ans记录下 每个状态从12345678开始 最快能变到的步骤

init就是一次从12345678开始搜到底的bfs    ( 所谓搜到底 就是遍历了每一个状态

但是输入的起点(即初始状态)不是12345678怎么办呢？

比如输入的是82754631       17245368

我们只需要把这串数与12345678一一对应  

也就是把8看成1，2看成2，7看成3，5看成4，4看成5，6看成6，3看成7，1看成8

那么我们希望得到的最终状态就相当于83254761

于是我们只要求出83254761的康诺展开 它对应的ans就是答案。

//由于此题数字1~8，康托展开的所有情况为8!，共40320种
LL JC[]={1,1,2,6,24,120,720,5040};//康托展开中用到的0~7的阶乘
string ans[50005];
struct node
{
    int a[8];
    int n;
}front, rear;
queue<node> q;
bool vis[50005];
void A(node &t) // 上下两行互换
{
    swap(t.a[0], t.a[7]);
    swap(t.a[1], t.a[6]);
    swap(t.a[2], t.a[5]);
    swap(t.a[3], t.a[4]);
}
void B(node &t)  // 每行同时循环右移一格
{
    swap(t.a[3], t.a[2]);
    swap(t.a[2], t.a[1]);
    swap(t.a[1], t.a[0]);
    swap(t.a[4], t.a[5]);
    swap(t.a[5], t.a[6]);
    swap(t.a[6], t.a[7]);

}
void C(node &t) // 中间4个方块顺时针旋转一格
{
    swap(t.a[1], t.a[6]);
    swap(t.a[6], t.a[5]);
    swap(t.a[5], t.a[2]);
}
int contor(node &t)
{
    int num=0;
    for(int i=0;i<8;i++)
    {
        int tmp=0;
        for(int j=i+1;j<8;j++)
            if(t.a[j]<t.a[i])
                tmp++;
        num+=tmp*JC[7-i];
    }
    return num;
}
void init()
{
    memset(vis, 0, sizeof(vis));
    while(!q.empty())
        q.pop();
    vis[0]=1;
    for(int i=0;i<8;i++) //由初始状态12345678开始
        front.a[i]=i+1;
    front.n=contor(front);
    q.push(front);
    void (*way[3])(node&);       //定义函数指针
    way[0]=A, way[1]=B, way[2]=C;//指向对应函数方便处理
    while(!q.empty())
    {
        front=q.front();
        q.pop();
        for(int i=0;i<3;i++) //三种变换
        {
            rear=front;
            (way[i])(rear);
            rear.n=contor(rear); //对副本执行操作并康托展开
            if(!vis[rear.n])    //重复
            {
                char ch='A'+i;
                ans[rear.n]=ans[front.n]+ch;   //当前排列的步数
                vis[rear.n]=1;
                q.push(rear);
            }
        }
    }
}
char a[10], b[10];
int n[10];
int main()
{
    init();
    while(~scanf("%s%s", a, b))
    {
        for(int i=0;i<8;i++)
            n[a[i]-'0']=i+1;
        for(int i=0;i<8;i++)
            front.a[i]=n[b[i]-'0'];
        cout<<ans[contor(front)]<<endl;
    }
    return 0;
}
/*
12345678
17245368

12345678
82754631
*/

本来想这种方法写一次八数码，然后发现预处理12345678的方法行不通，因为8(也就是x)所在的位置直接影响变换 也就是不能把某个数字当成是8

然后直接从输入的状态开始搜的话 先后经历了WA TLE MLE之后 放弃了。。。

逆展开

计算k个数字的全排列(从小到大) 第x+1个排列是：

int JC[]={1,1,2,6,24,120,720,5040,40320,362880};
int ans[9];  // 返回的数组
void uncantor(int x, int k)   //k个数字的全排列的 第x+1个
{
    bool h[12];
    for(int i=1; i<=k; i++)
    {
        int t=x/JC[k-i];
        x-=t*JC[k-i];
        int j, l=0;
        for(j=1; l<=t; j++)
            if(!h[j])
                l++;
        j--;
        h[j]=true;
        ans[i-1]=j;
    }
}
int main()
{
    uncantor(95, 5);
    for(int i=0;i<5;i++)
        printf("%d", ans[i]);
    return 0;
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
    static BigInteger li=BigInteger.ZERO;
    static BigInteger yi=BigInteger.ONE;
    static BigInteger er=BigInteger.valueOf(2);
    static BigInteger ten=BigInteger.valueOf(10);
    static BigInteger []JC=new BigInteger[25];
    static int []ans=new int[20];
    public static void getJC()
    {
        JC[0]=yi;
        for(int i=1;i<=20;i++)
            JC[i]=JC[i-1].multiply(BigInteger.valueOf(i));
    }
    public static void uncantor(BigInteger x, int k)
    {
        boolean []h=new boolean[25];
        for(int i=0;i<25;i++)
            h[i]=false;
        for(int i=1;i<=k;i++)
        {
            BigInteger t=x.divide(JC[k-i]);
            x=x.subtract(t.multiply(JC[k-i]));
            int j, l=0;
            int tt=t.intValue();
            for(j=1;l<=tt;j++)
                if(!h[j])
                    l++;
            j--;
            h[j]=true;
            ans[i-1]=j;
        }
    }
    public static void main(String[] args)
    {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        getJC();
        while(in.hasNext())
        {
            BigInteger x=in.nextBigInteger();
            int k=in.nextInt();
            uncantor(x, k);
            for(int i=0;i<k;i++)
                out.print(ans[i]);
        }
        out.close();
    }
}
class InputReader
{
    BufferedReader buf;
    StringTokenizer tok;
    InputReader()
    {
        buf = new BufferedReader(new InputStreamReader(System.in));
    }
    boolean hasNext()
    {
        while(tok == null || !tok.hasMoreElements()) 
        {
            try
            {
                tok = new StringTokenizer(buf.readLine());
            } 
            catch(Exception e) 
            {
                return false;
            }
        }
        return true;
    }
    String next()
    {
        if(hasNext()) 
            return tok.nextToken();
        return null;
    }
    int nextInt()
    {
        return Integer.parseInt(next());
    }
    long nextLong()
    {
        return Long.parseLong(next());
    }
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
    BigInteger nextBigInteger()
    {
        return new BigInteger(next());
    }
    BigDecimal nextBigDecimal()
    {
        return new BigDecimal(next());
    }
}