HHTC_学校集训编程题目（6）（搜索）

最新推荐文章于 2020-06-29 18:17:26 发布
最新推荐文章于 2020-06-29 18:17:26 发布
阅读量446 收藏
点赞数
分类专栏： 编程练习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42967398/article/details/97234668
版权

HHTC_学校集训编程题目（6）（搜索）

Rock, Scissors, Paper

Bart’s sister Lisa has created a new civilization on a two-dimensional grid. At the outset each grid location may be occupied by one of three life forms: Rocks, Scissors, or Papers. Each day, differing life forms occupying horizontally or vertically adjacent grid locations wage war. In each war, Rocks always defeat Scissors, Scissors always defeat Papers, and Papers always defeat Rocks. At the end of the day, the victor expands its territory to include the loser’s grid position. The loser vacates the position.
Your job is to determine the territory occupied by each life form after n days.

Input

The first line of input contains t, the number of test cases. Each test case begins with three integers not greater than 100: r and c, the number of rows and columns in the grid, and n. The grid is represented by the r lines that follow, each with c characters. Each character in the grid is R, S, or P, indicating that it is occupied by Rocks, Scissors, or Papers respectively.

Output

For each test case, print the grid as it appears at the end of the nth day. Leave an empty line between the output for successive test cases.

Sample Input

2
3 3 1
RRR
RSR
RRR
3 4 2
RSPR
SPRS
PRSP

Sample Output

RRR
RRR
RRR

RRRS
RRSP
RSPR

这道题目貌似是模拟题，，，，，
就是石头剪刀布，，，上下左右进行比较，，，比较多少次
用一个暂时的数组存放比完之后的结果，然后再次进行的时候在赋给原来的数组
AC代码:

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

char a[105][105],b[105][105];
int n,m,k;
int d[4][2] = {1,0,-1,0,0,1,0,-1};

bool judge(int x,int y){
    if(x >= 0 && y >= 0 && x < n && y < m)
        return true;
    return false;
}

void dfs(int x,int y){
    for(int i=0;i<4;i++){
        int xx = x + d[i][0];
        int yy = y + d[i][1];
        if(judge(xx,yy)){
            if(a[x][y] == 'R' && a[xx][yy] == 'S')
                b[xx][yy] = 'R';
            else if(a[x][y] == 'S' && a[xx][yy] == 'P')
                b[xx][yy] = 'S';
            else if(a[x][y] == 'P' && a[xx][yy] == 'R')
                b[xx][yy] = 'P';
        }
    }
}

int main(){
    int T,f = 0;
    cin>>T;
    while(T--){
        if(f != 0)
            cout<<endl;
        memset(a,0,sizeof(a));
        cin>>n>>m>>k;
        for(int i=0;i<n;i++){
            getchar();
            for(int j=0;j<m;j++){
                cin>>a[i][j];
            }
        }
        memcpy(b,a,sizeof(a));
        while(k--){
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    dfs(i,j);
                }
            }
            memcpy(a,b,sizeof(b));
        }
        for(int i=0;i<n;i++)
            cout<<a[i]<<endl;
        f++;
    }
    return 0;
}

Can you find it?

Give you three sequences of numbers A, B, C, then we give you a number X. Now you need to calculate if you can find the three numbers Ai, Bj, Ck, which satisfy the formula Ai+Bj+Ck = X.

Input

There are many cases. Every data case is described as followed: In the first line there are three integers L, N, M, in the second line there are L integers represent the sequence A, in the third line there are N integers represent the sequences B, in the forth line there are M integers represent the sequence C. In the fifth line there is an integer S represents there are S integers X to be calculated. 1<=L, N, M<=500, 1<=S<=1000. all the integers are 32-integers.

Output

For each case, firstly you have to print the case number as the form “Case d:”, then for the S queries, you calculate if the formula can be satisfied or not. If satisfied, you print “YES”, otherwise print “NO”.

Sample Input

3 3 3
1 2 3
1 2 3
1 2 3
3
1
4
10

Sample Output

Case 1:
NO
YES
NO

就是在ABC三个序列中找使之等式Ai+Bi+Ci = x成立的数，
x为你输入的数，如果有YES，否则NO
直接变换公式，然后使用二分法，Ai + Bi = x - Ci
先把A和B先加起来，然后利用二分法去搜索~
AC代码：

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

int a[505],b[505],c[505];
int a_b[250005];

