七数码&平分石子

七数码
输入

输出

样例输入

样例输出

分析

代码

平分石子
输入

输出

样例输入

样例输出

提示

分析

代码

七数码

有一个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");
}