UVa 167(八皇后)、POJ2258——记两个简单回溯搜索

UVa 167

题意:八行八列的棋盘每行每列都要有一个皇后,每个对角线上最多放一个皇后,让你放八个,使摆放位置上的数字加起来最大。

参考:https://blog.csdn.net/xiaoxiede_wo/article/details/79973171

 1 #include <iostream>
 2 #include <cstring>
 3 #include <iomanip>
 4 using namespace std;
 5 int pic[9][9];
 6 int ans;
 7 int v[3][20];
 8 void dfs(int cur,int num){
 9     if(cur==8){//出现一组解,看能否更新
10         ans=max(ans,num);
11         return ;
12     }
13     for(int i=0;i<8;i++){
14         if(!v[0][i]&&!v[1][cur+i]&&!v[2][cur-i+8]){//v[0] 代表行 v[1]代表副对角线 v[2]代表主对角线
15             v[0][i]=1;v[1][cur+i]=1;v[2][cur-i+8]=1;//选这个点,标记
16             dfs(cur+1,num+pic[cur][i]);//往下搜索
17             v[0][i]=0;v[1][cur+i]=0;v[2][cur-i+8]=0;//复原
18         }
19     }
20 }
21 int main()
22 {
23     int n;
24     cin>>n;
25     while(n--){
26         ans=0;
27         memset(v,0,sizeof(v));
28         for(int i=0;i<8;i++)
29             for(int j=0;j<8;j++)
30                 cin>>pic[i][j];
31         dfs(0,0);
32         cout<<setw(5)<<ans<<endl;//输出有个小坑
33     }
34 }

POJ2258

题意:给你点和边的数量,再给你边的连接关系,求最长路径。点可以重复访问,边不行。

参考:https://blog.csdn.net/miranda_ymz/article/details/79274577

 1 #include<iostream>
 2 #include<cstdio>
 3 #include<cstring>
 4 #define N 26
 5 using namespace std;
 6 int n,m,ans;
 7 int edg[N][N],vis[N][N];
 8
 9 void search(int cur,int len){
10     ans=max(ans,len);
11     for(int i=0;i<n;i++)
12     {
13         if(edg[cur][i]==0||vis[cur][i]==1) continue;//如果两顶点不相连或已访问过,就跳过
14         vis[cur][i]=vis[i][cur]=1;//选择这个边并继续搜索
15         search(i,len+1);
16         vis[cur][i]=vis[i][cur]=0;//复原 回溯
17     }
18 }
19
20 int main(){
21     while(scanf("%d%d",&n,&m)!=EOF&&(n||m))
22     {
23         int a,b;
24         memset(edg,0,sizeof(edg));
25         for(int i=0;i<m;i++){
26             cin>>a>>b;
27             edg[a][b]=edg[b][a]=1;//连边
28         }
29         ans=0;
30         for(int i=0;i<n;i++){
31             memset(vis,0,sizeof(vis));//清空访问
32             search(i,0);
33         }
34         cout<<ans<<endl;
35     }
36     return 0;
37 }

原文地址:https://www.cnblogs.com/noobimp/p/10301477.html

时间: 2024-11-05 18:35:28

UVa 167(八皇后)、POJ2258——记两个简单回溯搜索的相关文章

Don&#39;t Get Rooked UVA 639(八皇后问题变形)

说说: 这道题目类似于八皇后问题.有n*n的正方形棋盘,且n<=4.例如在n=4时,有下图所示的棋盘,其中每两个棋子不能放在同一行或者同一列,除非有围墙(黑色的格子)将它们隔开.求给定的棋盘,能放下的最多的棋子数目. 分析: 在八皇后问题中,我们对整个棋盘分成八行考虑的,每行插入一个棋子.所以对于这道题目解决方案也类似,同样是一行一行插入.但是与八皇后问题不同的是,本题中棋盘一行可能插入多个棋子,也可能没有棋子.所以在递归函数中,不仅要给出所要处理的行的信息,也要给出所要处理的列的信息,其实就是

八皇后问题的两个高效的算法(回溯与递归)