bool judge(int a_b[],int xx,int num){
    int left = 0;
    int right = num - 1;
    while(left <= right){
        int mid = (right + left) / 2;
        if(a_b[mid] == xx){
            return true;
        }
        if(a_b[mid] < xx)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return false;
}

int main(){
    int A,B,C,S,k = 0;
    while(scanf("%d %d %d",&A,&B,&C) != EOF){
        for(int i=0;i<A;i++)
            scanf("%d",&a[i]);
        for(int i=0;i<B;i++)
            scanf("%d",&b[i]);
        for(int i=0;i<C;i++)
            scanf("%d",&c[i]);
        int num = 0;
        for(int i=0;i<A;i++){
            for(int j=0;j<B;j++){
                a_b[num++] = a[i] + b[j];
            }
        }
        sort(a_b , a_b + num);
        scanf("%d",&S);
        printf("Case %d:\n",++k);
        while(S--){
            int x,f = 0;
            scanf("%d",&x);
            for(int i=0;i<C;i++){
                int xx = x - c[i];
                if(judge(a_b,xx,num)){
                    cout<<"YES"<<endl;
                    f = 1;
                    break;
                }
            }
            if(f == 0){
                cout<<"NO"<<endl;
            }
        }
    }
    return 0;
}

N皇后问题

在N*N的方格棋盘放置了N个皇后，使得它们不相互攻击（即任意2个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成45角的斜线上。
你的任务是，对于给定的N，求出有多少种合法的放置方法。

Input

共有若干行，每行一个正整数N≤10，表示棋盘和皇后的数量；如果N=0，表示结束。

Output

共有若干行，每行一个正整数，表示对应输入行的皇后的不同放置数量。

Sample Input

1
8
5
0

Sample Output

1
92
10

这道题目就是实打实的搜索题目，不过会超时
直接打表就AC了
AC代码：

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

int ans;
int a[15];

bool attack(int x0,int y0,int x1,int y1){
    if(x0 == x1 || y0 == y1)
        return true;
    if(x0 + y0 == x1 + y1 || x0 - y0 == x1 - y1)
        return true;
    return false;
}

void dfs(int x,int n){
    if(x == n){
        ans++;
        return ;
    }
    for(int i=0;i<n;i++){
        bool ok = true;
        for(int j=0;j<x;j++){
            if(attack(j,a[j],x,i)){
                ok = false;
                break;
            }
        }
        if(ok){
            a[x] = i;
            dfs(x+1,n);
        }
    }
}

int main(){
    int n;
    int a[15];
    for(int i=0;i<=10;i++){
        ans = 0;
        dfs(0,i);
        a[i] = ans;
    }
    while(scanf("%d",&n) && n != 0){
        printf("%d\n",a[n]);
    }
    return 0;
}

统计问题

在一无限大的二维平面中，我们做如下假设：
1、 每次只能移动一格；
2、 不能向后走（假设你的目的地是“向上”，那么你可以向左走，可以向右走，也可以向上走，但是不可以向下走）；
3、 走过的格子立即塌陷无法再走第二次；

求走n步不同的方案数（2种走法只要有一步不一样，即被认为是不同的方案）。

Input

首先给出一个正整数C，表示有C组测试数据
接下来的C行，每行包含一个整数n (n<=20)，表示要走n步。

Output

请编程输出走n步的不同方案总数；
每组的输出占一行。

Sample Input

2
1
2

Sample Output

3
7

这道题，直接使用搜索肯定是超市的，而且打表也会超时，
可以直接把数据抠出来，然后直接输出结果即可，
还有一种方法就是递推····
递推思路：
第n步，f(n) = a(n) + b(n);a(n)表示n步向上的走法，b(n)表示n步左右的走法，向上走的步数只有一种选择就是上一次的步数相加：a(n)=a(n-1)+b(n-1)（前（n-1）步内往上走的步数+前（n-1）步内往左或右的步数）;又因为走过的不能返回，所以往左或右走只有一种方法，但向上走可以是左上和右上两种，因此b(n)=2*a(n-1)+b(n-1);化简：
f(n)=a(n)+b(n)=a(n-1)+b(n-1)+b(n-1)+2a(n-1)=3a(n-1)+2b(n-1)
f(n)=2f(n-1)+a(n-1)=2f(n-1)+(a(n-2)+b(n-2))=2f(n-1)+f(n-2)
AC代码（搜索）：

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

int ans;
int d[3][2] = {0,-1,0,1,-1,0};
int vis[25][50];

void dfs(int cnt,int x,int y,int n){
    if(cnt == n)
        ans++;
    else
    {
        for(int i=0; i<3; i++)
        {
            int xx = x + d[i][0];
            int yy = y + d[i][1];
            if(!vis[xx][yy])
            {
                vis[xx][yy]=1;
                dfs(cnt+1,xx,yy,n);
                vis[xx][yy]=0;
            }
        }
    }

}

int main(){
    int n;
    int a[21] = {1,3,7,17,41,99,239,577,1393,3363,8119,19601,47321,114243,275807,665857,1607521,3880899,9369319,22619537,54608393};
    /*for(int i=0;i<=20;i++){
        ans = 0;
        memset(vis,0,sizeof(vis));
        vis[20][20] = 1;
        dfs(0,20,20,i);
        cout<<ans<<",";
    }*/
    int T;
    cin>>T;
    while(T--){
        int n;
        cin>>n;
        cout<<a[n]<<endl;
    }
    return 0;
}

AC代码（递推）：

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

int a[21]= {0,3,7};

int main()
{
    int i,k,n;
    for (i=3; i<=20; i++)
        a[i]=2*a[i-1]+a[i-2];
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&k);
        printf("%d\n",a[k]);
    }
    return 0;
}

