poj 1945 Power Hungry Cows A*

Description：

    就是给你一个数，你可以把它自乘，也可以把他乘或除以任意一个造出过的数，问你最多经过多少次操作能变换成目标数

思路：这题真的不怎么会啊。n = 20000，每一层都有很多个扩展状态，裸宽搜会被T，启发式函数又设计不出来……

看了一个Vjudge上的代码才知道这题怎么写。

就是每一个状态是由最多两个数转化而来的，所以可以把两个数看做一个状态。

用一个多元组$node(x,y,g,h)$表示状态，$x, y$分别表示两个数中的较大数和较小数，然后$g$表示转换成当前的状态需要多少步，$h$表示大数$x$转换到大于等于目标状态至少还要多少步。

启发式函数就是当前步数+预期至少需要的步数，即$g+h$

再用一个哈希表把二元组$(x,y)$与转换到这个状态需要几步对应起来，这样可以完成去重。当然也可以用$map$实现，但按照poj的尿性，很可能TLE。。

然后加几个剪枝，排除以下多余状态：

1.如果$x > 2*n$，这个都能理解吧。

2.如果$x=y$，因为该状态和一个$x$的状态对未来的贡献是等价的，反正自乘自除也能达到一样的效果，不管$y$取什么数，都比$x$与$y$相等时更优。

3.如果$x > n$ 并且 $y = 0$，因为这样的话该状态永远达不到$x=n$。

4.如果$n $ $mod$ $gcd(x,y) != 0$，因为这样的状态不管怎么乘怎么除，也永远达不到$x=n$。

5.如果$(x,y)$已经在哈希表里了且对应的$g$更小，这个也都能理解吧。

这样的话就应该能过了。

然后款搜的时候要注意下，枚举出一个二元组能变换出来的所有可能的二元组，这个具体可以看代码。

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 using namespace std;
 const int N = , SIZE = 1e6 + ;
 int n;
 struct node{
     int x, y, g, h;
     bool operator < (const node &a)const{
         return g + h == a.g + a.h ? h > a.h : g + h > a.g + a.h;
     }
 };
 struct Node{
     int to, next, w;
 };
 struct hash_map{
     int head[N], now;
     Node a[SIZE];
     bool insert(int sta, int w){
         int x = sta % N;
         for(int i = head[x]; i; i = a[i].next){
             if(a[i].to == sta){
                 if(a[i].w <= w) return ;
                 a[i].w = w; return ;
             }
         }
         a[++now] = {sta, head[x], w};
         head[x] = now;
         return ;
     }
 }dict;
 priority_queue<node> heap;
 node now;
 int gcd(int a, int b){ return b ? gcd(b, a % b) : a;}
 void che(int x, int y){
     if(x < y) swap(x, y);
     if(x >  * n) return ;
     if(x > n && y == ) return ;
     if(x == y) return ;
     if(n % gcd(x, y)) return;
     if(!dict.insert(x *  + y, now.g + )) return;
     int h = , tx = x;
     while(tx < n) h++, tx <<= ;
     heap.push({x, y, now.g + , h});
 }
 void A_star(){
     heap.push({, , , });
     while(!heap.empty()){
         now = heap.top(); heap.pop();
         if(now.x == n || now.y == n){
             printf("%d\n", now.g); break;
         }
         int a[] = {now.x, now.y};
         for(int i = ; i < ; i++)
           for(int j = i; j < ; j++)
             for(int k = ; k < ; k++){
                 int b[] = {a[], a[]};
                 b[k] = a[i] + a[j];
                 che(b[], b[]);
             }
         che(now.x - now.y, now.y);
         che(now.x, now.x - now.y);
     }
 }
 int main(){
     scanf("%d", &n);
     A_star();
     return ;
 }