第九届蓝桥杯JavaB组国(决)赛真题

解题代码部分来自网友，如果有不对的地方，欢迎各位大佬评论

题目1、三角形面积

已知三角形三个顶点在直角坐标系下的坐标分别为：

(2.3, 2.5)

(6.4, 3.1)

(5.1, 7.2)

求该三角形的面积。

注意，要提交的是一个小数形式表示的浮点数。

要求精确到小数后3位，如不足3位，需要补零。

// 海伦公式
public class Main {
	public static void main(String[] args) {
		double a = Math.sqrt((6.4 - 2.3) * (6.4 - 2.3) + (3.1 - 2.5) * (3.1 - 2.5));
		double b = Math.sqrt((5.1 - 2.3) * (5.1 - 2.3) + (7.2 - 2.5) * (7.2 - 2.5));
		double c = Math.sqrt((6.4 - 5.1) * (6.4 - 5.1) + (7.2 - 3.1) * (7.2 - 3.1));
		double q = (a + b + c) / 2.0;
		double area = Math.sqrt(q * (q - a) * (q - b) * (q - c));
		System.out.println(area);
	}
}

题目2、最大乘积

把 1~9 这9个数字分成两组，中间插入乘号，

有的时候，它们的乘积也只包含1~9这9个数字，而且每个数字只出现1次。

比如：

984672 * 351 = 345619872

98751 * 3462 = 341875962

9 * 87146325 = 784316925

…

符合这种规律的算式还有很多，请你计算在所有这些算式中，乘积最大是多少？

注意，需要提交的是一个整数，表示那个最大的积，不要填写任何多余的内容。

（只提交乘积，不要提交整个算式）

// 答案：839542176
public class Main {
	static int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
	static int ans = 0;
	public static void main(String[] args) {
		f(a.length - 1);
		System.out.println(ans);
	}
	public static void f(int start) {
		if (start >= 0 && start <= 7) {
			check(start);
		}
		for (int i = start; i >= 0; i--) {
			{
				int temp = a[i];
				a[i] = a[start];
				a[start] = temp;
			}
			f(start - 1);
			{
				int temp = a[i];
				a[i] = a[start];
				a[start] = temp;
			}
		}
	}
	public static boolean check(int start) {
		String s1 = "";
		for (int i = 0; i <= start; i++) {
			s1 += a[i];
		}
		String s2 = "";
		for (int i = start + 1; i < a.length; i++) {
			s2 += a[i];
		}
		int num1 = Integer.parseInt(s1);
		int num2 = Integer.parseInt(s2);
		int sum = num1 * num2;
		if (sum < 830000000 || sum > 987654321)
			return false;
		if (!isOk(sum))
			return false;
		if (sum > ans)
			ans = sum;
		return true;
	}
	public static boolean isOk(int num) {
		String s = "" + num;
		for (int i = 1; i <= 9; i++) {
			if (s.indexOf(i + "") == -1)
				return false;
		}
		return true;
	}
}

题目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

下面是实现程序，请仔细分析程序逻辑，并填写划线部分缺少的代码。

// 轮换前k个，再递归处理

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循环开始的交换方式还有上下两句代码，就可以得到答案了。
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，否则按无效代码处理。

PS：

分析

一开始想着用连通性做，发现挺麻烦的，后来主要思考矩形这个条件限制，想到了一个非常巧妙的做法。

既然是矩形，那就必然有固定的长和宽，那么我们为每一种玩具设置矩形的边界值，用maxX、maxY、minX、minY来确定矩形的范围。先假设所有的玩具都是符合在一个矩形中这个条件。读取数据不断更新更新矩形的边界，最后比较每种矩形是否有重叠的部分，如果有，说明存在不在一个矩形内的玩具，则是NO。

注：矩形重叠的充分必要条件是：横轴上矩形A的右边界值大于等于矩形B的左边界值且矩形A的左边界值小于等于矩形B的右边界值，同时竖轴上矩形A的上边界值大于等于矩形B的下边界值且矩形A的下边界值小于等于矩形B的上边界值。