Sudoku

Sudoku is a very simple task. A square table with 9 rows and 9 columns is divided to 9 smaller squares 3x3 as shown on the Figure. In some of the cells are written decimal digits from 1 to 9. The other cells are empty. The goal is to fill the empty cells with decimal digits from 1 to 9, one digit per cell, in such way that in each row, in each column and in each marked 3x3 subsquare, all the digits from 1 to 9 to appear. Write a program to solve a given Sudoku-task.
在这里插入图片描述

Input

The input data will start with the number of the test cases. For each test case, 9 lines follow, corresponding to the rows of the table. On each line a string of exactly 9 decimal digits is given, corresponding to the cells in this line. If a cell is empty it is represented by 0.

Output

For each test case your program should print the solution in the same format as the input data. The empty cells have to be filled according to the rules. If solutions is not unique, then the program may print any one of them.

Sample Input

1
103000509
002109400
000704000
300502006
060000050
700803004
000401000
009205800
804000107

Sample Output

143628579
572139468
986754231
391542786
468917352
725863914
237481695
619275843
854396127

就是填写数独~
直接使用dfs即可完成~
AC代码：

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;

int num[9][9];
char s[9][9];
bool sign = false;

bool check(int n, int key){
    //判断key在横列是否合法
    for(int i=0;i<9;i++){
        int j = n / 9;
        if(key == num[j][i])
            return false;
    }
    //判断key在竖列是否合法
    for(int i=0;i<9;i++){
        int j = n % 9;
        if(key == num[i][j])
            return false;
    }
    int x = n / 9 / 3 * 3;      //左顶点竖坐标
    int y = n % 9 / 3 * 3;      //左顶点横坐标
    for(int i=x;i<x+3;i++){     //判断小矩阵是否合法
        for(int j=y;j<y+3;j++){
            if(key == num[i][j])
                return false;
        }
    }
    return true;
}

void dfs(int n){
    if(n > 80){
        sign = true;
        return ;
    }
    if(num[n/9][n%9] != 0){
        dfs(n + 1);
    }else{
        for(int i=1;i<10;i++){
            if(check(n,i)){
                num[n/9][n%9] = i;
                dfs(n + 1);
                if(sign == true)
                    return ;
                num[n/9][n%9] = 0;
            }
        }
    }
}

