uva639 暴力、回溯

题意:

在象棋中,“车”是可以在棋盘上沿着纵向或横向走任意格子的棋子。 在这个问题中,我们假设有一个4*4的小棋盘,

在这个棋盘上面包含着“墙”,而“车”是不能越过墙的。而我们的目标就是尽可能地放置更多地“车”到这个棋盘上去,使所有

的这些”车“互相不能吃到其它棋子。

在上面几副图中给出了几个样例, 棋盘上,格子全部是黑色的代表是“墙”, 黑色圆形的代表是“车”。

其中第二,三副图的棋子的放置是正确的,第四,五副图的棋子是错误的,因为那两个棋子可以互相吃到对方。

 1 #include <cstdio>
 2 #include <cstdlib>
 3 #include <cctype>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <ctime>
 7 #include <string>
 8 #include <vector>
 9 #include <map>
10 #include <set>
11 #include <algorithm>
12 #include <iostream>
13 using namespace std;
14 int dir[5][2] = { {0,1}, {0,-1}, {1,0}, {-1,0} };
15 char ch[10][10];
16 int vis[10][10];
17 int ans, n;
18
19 inline bool judge( int x, int y )//从当前位置出发 判断改点所在的行列是否已经有车
20 {
21     for( int i = 0; i < 4; ++i )
22     {
23         int dx = x + dir[i][0];
24         int dy = y + dir[i][1];
25         while( dx < n && dx >= 0 && dy >= 0 && dy < n )
26         {
27             if( ch[dx][dy] == ‘X‘ )
28                 break;
29             if( vis[dx][dy] )
30                 return true;
31             dx += dir[i][0];
32             dy += dir[i][1];
33         }
34     }
35     return false;
36 }
37
38 void dfs( int x, int m )
39 {
40     for( int i = x; i < n; ++i )
41         for( int j = 0; j < n; ++j )
42             if( !vis[i][j] && ch[i][j] == ‘.‘ && !judge( i, j ) )
43             {
44                 vis[i][j] = 1;
45                 dfs( i, m+1 );
46                 vis[i][j] = 0;
47             }
48     if( ans < m )
49         ans = m;
50 }
51
52 int main()
53 {
54     while( ~scanf( "%d", &n ) && n )
55     {
56         for( int i = 0; i < n; ++i )
57             scanf( "%s", ch[i] );
58         memset( vis, 0, sizeof( vis ) );
59         ans = 0;
60         dfs( 0, 0 );
61         printf( "%d\n", ans );
62     }
63     return 0;
64 }

时间: 2024-10-21 09:27:07

uva639 暴力、回溯的相关文章

uva 639 Don&#39;t Get Rooked (暴力回溯 )

uva 639 Don't Get Rooked In chess, the rook is a piece that can move any number of squares vertically or horizontally. In this problem we will consider small chess boards (at most 44) that can also contain walls through which rooks cannot move. The g

暴力回溯法 解八皇后

国际象棋 八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同一列或同一斜线上,问有多少种摆法. public class _8Queen { //回溯法,暴力解8皇后 private static int ways = 0; //返回解法个数 public static int f8queen() { int[][] board = new int

Summer Training #10 Div.2 E(暴力+回溯)

题目链接 题意:给9乘9的数独矩阵,挖去其中5个元素,要求补全其余元素 所犯错误:1.题目中所给的数独矩阵本身可能就是错的(没认真看题,wa惨了)   2.回溯时,遇到正确的答案就终止循环 #include<stdio.h> #include<string.h> #include<queue> using namespace std; bool flag[3][11][11]; int n,a[11][11],b[7][5],k,ans[7],f; bool valid

UVALive 6585 &amp;&amp; Gym 100299F Draughts (暴力+回溯)

题意:给定一个 10*10的矩阵,每一个W可以跳过一个B向对角走到#并把B吃掉,并且可以一直跳直到不能动为止,现在是W走的时候,问你最多吃几个B. 析:直接暴力+回溯,深搜就好. 代码如下: #pragma comment(linker, "/STACK:1024000000,1024000000") #include <cstdio> #include <string> #include <cstdlib> #include <cmath&g

穷举递归和回溯算法终结篇

穷举递归和回溯算法 在一般的递归函数中,如二分查找.反转文件等,在每个决策点只需要调用一个递归(比如在二分查找,在每个节点我们只需要选择递归左子树或者右子树),在这样的递归调用中,递归调用形成了一个线性结构,而算法的性能取决于调用函数的栈深度.比如对于反转文件,调用栈的深度等于文件的大小:再比如二分查找,递归深度为O(nlogn),这两类递归调用都非常高效. 现在考虑子集问题或者全排列问题,在每一个决策点我们不在只是选择一个分支进行递归调用,而是要尝试所有的分支进行递归调用.在每一个决策点有多种

算法学习——DFS(暴力搜索)N皇后问题

N皇后问题是非常经典的一道问题,解题的方法也有很多,非常经典包括暴力回溯法. DFS就是深度优先搜索的首字母,简单理解就是把所有可能是答案的结果都尝试一遍,用走迷宫来举例子的话就是一条路走到黑,如果走到死路了,再退回上一个分岔口选择另一条路继续一条路走到黑. 属于入门时非常常用的暴力算法,考察的知识点主要是对递归的掌握和理解.递归也是新生入门算法时必经的一道门槛,理解透彻递归,就能明白DFS. #include<bits/stdc++.h> using namespace std; const

hdu 5956 The Elder 2016ACM/ICPC沈阳赛区现场赛I

Problem Description Once upon a time, in the mystical continent, there is a frog kingdom, ruled by the oldest frog, the Elder. The kingdom consists of N cities, numbered from east to west. The 1-th city, which is located to the east of others, is the

尝试解决N皇后问题(持续优化)

0层:神圣打表(∞) 1 #include <cstdio> 2 int main() { 3 int arr[11] = {0,1,0,0,2,10,4,40,92,352,724}; 4 int n; 5 while(~scanf("%d", &n) && n){ 6 printf("%d\n", arr[n]); 7 } 8 } 1层:一维暴力回溯(13) 1 const int maxn = 20; 2 int G[max

FZU 2107 Hua Rong Dao

dfs暴力回溯,这个代码是我修改以后的,里面的go相当简洁,以前的暴力手打太麻烦,我也来点技术含量.. #include<iostream> #include<cstring> #include<cstdio> using namespace std; #define m 4 int caocao[4][2] = {0,0,0,1,1,0,1,1}; int go[3][3][2] = {{{0,1},{0,0}},{{1,0},{0,0}},{{0,0}}}; int