搜索进阶

HDU 1868 八数码
双向广搜

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define PRIME 455809
using namespace std;

struct node
{
    node(unsigned int t)
    {
        s=t;
        next=NULL;
    }//结构体初始化
    unsigned int s;
    int step;
    node *next;
};
node *hashtable[460000][2];
struct State//每个八数码的状态
{
    int map[10];
    int pos;
    int step;
} states,statee;

void hinsert(State s,bool ty)//hash表开成两维的，分别储存两个队列的搜索结果
{
    unsigned int st=0;
    for(int i=1; i<=9; i++)
        st=st*10+s.map[i];
    node *f=new node(st);//指向结构体变量的指针
    f->step=s.step;
    f->next=hashtable[st%PRIME][ty];//指向下一个节点
    hashtable[st%PRIME][ty]=f;
}
bool exist(State s,bool ty,int &res)//拉链法判重
{
    unsigned int i,st=0;
    for(i=1; i<=9; i++)
        st=st*10+s.map[i];
    node *f=hashtable[st%PRIME][ty];
    while(f)
    {
        if(f->s==st)
        {
            res=f->step;
            return true;
        }
        f=f->next;
    }
    return false;
}
int transfer(State t,queue <State>&Q,bool ty)
{
    State s;
    int res;
    s=t;
    if((s.pos-3)>0)
    {
        swap(s.map[s.pos],s.map[s.pos-3]);
        s.step++;
        s.pos-=3;
        if(exist(s,!ty,res))
        {
            return (s.step+res);
        }
        if(!exist(s,ty,res))
        {
            Q.push(s);
            hinsert(s,ty);
        }
    }
    s=t;
    if(s.pos+3<10)
    {
        swap(s.map[s.pos],s.map[s.pos+3]);
        s.step++;
        s.pos+=3;
        if(exist(s,!ty,res))
        {
            return (s.step+res);
        }
        if(!exist(s,ty,res))
        {
            Q.push(s);
            hinsert(s,ty);
        }
    }
    s=t;
    if((s.pos+1)%3!=1)
    {
        swap(s.map[s.pos],s.map[s.pos+1]);
        s.step++;
        s.pos+=1;
        if(exist(s,!ty,res))
        {
            return (s.step+res);
        }
        if(!exist(s,ty,res))
        {
            Q.push(s);
            hinsert(s,ty);
        }
    }
    s=t;
    if((s.pos-1)%3!=0)
    {
        swap(s.map[s.pos],s.map[s.pos-1]);
        s.step++;
        s.pos-=1;
        if(exist(s,!ty,res))
        {
            return (s.step+res);
        }
        if(!exist(s,ty,res))
        {
            Q.push(s);
            hinsert(s,ty);
        }
    }
    return 0;
}

queue<State>Qs;
queue<State>Qe;
int reversenum(State a)
{
    int res=0;
    for(int i=1; i<=9; i++)
    {
        if(a.map[i]==0)continue;
        for(int j=i-1; j>=1; j--)
        {
            if(a.map[j]>a.map[i])res++;
        }
    }
    return res;
}
bool prejudge(State a,State b)//对特殊情况处理
{
    int t1=reversenum(states);
    int t2=reversenum(statee);
    if((t1+t2)%2!=0)
    {
        printf("-1\n");
        return true;
    }
    bool flag=0;
    for(int i=1; i<=9; i++)
    {
        if(a.map[i]!=b.map[i])
        {
            flag=1;
            break;
        }
    }
    if(!flag)
    {
        printf("0\n");
        return true;
    }
    else return false;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(hashtable,0,sizeof(hashtable));//初始化hash表
        for(int i=1; i<=9; i++)//开始状态
        {
            scanf("%d",&states.map[i]);
            if(states.map[i]==0)states.pos=i;
        }
        statee.step=0;
        for(int i=1; i<=9; i++)//结束状态
        {
            scanf("%d",&statee.map[i]);
            if(statee.map[i]==0)statee.pos=i;
        }
        states.step=0;

        hinsert(states,0);//初始状态搜索结果保存到第一列
        hinsert(statee,1);//结束状态搜索结果保存到第二列
        if(prejudge(states,statee))continue;

        bool endflag=0;
        while(!Qs.empty())Qs.pop();
        while(!Qe.empty())Qe.pop();
        Qs.push(states);
        Qe.push(statee);
        while(!Qs.empty()||!Qe.empty())
        {
            int ns=Qs.size(); //这个是处于同一层的状态的数量
            int ne=Qe.size();
            if(ns<ne||ne==0) //选择元素个数较少的队列进行扩展
            {
                for(int i=0; i<ns; i++)//扩展s队列。一次扩展一层，这是双广正确性(得到最优解)的重要保证
                {
                    State cur;
                    cur=Qs.front();
                    Qs.pop();
                    int res=transfer(cur,Qs,0);
                    if(res)
                    {
                        printf("%d\n",res);
                        endflag=1;
                        break;
                    }
                }
            }
            else
            {
                for(int i=0; i<ne; i++)
                {
                    State cur;
                    cur=Qe.front();
                    Qe.pop();
                    int res=transfer(cur,Qe,1);
                    if(res)
                    {
                        printf("%d\n",res);
                        endflag=1;
                        break;
                    }
                }
            }
            if(endflag)break;
        }
    }
    return 0;
}

迭代加深

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define int long long
using namespace std;
int ans[10100],sum[10100];
int find(int a,int b)
{
     int i=2;
     while(true)
     {
        if(b<a*i) return i;
        i++;
     }
}
int gcd(int a,int b)
{
    return !b?a:gcd(b,a%b);
}
bool check(int deep)
{
    int max1=-1,max2=-1;
    for(int i=1;i<=deep;i++)
    {
        if(!ans[i]) return 1;
        max1=std::max(max1,sum[i]);
        max2=std::max(max2,ans[i]);
    }
    return max1<max2;
}
bool dfs(int now,int deep,int mx,int x,int y)
{
    if(now==deep)
    {
        if(y%x) return 0;
        sum[now]=y/x;
        if(check(deep))
         for(int i=1;i<=deep;i++) ans[i]=sum[i];
        return 1;
    }
    int w=max(find(x,y),mx);
    int flag=0;
    for(int i=w;;i++)
    {
        if(y*(deep-now+1)<=i*x) break;
        sum[now]=i;
        int ax=x*i-y;
        int bx=y*i;
        int d=gcd(x,y);
        if(dfs(now+1,deep,i+1,ax/d,bx/d)) flag=1;
    }
    return flag;
}
int main()
{
    int a,b;
    scanf("%lld%lld",&a,&b);
    int min=find(a,b);
    int deep;
    for(deep=1;;deep++)
    {
        memset(ans,0,sizeof(ans));
        if(dfs(1,deep,min,a,b)) break;
    }

    for(int i=1;i<=deep;i++)
     printf("%lld ",ans[i]);
    return 0;
}