import java.util.Scanner;;
class Fanwei {
	int minX;
	int maxX;
	int minY;
	int maxY;
	Fanwei() {
		minX = minY = maxX = maxY = -10;
	}
}
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in = new Scanner(System.in);
		int T = in.nextInt();
		for (int i = 0; i < T; i++)
		{
			boolean res = true;
			Fanwei[] fanwei = new Fanwei[10];
			for (int j = 0; j < 10; j++)
				fanwei[j] = new Fanwei();
			int N = in.nextInt();
			int M = in.nextInt();
			in.nextLine();
			int[][] gezi = new int[N][M];
			for (int j = 0; j < N; j++)
			{
				char[] str = in.nextLine().toCharArray();
				for (int k = 0; k < M; k++)
				{
					gezi[j][k] = str[k]-48;
				}
			}
			for (int j = 0; j < N; j++)
			{
				for (int k = 0; k < M; k++)
				{
					int tmp = gezi[j][k];
					if (fanwei[tmp].minX == -10 || fanwei[tmp].minX > j)
						fanwei[tmp].minX = j;
					if (fanwei[tmp].maxX == -10 || fanwei[tmp].maxX < j)
						fanwei[tmp].maxX = j;
					if (fanwei[tmp].minY == -10 || fanwei[tmp].minY > k)
						fanwei[tmp].minY = k;
					if (fanwei[tmp].maxY == -10 || fanwei[tmp].maxY < k)
						fanwei[tmp].maxY = k;
				}
			}
			OUT:
			for (int j = 0; j < 9; j++)
			{
				if (fanwei[j].minX == -10)
					continue;
				for (int k = j+1; k < 10; k++)
				{
					if (fanwei[k].minX == -10)
						continue;
					if (fanwei[j].maxX >= fanwei[k].minX && fanwei[j].minX <= fanwei[k].maxX)
					{
						if (fanwei[j].maxY >= fanwei[k].minY && fanwei[j].minY <= fanwei[k].maxY)
						{
							res = false;
							break OUT;
						}
					}
				}
			}
			if (res)
				System.out.println("YES");
			else
				System.out.println("NO");
		}
	}
}

