<更新提示>
<第一次更新>
<正文>
Power Hungry Cows(POJ 1945)
Description
FJ的奶牛想要快速计算整数P的幂 (1 <= P <=20,000),它们需要你的帮助。因为计算极大数的幂，所以它们同一时间仅能使用2个存储器，每个存储器可记录某个结果值。 第一件工作是初始化存储器内的值一个为底数x， 另一个为1。 奶牛可以相乘或相除2个存储器中的值，并把结果存在其中某个存储器内，但所有存储的结果必须是整数。 例如, 如果他们想计算x^31, 一种计算方法是:
WV1 WV2
开始: x 1
存储器1和存储器1相乘，结果存于存储器2: x x^2
存储器2和存储器2相乘，结果存于存储器2: x x^4
存储器2和存储器2相乘，结果存于存储器2: x x^8
存储器2和存储器2相乘，结果存于存储器2: x x^16
存储器2和存储器2相乘，结果存于存储器2: x x^32
存储器2除以存储器1，结果存于存储器2: x x^31因此, x^31可以通过6次计算得出。给出要计算的幂次，要求求出最少需要几次计算。
Input Format
仅一个整数: P。
Output Format
仅一个整数：最少计算次数。
Sample Input
31Sample Output
6解析
如果考虑\(12\)种转移方式，花费均为\(1\)，那么直接\(bfs\)是可以的，但是状态将达到\(12^{ans}\)之多，实际数据中，\(ans\)最大将达到\(18\)。
可以考虑设计一个估价函数，将\(bfs\)算法直接改进为\(A^*\)的启发式搜索算法。这个是比较容易想到的。设置状态\((a,b)\)代表第一个存储器指数为\(a\)，第二个存储器指数为\(b\)，令
\[ f(state)=\min_{max(a,b)*2^{cnt}\geq p}\{cnt\} \]
当\(max(a,b)\geq p\)时，\(f(state)=0\)。对于第一个式子，很好理解，当\(a\)，\(b\)最大值小于\(p\)时，最小的计算次数就是成倍增长所要的次数，由于最后可能还需要减法微调，可以保证\(f(state)\geq g(state)\)。而对于第二个式子，由于减法我们无法保证，取\(f(state)=0\)即可。
这样的\(A^*\)算法可以得到\(42\)分。
剩下的测试点的错误的原因是\(MLE+TLE\)，但导致它们原因是相同的:状态太多。
对于解决这个问题，最好的办法是剪枝，删去不优或无用状态。
可以考虑如下几个剪枝:
\(1.\)\((a,b)\)和\((b,a)\)是一样的，令\(a>b\)，删去第二种状态
\(2.\)\((a,a)\)这个状态一定不如\((a,b)\)，自乘自除可以达到一样的效果，直接删去
\(3.\)形如\((a,0)\)的状态，当\(a>p\)时，无解，直接删去
\(4.\)当\(p\%gcd(a,b) ≠ 0\)时，状态\((a,b)\)无解，直接删去
\(5.\)当\(a>p*2\)时，这个状态即使能得到解，计算次数也一定不是最优的，直接删去
加上一堆剪枝后，就能得到\(81\)分的高分了。
还有两个测试点还因为\(TLE\)，而我们的思路\(A^*\)算法，记录计算次数的数组直接开二维是不行的，又因为状态稀疏，所以选择使用\(map\)。但是现在使用\(map\)的常数太大，需要改用\(hash\)表来存储。
这样就能完美解决本题了。
以下是几个有关\(A^*\)需要注意的地方:
\(1.\)一切\(A^*\)算法基于优先队列\(bfs\)算法，优先队列\(bfs\)要做的一切操作，\(A^*\)都要做，最容易被忽视的就是 "一个状态第一次被取出时就是最优解，所以一个状态只会拓展一次，但是一个状态可能会被更新多次"，所以要开数组(\(map\)或\(hash\))记录到这个状态的最小花费。
\(2.\)\(A^*\)算法堆的排序关键字是当前花费加上未来预估花费，但是当两个状态的当前花费加上未来花费相同时，以未来花费为第二关键字，这对时间影响极大。
\(Code:\)
#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
#define mset(name,val) memset(name,val,sizeof name)
#define filein(str) freopen(str".in","r",stdin)
#define fileout(str) freopen(str".out","w",stdout)
const int P=20020,SIZE=1000080;
int p,Head[P],cnt;
struct node
{
int next,val,s;
};
struct state
{
int a,b,f,s;
inline void fcost(void)
{
this->f = 0;
int Max = max( this->a , this->b );
while ( Max<p ) Max<<=1 , (this->f)++ ;
}
bool operator < (const state t)const
{
return this->s+this->f == t.s+t.f ? this->f < t.f : this->s+this->f < t.s+t.f ;
}
bool operator > (const state t)const
{
return this->s+this->f == t.s+t.f ? this->f > t.f : this->s+this->f > t.s+t.f ;
}
};
priority_queue < state,vector<state>,greater<state> > Heap;
state Begin;
node List[SIZE];
inline void input(void)
{
scanf("%d",&p);
Begin=(state){1,0,0,0};
}
inline int Hash(int x,int y)
{
return (int)(((long long)x*2023%SIZE+(long long)y*1926%SIZE)%SIZE);
}
inline bool retrieval(int val,int s)
{
int index=val%P;
for (int i=Head[index];i;i=List[i].next)
{
if (List[i].val==val)
{
if (List[i].s<=s)return true;
List[i].s=s;return false;
}
}
List[++cnt]=(node){Head[index],val,s};
Head[index]=cnt;
return false;
}
inline int gcd(int a,int b)
{
return b==0 ? a : gcd( b , a%b );
}
inline bool check(int x,int y)
{
return x==y || ( x>p && y==0 ) || p % gcd(x,y) || x>2*p ;
}
inline void transfer(int x,int y,int t)
{
if (x<y) swap(x,y);
if (check(x,y))return;
if (retrieval(Hash(x,y),t+1))return;
state next=(state){x,y,0,t+1};
next.fcost();
Heap.push(next);
}
inline int Astar(void)
{
Heap.push(Begin);
while (!Heap.empty())
{
state t=Heap.top();
Heap.pop();
if (t.a==p||t.b==p)return t.s;
int temp[2]={t.a,t.b};
for (int i=0;i<2;i++)
{
for (int j=i;j<2;j++)
{
for (int k=0;k<2;k++)
{
if (!k)
transfer(temp[i]+temp[j],temp[1],t.s);
if (k)
transfer(temp[0],temp[i]+temp[j],t.s);
}
}
}
transfer(temp[0],temp[0]-temp[1],t.s);
transfer(temp[0]-temp[1],temp[1],t.s);
}
}
int main(void)
{
filein("power");
fileout("power");
input();
printf("%d\n",Astar());
return 0;
}<后记>