검색 (8 번 문제 상세 설명: BFS, A *, IDA *) - Eight (POJ 1077)

참고 글: 1. DBFS, A *, IDA *, 링크 전환 (삭제) 2. 매우 상세 한 실험 보고서:http://blog.csdn.net/ray58750034/article/details/599897#comments
  • 제목 링크:http://poj.org/problem?id=2449
  • 분석: 구 궁 격 문제 라 고도 부 르 는데 한 상태의 구 궁 격 을 제시 하여 해 가 있 는 지 판단 하고 있 으 면 출력 해 를 판단 한다.
  • 8 야드 문제 에 대해 풀 수 있 는 결론 이 있 습 니까?
  • 한 상 태 는 1 차원 의 형식 으로 0 을 제외 한 모든 숫자의 역순 수의 합 을 구한다.
  • 만약 에 두 상태의 역순 수 패 리 티 가 같 으 면 서로 도착 할 수 있 고 그렇지 않 으 면 서로 도착 할 수 없다.원시 상태의 역순 이 0 (짝수) 이기 때문에 역순 이 짝수 인 상태 가 해 제 됩 니 다.증명: 좌우 로 빈 칸 을 이동 할 때 역순 수 는 변 하지 않 습 니 다.상하 로 빈 칸 을 이동 할 때 한 숫자 를 앞으로 (또는 뒤로) 두 칸 이동 하 는 것 과 같 습 니 다. 건 너 뛰 는 이 두 숫자 는 모두 그것 보다 크 거나 (작 음) 역순 은 ± 2 일 수 있 습 니 다.하 나 는 크 고 하 나 는 작 으 며 역 서 는 변 하지 않 는 다.그래서 결론 을 얻 을 수 있다. 서로 도달 할 수 있 는 두 가지 상태 라면 그들의 역순 패 리 티 는 같다.상세 한 증명 은 참고 하 시기 바 랍 니 다.http://blog.csdn.net/tiaotiaoyly/article/details/2008233

  • 강 타 쿠 전개 (모든 배열 을 강 타 쿠 로 전개 하여 유일 하 게 대응 하 는 수 를 얻 는 것 은 전체 배열 에 좋 은 해시 함수): 공식: X = an×(n−1)!+an−1×(n−2)!+...+ai×(i−1)!+...+a2×1!+a1×0! 그 중에서 ai 는 i - 1 번 째 수 (0 부터 수) 를 나타 내 고 이 배열 의 크기 위치 (0 부터 계산) 를 나타 낸다.코드 는 다음 과 같 습 니 다.
  • int fac[] = { 1,1,2,6,24,120,720,5040,40320 };//           。
    int Cantor( int s[])//     。
    {
        int sum = 0;
        for(int i = 0;i<9;i++)
        {
            int cnt = 0;
            for(int j=i+1;j<9;j++)
            {
                if( s[i] > s[j] ) cnt++;
            }
            sum+=(cnt*fac[9-i-1]);
        }
        return sum+1;
    }
  • 강 척 역 전 개 를 통 해 대응 하 는 전체 배열 을 생 성 합 니 다. 한 배열 의 강 척 전개 수 를 알 고 있다 면 이 배열 의 모든 ai: 搜索 ( 八数码问题详解:BFS,A*,IDA* )——Eight ( POJ 1077 )_第1张图片 배열 중의 요소 가 A, B, C, D 라면 a4 = 3 은 나머지 요소 가 4 라 는 것 을 표시 할 때 3 위 (모두 0 위 부터 계산), 즉 D 를 얻 을 수 있 습 니 다.a3 = 1 은 남 은 요소 가 3 일 때 첫 번 째, 즉 B 를 나타 낸다.a2 = 0 은 남 은 요소 가 2 일 때 0 위, 즉 A 를 나타 내 고 마지막 a1 은 C 이다.
  • BFS + 강 타 쿠 가 8 야드 문 제 를 해결 하기 시작 했다.
  • #include 
    #include 
    #include 
    #include 
    #include 
    #include 
    
    //       
    
    using namespace std;
    
    const int maxn = 1000000;
    int fac[] = { 1,1,2,6,24,120,720,5040,40320 };
    bool flag [maxn];
    int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
    string cmd = "udlr";
    int aim=46234;
    
    int Cantor( int s[])
    {
        int sum = 0;
        for(int i = 0;i<9;i++)
        {
            int cnt = 0;
            for(int j=i+1;j<9;j++)
            {
                if( s[i] > s[j] ) cnt++;
            }
            sum+=(cnt*fac[9-i-1]);
        }
        return sum+1;
    }
    
    struct node
    {
        int s[9];
        int loc;
        int status;
        string path;
    };
    
    node origin;
    string path;
    
    
    int BFS()
    {
        queue  q;
        while ( !q.empty() )
            q.pop();
    
        node cur,temp;
    
        q.push(origin);
    
        int x,y;
        while( !q.empty() )
        {
            cur = q.front();
            q.pop();
    
            if( cur.status == aim )
            {
                path = cur.path;
                return 1;
            }
            x = cur.loc/3;
            y = cur.loc%3;
            for(int i=0;i<4;i++)
            {
                int tx = x + dir[i][0];
                int ty = y + dir[i][1];
    
                if( tx<0 || ty <0 || tx>2 || ty>2 ) continue;
    
                temp = cur;
                temp.loc = tx*3 + ty;
    
                temp.s[cur.loc] = temp.s[temp.loc];
                temp.s[temp.loc] = 0;
                temp.status = Cantor(temp.s);
    
                if( !flag[temp.status] )
                {
                    flag[temp.status] = 1;
                    temp.path = temp.path + cmd[i];
                    if( temp.status == aim )
                    {
                        path = temp.path;
                        return 1;
                    }
                    q.push(temp);
                }
            }
        }
        return 0;
    }
    
    
    
    int main()
    {
        char ch;
        while(cin>>ch)
        {
            if(ch == 'x')
            {
                origin.s[0] = 0;
                origin.loc = 0;
            }
            else origin.s[0] = ch - '0';
            for(int i=1;i<9;i++)
            {
                cin >> ch;
                if( ch == 'x' )
                {
                origin.s[i] = 0;
                origin.loc = i;
                }
                else origin.s[i] = ch - '0';
            }
            origin.status = Cantor( origin.s );
            memset( flag , 0 ,sizeof(flag) );
    
            if(BFS())
                cout<else
                 printf("unsolvable
    "
    ); } return 0; }
  • 양 방향 검색: 목표 상태 와 초기 상태 가 모두 알 고 있 기 때문에 두 상태 에서 동시에 검색 할 수 있 습 니 다. 같은 노드 를 찾 았 을 때 검색 이 끝나 면 양쪽 의 걸음 수 를 더 해서 출력 할 수 있 습 니 다.이 문 제 는 각 노드 에 하나의 값 으로 표 시 됩 니 다. 이 노드 는 어느 상태 에서 접근 하 는 지, 따라서 하나의 대기 열 로 교체 하여 확장 해 야 합 니 다.양 방향 광 수 는 많은 노드 를 적 게 확장 하여 시간 효율 이 크게 향상 된다.
  • #include 
    #include 
    #include 
    #include 
    #define FUCK puts("fuck!")
    #define STOP system("pause")
    #define MAXN 388211
    using namespace std;
    struct state{
        int sta,pos,step;
        int visit;
    }st[MAXN],source,target;
    int temp[10],tar[10],sou[10];
    int d[9][4]={{0,4,0,2},{0,5,1,3},{0,6,2,0},{1,7,0,5},{2,8,4,6},{3,9,5,0},{4,0,0,8},{5,0,7,9},{6,0,8,0}};
    int num;
    int convert(int a[],state &b)
    {
        b.sta=0;
        for(int i = 0; i < 9; i ++) 
        {   
            if(a[i]!=0)
                b.sta |=((a[i]-1)<24-i*3));
            else
            {
                b.pos = i;
                b.sta |=(a[i]<24-i*3));
            }
        }
        return 1;
    }
    state exchange(state a,int pos)
    {
        int temp = 7<9-pos)*3);
        state s;
        s.sta = a.sta;
        temp = temp & a.sta;
        temp = ((temp>>((9-pos)*3))<9-a.pos-1)*3));
        s.sta |= temp;
        s.sta &= ~(7<9-pos)*3));
        s.pos = pos-1;
        return s;
    }
    int search(state a)
    {
        int index = a.sta%MAXN;
        bool flag = true;
        while(flag)
        {
            if(!st[index].sta)
            {
                st[index].sta = a.sta;
                st[index].pos = a.pos;
                flag = false;
            }
            else if(!(st[index].sta^a.sta)&&!(st[index].pos^a.pos))
                flag = false;
            else
                index = (index+1)%MAXN;
        }
        return index;
    }
    int main()
    {
        freopen("in.txt","r",stdin);
        clock_t start,end;
        for(int j=0;j<8;j++)temp[j] = j+1;
        temp[8]=0;
        convert(temp,target);
        while(1)
        {
            int i = 0;
            memset(st,0,sizeof(st));
            char ch;
            while((ch=getchar())!='
    '
    ) { if(ch<='9'&&ch>='0') sou[i++] = ch - '0'; else if(ch=='x') sou[i++] =0; } convert(sou,source); start = clock(); i = search(source); queue<int>q; q.push(i); i = search(target); st[i].visit = 1; st[i].step = 1; q.push(i); if(!(source.sta^target.sta)&&!(source.pos^target.pos)) { printf("0
    "
    ); while(!q.empty())q.pop(); continue; } int index; int count = 0; bool isSolve = false; while(!q.empty()&&!isSolve) { count ++; index = q.front(); for(int j = 0; j < 4; j ++) { if(d[st[index].pos][j]) { int flag = search(exchange(st[index],d[st[index].pos][j])); if(!st[flag].step) { st[flag].step = st[index].step + 1; st[flag].visit = st[index].visit; q.push(flag); } else { if(st[flag].visit^st[index].visit) { isSolve = true; printf("%d
    "
    ,st[index].step+st[flag].step); } } } } q.pop(); } while(!q.empty())q.pop(); end = clock(); printf("Time:%dms
    state number:%d
    "
    ,end-start,count); } system("pause"); return 0; }
  • A * 검색: 두 가지 실행 가능 한 계발 함수 가 있 습 니 다. 자릿수 (difference) 와 맨 해 튼 거리 (manhattan) 가 모든 노드 에 int 형 변 수 를 추가 하여 이 노드 의 평가 가격 을 저장 합 니 다.이 때 우선 대기 열 로 노드 를 저장 합 니 다.그러나 계발 함수 의 효율 이 높 지 않 으 면 줄 어 든 확장 노드 의 시간 은 작은 지붕 이 조정 하 는 시간 을 초과 하지 못 할 수 있 습 니 다. 결 과 는 시간 효율 이 일반 bfs 보다 더 떨 어 질 수 있 습 니 다.부재 함수 기반 A * 검색:
  • #include 
    #include 
    #include 
    #include 
    #define FUCK puts("fuck!")
    #define STOP system("pause")
    #define MAXN 388211
    using namespace std;
    struct state{
        int sta,pos,step;
        int f;
    }st[MAXN],source,target;
    int temp[10],tar[10],sou[10];
    int d[9][4]={{0,4,0,2},{0,5,1,3},{0,6,2,0},{1,7,0,5},{2,8,4,6},{3,9,5,0},{4,0,0,8},{5,0,7,9},{6,0,8,0}};
    int num;
    int h(state a)
    {
        int temp = target.sta;
        int cnt=0;
        for(int i = 0;i < 9; i ++)
        {
            if(a.pos==target.pos)
            {
                if(!(((temp>>(3*i))&7)^((a.sta>>(3*i))&7)))
                    cnt++;
            }
            else
            {
                if((!(((temp>>(3*i))&7)^((a.sta>>(3*i))&7)))&&((a.sta>>(3*i))&7))
                    cnt++;
            }
        }
        return 9-cnt;
    }
    struct cmp
    {
        bool operator () (int u, int v)
        {
            return st[u].f > st[v].f;       
        }
    };
    int convert(int a[],state &b)
    {
        b.sta=0;
        for(int i = 0; i < 9; i ++) 
        {   
            if(a[i]!=0)
                b.sta |=((a[i]-1)<24-i*3));
            else
            {
                b.pos = i;
                b.sta |=(a[i]<24-i*3));
            }
        }
        return 1;
    }
    state exchange(state a,int pos)
    {
        int temp = 7<9-pos)*3);
        state s;
        s.sta = a.sta;
        temp = temp & a.sta;
        temp = ((temp>>((9-pos)*3))<9-a.pos-1)*3));
        s.sta |= temp;
        s.sta &= ~(7<9-pos)*3));
        s.pos = pos-1;
        return s;
    }
    int search(state a)
    {
        int index = a.sta%MAXN;
        bool flag = true;
        while(flag)
        {
            if(!st[index].sta)
            {
                st[index].sta = a.sta;
                st[index].pos = a.pos;
                flag = false;
            }
            else if(!(st[index].sta^a.sta)&&!(st[index].pos^a.pos))
                flag = false;
            else
                index = (index+1)%MAXN;
        }
        return index;
    }
    int main()
    {
        freopen("in.txt","r",stdin);
        clock_t start,end;
        for(int j=0;j<8;j++)temp[j] = j+1;
        temp[8]=0;
        convert(temp,target);
        while(1)
        {
            int i = 0;
            memset(st,0,sizeof(st));
            char ch;
            while((ch=getchar())!='
    '
    ) { if(ch<='9'&&ch>='0') sou[i++] = ch - '0'; else if(ch=='x') sou[i++] =0; } convert(sou,source); start = clock(); i = search(source); st[i].f = h(st[i]); priority_queue<int,vector<int>,cmp>q; q.push(i); int index; int count = 0; while(!q.empty()) { count++; index = q.top(); q.pop(); //!!!! if(!(st[index].sta^target.sta)&&st[index].pos == target.pos) { printf("%d
    "
    ,st[index].step); break; } for(int j = 0; j < 4; j ++) { if(d[st[index].pos][j]) { int flag = search(exchange(st[index],d[st[index].pos][j])); if(!st[flag].step||st[flag].step > st[index].step + 1) { st[flag].step = st[index].step + 1; st[flag].f = st[flag].step + h(st[flag]); q.push(flag); } } } } while(!q.empty())q.pop(); end = clock(); printf("Time:%dms
    state number:%d
    "
    ,end-start,count); } system("pause"); return 0; }

    manhattan 거리 함수 기반 A * 검색:
    #include 
    #include 
    #include 
    #include 
    #define FUCK puts("fuck!")
    #define STOP system("pause")
    #define MAXN 388211
    using namespace std;
    struct state{
        int sta,pos,step;
        int f;
    }st[MAXN],source,target;
    int temp[10],tar[10],sou[10];
    int d[9][4]={{0,4,0,2},{0,5,1,3},{0,6,2,0},{1,7,0,5},{2,8,4,6},{3,9,5,0},{4,0,0,8},{5,0,7,9},{6,0,8,0}};
    int num;
    int manhattan[10][10] = // i           Manhattan    
    {
    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
    {-1, 0, 1, 2, 1, 2, 3, 2, 3, 4},
    {-1, 1, 0, 1, 2, 1, 2, 3, 2, 3},
    {-1, 2, 1, 0, 3, 2, 1, 4, 3, 2},
    {-1, 1, 2, 3, 0, 1, 2, 1, 2, 3},
    {-1, 2, 1, 2, 1, 0, 1, 2, 1, 2},
    {-1, 3, 2, 1, 2, 1, 0, 3, 2, 1},
    {-1, 2, 3, 4, 1, 2, 3, 0, 1, 2},
    {-1, 3, 2, 3, 2, 1, 2, 1, 0, 1},
    {-1, 4, 3, 2, 3, 2, 1, 2, 1, 0}
    
    };
    int h(state a)
    {
        int cnt=0;
        for(int i = 0;i < 9; i ++)
        {
            if(a.pos != i)
                cnt += manhattan[((a.sta>>(3*(8-i)))&7)+1][i+1];
        }
        return cnt;
    }
    class cmp
    {
          public:
        bool operator () (int u, int v)
        {
            return st[u].f > st[v].f;       
        }
    };
    int convert(int a[],state &b)
    {
        b.sta=0;
        for(int i = 0; i < 9; i ++) 
        {   
            if(a[i]!=0)
                b.sta |=((a[i]-1)<24-i*3));
            else
            {
                b.pos = i;
                b.sta |=(a[i]<24-i*3));
            }
        }
        return 1;
    }
    state exchange(state a,int pos)
    {
        int temp = 7<9-pos)*3);
        state s;
        s.sta = a.sta;
        temp = temp & a.sta;
        temp = ((temp>>((9-pos)*3))<9-a.pos-1)*3));
        s.sta |= temp;
        s.sta &= ~(7<9-pos)*3));
        s.pos = pos-1;
        return s;
    }
    int search(state a)
    {
        int index = a.sta%MAXN;
        bool flag = true;
        while(flag)
        {
            if(!st[index].sta)
            {
                st[index].sta = a.sta;
                st[index].pos = a.pos;
                flag = false;
            }
            else if(!(st[index].sta^a.sta)&&!(st[index].pos^a.pos))
                flag = false;
            else
                index = (index+1)%MAXN;
        }
        return index;
    }
    int main()
    {
        freopen("in.txt","r",stdin);
        clock_t start,end;
        for(int j=0;j<8;j++)temp[j] = j+1;
        temp[8]=0;
        convert(temp,target);
        while(1)
        {
            int i = 0;
            memset(st,0,sizeof(st));
            char ch;
            while((ch=getchar())!='
    '
    ) { if(ch<='9'&&ch>='0') sou[i++] = ch - '0'; else if(ch=='x') sou[i++] =0; } convert(sou,source); start = clock(); i = search(source); st[i].f = h(st[i]); priority_queue<int,vector<int>,cmp>q; q.push(i); int index; int count = 0; while(!q.empty()) { count++; index = q.top(); q.pop(); //!!!! if(!(st[index].sta^target.sta)&&st[index].pos == target.pos) { printf("%d
    "
    ,st[index].step); break; } for(int j = 0; j < 4; j ++) { if(d[st[index].pos][j]) { int flag = search(exchange(st[index],d[st[index].pos][j])); if(!st[flag].step||st[flag].step > st[index].step + 1) { st[flag].step = st[index].step + 1; st[flag].f = st[flag].step + h(st[flag]); q.push(flag); } } } } while(!q.empty())q.pop(); end = clock(); printf("Time:%dms
    state number:%d
    "
    ,end-start,count); } system("pause"); return 0; }
  • IDA * 검색: 일반적인 심층 검색 으로 인해 잘못된 결 과 를 검색 하거나 모든 상 태 를 검색 해 야 최 적 여 부 를 확인 할 수 있 기 때문에 여기 서 IDA * 를 사용 합 니 다.IDA * 는 반복 적 으로 깊이 있 는 검색 입 니 다. 이 깊이 에서 목표 점 을 찾 지 못 하면 깊이 를 다시 검색 합 니 다.상태 가 무 거 워 질 필요 가 없고 가격 을 평가 할 필요 가 없 으 며 해시 표를 사용 할 수 없고 쌓 아 올 려 도 응용 할 필요 가 없 으 며 공간 수요 가 매우 적어 지고 실현 도 가장 간단 하 다.심층 검색 과정 에서 계발 함수 에 따라 가 지 를 자 르 면 효율 이 매우 높다.또한 경 로 를 구 할 때 IDA * 도 가장 편리 합 니 다.함수 가 아 닌 IDA * 검색 기반:
  • #include 
    #include 
    #include 
    #include 
    #define FUCK puts("fuck!")
    #define STOP system("pause")
    #define MAXN 388211
    using namespace std;
    struct state{
        int sta,pos;
    }source,target;
    int temp[10],tar[10],sou[10];
    int pathLimit;
    int cnt;
    int d[9][4]={{0,4,0,2},{0,5,1,3},{0,6,2,0},{1,7,0,5},{2,8,4,6},{3,9,5,0},{4,0,0,8},{5,0,7,9},{6,0,8,0}};
    int h(state a)
    {
        int temp = target.sta;
        int cnt=0;
        for(int i = 0;i < 9; i ++)
        {
            if(a.pos==target.pos)
            {
                if(!(((temp>>(3*i))&7)^((a.sta>>(3*i))&7)))
                    cnt++;
            }
            else
            {
                if(!(((temp>>(3*i))&7)^((a.sta>>(3*i))&7))&&((a.sta>>(3*i))&7))
                    cnt++;
            }
        }
        return 9-cnt;
    }
    int convert(int a[],state &b)
    {
        b.sta=0;
        for(int i = 0; i < 9; i ++) 
        {   
            if(a[i]!=0)
                b.sta |=((a[i]-1)<24-i*3));
            else
            {
                b.pos = i;
                b.sta |=(a[i]<24-i*3));
            }
        }
        return 1;
    }
    state exchange(state a,int pos)
    {
        int temp = 7<9-pos)*3);
        state s;
        s.sta = a.sta;
        temp = temp & a.sta;
        temp = ((temp>>((9-pos)*3))<9-a.pos-1)*3));
        s.sta |= temp;
        s.sta &= ~(7<9-pos)*3));
        s.pos = pos-1;
        return s;
    }
    bool IDAStar(state &a,int depth,int diff,int prepos)
    {
        cnt++;
        if(!(a.sta^target.sta)&&a.pos == target.pos)
        {
            printf("%d
    "
    ,depth); return true; } if(depth >= pathLimit) return false; if( depth + diff > pathLimit ) return false; for(int j = 0; j < 4; j ++) { if(d[a.pos][j] == prepos+1) continue; if(d[a.pos][j]) { state next = exchange(a,d[a.pos][j]); if(IDAStar(next,depth+1, h(next),a.pos)) return true; } } return false; } int main() { freopen("in.txt","r",stdin); clock_t start,end; int diff = 0; for(int j=0;j<8;j++)temp[j] = j+1; temp[8]=0; convert(temp,target); while(1) { int i = 0; char ch; while((ch=getchar())!='
    '
    ) { if(ch<='9'&&ch>='0') sou[i++] = ch - '0'; else if(ch=='x') sou[i++] =0; } start = clock(); cnt = 0; convert(sou,source); pathLimit = h(source); diff = pathLimit; while(!IDAStar(source,0,diff,-1))pathLimit++; end = clock(); printf("Time:%dms
    state number:%d
    "
    ,end-start,cnt); } system("pause"); return 0; }

    manhattan 거리 함수 기반 검색:
    #include 
    #include 
    #include 
    #include 
    #define FUCK puts("fuck!")
    #define STOP system("pause")
    #define MAXN 388211
    using namespace std;
    struct state{
        int sta,pos;
    }source,target;
    int temp[10],tar[10],sou[10];
    int pathLimit;
    int d[9][4]={{0,4,0,2},{0,5,1,3},{0,6,2,0},{1,7,0,5},{2,8,4,6},{3,9,5,0},{4,0,0,8},{5,0,7,9},{6,0,8,0}};
    int manhattan[10][10] = // i           Manhattan    
    {
    {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1},
    {-1, 0, 1, 2, 1, 2, 3, 2, 3, 4},
    {-1, 1, 0, 1, 2, 1, 2, 3, 2, 3},
    {-1, 2, 1, 0, 3, 2, 1, 4, 3, 2},
    {-1, 1, 2, 3, 0, 1, 2, 1, 2, 3},
    {-1, 2, 1, 2, 1, 0, 1, 2, 1, 2},
    {-1, 3, 2, 1, 2, 1, 0, 3, 2, 1},
    {-1, 2, 3, 4, 1, 2, 3, 0, 1, 2},
    {-1, 3, 2, 3, 2, 1, 2, 1, 0, 1},
    {-1, 4, 3, 2, 3, 2, 1, 2, 1, 0}
    
    };
    int h(state a)
    {
        int cnt=0;
        for(int i = 0;i < 9; i ++)
        {
            if(a.pos != i)
                cnt += manhattan[((a.sta>>(3*(8-i)))&7)+1][i+1];
        }
        return cnt;
    }
    int convert(int a[],state &b)
    {
        b.sta=0;
        for(int i = 0; i < 9; i ++) 
        {   
            if(a[i]!=0)
                b.sta |=((a[i]-1)<24-i*3));
            else
            {
                b.pos = i;
                b.sta |=(a[i]<24-i*3));
            }
        }
        return 1;
    }
    state exchange(state a,int pos)
    {
        int temp = 7<9-pos)*3);
        state s;
        s.sta = a.sta;
        temp = temp & a.sta;
        temp = ((temp>>((9-pos)*3))<9-a.pos-1)*3));
        s.sta |= temp;
        s.sta &= ~(7<9-pos)*3));
        s.pos = pos-1;
        return s;
    }
    bool IDAStar(state &a,int depth,int diff,int prepos)
    {
        if(!(a.sta^target.sta)&&a.pos == target.pos)
        {
            printf("%d
    "
    ,depth); return true; } if(depth > pathLimit) return false; if( depth + diff > pathLimit ) return false; for(int j = 0; j < 4; j ++) { if(d[a.pos][j] == prepos+1) continue; if(d[a.pos][j]) { state next = exchange(a,d[a.pos][j]); if(IDAStar(next,depth+1, h(next),a.pos)) return true; } } return false; } int main() { freopen("in.txt","r",stdin); clock_t start,end; int diff = 0; for(int j=0;j<8;j++)temp[j] = j+1; temp[8]=0; convert(temp,target); while(1) { int i = 0; char ch; while((ch=getchar())!='
    '
    ) { if(ch<='9'&&ch>='0') sou[i++] = ch - '0'; else if(ch=='x') sou[i++] =0; } start = clock(); convert(sou,source); pathLimit = h(source); diff = pathLimit; while(!IDAStar(source,0,diff,-1))pathLimit++; end = clock(); printf("Time:%dms
    depthlimit:%d
    "
    ,end-start,pathLimit); } system("pause"); return 0; }
  • 요약: 효율 적 으로 볼 때 IDA * > A * > DBFS > BFS + Canton > BFS, 그 중에서 Manhattan 평가 함수 의 우 여 difference 평가 함수.
  • 좋은 웹페이지 즐겨찾기