poj 1077 解题报告

最新推荐文章于 2020-03-05 23:36:32 发布
最新推荐文章于 2020-03-05 23:36:32 发布
阅读量505 收藏
点赞数 1
分类专栏： 风雨飘摇路 acm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisc741/article/details/8619376
版权

最近学人工智能，要学A*算法，就重新做这道题经典的8数码问题，传说不做这道题人生不完整呢我之前是用的广搜暴力搞的，不过太慢了，还要说说我的hash方法，我是用康托展开来hash的，这个东西是算一个排列在所有排列大小排多少，比如（1,2,3）有6个排列，321是最大的就是第六个。还有就是康托展开的逆运算，就是知道是第几大的，算出这个排列来；

康托展开：

long  cantor( int s[] )
{
	int  i , j , t ;
	long num = 0 ;
	for( i = 0 ; i < 9 - 1 ; i ++ )
	{
		t = 0 ;
		for( j = i + 1 ; j < 9 ; j ++ )
			if( s[j] < s[i] ) ++ t ;
		num += fac[9-i-1] * t ;
	}
	return num ;
}

它的逆运算： 

void uncantor( int s[] , int ct )
{
	int  i , j , t , r ;
	bool p[10] = { 0 } ;
	for( i = 0 ; i < 9 ; i ++ )
	{
		t = ct / fac[9 - i - 1] + 1 ;
		ct %= fac[9 - i - 1] ;
		r = 0 , j = 1 ;
		while( 1 )
		{
			if( !p[j] ) r ++ ;
			if( r == t ) break ;
			j ++ ;
		}
		s[i] = j ; p[j] = 1 ;
	}
}

就是这样的，，，


用爆搜的代码是这样的：

Problem: 1077 User: 925695531
Memory: 2404K Time: 547MS
Language: C++ Result: Accepted

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <stack>
#include <cmath>
using namespace std;

int  fac[10] ;
int  pre[400000] ;
char dir[400000] ;

void  init( )
{
	fac[0] = 1 ;
	for( int i = 1 ; i <= 9 ; i ++ )
		fac[i] = i * fac[i-1] ;
}

long  cantor( int s[] )
{
	int  i , j , t ;
	long num = 0 ;
	for( i = 0 ; i < 9 - 1 ; i ++ )
	{
		t = 0 ;
		for( j = i + 1 ; j < 9 ; j ++ )
			if( s[j] < s[i] ) ++ t ;
		num += fac[9-i-1] * t ;
	}
	return num ;
}

void uncantor( int s[] , int ct )
{
	int  i , j , t , r ;
	bool p[10] = { 0 } ;
	for( i = 0 ; i < 9 ; i ++ )
	{
		t = ct / fac[9 - i - 1] + 1 ;
		ct %= fac[9 - i - 1] ;
		r = 0 , j = 1 ;
		while( 1 )
		{
			if( !p[j] ) r ++ ;
			if( r == t ) break ;
			j ++ ;
		}
		s[i] = j ; p[j] = 1 ;
	}
}