序言 八皇后问题是一个经典的问题,在一个N*N的棋盘上放置N个皇后,每行一个并使其不能互相攻击(同一行.同一列.同一斜线上的皇后都会自动攻击). 求解八皇后问题是算法中回溯法应用的一个经典案例 回溯算法也叫试探法,它是一种系统地搜索问题的解的方法.回溯算法的基本思想是:从一条路往前走,能进则进,不能进则退回来,换一条路再试. 在现实中,有很多问题往往需要我们把其所有可能穷举出来,然后从中找出满足某种要求的可能或最优的情况,从而得到整个问题的解.回溯算法就是解决这种问题的“通用算法”,有“万能算法

【八皇后问题】 回溯算法

回溯算法:回溯算法实际上是一个类似枚举的搜索尝试方法,它的思想是在搜索尝试中寻找问题的解,当发现不满足求解条件时,就“回溯”返回,尝试别的路径.之前介绍的基础算法中的贪婪算法,动态规划等都具有“无后效性”,也就是在分段处理问题时,某状态一旦确定,将不再改变.而多数问题很难找到"无后效性”的阶段划分和相应决策,而是通过深入搜索尝试和回溯操作完成的. 八皇后问题:8*8的国际象棋棋盘中放八个皇后,是任意两个皇后不能互相吃掉.规则:皇后能吃掉同一行,同一列,同一对角线的任意棋子. 模型建立:不妨设八个

回溯法与八皇后问题

tail recursion 函数在调用的时候,会提前创建一个栈空间,给传递的参数也分配空间,当函数结束返回上层函数的时候,一些局部变量需要从栈中弹出并恢复到调用子函数之前的值,返回到上一个函数调用子函数之前的现场.如果是尾递归,从子函数返回的时候这个函数同时也会结束了,所以没有必要恢复一些局部变量,直接把局部变量的栈空间删除.因此一个尾递归的函数根本不需要使用栈来给子函数变量空间,可以直接使用当前变量的值为新参数的值. backtracking 八皇后问题 用一个类Queens表示棋盘上现在的

The Sultan&#39;s Successors UVA 167(八皇后问题)

说说: 其实这道题本质上就是一个八皇后问题.唯一的区别就是每个棋盘的格子都对应一个数字.最后要求输出,对应的解占据的格子的和的最大值.这只要在最后求出解的时候统计一下就可以了.下面就简单的说说八皇后问题,其实解法也不难.因为要求每行每列都要有棋子.因此只要确定每一行对应的棋子的列数就可以了.而对于每个棋子的所放的位置,同列上和对角线上不能有其他棋子,这个只要设一个访问数组保存一下就可以了.(注意要记得回溯).至于对角线的表示方法,例如所在位置为(x,y),那么一条对角线可以用x+y表示,另一条对

uva 167 - The Sultan&amp;#39;s Successors(典型的八皇后问题)

这道题是典型的八皇后问题,刘汝佳书上有具体的解说. 代码的实现例如以下: #include <stdio.h> #include <string.h> #include <stdlib.h> int vis[100][100];//刚開始wrong的原因就是这里数组开小了,开了[8][8],以为可以.后来看到[cur-i+8]意识到可能数组开小了.改大之后AC. int a[8][8]; int C[10]; int max_,tot; void search_(int

UVA The Sultan&#39;s Successors (八皇后问题)

 The Sultan's Successors  The Sultan of Nubia has no children, so she has decided that the country will be split into up to k separate parts on her death and each part will be inherited by whoever performs best at some test. It is possible for any in

java实现八皇后问题(递归和循环两种方式)

循环方式: package EightQueens; public class EightQueensNotRecursive { private static final boolean AVAILABLE = true; private int squares = 8, norm = squares - 1; private int positionInRow[] = new int[squares]; private int p=-1; private boolean[] rows = n

解决八皇后问题,递归与非递归方式两种

回溯法理解,一般形式 void Bcktrack(int t) //参数t表示当前递归深度 { if(t>n)Output(x); //遍历到解,则将解输出或其他处理 else { //f(n,t)和g(n,t)表示当前节点(扩展节点)处未搜索过的子树的起始编号和中指编号 for(int i=f(n,t);i<=g(n,t);i++) { x[t]=h(i); //h(i)表示当前节点(扩展节点)处x[i]的第i个可选值 if(Constarint(t)&&Bound(t))