PKU1077 Eight

最新推荐文章于 2024-07-24 20:44:05 发布
最新推荐文章于 2024-07-24 20:44:05 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： ACM/ICPC 文章标签： hp up 算法 algorithm string c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kilvdn/article/details/1727659
版权

2448969kilvdn1077Accepted4060K312MSG++3335B2007-08-05 16:43:39

广度优先搜索

 

#include  < stdio.h >
#include  < string .h >
#define  MAXN 362880
const   int  tar = 123456789  ,
    pw[ 10 ] = {1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000} ,
    jc[ 10 ] = {1,1,2,6,24,120,720,5040,40320,362880} ;
 int  s , st[ 10 ] , que[MAXN][ 3 ] ;
 char  ch[ 50 ];
 bool  used[MAXN] ;

 bool  Isok() {
    int i , j , sum ;
    sum=0 ;
    for (i=1;i<10;i++)
    for (j=i+1;j<10;j++){
        if (st[i]>st[j])    sum++ ;    
    }
    if (sum%2==0)    return true ;
    return false ;
}
int  Init() {
    int len , i , q , c=1;
    len=strlen(ch);
    s=0;
    for (i=0;i<len;i++){
        if ((ch[i]>='0'&&ch[i]<='9')||ch[i]=='x'){
            if (ch[i]=='x')        q=c , st[q]=10 ;
            else{
                if (s==0)    s=ch[i]-'0';
                else    s=s*10+ch[i]-'0' ;
                st[c]=ch[i]-'0' ;
                c++ ;        
            }    
        }    
    }    
    memset(used,0,sizeof(used));
    s=s*10+q ;
//    printf("%d ",s);
}
// 1R2L3U4D
int  Right( int  a ) {    return a+1 ;}
int  Left ( int  a) {    return a-1 ;}
int  Up( int  a ) {
    int t1,t2,t3 ;
    t1=9-a%10+1 ;
    t2=a/pw[t1] ; 
    t3=t2/1000*1000+t2%100*10+t2/100%10 ;
    return t3*pw[t1]+a%pw[t1]/10*10+a%10-3 ;
}
int  Down( int  a ) {
    int t1,t2,t3,t4;
    t1=9-a%10+1 ;    
    t2=a/pw[t1] ;
    t3=a%pw[t1];
    t4=(t3/pw[t1-2]+t3/pw[t1-3]%10*100)*pw[t1-3]+t3%pw[t1-3] ;
    return  t2*pw[t1]+t4/10*10+a%10+3 ;
}
int  Hash( int  a) {
    int t[9] , i , j , k , res=0;
    for (i=0;i<9;i++){
        t[i]=a/pw[8-i]%10 ;    
    }
    for (i=0;i<8;i++){
        k=0 ;
        for (j=0;j<i;j++)
            if (t[i]<t[j]) k++ ;        
        res+=k*jc[i] ;
    }
    res+=(9-t[8])*jc[8] ;
    return res ;
}
int  Solve() {
    int tmp , front ,rear ,i , tt;    
    que[0][0]=s ;
    tt=Hash(s);
    used[tt]=1 ;
    front=0 , rear=1 ;
    while(front<rear){
        if (que[front][0]==tar)    break;
        
        tmp=(que[front][0]%10-1)%3 ;
        if (tmp<2){
            tmp=Right(que[front][0]);
            tt=Hash(tmp);
            if (!used[tt]){
                used[tt]=1;
                que[rear][0]=tmp ;
                que[rear][1]=1 ;
                que[rear][2]=front ;
                rear++ ;
//                if (tmp==tar)    break;    
            }    
        }
        tmp=(que[front][0]%10-1)%3 ;
        if (tmp>0){
            tmp=Left(que[front][0]);
            tt=Hash(tmp);
            if (!used[tt]){
                used[tt]=1;
                que[rear][0]=tmp ;
                que[rear][1]=2 ;
                que[rear][2]=front ;
                rear++ ;    
//                if (tmp==tar)    break;
            }    
        }
        tmp=(que[front][0]%10-1)/3 ;
        if (tmp<2){
            tmp=Down(que[front][0]);
            tt=Hash(tmp);
            if (!used[tt]){
                used[tt]=1;
                que[rear][0]=tmp ;
                que[rear][1]=4 ;
                que[rear][2]=front ;
                rear++ ;    
//                if (tmp==tar)    break;
            }    
        }
        tmp=(que[front][0]%10-1)/3 ;
        if (tmp>0){
            tmp=Up(que[front][0]);
            tt=Hash(tmp);
            if (!used[tt]){
                used[tt]=1;
                que[rear][0]=tmp ;
                que[rear][1]=3 ;
                que[rear][2]=front ;
                rear++ ;    
//                if (tmp==tar)    break;
            }    
        }
//        printf("%d",rear);        
        front++;    
    }
    int stack[MAXN],top=0;
    rear=front;
    while (rear!=0){
        stack[top++]=que[rear][1];
        rear=que[rear][2] ;    
    }
    for (i=top-1;i>=0;i--){
        switch(stack[i]){
            case 1:putchar('r') ;    break;
            case 2:putchar('l') ; break;
            case 3:putchar('u') ; break;
            default:putchar('d');
        }    
    }
    printf(" ");
}



