HDOJ 4499 Cannon

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4499


oder?如何参加?

Cannon

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)

Total Submission(s): 513    Accepted Submission(s): 297

Problem Description

In Chinese Chess, there is one kind of powerful chessmen called Cannon. It can move horizontally or vertically along the chess grid. At each move, it can either simply move to another empty cell in the same line without any other chessman along the route or
perform an eat action. The eat action, however, is the main concern in this problem.

An eat action, for example, Cannon A eating chessman B, requires two conditions:

1、A and B is in either the same row or the same column in the chess grid.

2、There is exactly one chessman between A and B.

Here comes the problem.

Given an N x M chess grid, with some existing chessmen on it, you need put maximum cannon pieces into the grid, satisfying that any two cannons are not able to eat each other. It is worth nothing that we only account the cannon pieces you put in the grid, and
no two pieces shares the same cell.

Input

There are multiple test cases.

In each test case, there are three positive integers N, M and Q (1<= N, M<=5, 0<=Q <= N x M) in the first line, indicating the row number, column number of the grid, and the number of the existing chessmen.

In the second line, there are Q pairs of integers. Each pair of integers X, Y indicates the row index and the column index of the piece. Row indexes are numbered from 0 to N-1, and column indexes are numbered from 0 to M-1. It guarantees no pieces share the
same cell.

Output

There is only one line for each test case, containing the maximum number of cannons.

Sample Input

4 4 2
1 1 1 2
5 5 8
0 0 1 0 1 1 2 0 2 3 3 1 3 2 4 0 

Sample Output

8
9

Source

2013
ACM-ICPC吉林通化全国邀请赛——题目重现

题意:给定一个棋盘,以及棋子的位置,问在该棋盘上最多还能放多少个棋子"炮",并且要保证"炮"之间不能相互攻击。

题解:可以用搜索做,从左至右,从上至下摆棋子,每次都要判断该点是否可以摆放。

——开始一直WA/TLE  郁闷——又稀里糊涂的过了~~ 果断时间再来看看。

AC代码:

#include<iostream>
#include<cstring>
#define N 6
using namespace std;
int init[N][N];
int n,m,q,tx,ty,res;
bool check(int x,int y){
    if(init[x][y])return false;
   init[x][y]=2;
    for(int i=0;i<y-1;i++){
        if(init[x][i]==2){
            int k=i+1,flag=0;
            while(k<=y){
                if(init[x][k]==2&&flag){
                        init[x][y]=0;return false;
                }
                if(init[x][k]>0)flag++;
                if(flag>1)break;
                k++;
            }
        }
    }
    for(int i=0;i<x-1;i++){
        if(init[i][y]==2){
            int k=i+1,flag=0;
            while(k<=x){
                if(init[k][y]==2&&flag){
                    init[x][y]=0;return false;
                }
                if(init[k][y]>0)flag++;
               if(flag>1)break;
                k++;
            }
        }
    }
    init[x][y]=0;
    return true;
}
void dfs(int x,int y,int cnt){
    if(cnt>res)res=cnt;
     if(y==m){
        x++;y=0;
        if(x>=n)return;
    }
    for(int i=x;i<n;i++)
    for(int j=y;j<m;j++){
        if(check(i,j)){
            init[i][j]=2;
            dfs(i,j+1,cnt+1);
            init[i][j]=0;
        }
        return dfs(i,j+1,cnt);
    }
}
int main()
{
    cin.sync_with_stdio(false);
    while(cin>>n>>m>>q)
    {
        res=0;
        memset(init,0,sizeof(init));
        while(q--){
            cin>>tx>>ty; init[tx][ty]=1;
        }
        dfs(0,0,0);
        cout<<res<<endl;
    }
    return 0;
}
时间: 2024-10-23 16:11:38

HDOJ 4499 Cannon的相关文章

HDU 4499 Cannon (暴力搜索)

题意:在n*m的方格里有t个棋子,问最多能放多少个炮且每个炮不能互相攻击(炮吃炮) 炮吃炮:在同一行或同一列且中间有一颗棋子. #include <stdio.h> #include <iostream> #include <algorithm> #include <string.h> #include <queue> #include <math.h> #define M 50 #define LL long long using

hdu 4499 Cannon(暴力)

题目链接:hdu 4499 Cannon 题目大意:给出一个n*m的棋盘,上面已经存在了k个棋子,给出棋子的位置,然后求能够在这种棋盘上放多少个炮,要求后放置上去的炮相互之间不能攻击. 解题思路:枚举行放的情况,用二进制数表示,每次放之前推断能否放下(会不会和已经存在的棋子冲突),放下后推断会不会互相攻击的炮,仅仅须要对每一个新加入的炮考虑左边以及上边就能够了. #include <cstdio> #include <cstring> #include <algorithm&

hdu 4499 Cannon 暴力dfs搜索

Cannon Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 589    Accepted Submission(s): 338 Problem Description In Chinese Chess, there is one kind of powerful chessmen called Cannon. It can move

HDU 4499.Cannon 搜索

Cannon Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)Total Submission(s): 965    Accepted Submission(s): 556 Problem Description In Chinese Chess, there is one kind of powerful chessmen called Cannon. It can move

hdu 4499 Cannon dfs

Cannon Time Limit: 20 Sec Memory Limit: 256 MB 题目连接 http://acm.hdu.edu.cn/showproblem.php?pid=4499 Description In Chinese Chess, there is one kind of powerful chessmen called Cannon. It can move horizontally or vertically along the chess grid. At eac

HDU 4499 Cannon (暴力求解)

题意:给定一个n*m个棋盘,放上一些棋子,问你最多能放几个炮(中国象棋中的炮). 析:其实很简单,因为棋盘才是5*5最大,那么直接暴力就行,可以看成一行,很水,时间很短,才62ms. 代码如下: #include <cstdio> #include <string> #include <cstdlib> #include <cmath> #include <iostream> #include <cstring> #include &

HDU 4499 Cannon

题意: 思路: #include<cstdio> #include<iostream> #include<cstring> #include<cmath> #include<stdlib.h> #include<vector> #include<queue> #include<stack> #include<algorithm> using namespace std; const int MAXN

HDU ACM 4499 Cannon 暴力DFS

分析:N和M很小,直接暴力搜索即可. #include<iostream> using namespace std; #define N 6 #define M 6 int vis[N][M]; //有炮设为2,无炮为0,其他为1 int n,m,q,ans; #define max(a,b) ((a)>(b)?(a):(b)) bool Valid(int i,int j) //只需要判断当前和前面的即可(行列) { int fg=0; int k; if(vis[i][j]==1)

hdu4499 Cannon (DFS+回溯)

转载请注明出处:http://blog.csdn.net/u012860063 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4499 Cannon Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 363    Accepted Submission(s): 214 Problem Des