int main()
{
	int  tc[9] , ot , t , i;
	char c[2] ;
	bool ok = 0 ;
	queue<int> q ;

	init() ;
	memset( pre , 0 , sizeof( pre ) ) ;
	for( i = 0 ; i < 9 ; i ++ )
	{
		scanf( "%s" , c ) ;
		if( c[0] == 'x' ) tc[i] = 9 ;
		else tc[i] = c[0] - '0' ;
	}
	t = cantor( tc ) ;
	pre[t] = -1 ;
	q.push( t ) ;
	while( !q.empty() )
	{
		ot = q.front() ;
		q.pop() ;
		if( ot == 0 ) { ok = 1 ; break ; }
		uncantor( tc , ot ) ;
		for( i = 0 ; i < 9 ; i ++ ) if( tc[i] == 9 ) break ;
		if( i != 0 && i != 1 && i != 2 )
		{
			swap( tc[i] , tc[i-3] ) ;
			t = cantor(tc) ;
			if( !pre[t] )
			{
				pre[t] = ot ;
				dir[t] = 'u' ;
				q.push(t) ;
			}
			swap( tc[i] , tc[i-3] ) ;
		}
		if( i != 6 && i != 7 && i != 8 )  //down
		{
			swap( tc[i] , tc[i+3] ) ;
			t = cantor( tc ) ;
			if( !pre[t] )
			{
				pre[t] = ot ;
				dir[t] = 'd' ;
				q.push(t) ;
			}
			swap( tc[i] , tc[i+3] ) ;
		}
		if( i != 0 && i != 3 && i != 6 )  // left
		{
			swap( tc[i] , tc[i-1] ) ;
			t = cantor( tc ) ;
			if( !pre[t] )
			{
				pre[t] = ot ;
				dir[t] = 'l' ;
				q.push( t ) ;
			}
			swap( tc[i] , tc[i-1] ) ;
		}
		if( i != 2 && i != 5 && i != 8 )  // right
		{
			swap( tc[i] , tc[i+1] ) ;
			t = cantor( tc ) ;
			if( !pre[t] )
			{
				pre[t] = ot ;
				dir[t] = 'r' ;
				q.push(t) ;
			}
			swap( tc[i] , tc[i+1] ) ;
		}
	}
	if( ok )
	{
		stack<char> s ;
		while( pre[ot] != -1 )
		{
			s.push( dir[ot] ) ;
			ot = pre[ot] ;
		}
		while( !s.empty() )
		{
			printf( "%c" , s.top() ) ;
			s.pop() ;
		}
	}
	else printf( "unsolvable\n" ) ;
}

然后我用了A*算法，，启发函数是网上找的：

Problem: 1077 User: 925695531
Memory: 6988K Time: 16MS
Language: G++ Result: Accepted

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <stack>
#include <cmath>
using namespace std ;

int  fac[10] ;

struct Node
{
    int  pre  ;
    int  step ;
    int  h    ;
    char dir  ;
    bool vis  ;
} node[400000] ;

char  dir[400000] ;
bool  vis[400000] ;

void  init()
{
	fac[0] = 1 ;
	for( int i = 1 ; i <= 9 ; i ++ )
		fac[i] = i * fac[i-1] ;
}

long  cantor( int s[] )
{
	int  i , j , t ;
	long num = 0 ;
	for( i = 0 ; i < 9 - 1 ; i ++ )
	{
		t = 0 ;
		for( j = i + 1 ; j < 9 ; j ++ )
			if( s[j] < s[i] ) ++ t ;
		num += fac[9-i-1] * t ;
	}
	return num ;
}

void uncantor( int s[] , int ct )
{
	int  i , j , t , r ;
	bool p[10] = { 0 } ;
	for( i = 0 ; i < 9 ; i ++ )
	{
		t = ct / fac[9 - i - 1] + 1 ;
		ct %= fac[9 - i - 1] ;
		r = 0 , j = 1 ;
		while( 1 )
		{
			if( !p[j] ) r ++ ;
			if( r == t ) break ;
			j ++ ;
		}
		s[i] = j ; p[j] = 1 ;
	}
}

class cmp
{
public:
    bool operator()(int sa,int sb)
    {
        return node[sa].h+node[sa].step>node[sb].h+node[sb].step;
    }
};

int  h( int s[] )
{
    int  H = 0 ;
    for( int i = 0 ; i < 9 ; i ++ )
    {
        if( s[i] != 9 ) H += abs ( double ( ( s[i] - 1 ) / 3 - i / 3 ) ) + abs ( double ( ( s[i] - 1 ) % 3 - i % 3 ) ) ;
        //if( s[i] != 9 && i == s[i] - 1 ) H ++ ;
    }
    return H ;
}