int  main() {
//        printf("%d ",Down(123467584));
    while (gets(ch)){
        Init();    
        if(Isok()){
//            printf("yes ");
            Solve();
            
        }
        else    printf("unsolvable ");
    }
    return 0;    
}
/*
1 2 3 4 6 8 7 5 x
*/

双向广度优先搜索

2451174kilvdn1077Accepted5136K296MSG++5518B2007-08-05 19:13:22

 

#include  < stdio.h >
#include  < string .h >
#define  MAXN 362880
const   int  tar = 123456789  ,
    pw[ 10 ] = { 1 , 10 , 100 , 1000 , 10000 , 100000 , 1000000 , 10000000 , 100000000 , 1000000000 },
    jc[ 10 ] = { 1 , 1 , 2 , 6 , 24 , 120 , 720 , 5040 , 40320 , 362880 };
 int  s , st[ 10 ] , que[MAXN][ 3 ] , q1[MAXN][ 3 ];
 char  ch[ 50 ];
 int  used[MAXN] ;



 bool  Isok(){
     int  i , j , sum ;
    sum = 0  ;
     for  (i = 1 ;i < 10 ;i ++ )
     for  (j = i + 1 ;j < 10 ;j ++ ){
         if  (st[i] > st[j])    sum ++  ;    
    }
     if  (sum % 2 == 0 )     return   true  ;
     return   false  ;
}
 int  Init(){
     int  len , i , q , c = 1 ;
    len = strlen(ch);
    s = 0 ;
     for  (i = 0 ;i < len;i ++ ){
         if  ((ch[i] >= ' 0 ' && ch[i] <= ' 9 ' ) || ch[i] == ' x ' ){
             if  (ch[i] == ' x ' )        q = c , st[q] = 10  ;
             else {
                 if  (s == 0 )    s = ch[i] - ' 0 ' ;
                 else     s = s * 10 + ch[i] - ' 0 '  ;
                st[c] = ch[i] - ' 0 '  ;
                c ++  ;        
            }    
        }    
    }    
    memset(used, 0 , sizeof (used));
    s = s * 10 + q ;
}
 // 1R2L3U4D
