poj2243+poj1915骑士问题

2243是骑士问题，八个格子的，BFS，因为要最短路经，所以没有用A*,A*跑不出来，太慢了，因为要搜索到所有解啊！一直更新最优，而BFS，一层一层搜索，第一次得到的便是最短的了！300格子，标记的话，BFS遍历所有时间复杂度也算可以！500MS过！稍微剪枝即可！时间注意!要标记每层已经走过的情况时候要在入队的时候标记！大大降低复杂度！因为出队的时候，有些已经在队里了，但是还没有被标记，现在又让他入队！

1915，也是简单BFS过的，暴搜即可。标记一下。但是先用启发搜索怎么也过不了，TLE，用跑2W次就结束，但是WA，悲剧，用欧几里得距离作启发函数啊，奇怪，在几步之内到达目标附近，可能不是最优解了，因为这样不能像一层一层那样标记了，只能更新最小的情况！很多剪枝的时候要注意语句顺序！还有更新与剪枝的顺序！

#include<iostream>   //bfs
#include<string>
#include<queue>
#include<cstring>
using namespace std;
int  absnum(int x,int y)
{
    if(x>y) return x-y;
    else return y-x;
}
bool mark[8][8];
int a[8][8];
int f[8][2]={-2,1,-1,2,1,2,2,1,2,-1,1,-2,-1,-2,-2,-1};
int minpath=15;
struct xy
{
    int x,y;
    int count;
};
void bfs(string from,string end)
{
    queue<xy>q;
    xy start;
    start.x=from[0]-'a';
    start.y=from[1]-'1';
    start.count=0;
    q.push(start);
    int endx=end[0]-'a';
    int endy=end[1]-'1';
    if((start.x==endx&&absnum(start.y,endy)==1)||(start.y==endy&&absnum(start.x,endx)==1))
    {
        minpath=3;return;
    }
    while(!q.empty())
    {
        xy getfront=q.front();q.pop();
        mark[getfront.x][getfront.y]=1;
        if(getfront.count>6)return;      //无启发可以这样，一层一层，最多走7次。
        if(getfront.x==endx&&getfront.y==endy)
        {
            if(minpath>getfront.count)minpath=getfront.count;
        }
        for(int i=0;i<8;i++)
        {
            xy next(getfront);
            next.x+=f[i][0];
            next.y+=f[i][1];
            if(next.x>=0&&next.x<8&&next.y>=0&&next.y<8&&mark[next.x][next.y]==0)
            {
                if(next.count>minpath)continue;  //已经多了就不用了
                next.count++;
                q.push(next);
              mark[next.x][next.y]=1;         //在这里标记！
 
            }
        }
    }
}
int main()
{
    string from,end;
    while(cin>>from>>end)
    {
        minpath=15;
        memset(mark,0,sizeof(mark));
        bfs(from,end);
        cout<<"To get from "<<from<<" to "<<end<<" takes "<<minpath<<" knight moves."<<endl;
    }
    return 0;
}

