1.标题：三角形面积
已知三角形三个顶点在直角坐标系下的坐标分别为：
(2.3, 2.5)
(6.4, 3.1)
(5.1, 7.2)
求该三角形的面积。
注意，要提交的是一个小数形式表示的浮点数。
要求精确到小数后3位，如不足3位，需要补零。
思路:
- 利用两点求距离的公式求除三边长度
- 利用海伦公式根据三边长度求三角形面积:s=1/2(a+b+c),Math.sqrt(s*(s-l1)(s-l2)(s-l3))
代码:
public class Main {
public static void main(String[] args) {
double x1=2.3,y1=2.5;
double x2=6.4,y2=3.1;
double x3=5.1,y3=7.2;
// double x1=1,y1=0;
// double x2=0,y2=1;
// double x3=0,y3=0;
double l1 = (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
double l2 = (x2-x3)*(x2-x3)+(y2-y3)*(y2-y3);
double l3 = (x1-x3)*(x1-x3)+(y1-y3)*(y1-y3);
l1=Math.sqrt(l1);
l2=Math.sqrt(l2);
l3=Math.sqrt(l3);
double s = (l1+l2+l3)*1/2;
double rs = Math.sqrt(s*(s-l1)*(s-l2)*(s-l3));
System.out.printf("%.3f",rs);
}
}
答案:8.795
2.标题：最大乘积
把 1~9 这9个数字分成两组，中间插入乘号，
有的时候，它们的乘积也只包含1~9这9个数字，而且每个数字只出现1次。
比如：
984672 * 351 = 345619872
98751 * 3462 = 341875962
9 * 87146325 = 784316925
符合这种规律的算式还有很多，请你计算在所有这些算式中，乘积最大是多少？
注意，需要提交的是一个整数，表示那个最大的积，不要填写任何多余的内容。
（只提交乘积，不要提交整个算式）
思路:
- 求除1-9的各种排列
- 每种排列的8种插入✖的结果
- 判断结果是不是大于已知道结果的最大值，如果大于已知道结果的最大值，通过HashMap类型查看是否由1-9这9个不重复的数字构成
import java.util.*;
public class Main {
public static long max_2 = 0;
public static void main(String[] args) {
demo_2();
}
public static void demo_2(){
int[] arr = {1,2,3,4,5,6,7,8,9};
dfs_2(arr,0);
//sum_2(arr);
System.out.println(max_2);
}
//递归回溯求所有的排序形式
public static void dfs_2(int[] arr,int k){
if (k >= arr.length) {
sum_2(arr);//求出这种排序的9种方式结果
return;
}
for (int i = k; i < arr.length; i++) {
{
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
dfs_2(arr, k + 1);
{
int temp = arr[i];
arr[i] = arr[k];
arr[k] = temp;
}
}
}
public static void sum_2(int[] arr){
for(int i=0;i<arr.length-1;i++){
long left=0;
long right=0;
for(int j=0;j<=i;j++){
left = 10*left+arr[j];
}
for(int j=i+1;j<arr.length;j++){
right = 10*right+arr[j];
}
long rs = left*right;
if(rs>max_2){
isRigtht_2(rs); //大于最大值时看是否满足结果也是1-9位不重复的数组
}
}
}
public static void isRigtht_2(long rs){
long temp = rs;
HashSet<Long> stack =new HashSet<>();
while (temp!=0){
if(temp%10==0){ //必须是1-9
return;
}
stack.add(temp%10);
temp=temp/10;
}
if(stack.size()==9) {
max_2 = rs;
}
}
}
答案:839542176
3.标题：全排列
对于某个串，比如：“1234”，求它的所有全排列。
并且要求这些全排列一定要按照字母的升序排列。
对于“1234”，应该输出(一共4!=24行)：
1234
1243
1324
1342
1423
1432
2134
2143
2314
2341
2413
2431
3124
3142
3214
3241
3412
3421
4123
4132
4213
4231
4312
4321
下面是实现程序，请仔细分析程序逻辑，并填写划线部分缺少的代码。
思路：题目用的是递归回溯的方法求所有的排序集合，缺少的那部分代码就是回溯的那部分
import java.util.*;
public class A
{
static void permu(char[] data, int cur){
if(cur==data.length-1){
System.out.println(new String(data));
return;
}
for(int i=cur; i<data.length; i++){
char tmp = data[i];
for(int j=i-1; j>=cur; j--) data[j+1] = data[j];
data[cur] = tmp;
permu(data, cur+1);
tmp = data[cur];
__________________________________________ ;
data[i] = tmp;
}
}
static void permu(String x){
permu(x.toCharArray(),0);
}
public static void main(String[] args){
permu("1234");
}
}
答案：for(int j=cur; j<i; j++) data[j] = data[j+1];
4.标题：整理玩具
小明有一套玩具，一共包含NxM个部件。这些部件摆放在一个包含NxM个小格子的玩具盒中，每个小格子中恰好摆放一个部件。
每一个部件上标记有一个0~9的整数，有可能有多个部件标记相同的整数。
小明对玩具的摆放有特殊的要求：标记相同整数的部件必须摆在一起，组成一个矩形形状。
如以下摆放是满足要求的：
00022
00033
44444
12244
12244
12233
01234
56789
以下摆放不满足要求：
11122
11122
33311
111111
122221
122221
111111
11122
11113
33333
给出一种摆放方式，请你判断是否符合小明的要求。
输入
----
输入包含多组数据。
第一行包含一个整数T，代表数据组数。 (1 <= T <= 10)
以下包含T组数据。
每组数据第一行包含两个整数N和M。 (1 <= N, M <= 10)
以下包含N行M列的矩阵，代表摆放方式。
输出
---
对于每组数据，输出YES或者NO代表是否符合小明的要求。
【样例输入】
3
3 5
00022
00033
44444
3 5
11122
11122
33311
2 5
01234
56789
【样例输出】
YES
NO
YES
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
思路:
思路：
- 设置一个HashMap
- 对数组的每一个元素进行遍历，并且将这个元素添加到HashMap
- 对这个元素的同一行的个数进行搜索，且将相同元素的值改为-1，记录该行相同个数
- 如果这个元素的正下方和这个元素相同，那么对下一个元素进行相同操作，记录的个数与之前开始的个数进行比较，如果不相等则说明不是长方形
- 如果有元素添加进HashMap中失败，则说明相同元素不是放在一起
- 核心思想:由图说明,如在下面长方形里中,abcd四条线的长度是相等的,即a=b=c=d,如果有一条不相等是的话是无法构成长方形的
import java.util.*;
public class Main {
public static void main(String[] args) {
demo_4();
}
public static void demo_4(){
Scanner e = new Scanner(System.in);
int num = e.nextInt(); //要输入等数据个数
boolean[] rs = new boolean[num]; //判断结果记录
for(int i=0;i<num;i++){
int n = e.nextInt(); //行数
int m = e.nextInt(); //列数
int[][] arr = new int[n][m];
char[][] temp = new char[n][m];
for(int j=0;j<n;j++){ //数据输入
temp[j]=e.next().toCharArray();
}
for(int j=0;j<arr.length;j++){
for(int k=0;k<arr[j].length;k++){
arr[j][k]=temp[j][k]-'0';
}
}
rs[i] = fun_4(arr); //存储判断结果
}
for(int i=0;i<rs.length;i++){
if(rs[i]){
System.out.println("YES");
}else {
System.out.println("NO");
}
}
}
/**
* 判断这个数组是否满足题目需求
* @param arr
* @return
*/
public static boolean fun_4(int[][] arr){ //遍历每一个非-1的元素
Set<Integer> set = new HashSet<>();
for (int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
if(arr[i][j]!=-1){
if(!set.add(arr[i][j])){
return false; //如果HashNap添加失败，则说明相同元素并没有放在一起或者不是长方形（每一行长度不一样）
}else {
arr=isRight_4(arr,i,j,0);
}
}
}
}
return true;
}
public static int[][] isRight_4(int[][] arr,int x,int y,int max){ //将相邻的相同元素变为-1，并记录该行中相同元素的个数
int temp = arr[x][y];
int count=0;
for(int i=0;i<arr[x].length-y;i++){
if(arr[x][y+i]!=-1 && arr[x][y+i]==temp){
arr[x][y+i]=-1;
count++;
}
}
if(max==0){ //max为该元素在这一行中放在一起的元素个数
max=count;
}else if(count!=max){ //每一行个数不一样，这说明不是长方形
return arr;
}
if(x+1<arr.length&&arr[x+1][y]==temp){ //该位置的正下方也是相同元素且不是最后一行
arr = isRight_4(arr, x+1, y, max);
}
return arr;
}
}
5.标题：版本分支
小明负责维护公司一个奇怪的项目。这个项目的代码一直在不断分支(branch)但是从未发生过合并(merge)。
现在这个项目的代码一共有N个版本，编号1~N，其中1号版本是最初的版本。
除了1号版本之外，其他版本的代码都恰好有一个直接的父版本；即这N个版本形成了一棵以1为根的树形结构。
如下图就是一个可能的版本树：
1
/ \
2 3
| / \
5 4 6
现在小明需要经常检查版本x是不是版本y的祖先版本。你能帮助小明吗？
输入
----
第一行包含两个整数N和Q，代表版本总数和查询总数。
以下N-1行，每行包含2个整数u和v，代表版本u是版本v的直接父版本。
再之后Q行，每行包含2个整数x和y，代表询问版本x是不是版本y的祖先版本。
对于30%的数据，1 <= N <= 1000 1 <= Q <= 1000
对于100%的数据，1 <= N <= 100000 1 <= Q <= 100000
输出
----
对于每个询问，输出YES或NO代表x是否是y的祖先。
【样例输入】
6 5
1 2
1 3
2 5
3 6
3 4
1 1
1 4
2 6
5 2
6 4
【样例输出】
YES
YES
NO
NO
NO
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
思路
- 一开始我是想先构建一个二叉树后通过dfs遍历子树来判断,但是仔细看了题目,人家都已经把父树和儿树之间的对应和我们说清楚了,所以之间从输入的对应关系中从子树找父树即可.
- 设置一个临时遍历用于存储当前的元素值(开始赋值询问的子元素)
- 遍历查询的临时变量的位置,获取目前临时变量的父元素,将临时变量赋值为父元素,当临时变量的值部位根元素时泽说明询问的两个元素不存在父子关系
- 核心思想:在二叉树中一个子元素只有一个父元素
import java.util.*;
public class Main {
public static void main(String[] args) {
demo_5();
}
public static void demo_5(){
Scanner e = new Scanner(System.in);
int n = e.nextInt(); //这颗二叉树有多少个元素
int m = e.nextInt(); //进行询问的个数
int[][] tree = new int[n-1][2]; //父树和子树的联系
int[][] question = new int[m][2]; //询问
boolean[] rs = new boolean[m]; //判断结果记录
//赋值
for(int i=0;i<tree.length;i++){
for(int j=0;j<2;j++){
tree[i][j]=e.nextInt();
}
}
for(int i=0;i<tree.length;i++){
for(int j=0;j<2;j++){
question[i][j]=e.nextInt();
}
if(question[i][0]==question[i][1]){ //特殊情况:根据案例我们可以知道在这个题目中,一个元素本身是自己的父元素也是自己的子元素
rs[i]=true;
}else {
rs[i] = isRight_5(tree, question[i][0], question[i][1]);
}
}
//判断
for(int i=0;i<rs.length;i++){
if(rs[i]){
System.out.println("YES");
}else {
System.out.println("NO");
}
}
}
public static boolean isRight_5(int[][] tree,int father,int son){
int temp = son; //目前元素
int now = 0; //当前位置
while(temp!=1){ //当前位置不是根元素
for(int i=0;i<tree.length;i++){
if(temp==father){
return true;
}else{ //找到temp元素的位置
if(tree[i][1]==temp){
temp=tree[i][0];
}
}
}
}
return false;
}
}
6.标题：防御力
小明最近在玩一款游戏。对游戏中的防御力很感兴趣。
我们认为直接影响防御的参数为“防御性能”，记作d，而面板上有两个防御值A和B，与d成对数关系，A=2^d，B=3^d（注意任何时候上式都成立）。
在游戏过程中，可能有一些道具把防御值A增加一个值，有另一些道具把防御值B增加一个值。
现在小明身上有n1个道具增加A的值和n2个道具增加B的值，增加量已知。
现在已知第i次使用的道具是增加A还是增加B的值，但具体使用那个道具是不确定的，请找到一个字典序最小的使用道具的方式，使得最终的防御性能最大。
初始时防御性能为0，即d=0，所以A=B=1。
【输入格式】
输入的第一行包含两个数n1,n2，空格分隔。
第二行n1个数，表示增加A值的那些道具的增加量。
第三行n2个数，表示增加B值的那些道具的增加量。
第四行一个长度为n1+n2的字符串，由0和1组成，表示道具的使用顺序。0表示使用增加A值的道具，1表示使用增加B值的道具。输入数据保证恰好有n1个0，n2个1。
【输出格式】
对于每组数据，输出n1+n2+1行，前n1+n2行按顺序输出道具的使用情况，若使用增加A值的道具，输出Ax，x为道具在该类道具中的编号（从1开始）。若使用增加B值的道具则输出Bx。最后一行输出一个大写字母E。
【样例输入1】
1 2
4
2 8
101
【样例输出1】
B2
A1
B1
E
【样例输入2】
3 0
7 11 13
000
【样例输出2】
A1
A2
A3
E
【样例说明】
对于第一组测试数据，操作过程如下：
操作 d A B
初始 0 1 1
B2 2 4 9
A1 3 8 27
B1 log3(29) 2^(log3(29)) 29
可以证明，这个值是最大的。
对于第二组测试数据，可见无论用什么顺序，A最后总为32，即d总为5，B总为243。
【数据规模】
对于20%的数据，字符串长度<=10000；
对于70%的数据，字符串长度<=200000；
对于100%的数据，字符串长度<=2000000，输入的每个增加值不超过2^30。
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
思路:我不会
882
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