bool AStar( int s[] )
{
    int  tc[9] , t , i , flag = 0 ;
    //if( !isResolve( s ) ) return false ;
    memset( vis , 0 , sizeof( vis ) ) ;
    priority_queue< int , vector<int> , cmp > q ;
    int  temp = cantor( s ) ;
    node[temp].pre = -1 ;
    node[temp].step = 0 ;
    node[temp].h    = h( s ) ;

    q.push( temp ) ;
    while( !q.empty() )
    {
        temp = q.top() ;
        q.pop() ;
        if( temp == 0 ){
            flag = 1 ;
            break ;
        }
        if( vis[temp] ) continue ;
        uncantor( tc , temp ) ;
        for( i = 0 ; i < 9 ; i ++ ) if( tc[i] == 9 ) break ;
		if( i != 0 && i != 1 && i != 2 )
		{
			swap( tc[i] , tc[i-3] ) ;
			t = cantor(tc) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( tc ) ;
				dir[t] = 'u' ;
				q.push(t) ;
			}
			swap( tc[i] , tc[i-3] ) ;
		}
		if( i != 6 && i != 7 && i != 8 )
		{
			swap( tc[i] , tc[i+3] ) ;
			t = cantor( tc ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( tc ) ;
				dir[t] = 'd' ;
				q.push(t) ;
			}
			swap( tc[i] , tc[i+3] ) ;
		}
		if( i != 0 && i != 3 && i != 6 )
		{
		    swap( tc[i] , tc[i-1] ) ;
			t = cantor( tc ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( tc ) ;
				dir[t] = 'l' ;
				q.push(t) ;
			}
		    swap( tc[i] , tc[i-1] ) ;
		}
		if( i != 2 && i != 5 && i != 8 )
		{
		    swap( tc[i] , tc[i+1] ) ;
			t = cantor( tc ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( tc ) ;
				dir[t] = 'r' ;
				q.push( t ) ;
			}
		    swap( tc[i] , tc[i+1] ) ;
		}
    }
    return flag ;
}

int  main()
{
    int  tc[9] , ot = 0 , i ;
    char ch ;
    init() ;
    for( i = 0 ; i < 9 ; i ++ )
    {
        cin >> ch ;
        if( ch == 'x' ) tc[i] = 9 ;
        else tc[i] = ch - '0' ;
    }
    if( AStar( tc ) )
    {
        stack < char > s ;
        while( node[ot].pre != -1 )
        {
            s.push( dir[ot] ) ;
            ot = node[ot].pre ;
        }
        while( !s.empty() )
        {
            cout << s.top() ;
            s.pop() ;
        }
        cout << endl ;
    }
    else cout << "unsolvable" << endl ;
    return 0 ;
}

然后我自己想了一个启发函数

结果是这样了：

Problem: 1077 User: 925695531
Memory: 6988K Time: 0MS
Language: G++ Result: Accepted
注释的部分就是被改掉的 

#include <iostream>
#include <cstring>
#include <queue>
#include <stack>
#include <cmath>
using namespace std ;

struct Node{
    int  pre , h , step ;
    char dir     ;
    bool vis     ;
} node[400000] ;

struct cmp
{
    bool operator () ( int a , int b )
    {
        //return node[a].h + node[a].step > node[b].h + node[b].step ;
        return node[a].h < node[b].h ;
    }
} ;

int  fac[10] ;

void  init() ;
int   cantor( int s[] ) ;
void  uncantor( int s[] , int num ) ;
int   h( int s[]  ) ;
bool  AStar( int s[] ) ;

int  main()
{
    int  str[10] , State = 0 ;
    char ch ;
    init()  ;
    for( int i = 0 ; i < 9 ; i ++ )
    {
        cin >> ch ;
        if( ch == 'x' ) str[i] = 9 ;
        else str[i] = ch - '0' ;
    }
    if( AStar( str ) )
    {
        stack < char > s ;
        while( node[State].pre != -1 )
        {
            s.push( node[State].dir ) ;
            State = node[State].pre   ;
        }
        while( !s.empty() )
        {
            cout << s.top() ;
            s.pop() ;
        }
        cout << endl ;
    }
    else cout << "unsolvable" << endl ;
    return 0 ;
}

void  init()
{
	fac[0] = 1 ;
	for( int i = 1 ; i <= 9 ; i ++ )
		fac[i] = i * fac[i-1] ;
}

int  cantor( int s[] )                          //康托展开
{
    int  num = 0 , t ;
    for( int i = 0 ; i < 9 ; i ++ )
    {
        t = 0 ;
        for( int j = i + 1 ; j < 9 ; j ++ )
            if( s[i] > s[j] ) t ++ ;
        num += fac[9 - i - 1] * t ;
    }
    return num ;
}