#include<iostream>     //bfs1915爆搜过
#include<string>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
int  absnum(int x,int y)
{
    if(x>y) return (x-y);
    else return (y-x);
}
int mark[301][301];
int f[8][2]={-2,1,-1,2,1,2,2,1,2,-1,1,-2,-1,-2,-2,-1};
int minpath=300;
struct xy
{
    int x,y;
    int count;
    double juli;
    bool operator <(const xy &a)const
    {
        return a.juli<juli;
    }
};
double hamit(xy f,xy e)
{
     double res=0;
     int tx=absnum(f.x,e.x);
     int ty=absnum(f.y,e.y);
    res=sqrt(0.0+tx*tx+ty*ty);
    return res;
}
xy from,end;int daxiao;
void bfs(xy from,xy end)
{
    priority_queue<xy>q;
    xy start;
    start.x=from.x;
    start.y=from.y;
    start.count=0;
    start.juli=hamit(start,end);
    q.push(start);
    mark[start.x][start.y]=-1;
    int counted=0;
    while(!q.empty())
    {
        xy getfront=q.top();
        counted++;
        q.pop();
        if(counted>10000)
        {
            if(hamit(getfront,end)>6)continue;
        }
        if(getfront.x==end.x&&getfront.y==end.y)
        {
            if(minpath>getfront.count)
            {
              minpath=getfront.count;
            }
            continue;
        }
        for(int i=0;i<8;i++)
        {
            xy next(getfront);
            next.x+=f[i][0];
            next.y+=f[i][1];
            if(next.x>=0&&next.x<daxiao&&next.y>=0&&next.y<daxiao&&next.count<mark[next.x][next.y])
            {
                next.juli=hamit(next,end);
                 next.count++;
                  if(next.count>=minpath)continue;     //比最优差，剪枝！
                  if(next.count>daxiao/2+3)continue;
                  if(mark[next.x][next.y]>next.count)
                    {
                     mark[next.x][next.y]=next.count;
                    }
                    if(next.x==end.x&&next.y==end.y)
                     {
                           if(minpath>next.count)
                            {
                             minpath=next.count;
                            }
                        continue;
                    }
                q.push(next);
            }
        }
    }
    return;
}
int main()
{
    int na;cin>>na;
    while(na--)
    {
        cin>>daxiao;
        cin>>from.x>>from.y>>end.x>>end.y;
        minpath=daxiao;
        memset(mark,0x3f3f3f3f,sizeof(mark));
        bfs(from,end);
        cout<<minpath<<endl;
    }
    return 0;
}

#include<iostream>     //bfs，A*/WA不解ing
#include<string>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
int  absnum(int x,int y)
{
    if(x>y) return (x-y);
    else return (y-x);
}
int mark[301][301];
int f[8][2]={-2,1,-1,2,1,2,2,1,2,-1,1,-2,-1,-2,-2,-1};
int minpath=300;
struct xy
{
    int x,y;
    int count;
    double juli;
    bool operator <(const xy &a)const
    {
        return a.juli<juli;
    }
};
double hamit(xy f,xy e)
{
     double res=0;
     int tx=absnum(f.x,e.x);
     int ty=absnum(f.y,e.y);
    res=sqrt(0.0+tx*tx+ty*ty);
    return res;
}
xy from,end;int daxiao;
void bfs(xy from,xy end)
{
    priority_queue<xy>q;
    xy start;
    start.x=from.x;
    start.y=from.y;
    start.count=0;
    start.juli=hamit(start,end);
    q.push(start);
    mark[start.x][start.y]=-1;
   // int counted=0;
    while(!q.empty())
    {
        xy getfront=q.top();
       // counted++;
        //cout<<counted<<"kkk"<<endl;
        q.pop();
      /*  if(counted>20000)  //到达2W次，差不多可以出来！
        {
            return;
        }*/
      //  cout<<getfront.count<<":"<<getfront.x<<"-"<<getfront.y<<endl;
       // if( mark[getfront.x][getfront.y]>getfront.count) mark[getfront.x][getfront.y]=getfront.count;
        for(int i=0;i<8;i++)
        {
            xy next(getfront);
            next.x+=f[i][0];
            next.y+=f[i][1];
            if(next.x>=0&&next.x<daxiao&&next.y>=0&&next.y<daxiao)
            //有优先队列后已经不是BFS本质，步数多的以及访问过，少的还可访问！不是简单标记！
            {
                next.juli=hamit(next,end);
                      next.count++;
                  if(next.count>=mark[next.x][next.y])continue; //注意这几个语句之间顺序！continue很重要！
                   mark[next.x][next.y]=next.count;
                 if(next.x==end.x&&next.y==end.y)
                     {
                           if(minpath>next.count)
                            {
                             minpath=next.count;
                            }
                        continue;
                    }
                  if(next.count>=minpath)continue;     //比最优差，剪枝！
                 // if(next.count>daxiao/2+3)continue;
                q.push(next);
            }
        }
    }
    return;
}
int main()
{
    int na;cin>>na;
    while(na--)
    {
        cin>>daxiao;
        cin>>from.x>>from.y>>end.x>>end.y;
        minpath=daxiao;
        memset(mark,0x3f3f3f3f,sizeof(mark));
        bfs(from,end);
        cout<<minpath<<endl;
    }
    return 0;
}