精华内容
下载资源
问答
  • 2019 第十届蓝桥杯Java省赛B组个人题解

    万次阅读 多人点赞 2019-04-01 17:54:12
    2019 第十届蓝桥杯Java省赛B组个人题解 前言   以下的第十届蓝桥杯Java B组省赛的题目题解只是我个人的题解,提供一些解题思路,仅作参考,如有错误,望大家指出,不甚感激,我会及时更改。   本来想上传到CSDN...

    2019 第十届蓝桥杯Java省赛B组个人题解

    前言

      以下的第十届蓝桥杯Java B组省赛的题目题解只是我个人的题解,提供一些解题思路,仅作参考,如有错误,望大家指出,不胜感激,我会及时更改。

      本来想把比赛题目上传到CSDN上免费下载,上传之后发现默认是5积分(根据下载热度和评星积分会自己调整),后来了解到现在的CSDN向知识付费靠拢,激励用户上传资源,取消了用户自行定价的功能和下架资源的功能(需要找客服下架,客服根本不理啊)。

      2019 第十届蓝桥杯Java省赛B组题目——CSDN(需要5或者更多积分(系统自己调的),希望大家尽量下载下面链接的,谁的积分来的都不容易)

      2019 第十届蓝桥杯Java省赛B组题目下载——提取码: yukk

    试题A:组队——答案:490

    import java.util.Scanner;
    /**
     * 
     * @ClassName: Team组队
     * @Description: 题目不难理解,让有的人迷糊的可能就是一个队员只能选中一次。此题考试手动筛选一下就行,想写程序验证的也可以。
     * @author: colou
     * @date: 2019年3月30日 上午8:58:21
     */
    public class Team组队 {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			int[][] team = new int[20][5];
    			for (int i = 0; i < 20; i++) {
    				for (int j = 0; j < 5; j++) {
    					team[i][j] = input.nextInt();
    				}
    			}
    			int maxSum = 0;
    			for (int i = 0; i < 20; i++)
    				for (int j = 0; j < 20; j++)
    					for (int k = 0; k < 20; k++)
    						for (int h = 0; h < 20; h++)
    							for (int g = 0; g < 20; g++)
    								if ((i != j && i != k && i != h && i != g) && (j != k && j != h && j != g)
    										&& (k != h && k != g) && h != g) {
    									int max = team[i][0] + team[j][1] + team[k][2] + team[h][3] + team[g][4];
    									if (max > maxSum)
    										maxSum = max;
    								}
    			System.out.println(maxSum);
    			// 测试用例
    			/*
    			 * 97 90 0 0 0 92 85 96 0 0 0 0 0 0 93 0 0 0 80 86 89 83 97 0 0 82 86 0 0 0 0 0
    			 * 0 87 90 0 97 96 0 0 0 0 89 0 0 95 99 0 0 0 0 0 96 97 0 0 0 0 93 98 94 91 0 0
    			 * 0 0 83 87 0 0 0 0 98 97 98 0 0 0 93 86 98 83 99 98 81 93 87 92 96 98 0 0 0 89
    			 * 92 0 99 96 95 81
    			 */
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    }
    
    

    试题B:不同子串——答案:100

    import java.util.HashSet;
    import java.util.Set;
    
    /**
     * 
     * @ClassName: DifferentSubstring不同子串
     * @Description: 审题发现要求是不同的非空子串,则想到Set集合去重,String.substring()方法求子串(一切	为快速解题为前提),然后我们发现它的子串规律为一开始子串长度为1,然后在为2,……,最后为原字符串,这就好	比切豆腐,一开始要求切成每刀间隔为1豆腐块,每次移动距离为1,后来要求切成每刀间隔为2豆腐块,每次移动距离	为1,……,直至为整个大豆腐的大小。
     * @author: colou
     */
    public class DifferentSubstring不同子串 {
    	public static void main(String[] args) {
    		String target = "0100110001010001";
    		Set<String> sub = new HashSet<String>();
    		for (int step = 0; step <= target.length() - 1; step++) {
    			for (int beginIndex = 0, endIndex = 1 + step; endIndex <= target.length(); beginIndex++, endIndex++) {
    				sub.add(target.substring(beginIndex, endIndex));
    			}
    		}
    		System.out.println(sub.size());
    	}
    }
    

    试题C:数列求值——答案:4659

    /**
     * 
     * @ClassName: SequenceEvaluation数列求值
     * @Description: 此题类似于斐波那契数列,但是所求20190324项的最后四位数字,要是单纯按照斐波那契数列的
     *               思想求下去,别说long类型,BigInteger类型都存不了这么大的数,然后我们发现,所求
     *               20190324项的最后四位数字(也就是变相的告诉我们运算过程只和每个数的后四位有关系),那					 么我们只需要保留每次运算结果的后四位就OK了,这样绝对不会溢出。
     * @author: colou
     */
    public class SequenceEvaluation数列求值 {
    
    	public static void main(String[] args) {
    		int a = 1, b = 1, c = 1;
    		// 要是求第四项,则i < 4, 同理推得求20190324,则i < 20190324。
    		for (int i = 3; i < 20190324; i++) {
    			int temp = (a + b + c) % 10000;
    			a = b;
    			b = c;
    			c = temp;
    		}
    		System.out.println(c);
    	}
    }
    

    试题D:数的分解——答案:40785

    /**
     * 
     * @ClassName: DecompositionOfNumbers数的分解
     * @Description: 首先我们分析组成2019的三个数有哪几类?1.ABC类排列方式为六种(ABC,ACB,BAC,BCA,
     *               CAB,CBA),2.AAB类排列方式有三种(AAB,ABA,BAA),3.AAA类排列方式一种。而题目要
     *               求把 2019 分解成 3 个各不相同的正整数之和也就是说只保留ABC类的组合方式,j = i + 1,减少一半排列方式。
     * @author: colou
     */
    public class DecompositionOfNumbers数的分解 {
    
    	public static void main(String[] args) {
    		int n = 2019;
    		int num = 0;
    		for (int i = 1; i < n; i++) {
    			if ((i + "").indexOf("2") != -1 || (i + "").indexOf("4") != -1)
    				continue;
    			for (int j = i + 1; j < n; j++) {
    				if ((j + "").indexOf("2") != -1 || (j + "").indexOf("4") != -1)
    					continue;
    				int k = n - i - j;
    				if (i == k || j == k || i == j)
    					continue;
    				if (k > 0 && (k + "").indexOf("2") == -1 && (k + "").indexOf("4") == -1)
    					num++;
    			}
    		}
    		System.out.println(num / 3);
    	}
    }
    

    试题E:迷宫

    答案:DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR
    
    import java.util.LinkedList;
    import java.util.Queue;
    import java.util.Scanner;
    import java.util.Stack;
    
    /**
     * @ClassName: LabyrinthProblem迷宫问题
     * @Description: 广度优先搜索:https://blog.csdn.net/raphealguo/article/details/7523411
     *               https://blog.csdn.net/u011815404/article/details/79582206
     * @author: colou
     */
    public class Labyrinth迷宫 {
    	/*
    	 * 深度优先可以这样想,一个人迷路,遇到很多分叉路口,他只有一个人,并且想走出去,所以只能一个个尝试,
    	 * 一条道路走到黑,发现到头了,然后再拐回去走刚才这条路的其他分叉路口,最后发现这条路的所有分叉路口走完了
    	 * ,选择另外一条路继续以上操作,直到所有的路都走过了。
    	 * 广度优先并不是这样,一个人迷路,但是他有技能(分身术)它遇到分叉路口,不是选一个走,而是分身多个人都试试,
    	 * 比如有A、B、C三个分叉路口,它A路走一步,紧接着B路也走一步,然后C路也赶紧走一步,步伐整齐统一,直到所有的路走过了。
    	 */ public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			String s = "01010101001011001001010110010110100100001000101010"
    					+ "00001000100000101010010000100000001001100110100101"
    					+ "01111011010010001000001101001011100011000000010000"
    					+ "01000000001010100011010000101000001010101011001011"
    					+ "00011111000000101000010010100010100000101100000000"
    					+ "11001000110101000010101100011010011010101011110111"
    					+ "00011011010101001001001010000001000101001110000000"
    					+ "10100000101000100110101010111110011000010000111010"
    					+ "00111000001010100001100010000001000101001100001001"
    					+ "11000110100001110010001001010101010101010001101000"
    					+ "00010000100100000101001010101110100010101010000101"
    					+ "11100100101001001000010000010101010100100100010100"
    					+ "00000010000000101011001111010001100000101010100011"
    					+ "10101010011100001000011000010110011110110100001000"
    					+ "10101010100001101010100101000010100000111011101001"
    					+ "10000000101100010000101100101101001011100000000100"
    					+ "10101001000000010100100001000100000100011110101001"
    					+ "00101001010101101001010100011010101101110000110101"
    					+ "11001010000100001100000010100101000001000111000010"
    					+ "00001000110000110101101000000100101001001000011101"
    					+ "10100101000101000000001110110010110101101010100001"
    					+ "00101000010000110101010000100010001001000100010101"
    					+ "10100001000110010001000010101001010101011111010010"
    					+ "00000100101000000110010100101001000001000000000010"
    					+ "11010000001001110111001001000011101001011011101000"
    					+ "00000110100010001000100000001000011101000000110011"
    					+ "10101000101000100010001111100010101001010000001000"
    					+ "10000010100101001010110000000100101010001011101000"
    					+ "00111100001000010000000110111000000001000000001011"
    					+ "10000001100111010111010001000110111010101101111000";
    			int[][] labyrinth = new int[30][50];
    			for (int i = 0; i < 30; i++) {
    				for (int j = 0; j < 50; j++) {
    					labyrinth[i][j] = s.charAt(50 * i + j) - '0';
    				}
    			}
    			System.out.println(BFS(labyrinth, 30, 50));
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    
    	public static String BFS(int[][] labyrinth, int row, int column) {
    		int[][] stepArr = { { -1, 0 }, { 0, 1 }, { 0, -1 }, { 1, 0 } };
    		String[] direction = { "U", "R", "L","D"}; 
    		int[][] visit = new int[row][column];// 标记是否已经访问过
    		StringBuilder sb = new StringBuilder();
    		Node node = new Node(0, 0, -1, -1, 0, null);
    		Queue<Node> queue = new LinkedList<Node>();
    		Stack<Node> stack = new Stack<Node>();
    		queue.offer(node);
    		while (!queue.isEmpty()) {
    			Node head = queue.poll();
    			stack.push(head); // 用于回溯路径
    			visit[head.x][head.y] = 1;
    			for (int i = 0; i < 4; i++) {
    				int x = head.x + stepArr[i][0];
    				int y = head.y + stepArr[i][1];
    				String d = direction[i];
    				// exit
    				if (x == row - 1 && y == column - 1 && labyrinth[x][y] == 0 && visit[x][y] == 0) {
    					// 打印路径
    					Node top = stack.pop();
    					sb.append(d);
    					sb.append(top.direction);
    					int preX = top.preX;
    					int preY = top.preY;
    					while (!stack.isEmpty()) {
    						top = stack.pop();
    						if (preX == top.x && preY == top.y) {
    							if (top.direction != null)
    								sb.append(top.direction);
    							preX = top.preX;
    							preY = top.preY;
    						}
    
    					}
    					return sb.reverse().toString();
    				}
    				// bfs
    				if (x >= 0 && x < row && y >= 0 && y < column && labyrinth[x][y] == 0 && visit[x][y] == 0) {
    					Node newNode = new Node(x, y, head.x, head.y, head.step + 1, d);
    					queue.offer(newNode);
    				}
    			}
    		}
    		return null;
    	}
    }
    
    class Node {
    	int x, y;
    	int step;
    	int preX, preY;
    	String direction;
    
    	Node(int x, int y, int preX, int preY, int step, String direction) {
    		this.x = x;
    		this.y = y;
    		this.preX = preX;
    		this.preY = preY;
    		this.step = step;
    		this.direction = direction;
    	}
    }
    

    试题F:特别数的和

    import java.util.Scanner;
    /**
     * 
     * @ClassName: SpecialSum特别数的和
     * @Description: int转String,使用String.indexOf();判断包含不包含"2", "0", "1", "9",可以使用while循环加%,/运算判断。
     * @author: colou
     */
    public class SpecialSum特别数的和 {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			int n = input.nextInt();
    			int sum = 0;
    			for (int i = 1; i <= n; i++) {
    				String target = Integer.toString(i);
    				if (target.indexOf("2") != -1 || target.indexOf("0") != -1 || target.indexOf("1") != -1
    						|| target.indexOf("9") != -1) {
    					sum += i;
    				}
    			}
    			System.out.println(sum);
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    }
    

    试题G:外卖店优先级

    import java.util.HashSet;
    import java.util.Scanner;
    import java.util.Set;
    
    /**
     * @ClassName: TakeawayShopPriority外卖店优先级
     * @Description: 创建一个记录店铺优先级的数组来存储优先级,另外创建一个用来判断每个时间点是否有订单的数组(1代表有 ,0无)
     * 这里偷懒使用集合充当缓存,可以使用数组之类的。
     * @author: colou
     */
    public class TakeawayShopPriority外卖店优先级 {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			Set<Integer> set = new HashSet<Integer>();
    			int N = input.nextInt();
    			int M = input.nextInt();
    			int T = input.nextInt();
    			int[][] orders = new int[M][2];
    			for (int i = 0; i < M; i++) {
    				for (int j = 0; j < 2; j++) {
    					orders[i][j] = input.nextInt();
    				}
    			}
    			int[] priority = new int[N];
    			int[] sign = new int[N];
    			for (int i = 1; i <= T; i++) {
    				for (int j = 0; j < M; j++) {
    					if (orders[j][0] == i) {
    						priority[orders[j][1] - 1] += 2;
    						if (priority[orders[j][1] - 1] > 5 && !set.contains(orders[j][1] - 1)) {
    							set.add(orders[j][1] - 1);
    						}
    						sign[orders[j][1] - 1] = 1;
    					}
    				}
    				for (int j = 0; j < N; j++) {
    					if (sign[j] == 0 && priority[j] > 0)
    						priority[j]--;
    					if (priority[j] <= 3) {
    						set.remove(j);
    					}
    				}
    				sign = new int[N];
    			}
    			System.out.println(set.size());
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    }
    

    试题H:人物相关性分析

    import java.util.Scanner;
    /**
     * 
     * @ClassName: CharacterCorrelationAnalysis人物相关性分析
     * @Description: "."和"|"都是转义字符,必须得加"\\";
     * @author: colou
     */
    public class CharacterCorrelationAnalysis人物相关性分析 {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			int K = input.nextInt();
    			input.nextLine();
    			String text = input.nextLine();
    			//字符串分割,按照空格和.分割字符,若是(.空格)分割后为空字符串。
    			String[] words = text.split("\\s+|\\.");
    			int[] wordsLength = new int[words.length];
    			//将分割的字符串的长度值存储,避免三重循环中调用String.length();
    			for (int i = 0; i < words.length; i++) {
    				wordsLength[i] = words[i].length();
    			}
    			int num = 0;
    			//Alice ——> Bob的距离
    			for (int i = 0; i < words.length; i++) {
    				if (words[i].equals("Alice")) {
    					for (int j = i + 1; j < words.length; j++) {
    						int sum = 1;
    						if (words[j].equals("Bob")) {
    							for (int k = i + 1; k < j; k++) {
    								//每个单词的长度加空格占据的长度
    								sum += wordsLength[k] + 1;
    							}
    							if (sum <= K) {
    								num++;
    							}
    						}
    					}
    				}
    			}
    			//Bob ——> Alice的距离
    			for (int i = 0; i < words.length; i++) {
    				if (words[i].equals("Bob")) {
    					for (int j = i + 1; j < words.length; j++) {
    						int sum = 1;
    						if (words[j].equals("Alice")) {
    							for (int k = i + 1; k < j; k++) {
    								sum += wordsLength[k] + 1;
    							}
    							if (sum <= K) {
    								num++;
    							}
    						}
    					}
    				}
    			}
    			System.out.println(num);
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    }
    

    试题I:后缀表达式

    import java.util.Arrays;
    import java.util.Scanner;
    
    /**
     * @ClassName: PostfixExpression后缀表达式
     * @Description: 这道题我的思想是分情况讨论:
     * 1.如果只有+号,没有-号,则遍历数组累加即可;
     * 2.如果只有-号,没有+号,首先从小到大排序,然后分两种情况考虑:
     * (1).最小值是负数(也就是含有负数),例如[-2, -1, 3, 4, 5],四个减号,运算过程为5 - (-1) - (-2 - 3 - 4) = 5 + 1 - (-9)
     *  = 5 + 1 + 9 = 15,也就是说只要含有负数,负数转正数,全部相加即可
     * (2).最小值是正数(全部是正数),例如[1, 2, 3],两个减号,运算过程为3 - (1 - 2) = 3 + 2 - 1,也就是说运算规则为除了
     *         最小值以外的正数相加减去最小值 
     * 3.如果有+号,有-号,则讨论减号的个数与负数的个数,分两种情况讨论(实际分为三种):
     *( 1).减号个数大于等于负数个数(则将负数变正数,每一个负数变正数的过程中, 减号的数量需要减一,然后排序,遍历数组从大到小累加,
     * 直至剩下的数字个数和减号数量相同,然后再减去这些剩下的数字);
     * (2).减号个数小于负数个数,这个时候我们就应该使用+号,消除负数(比如[2, -5 , -6, + , -],运算过程为2 - ((-5) + (-6)) = 
     * 2 + 11 = 13),我们可以再分情况讨论:
     * (2.1).全是负数,如[-1, -2, -3, -4, -5],其中一个加号三个减号,运算过程为(-1 - ((-4) + (-5)) - (-3) - (-2) = -1 + 9 
     * + 3 + 2),则运算规律为首先排序选择其中的最大值,加上其他数字的绝对值就行(可以自行继续证明)。(2.2).有正数,有负数,
     * [-1, 19, 17, -4, -5],其中两个加号两个减号,则运算过程为(19 + 17 - ((-4) + (-5)) - (-1) = 19 + 17 + 9 + 1),则运算
     * 规律为首先排序选择其中的最大值,加上其他数字的绝对值就行(可以自行继续证明)。所有情况讨论完毕。
     * @author: colou
     */
    public class PostfixExpression后缀表达式 {
    
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		try {
    			int add = input.nextInt();
    			int reduce = input.nextInt();
    			int totalLength = add + reduce + 1;
    			int[] number = new int[totalLength];
    			for (int i = 0; i < totalLength; i++) {
    				number[i] = input.nextInt();
    			}
    			int sum = 0;
    			if (reduce == 0) {
    				for (int i = 0; i < totalLength; i++) {
    					sum += number[i];
    				}
    			}
    			if (add == 0) {
    				Arrays.sort(number);
    				if (number[0] < 0) {
    					for (int i = 0; i <= reduce; i++) {
    						if (number[i] > 0) 
    							sum += number[i];
    						else
    							sum -= number[i];
    					}
    				} else {
    					for (int i = 1; i <= reduce; i++) {
    							sum += number[i];
    					}
    					sum -= number[0];
    				}
    			}
    			if (add != 0 && reduce != 0) {
    				int reduceNum = 0;
    				for (int i = 0; i < totalLength; i++) {
    					if (number[i] < 0) {
    						reduceNum++;
    					}
    				}
    				if (reduce >= reduceNum) {
    					Arrays.sort(number);
    					int temp = reduce;
    					for (int i = 0; i < reduceNum; i++) {
    						number[i] = -number[i];
    						temp--;
    					}
    					Arrays.sort(number);
    					for (int i = totalLength - 1; i >= temp; i--) {
    						sum += number[i];
    					}
    					for (int i = temp - 1; i >= 0; i--) {
    						sum -= number[i];
    					}
    				} else {
    					Arrays.sort(number);
    					sum += number[totalLength - 1];
    					for (int i = 0; i < totalLength - 1; i++) {
    						if (number[i] > 0)
    							sum += number[i];
    						else
    							sum -= number[i];
    					}
    				}
    			}
    			System.out.println(sum);
    		} catch (Exception e) {
    			input.close();
    		}
    	}
    }
    

    至此完毕,最后一题想偷个懒,等看了之后再更新,如果有错误,请阅读者评论指出,不胜感激。

    展开全文
  • 第十届蓝桥杯题目

    2019-03-24 13:32:27
    第十届蓝桥杯原题目压缩包,里面有10道题的题目的图片形式和PDF形式
  • 2019年第十届蓝桥杯省赛B组题目、第十届蓝桥杯省赛本科B组赛题!
  • 第十届蓝桥杯嵌入式省赛题代码,功能全能实现,亲测有效。第十届蓝桥杯自我感觉不论是在单片机组还是嵌入式组都是十分简单的。但是如果不会ADC那就凉凉了。
  • 第十届蓝桥杯.rar

    2019-07-16 19:51:23
    第十届蓝桥杯省赛代码(回忆篇),在此程序中实现题目要求的所有功能,通过使用计数器检测频率,具有独特的单片机程序风格。
  • 第十届蓝桥杯Scratch组国赛编程题
  • 2019第十届蓝桥杯JavaB组题目
  • 第十届蓝桥杯

    2019-04-03 21:53:56
    7、第十届省赛前最后的总结与程序封装 8、第十届省赛再现 到现在蓝桥杯也准备好久了,也水了不少博客,现在给整理一下。 1、关于开发板 STC15F2K60S2设置内部时钟工作频率:https://blog.csdn.net/Xiaomo_haa/...

    目录

    1、关于开发板

    2、关于各个模块

    3、历年省赛真题

    4、省赛代码资源下载

    5、历年国赛真题

    6、国赛代码资源下载

    7、第十届省赛前最后的总结与程序封装

    8、第十届省赛再现


    到现在蓝桥杯也准备好久了,也水了不少博客,现在给整理一下。

    1、关于开发板

    STC15F2K60S2设置内部时钟工作频率:https://blog.csdn.net/Xiaomo_haa/article/details/84591273

    IAP15F2K61S2芯片引脚图:https://blog.csdn.net/Xiaomo_haa/article/details/84337675

    使用STC-ISP直接导入单片机头文件:https://blog.csdn.net/Xiaomo_haa/article/details/86494757

    CT107D开发板了解与准备:https://blog.csdn.net/Xiaomo_haa/article/details/86493623

    2、关于各个模块

    LED:https://blog.csdn.net/Xiaomo_haa/article/details/86495641

    流水灯和数码管:https://blog.csdn.net/Xiaomo_haa/article/details/86509515

    独立按键:https://blog.csdn.net/Xiaomo_haa/article/details/86648920

    独立按键控制流水灯:https://blog.csdn.net/Xiaomo_haa/article/details/86669517

    独立按键实现计时器:https://blog.csdn.net/Xiaomo_haa/article/details/86724574

    矩阵键盘:https://blog.csdn.net/Xiaomo_haa/article/details/86649021

    矩阵键盘输入数字:https://blog.csdn.net/Xiaomo_haa/article/details/86695769

    定时器仿真输出PWM实现呼吸灯:https://blog.csdn.net/Xiaomo_haa/article/details/86726288

    呼吸灯:https://blog.csdn.net/Xiaomo_haa/article/details/86753322

    UART串口通信:https://blog.csdn.net/Xiaomo_haa/article/details/87632959

    IIC:https://blog.csdn.net/Xiaomo_haa/article/details/87902379

    https://blog.csdn.net/Xiaomo_haa/article/details/87803309

    E2PROM单字节操作:https://blog.csdn.net/Xiaomo_haa/article/details/87918394

    E2PROM多字节和页操作:https://blog.csdn.net/Xiaomo_haa/article/details/87920499

    AD:https://blog.csdn.net/Xiaomo_haa/article/details/87922645

    DS18B20:https://blog.csdn.net/Xiaomo_haa/article/details/87978956

    DS1302:https://blog.csdn.net/Xiaomo_haa/article/details/88061555

    超声波:https://blog.csdn.net/Xiaomo_haa/article/details/88081708

    官方DS1302驱动程序的使用:https://blog.csdn.net/Xiaomo_haa/article/details/88650540

    官方DS18B20驱动程序的使用:https://blog.csdn.net/Xiaomo_haa/article/details/88726248

    3、历年省赛真题

    常用程序封装:https://blog.csdn.net/Xiaomo_haa/article/details/88084454

    2018_第九届_蓝桥杯_省赛——“彩灯控制器”:https://blog.csdn.net/Xiaomo_haa/article/details/88094849

    2017_第八届_蓝桥杯_省赛——“基于单片机的电子钟”:https://blog.csdn.net/Xiaomo_haa/article/details/88173499

    2016_第七届_蓝桥杯_省赛——“模拟风扇控制系统”:https://blog.csdn.net/Xiaomo_haa/article/details/88227539

    2015_第六届_蓝桥杯_省赛——“温度记录器”:https://blog.csdn.net/Xiaomo_haa/article/details/88295970

    2014_第五届_蓝桥杯_省赛——“简易温度采集与控制装置”:https://blog.csdn.net/Xiaomo_haa/article/details/88368992

    2013_第四届_蓝桥杯_省赛——“模拟智能灌溉系统”:https://blog.csdn.net/Xiaomo_haa/article/details/88397501

    2012_第三届_蓝桥杯_省赛——“自动售水机”:https://blog.csdn.net/Xiaomo_haa/article/details/88400149

    2011_第二届_国信长天杯_省赛——“温度监控器”:https://blog.csdn.net/Xiaomo_haa/article/details/88409694

    4、省赛代码资源下载

    2018_第九届_蓝桥杯_省赛——“彩灯控制器”:https://download.csdn.net/download/xiaomo_haa/10991680

    2017_第八届_蓝桥杯_省赛——“基于单片机的电子钟”:https://download.csdn.net/download/xiaomo_haa/10997235

    2016_第七届_蓝桥杯_省赛——“模拟风扇控制系统":https://download.csdn.net/download/xiaomo_haa/11002294

    2015_第六届_蓝桥杯_省赛——“温度记录器”:https://download.csdn.net/download/xiaomo_haa/11004437

    2014_第五届_蓝桥杯_省赛——“简易温度采集与控制装置”:https://download.csdn.net/download/xiaomo_haa/11010289

    2013_第四届_蓝桥杯_省赛——“模拟智能灌溉系统”:https://download.csdn.net/download/xiaomo_haa/11012084

    2012_第三届_蓝桥杯_省赛——“自动售水机”:https://download.csdn.net/download/xiaomo_haa/11012255

    2011_第二届_国信长天杯_省赛——“温度监控器”:https://download.csdn.net/download/xiaomo_haa/11012527

    5、历年国赛真题

    2016_第七届_蓝桥杯_国赛——“电压、频率采集设备”:https://blog.csdn.net/Xiaomo_haa/article/details/88597373

     

    6、国赛代码资源下载

    2016_第七届_蓝桥杯_国赛——“电压、频率采集设备”:https://download.csdn.net/download/xiaomo_haa/11025753

     

    7、第十届省赛前最后的总结与程序封装

    第十届省赛前最后总结与程序封装:https://blog.csdn.net/Xiaomo_haa/article/details/88756222

    8、第十届省赛再现

    客观题:https://blog.csdn.net/Xiaomo_haa/article/details/88783449

    编程题:https://blog.csdn.net/Xiaomo_haa/article/details/88780738

     

     

    展开全文
  • 2019第十届蓝桥杯省赛真题.zip
  • 2019年第十届蓝桥杯[Java]特别数的和【题目描述】小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。请问,在 1 到 n...

    2019年第十届蓝桥杯[Java]

    特别数的和

    【题目描述】

    小明对数位中含有 2、0、1、9 的数字很感兴趣(不包括前导 0),在 1 到 40 中这样的数包括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574。

    请问,在 1 到 n 中,所有这样的数的和是多少?

    【输入】

    输入一行包含两个整数 n。

    【输出】

    输出一行,包含一个整数,表示满足条件的数的和

    【样例输入】

    40

    【样例输出】

    574

    代码

    import java.util.Scanner;

    public class Main {

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();

    int sum = 0;

    for(int i = 1; i <= n; i++) { String str = Integer.toString(i);

    //if(str.indexOf('2') != -1 || str.indexOf('0') != -1 || str.indexOf('1') != -1 || str.indexOf('9') != -1) { if(str.contains("2") || str.contains("0") || str.contains("1") || str.contains("9")) { sum += i; }

    }

    System.out.println(sum);

    sc.close();

    }

    }1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    等差数列

    【题目描述】

    数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一 部分的数列,只记得其中 N 个整数。现在给出这 N 个整数,小明想知道包含这 N 个整数的最短的等差数列有 几项?

    【输入】

    输入的第一行包含一个整数 N。 第二行包含N个整数A1,A2,···,AN。(注意A1 ∼AN并不一定是按等差数列中的顺序给出)

    【输出】

    输出一个整数表示答案

    【样例输入】

    5

    2 6 4 10 20

    【样例输出】

    10

    代码

    import java.util.Arrays;

    import java.util.Scanner;

    public class Main {

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int N = sc.nextInt();

    int[] x = new int[N];

    for (int i = 0; i < N; i++) { x[i] = sc.nextInt();

    }

    Arrays.sort(x);

    int d = Integer.MAX_VALUE;

    for (int i = 0; i < x.length - 1; i++) { if (d > x[i + 1] - x[i]) { d = x[i + 1] - x[i]; }

    }

    if (d == 0) { System.out.println(N);

    } else { System.out.println((x[x.length - 1] - x[0]) / d + 1);

    }

    sc.close();

    }

    }1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    后缀表达式

    【题目描述】

    给定 N 个加号、M 个减号以及 N + M + 1 个整数 A1, A2, · · · , AN+M+1,小 明想知道在所有由这 N 个加号、M 个减号以及 N + M + 1 个整数凑出的合法的 后缀表达式中,结果最大的是哪一个?

    请你输出这个最大的结果。

    例如使用1 2 3 + -,则 “2 3 + 1 -” 这个后缀表达式结果是 4,是最大的。

    【输入】

    第一行包含两个整数 N 和 M。

    第二行包含 N + M + 1 个整数 A1, A2, · · · , AN+M+1。

    【输出】

    输出一个数,表示答案

    【样例输入】

    1 1

    1 2 3

    【样例输出】

    4

    代码

    import java.util.Arrays;

    import java.util.Scanner;

    public class Main{

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int add = sc.nextInt();

    int reduce = sc.nextInt();

    int t = add + reduce + 1;

    int[] number = new int[t];

    for (int i = 0; i < t; i++) { number[i] = sc.nextInt();

    }

    long sum = 0;

    if (reduce == 0 && add == 0) { sum += number[0];

    }

    if (reduce == 0 && add != 0) { for (int i = 0; i < t; i++) { sum += number[i]; }

    }

    if (add == 0 && reduce != 0) { Arrays.sort(number); if (number[0] < 0) { for (int i = 0; i <= reduce; i++) { if (number[i] > 0) { sum += number[i]; } else { sum -= number[i]; } } } else { for (int i = 1; i <= reduce; i++) { sum += number[i]; } sum -= number[0]; }

    }

    if (add != 0 && reduce != 0) { int reduceNum = 0; for (int i = 0; i < t; i++) { if (number[i] < 0) { reduceNum++; } } if (reduce >= reduceNum) { if (reduceNum != 0) { Arrays.sort(number); for (int i = 0; i < reduceNum; i++) { number[i] = -number[i]; } // Arrays.sort(number); for (int i = t - 1; i >= 0; i--) { sum += number[i]; } }else { Arrays.sort(number); for (int i = t - 1; i > 0; i--) { sum += number[i]; } sum -= number[0]; } } else { Arrays.sort(number); sum += number[t - 1]; for (int i = 0; i < t - 1; i++) { if (number[i] > 0) { sum += number[i]; } else { sum -= number[i]; } } }

    }

    System.out.println(sum);

    sc.close();

    }

    }1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    25

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    36

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    49

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    64

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    旋转

    【题目描述】

    图片旋转是对图片最简单的处理方式之一,在本题中,你需要对图片顺时针旋转 90 度。

    我们用一个 n × m 的二维数组来表示一个图片,例如下面给出一个 3 × 4 的图片例子:

    1 3 5 7

    9 8 7 6

    3 5 9 7

    这个图片顺时针旋转 90 度后的图片如下:

    3 9 1

    5 8 3

    9 7 5

    7 6 7

    给定初始图片,请计算旋转后的图片

    【输入】

    输入的第一行包含两个整数 n 和 m,分别表示行数和列数。

    接下来 n 行,每行 m 个整数,表示给定的图片。图片中的每个元素(像

    素)为一个值为 0 至 255 之间的整数(包含 0 和 255)。

    【输出】

    输出 m 行 n 列,表示旋转后的图片。

    【样例输入】

    3 4

    1 3 5 7

    9 8 7 6

    3 5 9 7

    【样例输出】

    3 9 1

    5 8 3

    9 7 5

    7 6 7

    代码

    import java.util.Scanner;

    public class Main {

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();

    int m = sc.nextInt();

    int[][] x = new int[m][n];

    for (int j = n - 1; j >= 0; j--) { for(int i = 0; i < m; i++) { x[i][j] = sc.nextInt(); }

    }

    for(int i = 0; i < m; i++) { for(int j = 0; j < n; j++) { System.out.print(x[i][j] + " "); } System.out.println();

    }

    sc.close();

    }

    }1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    Fibonacci 数列与黄金分割

    【题目描述】

    Fibonacci 数列是非常著名的数列:

    F[1] = 1,

    F[2] = 1,

    对于 i > 3,F[i] = F[i − 1] + F[i − 2]

    Fibonacci 数列有一个特殊的性质,前一项与后一项的比值,F[i]/F[i + 1], 会趋近于黄金分割。

    为了验证这一性质,给定正整数 N,请你计算 F[N]/F[N + 1],并保留 8 位 小数。

    【输入】

    一个正整数 N。(1 ≤ N ≤ 2000000000)

    【输出】

    F[N]/F[N + 1]。答案保留 8 位小数。

    【样例输入】

    2

    【样例输出】

    0.50000000

    代码

    import java.math.BigDecimal;

    import java.util.Scanner;

    public class Main {

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    long n = sc.nextLong();

    if(n == 1) { System.out.println("1.00000000");

    }

    else if (n > 50) { System.out.println("0.61803399");

    } else { BigDecimal[] f = new BigDecimal[(int)n + 2]; f[1] = BigDecimal.ONE; f[2] = BigDecimal.ONE; for (int i = 3; i <= n + 1; i++) { f[i] = f[i - 1].add(f[i - 2]); } System.out.println(f[(int)n].divide(f[(int)n + 1], 8, BigDecimal.ROUND_HALF_UP));

    }

    sc.close();

    }

    }1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

    14

    15

    16

    17

    18

    19

    20

    21

    22

    23

    24

    文章来源: blog.csdn.net,作者:weixin_50586285,版权归原作者所有,如需转载,请联系作者。

    原文链接:blog.csdn.net/weixin_50586285/article/details/113484218

    展开全文
  • 2019年第十届蓝桥杯【省赛C/C++ A组】做题记录,文章到处都充斥着“暴力求解”、“暴力就够了”、“暴力可能能拿下一半分数”等字眼。最后感想:自身实力真的还很弱。

    试题A:平方和

    【问题描述】
      小明对数位中含有 2、0、1、9 的数字很感兴趣,在 1 到 40 中这样的数包 括 1、2、9、10 至 32、39 和 40,共 28 个,他们的和是 574,平方和是 14362。 注意,平方和是指将每个数分别平方后求和。 请问,在 1 到 2019 中,所有这样的数的平方和是多少?
      思路分析:从1遍历到2019,先将遍历变量记录下来,接着对该变量进行分解,如果其中包含2019四个数字中的一个,就停止分解,累加平方至结果变量sum。
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    
    int main() {
    	long long sum=0;
    	for(int i=1;i<=2019;i++) {
    		int j=i;
    		while(j) {
    			if(j%10==2||j%10==0||j%10==1||j%10==9) {
    				sum+=i*i;
    				break;
    			}
    			j/=10;
    		}
    	}
    	cout<<sum;//2658417853 
    	return 0;
    }
    

    答案:2658417853

    试题B:数列求值

    【问题描述】
      给定数列 1, 1, 1, 3, 5, 9, 17, …,从第 4 项开始,每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。

      思路分析:这道题其实就是考怎么防止溢出。求后四位数字,那就在每次求和之后都模上10000就好了。
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    
    const int mod=1e4;
    long long f[20190326];
    
    int main() {
    	f[1]=f[2]=f[3]=1;
    	for(int i=4;i<=20190324;i++) {
    		f[i]=(f[i-1]%mod+f[i-2]%mod+f[i-3]%mod)%mod;
    	}
    	cout<<f[20190324];
    	return 0;
    }
    

    答案:4659

    试题C:最大降雨量

    【问题描述】
      由于沙之国长年干旱,法师小明准备施展自己的一个神秘法术来求雨。 这个法术需要用到他手中的 49 张法术符,上面分别写着 1 至 49 这 49 个 数字。法术一共持续 7 周,每天小明都要使用一张法术符,法术符不能重复使 用。 每周,小明施展法术产生的能量为这周 7 张法术符上数字的中位数。法术 施展完 7 周后,求雨将获得成功,降雨量为 7 周能量的中位数。 由于干旱太久,小明希望这次求雨的降雨量尽可能大,请大最大值是多少?

      思路分析:1到49四个数,分成7周,每周都有7个数,因此中位数实际上就是第四周的中位数X。 在第四周,还有三天要大于X,另外第五六七周各有4天大于X:这三周的中位数以及中位数后面的三天,因此一共有3*4+3=15个数大于X,因此X=49-15=34。

    答案:34

    试题D:迷宫

    详见:第十届蓝桥杯省赛试题D:迷宫(BFS)

    试题E:RSA解密

    详见:【RSA解密】 蓝桥杯第十届省赛A组 扩展欧几里得算法(求逆元)+快速乘+快速幂

    试题F:完全二叉树的权值

      给定一棵包含 N 个节点的完全二叉树,树上每个节点都有一个权值,按从上到下、从左到右的顺序依次是 A1, A2, ··· AN,如下图所示:
    在这里插入图片描述
      现在小明要把相同深度的节点的权值加在一起,他想知道哪个深度的节点 权值之和最大?如果有多个深度的权值和同为最大,请你输出其中最小的深度。 注:根的深度是1。
    【输入格式】
    第一行包含一个整数 N。 第二行包含 N 个整数 A1, A2, ··· AN 。
    【输出格式】
    输出一个整数代表答案。
    【样例输入】
    7
    1 6 5 4 3 2 1
    【样例输出】
    2
      思路分析:这道题的关键是根据序号找到该节点对应的深度, 代码如下:

    // 获取下标为 n 的节点的深度 
    int getDepth(int n) {
    	int res = 0;
    	while (n > 0) {
    		n /= 2;
    		res++;
    	} 
    	return res;
    }
    

    获得深度后就好做了,把每一层都累加起来就好了。
    代码:

    #include<bits/stdc++.h>
    using namespace std; 
    
    const int MAX_DEPTH = 18;
    long long temp[MAX_DEPTH + 3];
    
    // 获取下标为 n 的节点的深度 
    int getDepth(int n) {
    	int res = 0;
    	while (n > 0) {
    		n /= 2;
    		res++;
    	} 
    	return res;
    }
    
    int main() {
    	int n, t;
    	cin >> n;
    	for (int i = 1; i <= n; i++) {
    		cin>>t;
    		temp[getDepth(i)] += t;
    	} 
    	int res = 0, resDepth;
    	for (int i = 1; i <= MAX_DEPTH; i++) {
    		if (temp[i] > res) {
    			res = temp[i];
    			resDepth = i;
    		}
    	}
    	cout << resDepth << endl;
    	return 0;
    }
    
    

    试题G:外卖店优先级

    【问题描述】
      “饱了么”外卖系统中维护着 N 家外卖店,编号 1 ∼ N。每家外卖店都有 一个优先级,初始时 (0 时刻) 优先级都为 0。
       每经过 1 个时间单位,如果外卖店没有订单,则优先级会减少 1,最低减 到 0;而如果外卖店有订单,则优先级不减反加,每有一单优先级加 2。
       如果某家外卖店某时刻优先级大于 5,则会被系统加入优先缓存中;如果 优先级小于等于 3,则会被清除出优先缓存。
       给定 T 时刻以内的 M 条订单信息,请你计算 T 时刻时有多少外卖店在优 先缓存中。
    【输入格式】
    第一行包含 3 个整数 N、M 和 T。 以下 M 行每行包含两个整数 ts 和 id,表示 ts 时刻编号 id 的外卖店收到 一个订单。
    【输出格式】
    输出一个整数代表答案。
    【样例输入】
    2 6 6
    1 1
    5 2
    3 1
    6 2
    2 1
    6 2
    【样例输出】
    1
    【样例解释】
      6时刻时,1 号店优先级降到 3,被移除出优先缓存;2 号店优先级升到 6, 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。
    【评测用例规模与约定】
      对于 80% 的评测用例,1≤ N,M,T ≤10000。 对于所有评测用例,1≤ N,M,T ≤100000,1≤ts≤T,1≤id ≤ N。

      思路分析:答案:暴力求解还是蛮简单的,只不过这样大概率会超时。

      暴力求解思路:先输入所有的订单信息,按照时间排好序。接着遍历所有的订单信息,并跟所有的外卖店进行匹配,如果收到订单优先级加2并判断要不要进入优先缓存,否则优先级减一,并判断是否需要踢出优先缓存。
    代码:

    #include<bits/stdc++.h>
    using namespace std;
    
    const int maxn=1e5;
    int n,m,t;
    struct out {
    	int id;
    	int prior;
    }a[maxn+5];
    
    struct order {
    	int ts;
    	int id;
    }b[maxn+5];
    
    set<int> s;   //优先缓存 
    
    bool cmp(order x,order y) {
    	return x.ts<y.ts;
    }
    
    int main() {
    	cin>>n>>m>>t;
    	for(int i=1;i<=n;i++) {    //初始时刻 
    		a[i].id=i;
    		a[i].prior=0;
    	}
    	for(int i=1;i<=m;i++) {    //先输入所有订单 
    		cin>>b[i].ts>>b[i].id;
    	}
    	sort(b+1,b+1+m,cmp);  //按时间顺序排好 
    	for(int i=1;i<=t;i++) {
    		for(int j=1;j<=m;j++) {
    			if(a[i].id!=b[j].id&&a[i].prior>0) {
    				a[i].prior--;
    				if(a[i].prior<=3&&s.find(a[i].id)!=s.end()) {
    					s.erase(a[i].id);
    				}
    			}else {
    				a[i].prior+=2;
    				if(a[i].prior>=5) {
    					s.insert(a[i].id);
    				}
    			}
    		}
    	}
    	cout<<s.size();
    	return 0;
    }
    

    暂时想不出优化的方法。。。

    试题H:修改数组

    【问题描述】
      给定一个长度为 N 的数组 A = [A1,A2,···￿AN],数组中有可能有重复出现的整数。
      现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改 A2,A3,··· ,AN。 当修改 Ai 时,小明会检查 Ai 是否在 A1 ∼ Ai−1 中出现过。如果出现过,则 小明会给 Ai 加上 1 ;如果新的 Ai 仍在之前出现过,小明会持续给 Ai 加 1 ,直 到 Ai 没有在 A1 ∼ Ai−1 中出现过。 当 AN 也经过上述修改之后,显然 A 数组中就没有重复的整数了。 现在给定初始的 A 数组,请你计算出最终的 A 数组。
    【输入格式】
    第一行包含一个整数 N。 第二行包含 N 个整数 A1,A2,··· ,AN 。
    【输出格式】
    输出 N 个整数,依次是最终的 A1,A2,··· ,AN。
    【样例输入】
    5 2 1 1 3 4
    【样例输出】
    2 1 3 4 5

      思路分析:考场上先别想那么多,暴力就完事了,说不定还能拿下一半分数。 暴力求解代码:

    #include<bits/stdc++.h>
    using namespace std;
    
    const int maxn=1e5+5;
    int a[maxn];
    int n;
    
    bool check(int n,int x) {   //检查x有没有在A1到An中出现过 
    	for(int i=1;i<=n;i++) {
    		if(a[i]==x) {
    			return false;
    		}
    	}
    	return true;
    }
    
    int main() {
    	int n;
    	cin>>n;
    	for(int i=1;i<=n;i++) {
    		cin>>a[i];
    	}
    	for(int i=2;i<=n;i++) {
    		while(!check(i-1,a[i])) {
    			a[i]++;
    		}
    	}
    	for(int i=1;i<=n;i++) {
    		cout<<a[i]<<' ';
    	} 
    	return 0;
    }
    

    这个百分百会超时…暂时想不出优化思路。

    试题I:糖果

    【问题描述】
      糖果店的老板一共有 M 种口味的糖果出售。为了方便描述,我们将 M 种 口味编号 1∼ M。 小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果,而 是 K 颗一包整包出售。 幸好糖果包装上注明了其中 K 颗糖果的口味,所以小明可以在买之前就知 道每包内的糖果口味。 给定 N 包糖果,请你计算小明最少买几包,就可以品尝到所有口味的糖 果。
    【输入格式】
    第一行包含三个整数 N、M 和 K。 接下来 N 行每行 K 这整数 T1,T2,··· ,TK,代表一包糖果的口味。
    【输出格式】 一个整数表示答案。如果小明无法品尝所有口味,输出 −1。
    【样例输入】
    6 5 3
    1 1 2
    1 2 3
    1 1 3
    2 3 5
    5 4 2
    5 1 2
    【样例输出】
    2

      思路分析:考场上先直接跳过!!

    试题J:组合数问题

    【问题描述】
      给 n,m,k,求有多少对 (i, j) 满足 1 ≤ i ≤ n,0 ≤ j ≤ min(i,m) 且 Cj i ≡ 0(mod k),k 是质数。其中 Cj i 是组合数,表示从 i 个不同的数中选出 j 个组成 一个集合的方案数。
    【输入格式】
      第一行两个数 t,k,其中 t 代表该测试点包含 t 组询问,k 的意思与上文中 相同。 接下来 t 行每行两个整数 n,m,表示一组询问。
    【输出格式】
      输出 t 行,每行一个整数表示对应的答案。由于答案可能很大,请输出答 案除以 10^9 + 7 的余数。
    【样例输入】
    1 2
    3 3
    【样例输出】
    1
    【样例说明】
    在所有可能的情况中,只有 C12C_{1}^{2}= 2 是 2 的倍数。
    【样例输入】
    2 5
    4 5
    6 7
    【样例输出】
    0
    7
    【数据规模和约定】
      对于所有评测用例,1k108,1t105,1n,m10181≤k≤10^8,1≤t≤10^5,1≤n,m≤10^{18},且 k 是质数。 评测时将使用 10 个评测用例测试你的程序,每个评测用例的限制如下:
    在这里插入图片描述
      思路分析:这个题很不好做,要是暴力求解的话应该能拿下评测用例1,2,20分在正式考试也蛮不错了,那就先暴力求解吧。
    我们都知道:
    在这里插入图片描述
    因此暴力求解代码就很简单了:

    #include<bits/stdc++.h>
    using namespace std;
    typedef long long ll;
    
    const ll maxn=1e9+7;
    ll n,m,t,k;
    ll f[2005][2005];
    
    void init(int k) {
    	 for(int i=1;i<=2000;i++) {
            f[i][0]=f[i][i]=1;
            for(int j=1;j<i;j++) {
                f[i][j]=(f[i-1][j]%k+f[i-1][j-1]%k)%k;
            }
        }
    }
    int main() {
    	cin>>t>>k;
    	init(k);
    	while(t--) {
    		cin>>n>>m;
    		ll ans=0;
    		for(ll i=1;i<=n;i++) {
    			ll t=min(i,m);
    			for(ll j=0;j<=t;j++) {
    				if(!f[i][j]) {
    					ans=((ans+1)%maxn);
    				}
    			}
    		}
    		cout<<ans<<endl;
    	}
    	return 0;
    }
    

    总结

      只会暴力求解是不行的,还得加强自身的硬实力!!

    展开全文
  • 第十届蓝桥杯省赛C语言b组.zip
  • 第十届蓝桥杯省赛B组C语言.rar
  • 第十届蓝桥杯之单片机设计与开发的试题,分为客观题和编程部分。
  • 2019第十届蓝桥杯JavaB组题目
  • 此压缩包含第十届蓝桥杯真题(软件类),要准备蓝桥杯的朋友可以参考。同时也欢迎任何喜欢编程的朋友下载,尝试解题,让我们一起享受编程的快乐。
  • 第十届蓝桥杯省赛B组C语言真题.zip
  • 2019年第十届蓝桥杯客观题资源,里面有十道2019年3月24号考试的蓝桥杯客观题,内容真实有效,可以下载下来用来备考下一年蓝桥杯。
  • 第十届蓝桥杯大赛青少年创意编程Scratch组国赛编程题.zip第十届蓝桥杯大赛青少年创意编程Scratch组国赛编程题.zip
  • 第十届蓝桥杯嵌入式比赛备赛资料汇总 made by cwt 免费下载
  • 第十届蓝桥杯Java大学本科B组省赛试题
  • 第十届 蓝桥杯

    2019-02-12 18:48:22
    第十届蓝桥杯省赛总结 第十届蓝桥杯 java B组 A ~ E 题目整合(填空题) 第十届蓝桥杯 java B组 F ~ J 题整合(编程题) 2.工具向: 大数运算别担心,BigDecimal照顾您 ...
  • 今天用python写了写第十届蓝桥杯的题,有几个题感觉自己用的方法不是太好,另外最后的那个题目还不会写,希望有人改善、告知。试题A:组队(5分)【问题描述】作为篮球队教练,你需要从以下名单中选出1 号位至5 号位各...
  • 2019年第十届蓝桥杯客观题资源,里面有十道2019年3月24号考试的蓝桥杯程序设计题,内容真实有效,可以下载下来用来备考下一年蓝桥杯。
  • 2019 第十届蓝桥杯Java省赛B组题目——河南赛区
  • 第十届蓝桥杯大赛省赛(软件类)真题
  • 第十届蓝桥杯省赛A组原题,有一些题解放到我的博客上去了。
  • 第十届蓝桥杯省赛Java B组的试题压缩包,就是考试时用的压缩包。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,766
精华内容 1,506
关键字:

第十届蓝桥杯