<更新提示>
<第一次更新>
<正文>
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
31
Sample Output
6
解析
如果考虑(12)种转移方式，花费均为(1)，那么直接(bfs)是可以的，但是状态将达到(12^{ans})之多，实际数据中，(ans)最大将达到(18)。
可以考虑设计一个估价函数，将(bfs)算法直接改进为(A^*)的启发式搜索算法。这个是比较容易想到的。设置状态((a,b))代表第一个存储器指数为(a)，第二个存储器指数为(b)，令
当(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
",Astar());
return 0;
}
<后记>