void uncantor( int s[] , int num )              //逆向康托展开
{
	int  j , t , r ;
	bool p[10] ;
	memset( p , 0 , sizeof( p ) ) ;
	for( int i = 0 ; i < 9 ; i ++ )
	{
		t = num / fac[9 - i - 1] + 1 ;
		num %= fac[9 - i - 1] ;
		r = 0 , j = 1 ;
		while( 1 )
		{
			if( !p[j] ) r ++ ;
			if( r == t ) break ;
			j ++ ;
		}
		s[i] = j ; p[j] = 1 ;
	}
}

int  h( int s[] )                      //估价函数
{
    int H = 0 ;
    for( int i = 0 ; i < 9 ; i ++ )
        //if( s[i] != 9 ) H += abs ( double ( ( s[i] - 1 ) / 3 - i / 3 ) ) +
          //                   abs ( double ( ( s[i] - 1 ) % 3 - i % 3 ) ) ;
        if( s[i] != 9 && i == s[i] - 1 ) H ++ ;
    return H ;
}

bool AStar( int s[] )                  //A*
{
    int  str[9] , flag = 0 , i , t ;
    memset( node , 0 , sizeof( node ) ) ;
    priority_queue< int , vector<int> , cmp > q ;
    int  temp = cantor( s )  ;
    node[temp].step = 0      ;
    node[temp].pre  = -1     ;
    node[temp].h    = h( s ) ;
    q.push( temp ) ;
    while( !q.empty() )
    {
        temp = q.top() ;
        q.pop()        ;
        if( temp == 0 ) {
            flag = 1 ;
            break ;
        }
        if( node[temp].vis ) continue ;
        uncantor( str , temp ) ;
        for( i = 0 ; i < 9 ; i ++ ) if( str[i] == 9 ) break ;
        if( i != 0 && i != 1 && i != 2 )
        {
			swap( str[i] , str[i-3] ) ;
			t = cantor( str ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp                ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( str )            ;
				node[t].dir  = 'u'                 ;
				q.push( t ) ;
			}
			swap( str[i] , str[i-3] ) ;
        }
        if( i != 6 && i != 7 && i != 8 )
        {
			swap( str[i] , str[i+3] ) ;
			t = cantor( str ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp                ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( str )            ;
				node[t].dir  = 'd'                 ;
				q.push( t ) ;
			}
			swap( str[i] , str[i+3] ) ;
        }
        if( i != 0 && i != 3 && i != 6 )
        {
			swap( str[i] , str[i-1] ) ;
			t = cantor( str ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp                ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( str )            ;
				node[t].dir  = 'l'                 ;
				q.push( t ) ;
			}
			swap( str[i] , str[i-1] ) ;
        }
        if( i != 2 && i != 5 && i != 8 )
        {
			swap( str[i] , str[i+1] ) ;
			t = cantor( str ) ;
			if( !node[t].pre )
			{
				node[t].pre  = temp                ;
				node[t].step = node[temp].step + 1 ;
				node[t].h    = h( str )            ;
				node[t].dir  = 'r'                 ;
				q.push( t ) ;
			}
			swap( str[i] , str[i+1] ) ;
        }
    }
    return flag ;
}


