七数码&平分石子

七数码

有一个4*2的方框，里面随机填充着0-7这8个数。每次可以交换0和它相邻的格子里的数。比如：

可以变换为：

也可以变换为：

最终希望8个数整齐地排列为：

给出T组初始状态，求出每种状态移动到目标状态的最少步数。

输入

第1行：1个整数T(1<=T<=10000)
接下来T行，每行一个数字串，表示初始状态

输出

输出T行，每行1个整数，表示每个初始状态对应的最少移动步数。

样例输入

3
0 1 2 3 4 5 6 7
1 0 2 3 4 5 6 7
7 6 5 4 3 2 1 0

样例输出

0
1
28

分析

由于多组数据，而每组数据都出现在变换之中，所以考虑在输入前将所有状态存起来；
所以设置初始状态为0,1,2,3,4,5,6,7
再依次拓展开，存每个状态；
这里涉及到一个知识（康托展开）,计算每种状态的康托展开值，存每种状态；

代码

我的做法是用数组模拟队列，所以代码量会比较大

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct node{
    int a[8],b;
}que[300005];//队列，用于存步数与每种状态的数列
int T,dp[300005];//dp存状态
int fac[]={1,1,2,6,24,120,720,5040,40320};//阶乘（用于康托展开）
int head,tail;//数组模拟队列用来删除与插入
/*
康托展开值的计算：
从当前数开始比它小的数有n个，就让n乘上当前（从右往左）所处位置的阶乘
计算每个数，再求和

两层循环。
第一层枚举数列
第二层从第一层选定值开始枚举到最后
*/
int cont(int x)//计算康托展开值
{
    int r=0;//存展开值
    for (int i=0;i<=7;i++)//选定值i
        for(int j=i+1;j<=7;j++)//枚举后面的数
            if(que[x].a[i]>que[x].a[j])r+=fac[7-i];//比它小，就加一个阶乘
    return r;
}
void swa(int &x,int &y)//最好自己写交换函数
{
    int t=x;x=y;y=t;
}
void gai(int x,int y)//转移状态
{
    for(int i=0;i<=7; i++)
        que[y].a[i]=que[x].a[i];//将上一状态赋值给计算状态
}
int main()
{
    memset(dp,-1,sizeof(dp));//初始值
    head=tail=1;//设置队头队尾
    for(int i=0;i<=7;i++)
        que[tail].a[i]=i;//赋初始状态
    dp[0]=0;//初始状态也算一种
    que[tail].b=0;
    tail++;
    while(head<tail)//队列不为空
    {
        int x;//存0的位置
        for(int i=0;i<=7;i++)//找0
            if(que[head].a[i]==0){x=i;break;}
        if(x!=0&&x!=4)//向左
        {
            gai(head,tail);//转移状态
            swa(que[tail].a[x],que[tail].a[x-1]);//交换
            int q=cont(tail);//计算康托展开值
            if(dp[q]==-1)//没被计算过
            {
                dp[q]=que[head].b+1;
                que[tail++].b=que[head].b+1;
                //转移状态
            }
        }
        if(x!=3&&x!=7)//向右
        {
            gai(head,tail);
            swa(que[tail].a[x],que[tail].a[x+1]);
            int q=cont(tail);
            if(dp[q]==-1)
            {
                dp[q]=que[head].b+1;
                que[tail++].b=que[head].b+1;
            }
        }
        if(x<4)//向下
        {
            gai(head,tail);
            swa(que[tail].a[x],que[tail].a[x+4]);
            int q=cont(tail);
            if(dp[q]==-1)
            {
                dp[q]=que[head].b+1;
                que[tail++].b=que[head].b+1;
            }
        }
        else if(x>3)//向上
        {
            gai(head,tail);
            swa(que[tail].a[x],que[tail].a[x-4]);
            int q=cont(tail);
            if(dp[q]==-1)
            {
                dp[q]=que[head].b+1;
                que[tail++].b=que[head].b+1;
            }
        }
        head++;//拓展下一个状态
    }
    scanf("%d",&T);//输入数据组数
    for(int i=1;i<=T;i++)
    {
        for(int j=0;j<=7;j++)
            scanf("%d",&que[0].a[j]);//输入数据
        printf("%d\n",dp[cont(0)]);//输出
    }
}

平分石子

有3堆石子，初始时数量分别有A,B,C颗。每次操作是针对某两堆，设这两堆的当前石子数量为X,Y且X < Y. 然后从数量多的一堆中取出X颗石子放入数量少的一堆，使数量少的一堆加倍。操作后两堆石子的数量为：X+X, Y-X
问：经过任意多次的操作，能否使得3堆石子的数量相等？

输入

第1行：3个整数A,B,C (1<=A,B,C<=1000)

输出

第1行：如果可以相等，输出”possible”，否则输出”impossible”

样例输入

10 15 35

样例输出

possible

提示

第1次操作：10, (15,35) => 10, 20, 30
第2次操作：20, (10,30) => 20, 20, 20

分析

这一题跟上面那一题比起来简直水爆。
先不说这些。
这里提供一个考试技巧，
当实在对一道题没思路时，就用爆搜
这一题比之前那道简单是因为，这里不用计算康托展开。

代码

#include<cstdio>
#include<algorithm>
using namespace std;
int a[4];//存这三个数
bool f,q[3005][3005];//存状态（f为是否找到，q为是否计算）
void dfs(int x,int y,int z)
{
    if(x==y&&y==z){f=1;return;}//满足条件，标记找到
    if((q[x][y]||q[x][z]||q[y][z])||f)return;//计算过
    q[x][y]=q[x][z]=q[y][z]=1;//标记计算
    a[1]=x+x;a[2]=y-x;a[3]=z;//计算前两个
    sort(a+1,a+1+3);//排序
    dfs(a[1],a[2],a[3]);
    a[1]=x;a[2]=y+y;a[3]=z-y;//计算后两个
    sort(a+1,a+1+3);//排序
    dfs(a[1],a[2],a[3]);
    a[1]=x+x;a[2]=y;a[3]=z-x;//计算一三个
    sort(a+1,a+1+3);//排序
    dfs(a[1],a[2],a[3]);
}
int main()
{
    scanf("%d%d%d",&a[1],&a[2],&a[3]);
    if((a[1]+a[2]+a[3])%3!=0){printf("impossible\n");return 0;}//当加起来不能被3整除，就不可能构成
    sort(a+1,a+1+3);//从小到大排序，避免分类
    dfs(a[1],a[2],a[3]);
    if(f){printf("possible\n");return 0;}
    printf("impossible\n");
}