int  Right( int  a ){     return  a + 1  ;}
 int  Left ( int  a){     return  a - 1  ;}
 int  Up( int  a ){
     int  t1,t2,t3 ;
    t1 = 9 - a % 10 + 1  ;
    t2 = a / pw[t1] ; 
    t3 = t2 / 1000 * 1000 + t2 % 100 * 10 + t2 / 100 % 10  ;
     return  t3 * pw[t1] + a % pw[t1] / 10 * 10 + a % 10 - 3  ;
}
 int  Down( int  a ){
     int  t1,t2,t3,t4;
    t1 = 9 - a % 10 + 1  ;    
    t2 = a / pw[t1] ;
    t3 = a % pw[t1];
    t4 = (t3 / pw[t1 - 2 ] + t3 / pw[t1 - 3 ] % 10 * 100 ) * pw[t1 - 3 ] + t3 % pw[t1 - 3 ] ;
     return   t2 * pw[t1] + t4 / 10 * 10 + a % 10 + 3  ;
}
 int  Hash( int  a){
     int  t[ 9 ] , i , j , k , res = 0 ;
     for  (i = 0 ;i < 9 ;i ++ ){
        t[i] = a / pw[ 8 - i] % 10  ;    
    }
     for  (i = 0 ;i < 8 ;i ++ ){
        k = 0  ;
         for  (j = 0 ;j < i;j ++ )
             if  (t[i] < t[j]) k ++  ;        
        res += k * jc[i] ;
    }
    res += ( 9 - t[ 8 ]) * jc[ 8 ] ;
     return  res ;
}

 int  Solve(){
     int  tmp , front ,rear ,i , tt , f1 , r1 ;    
     if  (s == tar)    {
        printf( " " );
         return   1 ;    
    }
    que[ 0 ][ 0 ] = s ;
    tt = Hash(s);
    used[tt] = 1  ;
    tt = Hash(tar);
    used[tt] = 2  ;
    q1[ 0 ][ 0 ] = tar ;
    f1 = 0  , r1 =   1 ;
    front = 0  , rear = 1  ;
    
     while ( 1 ){
         if  (rear - front >= r1 - f1){    
            tmp = (que[front][ 0 ] % 10 - 1 ) % 3  ;
             if  (tmp < 2 ){
                tmp = Right(que[front][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 1 ;
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 1  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;
                }
                 else   if  (used[tt] == 2 ){
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 1  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;
                     break ;    
                }
            }
            tmp = (que[front][ 0 ] % 10 - 1 ) % 3  ;
             if  (tmp > 0 ){
                tmp = Left(que[front][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 1 ;
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 2  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;    
                }
                 else   if  (used[tt] == 2 ){
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 2  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;
                     break ;    
                }
            }
            tmp = (que[front][ 0 ] % 10 - 1 ) / 3  ;
             if  (tmp < 2 ){
                tmp = Down(que[front][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 1 ;
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 4  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;    
                }
                 else   if  (used[tt] == 2 ){
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 4  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;
                     break ;    
                }    
            }
            tmp = (que[front][ 0 ] % 10 - 1 ) / 3  ;
             if  (tmp > 0 ){
                tmp = Up(que[front][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 1 ;
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 3  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;    
                }
                 else   if  (used[tt] == 2 ){
                    que[rear][ 0 ] = tmp ;
                    que[rear][ 1 ] = 3  ;
                    que[rear][ 2 ] = front ;
                    rear ++  ;
                     break ;    
                }
            }
            front ++ ;
        }
         else {    
            tmp = (q1[f1][ 0 ] % 10 - 1 ) % 3  ;
             if  (tmp < 2 ){
                tmp = Right(q1[f1][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 2 ;
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 1  ;
                    q1[r1][ 2 ] = f1 ;
                    r1 ++  ;
                }
                 else   if  (used[tt] == 1 ){
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 1  ;
                    q1[r1][ 2 ] = f1 ;
                    rear ++  ;    
                     break ;    
                }
            }
            tmp = (q1[f1][ 0 ] % 10 - 1 ) % 3  ;
             if  (tmp > 0 ){
                tmp = Left(q1[f1][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 2 ;
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 2  ;
                    q1[r1][ 2 ] = f1 ;
                    r1 ++  ;    
                }
                 else   if  (used[tt] == 1 ){
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 2  ;
                    q1[r1][ 2 ] = f1 ;
                    rear ++  ;    
                     break ;    
                }    
            }
            tmp = (q1[f1][ 0 ] % 10 - 1 ) / 3  ;
             if  (tmp < 2 ){
                tmp = Down(q1[f1][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 2 ;
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 4  ;
                    q1[r1][ 2 ] = f1 ;
                    rear ++  ;    
                }
                 else   if  (used[tt] == 1 ){
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 4  ;
                    q1[r1][ 2 ] = f1 ;
                    rear ++  ;    
                     break ;    
                }
            }
            tmp = (q1[f1][ 0 ] % 10 - 1 ) / 3  ;
             if  (tmp > 0 ){
                tmp = Up(q1[f1][ 0 ]);
                tt = Hash(tmp);
                 if  ( ! used[tt]){
                    used[tt] = 2 ;
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 3  ;
                    q1[r1][ 2 ] = f1 ;
                    r1 ++  ;    
                }
                 else   if  (used[tt] == 1 ){
                    q1[r1][ 0 ] = tmp ;
                    q1[r1][ 1 ] = 3  ;
                    q1[r1][ 2 ] = f1 ;
                    rear ++  ;    
                     break ;    
                }
            }
            f1 ++  ;    
        }                        
    }
     for  (i = rear;i >= 0 ;i -- )
     if  (que[i][ 0 ] == tmp)         break ;
     int  stack[MAXN],top = 0 ;
    rear = i;
     while  (rear != 0 ){
        stack[top ++ ] = que[rear][ 1 ];
        rear = que[rear][ 2 ] ;    
    }
     for  (i = top - 1 ;i >= 0 ;i -- ){
         switch (stack[i]){
             case   1 :putchar( ' r ' ) ;     break ;
             case   2 :putchar( ' l ' ) ;  break ;
             case   3 :putchar( ' u ' ) ;  break ;
             default :putchar( ' d ' );
        }    
    }
     for  (i = r1;i >= 0 ;i -- )
     if  (q1[i][ 0 ] == tmp)     break ;
     while (i != 0 ){
         switch (q1[i][ 1 ]){
             case   1 :putchar( ' l ' ) ;     break ;
             case   2 :putchar( ' r ' ) ;  break ;
             case   3 :putchar( ' d ' ) ;  break ;
             default :putchar( ' u ' );
        }
        i = q1[i][ 2 ];    
    }
    printf( " " );
}



 int  main(){
      while  (gets(ch)){
        Init();    
        printf( " %d  " ,Hash(s));
         if (Isok()){
            Solve();            
        }
         else     printf( " unsolvable " );
    }
     return   0 ;    
}
 /*
1 2 3 4 6 8 7 5 x
2  3  4  1  5  x  7  6  8

uldr
 */

A*算法

2451851kilvdn1077Accepted1980K0MSG++4512B2007-08-05 20:36:57

 

#include  < cstdio >
#include  < cstdlib >
#include  < cstring >
#include  < algorithm >
using   namespace  std;
 #define  MAXN 362880
const   int  tar = 123456789  ,
    pw[ 10 ] = { 1 , 10 , 100 , 1000 , 10000 , 100000 , 1000000 , 10000000 , 100000000 , 1000000000 },
    jc[ 10 ] = { 1 , 1 , 2 , 6 , 24 , 120 , 720 , 5040 , 40320 , 362880 };
 int  s , st[ 10 ] , que[MAXN][ 4 ] , rear , front;
 char  ch[ 50 ];
 bool  used[MAXN] ;

typedef  struct  {
     int  pos,v ;    
}T ;

T heap[MAXN];
 int  hp = 0 ;

 int  cmp ( const  T  & a, const  T  & b ){ 
     return  a.v  >  b.v; 
}

 bool  Isok(){
     int  i , j , sum ;
    sum = 0  ;
     for  (i = 1 ;i < 10 ;i ++ )
     for  (j = i + 1 ;j < 10 ;j ++ ){
         if  (st[i] > st[j])    sum ++  ;    
    }
     if  (sum % 2 == 0 )     return   true  ;
     return   false  ;
}
 int  Init(){
     int  len , i , q , c = 1 ;
    len = strlen(ch);
    s = 0 ;
     for  (i = 0 ;i < len;i ++ ){
         if  ((ch[i] >= ' 0 ' && ch[i] <= ' 9 ' ) || ch[i] == ' x ' ){
             if  (ch[i] == ' x ' )        q = c , st[q] = 10  ;
             else {
                 if  (s == 0 )    s = ch[i] - ' 0 ' ;
                 else     s = s * 10 + ch[i] - ' 0 '  ;
                st[c] = ch[i] - ' 0 '  ;
                c ++  ;        
            }    
        }    
    }    
    memset(used, 0 , sizeof (used));
    s = s * 10 + q ;
}
 /*
astar 算法估价函数  
 */
int  Value( int  a){
     int  t[ 9 ] , i , j , p;
     for  (i = 0 ;i < 9 ;i ++ ){
        t[i] = a / pw[ 8 - i] % 10  ;    
    }     
     for (p  =   0 , i  =   0 ; i  <   9 ; i ++ ){
         if (t[i]  ==   ' x ' )  continue ;
         if (t[i]  !=  i + 1 ){
            j  =  t[i]  -   ' 1 ' ;
            p  +=  abs(i / 3   -  j / 3 )  +  abs(i % 3   -  j % 3 );
        }
    }
     return  p ;
}

 // 1R2L3U4D
int  Right( int  a ){     return  a + 1  ;}
 int  Left ( int  a){     return  a - 1  ;}
 int  Up( int  a ){
     int  t1,t2,t3 ;
    t1 = 9 - a % 10 + 1  ;
    t2 = a / pw[t1] ; 
    t3 = t2 / 1000 * 1000 + t2 % 100 * 10 + t2 / 100 % 10  ;
     return  t3 * pw[t1] + a % pw[t1] / 10 * 10 + a % 10 - 3  ;
}
 int  Down( int  a ){
     int  t1,t2,t3,t4;
    t1 = 9 - a % 10 + 1  ;    
    t2 = a / pw[t1] ;
    t3 = a % pw[t1];
    t4 = (t3 / pw[t1 - 2 ] + t3 / pw[t1 - 3 ] % 10 * 100 ) * pw[t1 - 3 ] + t3 % pw[t1 - 3 ] ;
     return   t2 * pw[t1] + t4 / 10 * 10 + a % 10 + 3  ;
}
 int  Hash( int  a){
     int  t[ 9 ] , i , j , k , res = 0 ;
     for  (i = 0 ;i < 9 ;i ++ ){
        t[i] = a / pw[ 8 - i] % 10  ;    
    }
     for  (i = 0 ;i < 8 ;i ++ ){
        k = 0  ;
         for  (j = 0 ;j < i;j ++ )
             if  (t[i] < t[j]) k ++  ;        
        res += k * jc[i] ;
    }
    res += ( 9 - t[ 8 ]) * jc[ 8 ] ;
     return  res ;
}

 bool  Find( int  front){
     int  tmp , tt;    
        tmp = (que[front][ 0 ] % 10 - 1 ) % 3  ;
         if  (tmp < 2 ){
            tmp = Right(que[front][ 0 ]);
            tt = Hash(tmp);
             if  ( ! used[tt]){
                used[tt] = 1 ;
                que[rear][ 0 ] = tmp ;
                que[rear][ 1 ] = 1  ;
                que[rear][ 2 ] = front ;
                que[rear][ 3 ] = que[front][ 3 ] + 1  ;
                heap[hp].v  =   10   *  Value(tmp)  +  que[rear][ 3 ];
                heap[hp].pos  =  rear;
                push_heap(heap,heap + ( ++ hp),cmp);
                rear ++  ;
            }    
        }
        tmp = (que[front][ 0 ] % 10 - 1 ) % 3  ;
         if  (tmp > 0 ){
            tmp = Left(que[front][ 0 ]);
            tt = Hash(tmp);
             if  ( ! used[tt]){
                used[tt] = 1 ;
                que[rear][ 0 ] = tmp ;
                que[rear][ 1 ] = 2  ;
                que[rear][ 2 ] = front ;
                que[rear][ 3 ] = que[front][ 3 ] + 1  ;
                heap[hp].v  =   10   *  Value(tmp)  +  que[rear][ 3 ];
                heap[hp].pos  =  rear;
                push_heap(heap,heap + ( ++ hp),cmp);
                rear ++  ;    
            }    
        }
        tmp = (que[front][ 0 ] % 10 - 1 ) / 3  ;
         if  (tmp < 2 ){
            tmp = Down(que[front][ 0 ]);
            tt = Hash(tmp);
             if  ( ! used[tt]){
                used[tt] = 1 ;
                que[rear][ 0 ] = tmp ;
                que[rear][ 1 ] = 4  ;
                que[rear][ 2 ] = front ;
                que[rear][ 3 ] = que[front][ 3 ] + 1  ;
                heap[hp].v  =   10   *  Value(tmp)  +  que[rear][ 3 ];
                heap[hp].pos  =  rear;
                push_heap(heap,heap + ( ++ hp),cmp);
                rear ++  ;    
            }    
        }
        tmp = (que[front][ 0 ] % 10 - 1 ) / 3  ;
         if  (tmp > 0 ){
            tmp = Up(que[front][ 0 ]);
            tt = Hash(tmp);
             if  ( ! used[tt]){
                used[tt] = 1 ;
                que[rear][ 0 ] = tmp ;
                que[rear][ 1 ] = 3  ;
                que[rear][ 2 ] = front ;
                que[rear][ 3 ] = que[front][ 3 ] + 1  ;
                heap[hp].v  =   10   *  Value(tmp)  +  que[rear][ 3 ];
                heap[hp].pos  =  rear;              
                push_heap(heap,heap + ( ++ hp),cmp);           
                rear ++  ;    
            }    
        }        
     return   false  ;    
}
 /*
A* 算法 

 */
int  Solve(){
     int  i,tt;
    T tm;    
    que[ 0 ][ 0 ] = s ;
    que[ 0 ][ 3 ] = 0 ;
    tt = Hash(s);
    used[tt] = 1  ;
    hp = 0 ;
    front = 0  , rear = 1  ;

     while  (que[front][ 0 ] != tar){
        Find(front) ;
        front = heap[ 0 ].pos ;
 //         printf("%d    %d ",heap[0].pos , heap[0].v ) ;    
        pop_heap(heap,heap + (hp -- ),cmp);    
        
    }

     int  stack[MAXN],top = 0 ;
    rear = front ;
     while  (rear != 0 ){
        stack[top ++ ] = que[rear][ 1 ];
        rear = que[rear][ 2 ] ;    
    }
     for  (i = top - 1 ;i >= 0 ;i -- ){
         switch (stack[i]){
             case   1 :putchar( ' r ' ) ; break ;
             case   2 :putchar( ' l ' ) ;  break ;
             case   3 :putchar( ' u ' ) ;  break ;
             default :putchar( ' d ' );
        }    
    }
    printf( " " );
}

 int  main(){
     while  (gets(ch)){
        Init();    
         if (Isok()){
            Solve();            
        }
         else     printf( " unsolvable " );
    }
     return   0 ;    
}
 /*
1 2 3 4 6 8 7 5 x
 */

 

 

kilvdn
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pku 1077 Eight
野生码农
01-21 143
&#13; 做了好几天,几个小错误,没耐心都没调试出来..&#13; A* 最小堆 hash表 还是超时..诶&#13; 告一段落...&#13; &#13; /*&#13; 分析:&#13; A*搜索的状态包含了布局和在搜索树中的深度.&#13; 因为在优先队列的优先级是f,所以无法实现布局的二分查找.但是在open和close表中又要查找布局.不可行..&#13; 通过h...
pku 1077 Eight BFS
jack 专栏
08-15 618
Eight Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 21718   Accepted: 9611   Special Judge http://poj.org/problem?id=1077 Description The 15-puzzle has
pku1077 Eight
weixin_30486037的博客
12-11 45
A* Memory:6384K Time:79MS 太烂了,估计是hash太肿...有空再来优化 #include<iostream> #include<string> #include<vector> #include<queue> usingnamespacestd; #defineMAXN36288...
pku 1077 eight(据说有人用8中搜索算法做了这道题目)
low coder
09-20 876
状态有9！种，用的全排列的hash。首先写了个A*算法，0ms过了，但内存消耗挺大。其他方法的代码会陆续添加。好久没写过这种2500B+的代码。 A*#include #include #include #define _clr(a,b) memset(a,b,sizeof(a))using namespace std;const int maxn=3628
8数码代码pku1077
05-21
8数码代码pku1077，300ms（哈希+广度搜索）
pku.zip_PKU
09-22
【标题】"pku.zip_PKU" 指的是一份与北京大学(Peking University, PKU)相关的压缩文件。从描述来看，这份压缩包包含了部分编程题目的代码，可能是学生或者爱好者在解决北京大学编程竞赛或课程作业时编写的。"pku"这...
PKU-ACM.rar_PKU_acm 题目
09-21
在编程竞赛的世界里，北京大学（PKU）的ACM团队以其高质量的题目和独特的解题思路闻名。"PKU-ACM.rar"这个压缩包包含了北大ACM题目的一些核心知识点，旨在帮助参赛者理解和掌握算法竞赛中的生命周期题目解法。本文将...
pku.rar_PKU_cpp
09-14
pku北大题库的部分题目，共12题。 1029.cpp，1032.cpp，1035.cpp，1128.cpp，1045.cpp，1051.CPP， 1056.cpp，3173.cpp，3186.cpp，3187.cpp，3191.cpp，3256.c
pku_ACM.rar_PKU_PKU_ACM
09-20
《北京大学PKU ACM竞赛题目解析》 北京大学(Peking University, 简称PKU)作为中国顶级学府，其在计算机科学领域的教育和竞赛有着深厚的底蕴。ACM（International Collegiate Programming Contest，国际大学生程序...
算法-KMP字符串匹配
xx_xb的博客
07-23 174
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 395
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 648
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 747
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 309
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 751
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 251
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 403
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
pku vehicleid dataset
07-20
### 回答1： PKU VehicleID数据集是由北京大学智能交通与多媒体实验室提供的一个用于车辆识别的图像数据库。该数据集包含了车辆在不同环境、不同拍摄条件下的图像，旨在用于车辆相关研究的数据训练和测试。 PKU VehicleID数据集收集了超过8万辆车的图像，涵盖了2000多个车型和16000多个车例。这些图像是在不同的拍摄条件下捕捉到的，包括不同的光照、天气、角度和距离。这使得该数据集在车辆识别和相关研究领域具有较高的多样性和可用性。 PKU VehicleID数据集不仅提供了车辆图像，还包含了车辆的标注信息，如车辆类型、颜色、品牌等。这些标注信息为研究者提供了更多的可用数据，可以辅助他们进行车辆特征识别、车辆分类等相关研究。 PKU VehicleID数据集可以广泛应用于车辆识别、车辆检测、交通监控等领域的研究和实践中。通过利用该数据集，研究者可以进行车辆模型的建立与识别、车辆行为的分析与预测等工作，从而为智能交通和城市管理提供更好的技术支持和解决方案。 综上所述，PKU VehicleID数据集是一个丰富的车辆图像数据库，它提供了大量的车辆图像和标注信息，为车辆识别和相关研究领域的研究者提供了重要的资源和工具。通过该数据集的应用，我们可以更好地理解和研究车辆特征识别、车辆分类等问题，为智能交通和城市管理带来更多的创新和进步。 ### 回答2： PKU VehicleID数据集是由北京大学人工智能与自动化研究所于2016年发布的一个车辆检测和识别的数据集。这个数据集主要包含了来自北京市道路监控系统的车辆图像和相关的车辆属性信息。 PKU VehicleID数据集的特点主要有以下几点。首先，该数据集包含了非常大量的车辆图像，总计约50万张，涵盖了丰富的场景和车型样本。其次，这些图像都是以野外真实道路监控视频截取得到的，具有较高的真实性和复杂性。此外，数据集中的每一辆车都被分配了一个唯一的ID号码，用于标识和跟踪车辆。最后，PKU VehicleID数据集还提供了诸如车辆类型、颜色、品牌等属性信息，方便进行车辆属性识别和分类任务。 PKU VehicleID数据集在车辆检测、跟踪和识别领域有着广泛的应用价值。通过利用这个数据集，可以开展车辆检测算法的研究和性能评估。同时，也可以进行车辆属性识别、车型分类等应用任务的研究。这个数据集的发布对于提升车辆智能监控和交通管理系统的性能具有重要意义。此外，PKU VehicleID数据集还可以为自动驾驶、交通安全和交通流量分析等领域的研究提供有价值的实验数据基础。总之，PKU VehicleID数据集是一个丰富而有用的资源，为车辆相关研究提供了有力的支持。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值