吾等前方绝无敌手
关注
专栏目录
POJ 1077 解题报告
thestoryofsnow的专栏
12-13 654
这道题我是用bfs+hash做的，最好的方法应该是双向bfs或是A*。虽然这学期刚学的AI，但是偷懒，就这样过了吧。 POJ不支持unordered_map，所以得自己写hash，好在比较简单。由于棋盘是9位的（算上空白位置，那一位我用0填充的），所以每个棋盘（即状态值）可以用一个int表示。每个状态需要记录状态值，空白位置，前一个状态值，及怎么从前一个状态值move过来的。这里用的是hash来
poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告
10-06
poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题报告poj 解题...
poj1077
weixin_34075551的博客
07-19 62
题意：给出一个八数码问题，求解法，不可解则输出unsolvable。 分析：可以用ida*算法，估价函数可以使用每个数码到其最终位置的最短距离之和。对于不可解的判断，我这里用迭代深度大于100时判定为不可解。 还有一种更高级的无解判断方法。就是将八数码矩阵中的空格忽略，然后将8个数字排成一排，第二行接在第一行后面，第三行接在第二行后面，通过观察我们发现移动空格不会影响这个8个数字组成的数列中逆...
poj1077解题报告详解
lovewangtaotao的专栏
03-09 847
在详细的讲解了一下康拓展开和A*搜索后，我们终于迎来了对八数码问题的致命一击，那这里我就秉承之前的解题报告流程，一不要怪我官方啊；； 1.题意： 此题是一个经典的老提，就是给出一个方阵，你要输出基本的路径，使得方阵为1，2，3，4，5，6，7，8，x； 2.思路： 太简单的思路了，就是一个简单的搜索，如果不是会超时，要寻找一个更合适的方案，是不会有人做的；； 3.如何针对超时：
POJ~1077~八数码~DFS解题报告
xiaosuC的博客
03-05 382
八数码： 文章目录八数码：题目描述：Input：Output：Sample Input：Sample Output：题目大意：思路分析：代码： 题目描述： The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructe...
poj2828解题报告
12-19
这篇解题报告主要介绍了如何解决POJ2828这个编程题目。该题目涉及的数据结构是区间树（Interval Tree），这是一种用于高效处理区间查询和修改的树形数据结构。在这个问题中，我们需要根据输入的元素位置和值，构建一...
北大poj解题报告
12-23
这个“北大poj解题报告”包含了作者在使用POJ平台解题过程中的学习总结和经验分享，旨在帮助软件工程专业的学生提升编程能力和算法理解。 解题报告通常会涵盖以下几个方面： 1. **基础算法讲解**：解题报告中可能...
poj1691解题报告
12-29
### poj1691解题报告 #### 题目信息 - **题目名称**：Painting A Board - **时间限制**：1S - **内存限制**：1000K - **提交总数**：62 - **通过总数**：35 - **来源**：...
用 A* 解决八数码问题
hazqfp的专栏
02-27 952
#include 8 s% W2 b- F3 j$ Y4 o #include 3 _  h, ^$ P9 ?/ ? #include using namespace std; 9 S+ n& Q  g  R4 y #define HEAP_PARENT(i)                        (i >> 1); n- q# z9 x0 {. O
POJ-1077 Eight （三种解法：IDA*、A*、bfs()+康托展开）
mjj1024的博客
04-23 841
题目链接：https://cn.vjudge.net/problem/POJ-1077（根据我自己的理解写的，有错误的地方希望大家可以指正一下，非常感谢！）IDA*解法：什么是IDA*算法？    IDA*是基于深搜的基础上的一种优化算法。    对于这个题来说，由于深搜算出最佳方案需要耗费很多的时间，所以我们就从假定最优解开始算起，若搜索不出来这个结果，就将假定最优解加一再搜一次，直到搜到与当前...
poj 1077 Eight A*解八数码问题
sepNINE的专栏
05-25 1083
110多行0ms的精简高效A*算法解决八数码问题，源代码详解。
POJ 1077 Eight A*算法求解
正月看雪花的博客
02-01 3424
题目描述         在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。 在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。 我们的目的是通过交换，使得网格变为如下排列（称为正确排列）： 例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交...
八数码问题相关题目解法 poj1077Eight hdu5012Dice
ZT在努力
09-23 787
八数码问题是bfs+hash中的经典
POJ1077 Eight —— 经典的搜索问题
A man can be destroyed, but not defeated.
09-03 3284
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1043 Eight Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 25408    Accepted Submiss
POJ 1077
一只菜鸟夹
07-07 451
https://blog.csdn.net/mjj1024/article/details/80047648 https://blog.csdn.net/a799581229/article/details/38925697
解密15拼图：从POJ 1077 Eight探讨解题策略
"这是一个关于ACM竞赛中的Poj 1077 Eight问题的讨论，主要涉及15拼图游戏的解决策略和算法。" 在计算机科学领域，特别是算法设计和编程竞赛（如ACM）中，解决问题的能力是至关重要的。Poj 1077 Eight是一个基于15...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值