HDU 2209(数据弱,双向直接过)

....由于某些人认为双向过这道比较爽,于是草草coding一番,用了G++才勉强过掉.

DK大牛说了,双向不能求出最优解,因为它不能保证起点出发10步终点出发1步的最优,和起点出发6步和终点出发6步的次优中,前者首先被发现....

 

正规解法是枚举第一格翻和不翻的状态,然后后面的跟着要求翻........

 

但双向广搜的方法值得借鉴  因此保存下我的代码思路.

 

要点是:

1.二进制位状态保存

2.长度记录

3.判重hash

4.类型区分

5.位运算加速

 

 

#include <iostream>
#include <queue>
using namespace std;
char key[25];

long hash_st[(1<<20)+10];
long hash_ed[(1<<20)+10];
 
long st;
long ed;
long len;
const long ST=1; 
const long ED=2;

typedef struct  
{
    long type;
    long state;
    long len;
}node;

queue<node> q;

inline void Bfs()
{
    while (!q.empty())
    {
        q.pop();
    }

    node Start,End;
    
    Start.state=st;
    End.state=ed;

    Start.type=ST;
    End.type=ED;

    Start.len=0;
    End.len=0;

    q.push(Start);
    q.push(End);

    bool finish=false;
    long cost=0;

    while (!q.empty())
    {
        node t=q.front();
        q.pop();
        
        if (t.type==ST)
        {
            if (hash_ed[t.state])
            {
                cost=t.len+hash_ed[t.state];
                finish=true;
                break;
            }


        }
        else
        {
            if (hash_st[t.state])
            {
                cost=t.len+hash_st[t.state];
                finish=true;
                break;
            }

        }

        long j;
        long temp;
        for (j=0;j<len;++j)
        {
            temp=t.state;
            if (j==0)
            {
                temp=temp^(1<<(len-1));
                if (j+1<len)
                {
                    temp=temp^(1<<(len-2));
                }
            }
            else if(j+1==len)
            {
                temp=temp^1;
                if (j-1>=0)
                {
                    temp=temp^2;
                }
            }
            else
            {
                temp=temp^(1<<(len-j-1));
                temp=temp^(1<<(len-j));
                temp=temp^(1<<(len-j-2));
            }

            node tt;

            if (t.type==ST)
            {
                if (!hash_st[temp])
                {
                    hash_st[temp]=t.len+1;
                    tt.len=hash_st[temp];
                    tt.state=temp;
                    tt.type=ST;
                    q.push(tt);
                }
            }
            else
            {
                if (!hash_ed[temp])
                {
                    hash_ed[temp]=t.len+1;
                    tt.len=hash_ed[temp];
                    tt.state=temp;
                    tt.type=ED;
                    q.push(tt);
                }
            }
            
        }
    
    }

    if (finish)
    {
        printf("%ld\n",cost);
    }
    else
    {
        printf("NO\n");
    }

}

int main()
{
    while (gets(key))
    {
        long i;
        st=ed=0;
        for (i=0;key[i]!='\0';++i)
        {
            st=(st<<1)+(key[i]-'0');
        }

        if (st==0)
        {
            printf("0\n");
            continue;
        }

        len=i;

        memset(hash_st,0,1<<(len+2));
        memset(hash_ed,0,1<<(len+2));

        Bfs();

    }
    return 0;
}