题目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，否则按无效代码处理。

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class MainB {
    public static InputReader in = new InputReader(new BufferedInputStream(System.in));
    public static PrintWriter out = new PrintWriter(System.out);
    public static int n, q, u, v, x, y;
    public static ArrayList<Integer>[] child = new ArrayList[100010];
    public static ArrayList<Integer>[] next = new ArrayList[100010];
    public static void main(String[] args) {
        n = in.nextInt();
        q = in.nextInt();
        for (int i = 1; i <= n; i++) {
            next[i] = new ArrayList<>();
            child[i] = new ArrayList<>();
        }
        for (int i = 1; i < n; i++) {
            u = in.nextInt();
            v = in.nextInt();
            next[u].add(v);
        }
        child[1] = getChild(1);
        while (q-- > 0) {
            x =in.nextInt();
            y = in.nextInt();
            if (child[x].contains(y)) {
                out.println("YES");
                out.flush();
            } else {
                out.println("NO");
                out.flush();
            }
        }
        out.close();
    }
    static ArrayList<Integer> getChild(int root) {
        int len = next[root].size();
        for (int i = 0; i < len; i++)
            child[root].addAll(getChild(next[root].get(i)));
        child[root].add(root);
        return child[root];
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public String nextLine() {
            String str = null;
            try {
                str = reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public Double nextDouble() {
            return Double.parseDouble(next());
        }
        public BigInteger nextBigInteger() {
            return new BigInteger(next());
        }
    }
}

题目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，否则按无效代码处理。

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;
public class MainB {
    public static InputReader in = new InputReader(new BufferedInputStream(System.in));
    public static PrintWriter out = new PrintWriter(System.out);
    public static int n1, n2, d, a, b, len, ka, kb, k;
    public static String s;
    public static A[] ai = new A[2000010];
    public static B[] bi = new B[2000010];
    public static int[] order;
    public static void main(String[] args) {
        d = 0;
        a = 1;
        b = 1;
        n1 = in.nextInt();
        n2 = in.nextInt();
        if (n1 == 0) s = in.nextLine();//吸取空行
        for (int i = 1; i <= n1; i++) {
            ai[i] = new A();
            ai[i].id = i;
            ai[i].value = in.nextInt();
        }
        if (n2 == 0) s = in.nextLine();
        for (int i = 1; i <= n2; i++) {
            bi[i] = new B();
            bi[i].id = i;
            bi[i].value = in.nextInt();
        }
        s = in.nextLine();
        Arrays.sort(ai, 1, n1+1);
        Arrays.sort(bi, 1, n2+1);
        len = s.length();
        ka = 1;
        kb = 1;
        for (int i = 0; i < len; i++) {
            if (s.charAt(i) == '0') {
                if (s.charAt(i) == '1') {
                    out.println("A" + ai[ka++].id);
                    out.flush();
                } else {//出现连续的0
                    order = new int[len-i+5];
                    k = 0;
                    order[k++] = ai[ka++].id;//将这一段连续的'0'对应的id存在一个数组里
                    int j = i + 1;
                    for (j = i+1; j < len; j++) {
                        if (s.charAt(j) != '0') break;
                        order[k++] = ai[ka++].id;
                    }
                    Arrays.sort(order, 0, k);//按id从小到大排(即字典序从小到大)
                    i = j - 1;//调整i，使i下一次循环是从后面第一个'1'处开始
                    for (j = 0; j < k; j++) {
                        out.println("A" + order[j]);
                        out.flush();
                    }
                }
            } else {
                if (s.charAt(i) == '0') {
                    out.println("B" + bi[kb++].id);
                    out.flush();
                } else {//出现连续的1
                    order = new int[len-i+5];
                    k = 0;
                    order[k++] = bi[kb++].id;//将这一段连续的'1'对应的id存在一个数组里
                    int j = i + 1;
                    for (j = i+1; j < len; j++) {
                        if (s.charAt(j) != '1') break;
                        order[k++] = bi[kb++].id;
                    }
                    Arrays.sort(order, 0, k);//按id从小到大排(即字典序从小到大)
                    i = j - 1;//调整i，使i下一次循环是从后面第一个'0'处开始
                    for (j = 0; j < k; j++) {
                        out.println("B" + order[j]);
                        out.flush();
                    }
                }
            }
        }
        out.println("E");
        out.flush();
        out.close();
    }
    static class A implements Comparable<A>{
        int id, value;
        @Override
        public int compareTo(A o) {
            if (o.value - this.value != 0) {
                return o.value - this.value;
            } else {
                return this.id - o.id;
            }
        }
    }
    static class B implements Comparable<B>{
        int id, value;
        @Override
        public int compareTo(B o) {
            if (o.value - this.value != 0) {
                return o.value - this.value;
            } else {
                return this.id - o.id;
            }
        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public String nextLine() {
            String str = null;
            try {
                str = reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public Double nextDouble() {
            return Double.parseDouble(next());
        }
        public BigInteger nextBigInteger() {
            return new BigInteger(next());
        }
    }
}

第九届蓝桥杯JavaB组国(决)赛真题的更多相关文章

第六届蓝桥杯JavaB组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.分机号 X老板脾气古怪,他们公司的电话分机号都是3位数,老板规定,所有号码必须是降序排列,且不能有重复的数位.比如: 751,520, ...
第六届蓝桥杯JavaA组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.胡同门牌号小明家住在一条胡同里.胡同里的门牌号都是连续的正整数,由于历史原因,最小的号码并不是从1开始排的. 有一天小明突然发现了有 ...
第四届蓝桥杯JavaB组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.猜灯谜题目描述 A 村的元宵节灯会上有一迷题: 请猜谜 * 请猜谜 = 请边赏灯边猜小明想,一定是每个汉字代表一个数字,不同的汉字 ...
第六届蓝桥杯JavaC组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.机器人数目少年宫新近邮购了小机器人配件,共有3类,其中, A类含有:8个轮子,1个传感器 B类含有: 6个轮子,3个传感器 C类含有 ...
第三届蓝桥杯JavaB组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.数量周期 [结果填空](满分9分) 复杂现象背后的推动力,可能是极其简单的原理.科学的目标之一就是发现纷繁复杂的自然现象背后的简单法则 ...
第七届蓝桥杯JavaC组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.平方末尾能够表示为某个整数的平方的数字称为"平方数" 比如,25,64 虽然无法立即说出某个数是平方数,但经常可 ...
第八届蓝桥杯JavaB组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.平方十位数题目描述由0~9这10个数字不重复.不遗漏,可以组成很多10位数字. 这其中也有很多恰好是平方数(是某个数的平方). 比 ...
第七届蓝桥杯JavaB组国(决)赛部分真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.愤怒小鸟题目描述 X星球愤怒的小鸟喜欢撞火车! 一根平直的铁轨上两火车间相距 1000 米两火车 (不妨称A和B) 以时速 10米 ...
第八届蓝桥杯JavaC组国(决)赛真题
解题代码部分来自网友,如果有不对的地方,欢迎各位大佬评论题目1.数位和题目描述数学家高斯很小的时候就天分过人.一次老师指定的算数题目是:1+2+-+100. 高斯立即做出答案:5050! 这次你 ...

随机推荐

通过PAML中的CODEML模块计算dnds的过程以及踩坑
最近帮女朋友做毕业设计的时候用到了 PAML这个软件的codeml功能,发现网上相关的资料很少,于是把自己踩的一些坑分享一下,希望能帮到其他有相同困难的人一.下载与安装 PAML软件下载地址 htt ...
JS理论：编码习惯
1.声明变量,你只会var吗?那你真的是JS小鲜肉如果要声明3个变量,你要var 三下吗? 不用: let [a,b,c] = ['name',18,'ddd'] console.log(a,b,c ...
1058 A+B in Hogwarts (20分)
1058 A+B in Hogwarts (20分) 题目: If you are a fan of Harry Potter, you would know the world of magic h ...
java ->网络通信协议（UDP协议、TCP协议）
网络通信协议通过计算机网络可以使多台计算机实现连接,位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则,这就好比在道路中行驶的汽车一定要遵守交通规则一样.在计算机网络中,这些连接和通信的规 ...
【比赛随笔】2020.4.25NOIonline2
之前许多比赛没有统一记录,可能从这次开始会认真打比赛的博客了. p.s.这里的数据是洛谷上的民间数据. T1 涂色游戏这题据说是cf的原题,不过作为蒟蒻的我,没有打过. 题目链接在这里题意分析这 ...
GitHub使用SSH连接以及生成修改添加密钥详细过程
目录 1. 先看看本地有没有SSH密钥 2. 生成/修改密钥 3. 把SSH密钥添加到ssh-agent 4. 把SSH密钥添加到GitHub账户里 5. 测试使用ssh地址clone仓库 6. 把远 ...
yield与park的区别
yield表示放弃本次cpu的时间片,但是操作系统在下一个时间片依旧可能会调用该线程/进程 park表示线程/进程睡眠,需要让其他线程/进程唤醒,才有可能重新被操作系统分配时间片, 非自旋锁,底层一般 ...
spark机器学习从0到1协同过滤算法 (九）
一.概念协同过滤算法主要分为基于用户的协同过滤算法和基于项目的协同过滤算法. 基于用户的协同过滤算法和基于项目的协同过滤算法 1.1.以用户为基础(User-based)的协同过滤用相似统 ...
查找算法----二分查找与hash查找
二分查找有序列表对于我们的实现搜索是很有用的.在顺序查找中,当我们与第一个元素进行比较时,如果第一个元素不是我们要查找的,则最多还有 n-1 个元素需要进行比较. 二分查找则是从中间元素开始,而不是 ...
mysql小白系列_04 binlog(未完)
mysql打开.查看.清理binlog 1.开启日志 log_bin=/var/lib/mysql/mysql-bin mysql> show variables like '%log_bin% ...

第九届蓝桥杯JavaB组国(决)赛真题

输入

输出

第九届蓝桥杯JavaB组国(决)赛真题的更多相关文章

随机推荐

热门专题