解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论
题目1、迷宫题目描述
X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立,则:
L表示走到左边的房间,
R表示走到右边的房间,
U表示走到上坡方向的房间,
D表示走到下坡方向的房间。
X星球的居民有点懒,不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此!
开始的时候,直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下:
UDDLUULRUL
UURLLLRRRU
RRUURLDLRD
RUDDDDUUUU
URUDLLRRUU
DURLRLDLRL
ULLURLLRDU
RDLULLRDDD
UUDDUDUDLL
ULRDLUURRR
请你计算一下,最后,有多少玩家会走出迷宫?
而不是在里边兜圈子。
请提交该整数,表示走出迷宫的玩家数目,不要填写任何多余的内容。
如果你还没明白游戏规则,可以参看一个简化的4x4迷宫的解说图:p1.png
public class Main
{
static char[][] a = new char[10][10];
static boolean[][] b = new boolean[10][10];
static int cnt = 0;
public static void main(String[] args) {
String str="UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR";
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
a[i][j] = str.charAt(i*10+j);
}
}
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int x = i;
int y = j;
init();
while (true) {
if (x < 0 || x > 9 || y < 0 || y > 9) {
cnt++;
break;
}
if (b[x][y] == true) {
break;
}
b[x][y] = true;
switch (a[x][y]) {
case 'U':
x -= 1;
break;
case 'D':
x += 1;
break;
case 'L':
y -= 1;
break;
case 'R':
y += 1;
break;
default:
break;
}
}
}
}
System.out.println(cnt);
}
private static void init() {
// TODO Auto-generated method stub
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
b[i][j] = false;
}
}
}
}
题目2、9算数式
题目描述
观察如下的算式:
9213 x 85674 = 789314562
左边的乘数和被乘数正好用到了1~9的所有数字,每个1次。
而乘积恰好也是用到了1~9的所有数字,并且每个1次。
请你借助计算机的强大计算能力,找出满足如上要求的9数算式一共有多少个?
注意:
- 总数目包含题目给出的那个示例。
- 乘数和被乘数交换后作为同一方案来看待。
import java.io.File;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.util.Scanner;
/**
*
* @description TODO
* @author frontier
* @time 2019年3月23日 上午9:24:01
*
*/
public class 结果填空29算数式 {
static Scanner in = new Scanner(System.in);
static boolean[] vis = new boolean[10];
static int count;
static int a, b, result;
public static void main(String[] args) throws ParseException, FileNotFoundException {
Scanner in = new Scanner(new File("src/JavaA/s8/1.txt"));
dfs(0, "");
System.out.println(count / 2);
}
static boolean check(int num) {
String n = num + "";
boolean[] v = new boolean[10];
if (n.length() != 9)
return false;
for (int i = 0; i < 9; ++i) {
int cur = Integer.parseInt(n.charAt(i) + "");
if (cur < 1 || cur > 9)
return false;
if (!v[cur])
v[cur] = true;
else
return false;
}
return true;
}
static boolean check1(int resultNum) {
boolean isVisitedC[] = new boolean[10];
while (resultNum != 0) {
int numNow = resultNum % 10;
if (numNow < 1 && numNow > 9)
return false;
isVisitedC[numNow] = true;
resultNum /= 10;
}
for (int i = 1; i < 10; i++) {
if (isVisitedC[i] == false)
return false;
}
return true;
}
static void dfs(int n, String s) {
if (n == 9) {
for (int i = 1; i <= 8; ++i) {
a = Integer.parseInt(s.substring(0, i));
b = Integer.parseInt(s.substring(i));
result = a * b;
if (check(result))
count++;
}
return;
}
for (int i = 1; i <= 9; ++i) {
if (!vis[i]) {
vis[i] = true;
dfs(n + 1, s + i);
vis[i] = false;
}
}
}
}
题目3、魔方状态
题目描述
二阶魔方就是只有2层的魔方,只由8个小块组成。
如图p1.png所示。
小明很淘气,他只喜欢3种颜色,所有把家里的二阶魔方重新涂了颜色,如下:
前面:橙色
右面:绿色
上面:黄色
左面:绿色
下面:橙色
后面:黄色
请你计算一下,这样的魔方被打乱后,一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后,各个面的颜色都一致,则认为是同一状态。
请提交表示状态数的整数,不要填写任何多余内容或说明文字。
开始拿到这道题没什么思路,笔算算不来,模拟判重感觉太麻烦。大神说burnside引理可以做,学渣表示看不懂。。网上基本没有求解的,有的也答案不一。最后还是模拟判重这么写了。
我的答案:229878
测试:全同色魔方状态为1,正确。正常二阶魔方状态3674160,正确。
思路:其实就是空间状态搜索。模拟操作+判重。关于操作,二阶魔方只做U(顶层顺时针) R(右层顺时针) F(前层顺时针)就可以得到所有状态了。判重需要旋转整个魔方去比较。(判重小白现在只会用set)。
然后是,怎么去表示一个二阶魔方。二阶魔方8个块,一个块6面(看不见的作黑色考虑),所以我用了char st[8][7]去表示一个魔方。块的顺序如下:
上面的初始状态表示就是{{“oybbgb”},{“oygbbb”},{“bygbby”},{“bybbgy”},{“obbogb”},{“obgobb”},{“bbgoby”},{“bbbogy”}}
o表示橙色,b表示黑色,g表示绿色,y表示黄色。
对于一个小块,6个面的颜色定义顺序如下:
所以,比如说,上面题目给的魔方,前面一层,左上角的橙黄绿块,表示就是oybbgb
博主还是个小白,只能找来C++的代码,还望 Java大佬及时写出
#include <bits/stdc++.h>
using namespace std;
typedef char st[8][7];
st state[2000000];
set<string> all;
st begin={{"oybbgb"},{"oygbbb"},{"bygbby"},{"bybbgy"},{"obbogb"},{"obgobb"},{"bbgoby"},{"bbbogy"}};
//st begin={{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"},{"oooooo"}};
//只有一个颜色的魔方 ans=1
//st begin={{"rykkbk"},{"rygkkk"},{"kygkko"},{"kykkbo"},{"rkkwbk"},{"rkgwkk"},{"kkgwko"},{"kkkwbo"}};
//正常2阶魔方状态 r红 y黄 b蓝 g绿 w白 o橙 k黑(红对橙,白对黄,蓝对绿,颜色相近的相对)这里白为底 前为红
//需要将state大小改为4000000
//这个测试用例跑了20分钟左右 560M内存 ans=3674160 与实际二阶魔方状态数相同 见下截图
int front, tail;
void ucell(char *a){swap(a[0], a[2]); swap(a[2], a[5]); swap(a[5], a[4]);}
void rcell(char *a){swap(a[1], a[0]); swap(a[0], a[3]); swap(a[3], a[5]);}
void fcell(char *a){swap(a[2], a[1]); swap(a[1], a[4]); swap(a[4], a[3]);}
void u(st &s)//顶层顺时针旋转
{
ucell(s[0]);
ucell(s[1]);
ucell(s[2]);
ucell(s[3]);
swap(s[1], s[0]);
swap(s[2], s[1]);
swap(s[3], s[2]);
}
void uwhole(st &s)//整个魔方从顶部看 顺时针转 用于判重
{
u(s);
ucell(s[4]);
ucell(s[5]);
ucell(s[6]);
ucell(s[7]);
swap(s[5], s[4]);
swap(s[6], s[5]);
swap(s[7], s[6]);
}
void f(st &s)//前面一层 顺时针转
{
fcell(s[0]);
fcell(s[1]);
fcell(s[4]);
fcell(s[5]);
swap(s[1], s[5]);
swap(s[0], s[1]);
swap(s[4], s[0]);
}
void fwhole(st &s)//整个魔方从前面看 顺时针转 用于判重
{
f(s);
fcell(s[2]);
fcell(s[6]);
fcell(s[7]);
fcell(s[3]);
swap(s[2], s[6]);
swap(s[3], s[2]);
swap(s[7], s[3]);
}
void r(st &s)//魔方右层顺时针转
{
rcell(s[1]);
rcell(s[2]);
rcell(s[6]);
rcell(s[5]);
swap(s[2], s[1]);
swap(s[5], s[1]);
swap(s[6], s[5]);
}
void rwhole(st &s)//整个魔方从右边看 顺时针转 用于判重
{
r(s);
rcell(s[0]);
rcell(s[3]);
rcell(s[4]);
rcell(s[7]);
swap(s[3], s[7]);
swap(s[0], s[3]);
swap(s[4], s[0]);
}
string convert(st &s)//魔方状态二维字符数组 转化为string
{
string ss;
for(int i=0; i<8; i++)ss+=s[i];
return ss;
}
bool try_to_insert(int tail)//判重
{
st k;
memcpy((void*)k, (void*)state[tail], sizeof(state[tail]));
for(int i=0; i<4; i++)
{
fwhole(k);
for(int j=0; j<4; j++)
{
uwhole(k);
for(int q=0; q<4; q++)
{
rwhole(k);
if(all.count(convert(k))==1)
{
return false;
}
}
}
}
all.insert(convert(k));
return true;
}
int main()
{
front=0,tail=1;
all.insert(convert(begin));
memcpy((void*)state[0],(void*)begin,sizeof(begin));
while(front!=tail)
{
//对当前状态分别模拟三种操作U R F 然后判重
for(int i=0; i<3; i++)
{
memcpy((void*)state[tail], (void*)state[front], sizeof(state[front]));
if(i==0)
{
u(state[tail]);
if(try_to_insert(tail))tail++;
}
else if(i==1)
{
r(state[tail]);
if(try_to_insert(tail))tail++;
}
else if(i==2)
{
f(state[tail]);
if(try_to_insert(tail))tail++;
}
}
front++;
}
cout<<front<<endl;
return 0;
}
//ans 229878
题目4、方格分割
题目描述
6x6的方格,沿着格子的边线剪开成两部分。
要求这两部分的形状完全相同。
如图:p1.png, p2.png, p3.png 就是可行的分割法。
试计算:
包括这3种分法在内,一共有多少种不同的分割方法。
注意:旋转对称的属于同一种分割法。
请提交该整数,不要填写任何多余的内容或说明文字。
PS:
包括这3种分法在内,一共有多少种不同的分割方法。
注意:旋转对称的属于同一种分割法。
请提交该整数,不要填写任何多余的内容或说明文字。
解析:从中心N/2开始进行深搜,需要定义方向数组dir[][]和记录数组vis[][]
public class Main
{
static int[][] a = new int[6][6];
static boolean[][] vis = new boolean[10][10];
static int[][] dir = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
static int cnt = 0;
public static void main(String[] args) {
vis[3][3] = true;
f(3, 3);
System.out.println(cnt/4);
}
private static void f(int x, int y) {
// TODO Auto-generated method stub
if (x == 0 || x == 6 || y == 0 || y == 6) {
cnt++;
return;
}
for (int i = 0; i < 4; i++) {
int dx = x + dir[i][0];
int dy = y + dir[i][1];
if (vis[dx][dy] == false) {
vis[dx][dy] = true;
vis[6-dx][6-dy] = true;
f(dx, dy);
vis[6-dx][6-dy] = false;
vis[dx][dy] = false;
}
}
}
}
题目5、字母组串
由 A,B,C 这3个字母就可以组成许多串。
比如:“A”,“AB”,“ABC”,“ABA”,“AACBB” …
现在,小明正在思考一个问题:
如果每个字母的个数有限定,能组成多少个已知长度的串呢?
他请好朋友来帮忙,很快得到了代码,
解决方案超级简单,然而最重要的部分却语焉不详。
请仔细分析源码,填写划线部分缺少的内容。
public class A
{
// a个A,b个B,c个C 字母,能组成多少个不同的长度为n的串。
static int f(int a, int b, int c, int n)
{
if(a<0 || b<0 || c<0) return 0;
if(n==0) return 1;
return ________________________________; //填空
}
public static void main(String[] args)
{
System.out.println(f(1,1,1,2));
System.out.println(f(1,2,3,3));
}
}
对于上面的测试数据,小明口算的结果应该是:
6
19
算法内部用列举法把所有排列情况都列举一遍,
每一个递归填写a或b或c三个字母
答案为:f(a-1,b,c,n-1)+f(a,b-1,c,n-1)+f(a,b,c-1,n-1)
题目6、最大公共子串
最大公共子串长度问题就是:
求两个串的所有子串中能够匹配上的最大长度是多少。
比如:“abcdkkk” 和 “baabcdadabc”,
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用矩阵法进行求解的,这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路,并补全划线部分缺失的代码。
这个有点dp的意思,分别计算两个字符串每一个字符到另一个字符是否相等 若相等 则加前面字符的最大字符串 若前面字符也分别相等则他就等于a[i-1][j-1]+1 若不想等则为0+1
public class 最大公共子串 {
static int f(String s1, String s2)
{
char[] c1 = s1.toCharArray();
char[] c2 = s2.toCharArray();
int[][] a = new int[c1.length+1][c2.length+1];
int max = 0;
for(int i=1; i<a.length; i++){
for(int j=1; j<a[i].length; j++){
if(c1[i-1]==c2[j-1]) {
a[i][j]=a[i-1][j-1]+1; //填空
if(a[i][j] > max) max = a[i][j];
}
}
}
return max;
}
public static void main(String[] args){
int n = f("abcdkkk", "baabcdadabc");
System.out.println(n);
}
}
题目7、正则问题
考虑一种简单的正则表达式:
只由 x ( ) | 组成的正则表达式。
小明想求出这个正则表达式能接受的最长字符串的长度。
例如 ((xx|xxx)x|(x|xx))xx 能接受的最长字符串是: xxxxxx,长度是6。
输入
一个由x()|组成的正则表达式。输入长度不超过100,保证合法。
输出
这个正则表达式能接受的最长字符串的长度。
例如,
输入:
((xx|xxx)x|(x|xx))xx
程序应该输出:
6
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
import java.io.File;
import java.io.FileNotFoundException;
import java.text.ParseException;
import java.util.Scanner;
/**
* 采用DFS,从前到后遍历遇到(就开始新的搜索,遇到)则停止搜索并通过比较,找出这个括号里的最大值;
* 如果遇到|,则需要记录之前的长度,用于在之后)的比较。遇到x,长度加一,且继续往下找
*
每一个()都是一次dfs,可返回期间最大x数量
*/
public class 编程7正则问题 {
// static Scanner in = new Scanner(System.in);
static int count;
static char[] a = new char[200];
static int p;
public static void main(String[] args) throws ParseException, FileNotFoundException {
Scanner in = new Scanner(new File("src/JavaA/s8/7.txt"));
a = in.next().toCharArray();
System.out.println(dfs());
}
static int dfs() {
int xnum = 0;
int maxx = 0;
while (p < a.length) {
if (a[p] == 'x') {
p++;
xnum++;
} else if (a[p] == '(') {
p++;
xnum += dfs();
} else if (a[p] == ')') {
p++;
break;
} else if (a[p] == '|') {
p++;
maxx=xnum;
//maxx = Math.max(xnum, maxx);
xnum = 0;
}
}
return Math.max(xnum, maxx);
}
}
题目8、包子凑数
题目描述
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼,其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼,可以认为是无限笼。
每当有顾客想买X个包子,卖包子的大叔就会迅速选出若干笼包子来,使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼,分别能放3、4和5个包子。当顾客想买11个包子时,大叔就会选2笼3个的再加1笼5个的(也可能选出1笼3个的再加2笼4个的)。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼,分别能放4、5和6个包子。而顾客想买7个包子时,大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)
输出
一个整数代表答案。如果凑不出的数目有无限多个,输出INF。
例如,
输入:
2
4
5
程序应该输出:
6
再例如,
输入:
2
4
6
程序应该输出:
INF
样例解释:
对于样例1,凑不出的数目包括:1, 2, 3, 6, 7, 11。
对于样例2,所有奇数都凑不出来,所以有无限多个。
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
提交程序时,注意选择所期望的语言类型和编译器类型。
package com.sihai.test;
import java.util.Scanner;
public class test {
static int dp[] = new int[10000];
public static boolean judge(int x,int y)
{
int t;
while(y>0)
{
t=x%y;
x=y;
y=t;
}
if(x==1)
return true;
return false;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int a[] = new int[200];
int n = 0,i,j,res,mark;
n = scanner.nextInt();
while(true)
{
res=0;
mark=0;
for(i=1;i<=n;i++)
{
a[i] = scanner.nextInt();
}
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
if(judge(a[i],a[j]))
{
mark=1;
break;
}
}
if(mark==1)
break;
}
if(mark!=1)
{
System.out.println("INF");
continue;
}
dp[0]=1;
for(i=1;i<=n;i++)
for(j=1;j<10000;j++)
{
if(a[i]>j)
continue;
if(dp[j-a[i]]==1)
dp[j]=1;
}
for(i=0;i<10000;i++)
{
if(dp[i]!=1)
res++;
}
System.out.println(res);
}
}
}
题目9、分巧克力
题目描述
儿童节那天有K位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有N块巧克力,其中第i块是Hi x Wi的方格组成的长方形。
为了公平起见,小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足:
1. 形状是正方形,边长是整数
2. 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大,你能帮小Hi计算出最大的边长是多少么?
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。
输出
输出切出的正方形巧克力最大可能的边长。
样例输入:
2 10
6 5
5 6
样例输出:
2
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
import java.util.Scanner;
class Cho {
int h;
int w;
public Cho(int h, int w) {
// TODO Auto-generated constructor stub
this.h = h;
this.w = w;
}
}
public class Main2 {
static int n, k;
static Cho[] cho;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
k = in.nextInt();
int low = 1;
int mid = 0;
int high = 100000;
cho = new Cho[n];
for (int i = 0; i < n; i++) {
int a = in.nextInt();
int b = in.nextInt();
cho[i] = new Cho(a, b);
}
// 二分,基本思路为暴力,从大到小能够保证最先出来的结果就是符合要求的最大情况
while (low < high -1) {
mid = (low + high) /2;
if (!judge(mid)) {
high = mid;
} else {
low = mid;
}
}
System.out.println(mid - 1);
}
private static boolean judge(int l) {
// TODO Auto-generated method stub
int sum = 0;
for (int i = 0; i < n; i++) {
sum += (cho[i].h * cho[i].w) / (l * l);
if (sum >= k) {
return true;
}
}
return false;
}
}
题目10、油漆问题
题目描述
X星球的一批考古机器人正在一片废墟上考古。
该区域的地面坚硬如石、平整如镜。
管理人员为方便,建立了标准的直角坐标系。
每个机器人都各有特长、身怀绝技。它们感兴趣的内容也不相同。
经过各种测量,每个机器人都会报告一个或多个矩形区域,作为优先考古的区域。
矩形的表示格式为(x1,y1,x2,y2),代表矩形的两个对角点坐标。
为了醒目,总部要求对所有机器人选中的矩形区域涂黄色油漆。
小明并不需要当油漆工,只是他需要计算一下,一共要耗费多少油漆。
其实这也不难,只要算出所有矩形覆盖的区域一共有多大面积就可以了。
注意,各个矩形间可能重叠。
本题的输入为若干矩形,要求输出其覆盖的总面积。
输入格式:
第一行,一个整数n,表示有多少个矩形(1<=n<10000)
接下来的n行,每行有4个整数x1 y1 x2 y2,空格分开,表示矩形的两个对角顶点坐标。
(0<= x1,y1,x2,y2 <=10000)
输出格式:
一行一个整数,表示矩形覆盖的总面积。
例如,
输入:
3
1 5 10 10
3 1 20 20
2 7 15 17
程序应该输出:
340
再例如,
输入:
3
5 2 10 6
2 7 12 10
8 1 15 15
程序应该输出:
128
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 2000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是:Main,否则按无效代码处理。
import java.util.Scanner;
public class youqiwenti3 {
static int n, sum = 0;
static int[][] p = new int[1000][10000];
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
for (int i = 0; i < n; i++) {
int x1 = in.nextInt();
int y1 = in.nextInt();
int x2 = in.nextInt();
int y2 = in.nextInt();
paint(x1, y1, x2, y2);
}
for (int i = 0; i < p.length; i++) {
for (int j = 0; j < p[i].length; j++) {
sum += p[i][j];
}
}
System.out.println(sum);
}
private static void paint(int x1, int y1, int x2, int y2) {
// TODO Auto-generated method stub
for (int i = x1; i < x2; i++) {
for (int j = y1; j < y2; j++) {
p[i][j] = 1;
}
}
}
}