int main(){
    int T;
    cin>>T;
    while(T--){
        sign = false;
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                cin>>s[i][j];
                num[i][j] = s[i][j] - '0';
            }
        }
        dfs(0);
        for(int i=0;i<9;i++){
            for(int j=0;j<9;j++){
                cout<<num[i][j];
            }
            cout<<endl;
        }
    }
    return 0;
}
A_dmins
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
编程题——查找和排序
TNT_xixixi的博客
02-25 319
 旋转数组的最小数字 题目描述：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。 解题代码：   class Solution { public: i...
hhtc2010acm 暑期集训图算法(最短路径)专题训练解题报告
08-08
最短路是图算法中一个重要的组成部分,也是acm比赛中的经典算法,暑假老师搞了个专题训练,做完后,自己写了一个解题报告,作为了一个总结,并把其中的题目及相应的代码所用到算法全部写在了上面,里面有PKU及TJO题目的链接...
每天一道编程题1--查找
最后的武艺集大成者
12-04 268
1.题目 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 将每一列看作有序的序列进行折半查找 package com.wx.day01; /** * 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序， * 每一...
Java编程题：搜索算法（汇总）
长不大的大灰狼
06-29 625
搜索算法（汇总） 搜索算法就是去搜索每一个解的可能。 搜索算法的分类： 枚举法：暴力搜索 深度优先搜索 广度优先搜索 回溯 目录搜索算法（汇总）Ⅰ 深度优先搜索（1）放牌（2）员工的重要性（3）图像渲染（4）被围绕的区域（5）岛屿数量Ⅱ 广度优先搜索（1）员工的重要性（2）N叉树的层序遍历（3）腐烂的橘子（4）单词接龙（5）打开转盘锁 Ⅰ 深度优先搜索 Dfs(当前这一步的处理逻辑) { 1.判断边界，是否已经到头了：向上回退 2.尝试当下的每一种可能 3.确定一种可能之后，继续下一步Dfs } （1
Java编程练习之：搜索插入位置（Leecode题库）
qq_42902997的博客
04-23 239
文章目录1. 题目2. 解题思路3. 代码4. 运行结果 1. 题目 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 你可以假设数组中无重复元素。 2. 解题思路 其实当 target == nums[i] 的这种情况处理方式很简单，复杂的点在于不相等的情况。 让 target 只要大于 nums[i] 的情况下就...
【3.搜索算法——编程题】
Frank Kong的博客
02-07 1825
目录 1.简单题目 1.1平衡二叉树（深度优先搜索） 1.2对称二叉树（广度优先搜索） 1.3只出现一次的数字（哈希） 1.4相同的树（深度优先搜索） 1.5 二叉树的最大深度（深度优先搜索） 2.中等题目 2.1组合总和（回溯算法） 2.2组合总和Ⅱ（回溯算法） 2.3全排列（回溯算法） 2.4全排列问题Ⅱ（回溯算法） 2.5有效的数独（哈希） 3.困难题目 3.1N...
hhtc-nuxt-app
03-18
nuxt应用 构建设置 # install dependencies $ npm install # serve with hot reload at localhost:3000 $ npm run dev # build for production and launch server $ npm run build $ npm run start ...
hhtc大一期末测试题Java分析题
06-06
Java新手题目
希尔伯特黄变换c++源代码
09-14
希尔伯特黄变换（Hilbert-Huang Transform, HHT）是一种数据分析方法，主要用于处理非线性、非平稳信号。这种变换是由物理学家尹鸿钧和数学家乔治·希尔伯特在1990年代提出的，它结合了经验模态分解（Empirical Mode...
网络命令(ARP、PING)的使用分析.doc
最新发布
07-09
- 例如：`tracert www.hhtc.edu.cn`，可以显示出从当前主机到目标主机www.hhtc.edu.cn经过的路由器列表。 4. netstat命令： netstat用于显示网络状态信息，如活动连接、接口统计等。 - `netstat -a`：显示所有...
JAVA编程题全集(100题及答案)
07-28
JAVA编程题全集(100题及答案)
搜索专题
06-10
搜索问题，各种搜索问题的算法分析以及思路引导，以及剪枝
蓝桥杯编程题——密文搜索
perfect-顾（coder）的博客
04-30 712
福尔摩斯从X星收到一份资料，全部是小写字母组成。 他的助手提供了另一份资料：许多长度为8的密码列表。 福尔摩斯发现，这些密码是被打乱后隐藏在先前那份资料中的。 请你编写一个程序，从第一份资料中搜索可能隐藏密码的位置。要考虑密码的所有排列可能性。 数据格式： 输入第一行：一个字符串s，全部由小写字母组成，长度小于1024*1024 紧接着一行是一个整数n,表示以下有n行密码，1 紧接着
ZOJ 1921 Rock, Scissors, Paper（模拟题）
weixin_34161064的博客
12-15 111
Rock, Scissors, PaperTime Limit: 5 Seconds      Memory Limit: 32768 KB Bart's sister Lisa has created a new civilization on a two-dimensional grid. At the outset each grid location may be occupied by...
[编程题]查找employees表
matthew_leung的博客
10-27 828
链接：https://www.nowcoder.com/questionTerminal/a32669eb1d1740e785f105fa22741d5c 来源：牛客网   [编程题]查找employees表 热度指数：25828 时间限制：1秒 空间限制：32768K 算法知识视频讲解 查找employees表所有emp_no为奇数，且last_name不为Mary的员工信息，并按照hi...
B - Can you find it? 与C - 4 Values whose Sum is 0
Abandoninged的博客
03-29 238
B：Give you three sequences of numbers A, B, C, then we give you a number X. Now you need to calculate if you can find the three numbers Ai, Bj, Ck, which satisfy the formula Ai+Bj+Ck = X. InputThere a...
Python实现问卷星自动填写和选择
A_dmin的博客
06-14 6864
我朋友叫我帮他填写问卷星，，我就直接写了个脚本进行自动提交了 全随机，然后一开始我用的是BP直接抓包发送，不过发送频率过快会让你验证，，， 就很恶心，，问卷上一共有十五个问题，其实十四个，有个选择不同会显示不同问题 在书写过程中遇见一个问题，多选框的选中，经历多种摧残，终于找到解决办法：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值