蓝桥杯| 备赛练习题+知识点合集
文章目录
-
-
- [知识点] 两个数的最小公倍数&最大公因数
- [判断一个数是否为素数]
- [2017真题]k倍区间
- [2020填空]路径
- [2017填空] ：纸牌三角形
- [2020 七段码]
- [2018]字母阵列
- [2015填空]三羊献瑞
- 逗志芃的危机
- 幸运的店家
- 礼物
-
算法常见的考点和刷题记录
[知识点] 两个数的最小公倍数&最大公因数
约分法： a*b = （这两个数的最大公因数）* （这两个数的最小公倍数）
假设a=18，b=30,要求最小公倍数。
最大公因数： 6
最小公倍数：90
a*b=540
可以看到18乘30也是 540；
所以 最小公倍数 = a*b / (a和b的最大公因数) = 90
java 实现：
// 最小公倍数=两个数的乘积/两个数的最大公因数。
static int gbs(int a,int b) {
return a*b/gcd(a,b) ;
}
// 最大公因数
// 这里的最大公因数算法用的是辗转相除法: a和b(a>b)的最大公因数也等于a除以b得到的余数c和b的最大公因数。
static int gcd(int a,int b ){
return a%b==0?b:gcd(a,a%b) ;
}
参考1：最小公倍数证明
参考2：最大公因数计算&证明
[判断一个数是否为素数]
素数/质数 定义为：指在大于1的自然数中，除了1和该数自身外，无法被其他自然数整除的数。（也可定义为只有1与该数本身两个正因数的数）
- 0和1既不是质数也不是合数，最小的质数是2
比较容易写出的代码是：
public static boolean isPrime(int n) {
if (n <= 3) {
return n > 1;
}
int sqrt = (int)Math.sqrt(n);
for (int i = 2; i <= sqrt; i++) {
if(n % i == 0) {
return false;
}
}
return true;
}
优化思路：
质数还有一个特点，它总是等于6x+1或者6x-1,其中x>=1
证明：
首先 6x 肯定不是质数，因为它能被 6 整除；其次 6x+2 肯定也不是质数，因为它还能被2整除；依次类推，6x+3 肯定能被 3 整除；6x+4 肯定能被 2 整除。那么，就只有 6x+1 和 6x+5 (即等同于6x-1) 可能是质数了。所以循环的步长可以设为 6，然后每次只判断 6 两侧的数即可。
public static boolean isPrime(int num) {
if (num <= 3) {
return num > 1;
}
// 不在6的倍数两侧的一定不是质数
if (num % 6 != 1 && num % 6 != 5) {
return false;
}
int sqrt = (int) Math.sqrt(num);
for (int i = 5; i <= sqrt; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) {
return false;
}
}
return true;
}
[2017真题]k倍区间
给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)
输出
输出一个整数，代表K倍区间的数目。
例如，
输入：
5 2
1
2
3
4
5
程序应该输出：
6
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms
解题思路
首先是想到暴力法，对每一个下标都往前计算包含它的区间，符合题意就ans++
这样做的复杂度大概是 O(n^2) 对于本题的数据量就是10^6， 直接超时。
下一步优化策略是前缀和：
下标： 0 1 2 3 4 5
原数组Q：1 2 3 4 5
前缀和S：0 1 3 6 10 15
对应关系： S[i] - S[j] = Arr[j]
但这样做的复杂度依然会很高，（只是将往前遍历的操作优化了一些）依然会超时。
最终思路：需要数学的知识（蓝桥杯的题很多需要数论知识。。）
一个数mod k 的结果肯定是 [0-k-1] ，我们试着前缀和都模k。
下标： 0 1 2 3 4 5
原数组Q： 1 2 3 4 5
前缀和S： 0 1 3 6 10 15
(S%k)S'：0 1 1 0 0 1
这时候需要一个数论的定理了，同余定理：如果两个数a，b的差(a-b)能被k整除，那么就说a，b对模数k同余。
比如说 16和7， （16-7)/3 = 3 …0 , 可以得到 16%3=7%3=1 这样的结论。
我们把这个结论反过来用， 前缀和数组模k的若干个 0-k-1的数，相同余数的任意选两个相减实际上就是原数组的一个区间，同时可以被k整除，我们统计这样的组合，答案就出来了。
比如说 S2=S1=S5=1, 用S5-S2==>[3,4,5]，S2-S1=[2], 从中任意挑两个相减，也就是Cm2(组合）从m个数中任意挑选2个相减 。
实现：使用一个yushu数组，用来统计相同余数的前缀和的个数，
对于例子就是：
下标 0 1 2 3 4 5
(S%k)S' 0 1 1 0 0 1
yushu 3 3
题目的答案就是 C32+C32=3+3=6;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
int n=Reader.nextInt() ,k=Reader.nextInt() ;
int nums[]=new int[n+1],yushu[]=new int [k+1];
long pre[]=new long[n+1] ;
long ans =0,last=0 ;
yushu[0] = 1 ;//注意这里要手动设置为1，因为下面计算前缀和数组时，是从下标1开始计算的。
for(int i=1;i<=n;i++){
nums[i] = Reader.nextInt() ;
pre[i] = pre[i-1]+nums[i];
yushu[(int) (pre[i]%k)]++ ; // 求余数。
}
for(int i=0;i<k;i++){
ans += (long) (yushu[i] - 1) *yushu[i]/2;
// 所有前缀和余k相同的数，从中任意选择2个相减就可以得到一个k倍区间，就是组合问题 如C32
// Cn2= n(n-1)/2;
}
System.out.println(ans);
}
}
[2020填空]路径
最短路问题：我只会dijistra和floyd。 可以用dp做，更优雅。
class Main {
// 最小公倍数=两个数的乘积/两个数的最大公因数。
static long gbs(int a,int b) {
return (long) a *b/gcd(b,a) ;
}
// 最大公因数
static long gcd(int a,int b ){
return a%b==0?b:gcd(a,a%b) ;
}
public static void main(String[] args) {
int n=2021;
long[][] node = new long[n+1][n+1];
for(int i=1;i<n+1;i++) Arrays.fill(node[i],Integer.MAX_VALUE) ;
for(int i=1;i<=n;i++){
for (int j = i; j<=i+21; j++) {
if(j>2021) break ;
if(i==j) node[i][j] = node[j][i] = 0;
else node[i][j] = node[j][i] = gbs(i,j) ;
}
}
//floyd处理
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
node[i][j] =Math.min(node[i][j],node[i][k]+node[k][j]) ;
}
}
}
System.out.println(node[1][2021]) ;
}
}
[2017填空] ：纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
解题思路
这是一类全排列的题目， 本题就是将9个数字全排列，然后看哪一种组合符合要求。
如何求一组数字的全排列
C++是有全排列的函数的 next_permutation ，我们java党就自己造一个把！
- 如果只有一个数字，全排列就是他自己。
- 如果有两个数字，那就每次固定一个数字的位置，然后看下一个怎么排（回到第一点了）
写到这里，就明白是递归了，第一点就是全排列的终止条件，第二点就是每次递归要做的处理。
再仔细讲讲。懂了的可以直接跳过了。看这样一个例子 ：
[1,2,3]
[1,3,2]
[2,3,1]
[2,1,3]
[3,1,2]
[3,2,1] 可以看到数组里的每一个数字都有机会做开头数字，我们递归的过程就是不去思考后面怎么排，函数要处理的就是让将[1,2,3]三个数字逐一拉到开头，再递归下去做全排列（考虑后面的数字）
//arr：待排列的数组。参数p：数组中要实现全排列的下标开头。 q：要实现全排列的结尾下标
static void perm(int []arr,int p,int q) {
if(p==q) {
for(int i:arr) System.out.println(i);//打印排列好的数组。
return ;
}
for(int i=p;i< q;i++){
swap(arr,p,i); //交换函数：第i个数和第p个数交换
perm(arr,p+1,q) ;
swap(arr,p,i); // 换回来。
}
}
回到题目：全排列做好了，只需要检查一下结果是否符合题意。
class Main {
static int ans=0 ;
public static void main(String[] args) throws IOException {
int [] arr=new int[]{1,2,3,4,5,6,7,8,9} ;
perm(arr,0,arr.length) ;
System.out.println(ans / 6);
}
static void check3(int []arr){
//计算三角形的三条边。
int r1= arr[0]+arr[1]+arr[3]+arr[5] ;
int r2= arr[0]+arr[2]+arr[4]+arr[8] ;
int r3= arr[5]+arr[6]+arr[7]+arr[8] ;
if(r1==r2&&r2==r3) {//是否为正三角形。
ans++;
}
}
//arr：待排列的数组。参数p：数组中要实现全排列的下标开头。
//q：要实现全排列的结尾下标
static void perm(int []arr,int p,int q) {
//递归终止条件：p==q说明要排序的只有一个数，就是它自己。
if(p==q) {
check3(arr) ;
return ;
}
for(int i=p;i< q;i++){
swap(arr,p,i);
perm(arr,p+1,q) ;
swap(arr,p,i);
}
}
}
注意：题目中说了旋转，镜像后相同的序列也相同，需要去重，所以答案要/6
旋转有3种，三角形的顶点可以是三个角 /3
镜像两种： 对称轴 /2
答案： 144
结语：
相似题目还有蛮多的，可以找来做做：
2014 JavaA组 ： 6角填数
[2020 七段码]
题目：
小蓝要用七段码数码管来表示一种特殊的文字。
上图给出了七段码数码管的一个图示，数码管中一共有 7 段可以发光的二
极管，分别标记为 a, b, c, d, e, f, g。
小蓝要选择一部分二极管（至少要有一个）发光来表达字符。在设计字符
的表达时，要求所有发光的二极管是连成一片的。
例如：b 发光，其他二极管不发光可以用来表达一种字符。
例如：c 发光，其他二极管不发光可以用来表达一种字符。
这种方案与上一行的方案可以用来表示不同的字符，尽管看上去比较相似。
例如：a, b, c, d, e 发光，f, g 不发光可以用来表达一种字符。
例如：b, f 发光，其他二极管不发光则不能用来表达一种字符，因为发光
的二极管没有连成一片。
请问，小蓝可以用七段码数码管表达多少种不同的字符？
解题思路
dfs搜索，每一段二极管选择点亮或者不点亮，到最后检查一下符不符合条件：
class s2020{
static int ans =0 ;
static HashSet<String> set=new HashSet();
public static void main(String[] args) {
int []arr=new int[7] ;
int []vis=new int[7] ;
dfs(arr,vis,0) ;
System.out.println(set.size());
}
static void dfs(int []arr,int []vis,int level){
if(level==7) {
check(arr) ;return ;
}
vis[level]=1;
arr[level] =1;
dfs(arr,vis,level+1) ; // 点亮的
vis[level]=0;
arr[level]= 0;
dfs(arr,vis,level+1) ;
}
static void check(int []arr){
ArrayList<Integer> tmp =new ArrayList<>();
for(int i=0;i<arr.length;i++){
if(arr[i]!=0) tmp.add(i+1) ;
}
arr=new int[tmp.size()] ;
for(int i=0;i<arr.length;i++) arr[i]=tmp.get(i) ;
if(isVaild(tmp)){
System.out.println(Arrays .toString(arr));
set.add(Arrays.toString(arr));
}
}
static boolean isVaild(List<Integer> arr){
if(arr.size()==1) return true ;
if(arr.contains(1) && !arr.contains(2) && !arr.contains(6)) return false;
if(arr.contains(4) && !arr.contains(3) && !arr.contains(5)) return false;
if(arr.contains(2) && !arr.contains(1) && !arr.contains(3) && !arr.contains(7)) return false;
if(arr.contains(3) && !arr.contains(2) && !arr.contains(4) && !arr.contains(7)) return false;
if(arr.contains(5) && !arr.contains(4) && !arr.contains(6) && !arr.contains(7)) return false;
if(arr.contains(6) && !arr.contains(5) && !arr.contains(1) && !arr.contains(7)) return false;
if(arr.contains(7) && !arr.contains(2) && !arr.contains(3) && !arr.contains(5) &&!arr.contains(6)) return false;
return arr.size()!=0 ;
}
static void perm(int []arr,int start,int end){
if(start==end) {
check(arr) ;
}
for(int i=start;i<end;i++){
swap(arr,i,start) ;
perm(arr,i,end) ;
swap(arr,i,start) ;
}
}
static void swap(int []arr,int i,int j ){
int t=arr[i] ;
arr[i]=arr[j] ;
arr[j]=t;
}
}
[2018]字母阵列
仔细寻找，会发现：在下面的8×8的方阵中，隐藏着字母序列：“LANQIAO”。
SLANQIAO
ZOEXCCGB
MOAYWKHI
BCCIPLJQ
SLANQIAO
RSFWFNYA
XIFZVWAL
COAIQNA
L
我们约定: 序列可以水平，垂直，或者是斜向；
并且走向不限（实际上就是有一共8种方向）。
上图中一共有4个满足要求的串。
下面有一个更大的（100×100）的字母方阵。
你能算出其中隐藏了多少个“LANQIAO”吗？
FOAIQNALWIKEGNICJWAOSXDHTHZPOLGYELORAUHOHCZIERPTOOJUITQJCFNIYYQHSBEABBQZPNGYQTCLSKZFCYWDGOAIADKLSNGJ
GSOZTQKCCSDWGUWAUOZKNILGVNLMCLXQVBJENIHIVLRPVVXXFTHQUXUAVZZOFFJHYLMGTLANQIAOQQILCDCJERJASNCTLYGRMHGF
TSDFYTLVIBHKLJVVJUDMKGJZGNNSTPVLCKTOFMUEUFSVQIAUVHNVFTGBDDARPKYNNCUOYUAZXQJNOEEYKLFRMOEMHUKJTPETHLES
FKVINSLWEVGAGMKVFVIUBMYOIAFHLVNKNTYKTZWVXQWRWIGPENFXYDTKRVPKRTHMGHVYOCLDCKMEKRLGEKBYUCLOLYPAKPFSOREH
KWPUOLOVMOFBIXYACWRDYBINTMPASPCEOKHXQIGBQQMCEOIVULIEOPFSCSIHENAJCVDPJDOIWIIULFDNOZOFVAMCABVGKAKCOZMG
XWMYRTAFGFOCNHLBGNGOXPJSTWLZUNNAGIRETGXFWAQSSJPFTQAXMTQWMZWYVEPQERKSWTSCHSQOOBGXAQTBCHOEGBDVKGWJIFTG
ZWWJEIISPLMXIMGHOOGDRZFTGNDDWDWMNUFWJYJGULPHNUFSAQNNIUVAAFZIAZKFXXNWCEABGJAUMGYEIEFVQXVHHHEDYUITRCQB
XZHDPZQTOBECJVBZLACVXACZEDYOGVAVQRNWEOWGRAQYUEUESTEDQTYJUTEFOOITSHDDZHONJGBRCWNEQLZUTBNQIADKNFIOMWZR
EBFKCVNLURZSNPOLTISRPDTNUMCDGKTYRGIOVEPTUTSBAWQKWWEUWIWHAANUZUADGZEATZOQICWFUJTWNZDBKLQNELWVTBNDLNFH
PESISEATZNCDFRMXBQUKBFTIGYSFCWVHPMSUSDKPSCOMVLDOHYQVFHAJKRDTAVLIMNZBZSMLMRTLRPSLAHXDBASDMWAAYBPYVJZF
SCCWYHLQOUKBMCEYENQNJXFOMOOJMTKDSHJJOHDKEGATFZHGWJJAZJROWHAZUFGEQKPYXLCAAXHHQBDALPYUDWZQHBASBBCFGQCQ
ZKNXUBRYZVSPQHOVLAEUAUITMPWXNXJQVIBJVBCSVXKWFAFRPRWOLYVSDVTGGOFFMNQJZOBUDJLFHJTCYMPNOBHQJHGKLIKLZMLA
POCKVEQXUAVHERIAQLGJHYOOVOMTXQFRTBFSETOZICPCHZHFBWNESVJJLSVSVOOGYYABFESWNWDNYBGBNAKRCFQMTCUMIFTESVIN
JCAULIQRYUMAMAOVVWSEUTMECXSDTONRMMROQUISYEURSAYNZUVOPXLIFBDOHPXMABBLEQZGLJXQJOEYYRRRCFTEZQAOIWKRJQDL
ZNUUDWZXZZURPMHGXQGNQBIQWWNERZWULSAPIBODBFFQQIHEQKCKLJYQNXQUTAAYGRBXSLLQNOQPZJEWHETQHPXJANMJFOHINWOW
KJGAWWFSVIZHFNUWBLWYVPIWAEICCAHOEIWRADSLOZGPSVGPUBUUQAVYCHOIGINKYKJABWAQCZCXOBKTNJZQRHLUFKQLACAAOIWJ
SIKWLXQHKDFJVGBVXWDWJKUSFRQRTDJYQMNFOQQALHRLMHSDMCFLAOVKDMTKMTPVTLAZLYJNJXZCFRHHSDIXYUUSVIMIICLUJHFW
JHWUSMCFYHPIXHAPBBSHYDQCKVGQFTENLVERFVOVDCLSTQFUSEPUMTFODLZLYQXDOXAEPONIQWTDWSAWBNSZYACGSJQSHAUMIKXT
MVBNFXMFNPAYSODPXEAYNRKTEZJWMUACSIUYPIORUFPMXAOZZJPJXPFLNSKNIAMETMOVULZPQIJJIRCSYQXOEVRHCNACSBRHKYNW
KGKBTBHGWKVJYZCOVNSKUREKZEIWVLOHAMUAYKLUGHEUESICBZAHURNTJAECTHRNKSIJQFIPVZANSZYSPJWHPKHCAPEYWNXUYQSD
RRRFYQFIQSWYRQTSNGNUFOBMSLGAFWPJGYEHGASFKTJCCZPXFIQLSXNKNWCYVTETOAPCOZJNHEWOCCAWVDEZUQCLLAVUQJJTQCKJ
NMBKMUENVGXXVMQCLXPJDQIQCFWYADIFDSGINGZDJYHPUPXVRMWDIPJRWPNRYOFGYYPEAVKDEMLYRRRMNCRQXPTDSQIVKKGJWDEF
SBAEKIFZCKDOMIQKBDWVQGBYWPDIBOLQUGAQRXLJDAZMXVZXYSNWEWTNZKYREMBEUHOTFOCKEJSXCMUBCKXNGQXTQJRCRCLWJTOI
YXBFBIBRAAFNPKBLTSMCFERZURZNWHMOEHIHNQTBWXNPJGIDYDPRGEWACCBULJRACOFLANQIAOIHMYCNQHVKXSIGAMWAHUSNBBTD
QDGPTRONXHAZWOUPNBFJFEWAMFZUQZFDKAPNJUBQPWBPYGPZHKUDZZDLCCWHGAUKJCSLLFWGPYJKJQBNLCZESOGXXSQCVVKVRVAW
NXPGQOUEFLUZHHSAODIWEPZLXVQLYGVOOVCCREDJZJOMCSCFFKEIEAVCTPUZOWNOLJHGBJHJFBFFORGXOXXFOCAGBWEFCIDEKDLB
PTXSUINQAJURNFQPMMSPLZTQAHCIOFJUEFFZGIHTSJNIEXQLLHRQUXXLLORJEHGQJOXSLIAVFPEJNGMMVAXDDMPXLOSTRLLFLYRM
JQNCLENGTROIKDWBMXRNJYPGZRQOREPJJPTXKVVKPYYZENEOIQKZOPXAYGFXORXRIDGATHMZFDJIOIOKVDJBHSXQMYCBYFGXWHLH
CITGTILGPGBHZMNWWHXEFPGDPJUVFBJKAQWACZHPRPJYCOLGZTBDCVHNRSUAJUQAWAPMQJDQIFPZQZEONWHIYKMXDZOMVETEFJRB
RDOTIDCFEESOKYPYCGQQKOGPMGJRITSVTKOKDSXLRLJRRHNFRFXCMDNQMCEGZFJWHZOAFBQXXPXNBSWTSUYPAWQRHAUGLNPBRSJT
HOWRIUGMOQTUYIHDWJRFBWWKWYKCICSVBVKTBIIWGFSVIFCTUKIHHUUISCOTEOYRWQXTAEBXQQOLLMOALNIYVCCHNSWIKHMYYNZO
OFRIYYXPPSRTPAYMUJSSDILKIZAYSEIOLANQIAOVKARDPGVFCSYBSNHAPGTIKLAWTTKOEADWRLAACAAFYTBTNSGFTYLYUHJXBMMA
NJFTMLUIBKDPWBXQOMBVQXCZOIREHRSZCSJOIVBXWQIBUTYBQNTZRVROHGOIZYAJWXLEATLOZJIKJMIHSLGSVTCXJWIOOGWSERRQ
DBQJNGBLRIYFIKHBEYOZQBOAGGNIZKFDHWXCFNJLBQXVLHIQNIBZSDLTTRERHNWCMLJCVBBGGAQTPUQHIRABXPQSYGSDVMBNNDFG
KPLFUYXHYGOCZPPXMWCZYNKCYBCRZVKFBHQXPGPBZFTTGEPQTJMOFHAYSQQZDMQECGXOXADYHNNXUKNBXZBYHBOULXNBJZKIZREF
LVHAMSNXJOCVRPVGJUWXFVOCUCLCZDXRPBBDRLRAVVNLOZWOHWMXYSNMXAKJYWYGILNGUJGIPKAUDVANZLFWKUWWUSQYBRCBVDIJ
QCXPLOTPPGXCUZOUSSTXHVMLHVMJTUSSOPLRKEBQSGWNGVHKANVZWYQHSHLIPWSYCPKTUKPMWPLVFLLAHXZQANFXHFNYHIQVIOYN
ZPTJJCBHXPSUPOMNRVCKXSUFCNRCRNCPTPGIDQOEQUDFNUNMJPOEKVIMUJAJZOUKMAFSLDWYMCHTSNJYUDJAHQOIXPYSRHVAFFCR
DCGMEEWXWMNOSSJNIZCINRHENPPPCYVFWYCONOPKXMFZXXIHNXIGAHAMHSBRESOETGVXWDNQLGCEOUDDJXHQIVCHRNKBFFEWILGY
SOAIQNALXRBSGAQIDQVMVDKVZCPMJNXKXRXPFZAUVQPBHHQKTPDSQROLQTUGMFQRWGVEWCYPDYDZGNNNUFKJUEHJKPLIQNRQYXHU
GKGWUCJXUKAEHLRLNDFUQPSJAZTVJRXWXQVBMRJXULEMJJPDCVTOWVFDBVLSBHZRRQUVMUQYKTJCLSGGHGCPHPHMWYAECLJIZUWV
QQNKPQRJMSOCEAYDNKPHVEGKAGCKAPDXTGVXULHUXHJPDXCSKQTCJENVTZTMRUENCSWHBEORALSREBWAJEMQDXMRKGHJGICDHKHY
YNSDSWDRLBBFUFVVICMGUCGBSVDLJNXGKXNFGVLKAVBJRRRUHKRXTPBJAKIEBAVMDIOJLIUDABCGNPNJIYBCXMOOWKRPHPYSWRDC
BORWTNBISSLTVKBRTLWKRNCEDCNEGCIYJIPDICFAVNOISYAHWBLGMNFKXZYTTWJOBEPNMSJEJMHXVPGOJOLQQQVXFGEULANQIAOD
OQETOJHCZXGTUKIWGMEVVMXCURISUOFQSAWZWDMZWVYHZMPEIMWKJDGERODVVUXYRTYLCRGYQQOIOFZSSZRAIESWBQOAIQNALJNR
HEYWHPLLPCUEOCBAOWGAYEJZQJHLVNMVQNSQQGGUBOIMDPFLOVSQGBLYAMBRYJDVOXOQINLJAVYALAKHPKOYNKGXIISSJNGKHYMS
IQVRYKXCUFIRNENEXFJTMOTJWYXSMTDHHPRHWIXETWVVIXZELKLLWRWQYGBCGJNYSUQEFCOUDNIJMLJNLAWSYJGULKBCFPYVSSMW
WQHGWRQFWFOTGPBBSJBDUKOMBXNRPIMCGPGVZFADWTBVIEMVTBXVAFQDDMJALCOMZTXUFFKBQQZDFAMTFWEXTHBKNWRLUVITQXLN
OPPJQKNGHWWPENVQIABJCQNKXNPWOWRFEOKQPQLANQIAORGGOLAYCEGZBHZVLPBERWYIJNJUNXKULUQOJLTNRDZDEYWEMYCHJLLB
LJISOAQLXJEFXVTOZSICOLQIJEXUANJWIFSIMGUQWHBXUDWOEILYFUZTGDZDSPLZPDPXBLFAXLEFQFEPDSJQWEQMXKKHCXHMSATM
UMUJENPBYKZLWAJAXJKDIYCBREBPOETQHMRHLKSEZUIPRGWIZDDQLSJAPKPBWMJMPZWLNFLFCQOCDBMLIHIYCXUJLFLPZVGWBKMY
WHZJLKEWUPETVUREKVKCLBNYFLWCERVIPUDINNWGQTUHWXCTDVTMYATYUZLMVLOHKBOGIZCQDOWFBCWJAVUXYUEVRKPOXCKHAWZC
RPLNLCUHJRADHJNSDPZXIKXGUKEJZCFJQASVUBSNLXCJXVCJZXGMRYRLOBCNGPDUJQVEFKMYHNZGZOAIQNALQDHTBWJXPKJLFXJY
MKCEZEDAFGSOCORWJGMOKWPVVBVDYZDZHPXFWJBDELHPGOQHMBAHUUUJMGXAEKZCTQTBXNVYUIQUVZGXSKQXJWRUPSFIJDYIAORC
GKFKQNXPJWOPPBTUKTHUBIROSYOVFEMJBRREWICJPCIOSTWPAUSKTRQULXPWRSXHSRYBCWYCYOTCTPFSQLDIILIGMEVZKYSOYRPH
SFDSCSMLLNARCCGCBJOGZAEQTGNGSFAQIXLPDBSWZDTYVASYYPVBRFBTIAGGWONGSVKCJDBBLYKAIOXUATGMALZXFOHZFTXALCFU
CUSSTLCRYPDTFSFJFENKJWTEBOBEPLSNXLALQWCKSLVMZQDJITHZKVCCQXTEXOSVAUFYAZXJUOAPPVEEWOIIMOSZZMCOQBRUXWKG
PDOFSCKKJJTRYRWGLEZODQTJSIMXIAOLNMLPHBAYLPTTLPYWILSEIIQVSXNHIJEORVCNJHYXRBIZZJTADGMRTSXVRXYGVQQNUEIC
IHNJOQXUXTXFPALCHOELNVMWDWQTEARUKPIFWXJSMWZLMNLAODUTKNZDYRFRLGBLIBGIBXJBOYMLYLANQIAORORYKSJPOOOAMVRN
IWIUHLYJKTQGVJBDPROSRGZUFITDIBCDPICNEFIGHWGSROWBYKUCLCQYLJXLHLXSCTJWKDLHHMLDBZCVDKPXYYASHUUMUJMVSXAD
GXOYXQFEBFIEJJLHBNGSYALOUXNQBXXZAAZJXENJJVVGFVHOTKSLEGLJVSJCQHSSZFEIOGBOGWSPIRENQAAWRQFBEFEXBKGMSTRC
PYIANSGMNKBCDPHWDUPKICQEUDNZPNGRUJYSZIRLXGXXITAFBCANGDLVAQLDPVTJNSAUZMBBNOBBOERSHQIOLBVTSPPJKVCMXUBS
IKMDIYSNCJZKJKJQMTIKEPRUNAHJUSWJHSLWIVWHYAYLOIOGSZVWKQWXZDBPHWZRAIPMXDJHBIISVJWVEVZAEGAKCYYMNZARBZPC
DLDFVQDFDMVHYVOWEKMFKWUXLTPWIVKPRZZXOLMDAPAIQEKJHCHYAGJDBOFWDGNEGQGOOKWSKLTLREMGGTVJFHAIBCQKNZVRCZYS
FBQASGNCCBBGNKJHCDBTGBIIWKMPHDABKEWDEPYEAVKNMPATUZZUOEHGUGAZNECSGUCIIJPMMRAMTVADMTCRJCBWDLWWFNFOWMVZ
XFJFBGDAVGGAIZHAUIYENDZTRUWHPQUFWCHOXNCWYNAWVPLBLNQKQDTKQQKXNFXCTBGRWUZFHNRBDNLNKQVOLLGBBJQIYOBCEIKO
CURAGWXMLYBSIZLAXFONZZMQMRNNSRQKRHQGFGZUTLONAYRKSSOWAMKZBSGOOYQDPTBHGPBNQEDCZHRTOXREOFJEKJVIZXZBCJPN
KGYBZTZRKOGBETJRUWRNUCIFKIMCZGYTZLCZYGCGKVZRJIFZQIQPTCPPUHYWIXBOFFGSGSAIMNGKKUUROAVNJUQQNSWJRZIZEHAF
DDAOBVCPOVODVJFLSNPJXHWQBHILWZAHQQMTQASNADZLZNXJLJMFCOUWOZJCMVVTYCKTUBABWLCEBNYWAMOLNBQQYBRUJCQCZALE
TVVRPMYFIKINHIUEJBDLTCUMMUWICIUVCZNIQIUEWVAHLANQIAONMEYJWPDAFXVNOSOFDOCESSLGZPTJINBUAFWWWMPTYALZIGVD
DCZGKILMBFXIQQFEKJBIUDEMIFCANVGNYZAYSQFMNNQFEPZFUUVGTBKSMDXITBLANQIAOQUKTPNYPOWSQQYWWMJHSDYVFDJYXBAF
VGYXAMDRRZWVIHNQPZZWRNWBTROOJOLNUGXBILZKQEGIQSYGKZGODPWBJSCMRRWSSQURUFIAFQGEZLGZNOEQMNQEYUKPEQPPVAMO
SYSFUAJFKIPUJVQSZRWQCJYAUMLDDNOKODDXIEQIFLANQIAOZFUNKUBVDBLMJOAUTVCZVLKJRQIORQPGAVCEYVNYUZHXILHERYEC
GJEKWEKIJNIWUXZNVIWIAANHIOSOLATSQFSSCTAKESUTSPPYFHEHLVLIBJZEEBCOWMNHFTZMAPKFUPNFLTFFJQRVJHAKDVMGGUIX
KAKXXNKSOAIQNALLWKWGVACYWBQEVTFSEUCYRORQTHWFUJFLQHONWZEKPLSNPRPBOMOFFCPMKXFZBKIERBKDYFKYUEYVYRPMOAQI
WNICDLQKZXGTKDLIEFBGELGJOAIQNALXZLGGDQIBVEULDPBWUJNTYOKFBPGMAWRRUJPPIGYCNYURNOSQRIRBAZAGWWDUHAAZQWPT
KFXZQXRMKSBUXWOUVVHSJWTLKZELGXMMAIDSJIWGCJPCBWZIEKMNUPUAFHTUMOZKJWVTIAQNOHELEMWGKJHKPNJVSRVHAUFXBUOU
XOWCZJYQLXJRUOOYSKDLDXKWTTJBYBTLKSWRUYPOYTPBGUJXBMRWNELBWADCSZDAEEFGPVRHNNLBFDDXNPDXLKQUSJAZDEUDBMBD
QIKYEKMVUHGGWZDKXFVQQNECZOAWCFUBHQMEPEPKEFSDBAYJQOSGAIHRBRAUKLQRANKMTTIOJDDXAEWTQHIYSGRRMEFTNNWCLZSI
ZFUQAQCSFNVUQMKUQWBWFQIEQVVXPOSVIDTUOBLLTGHQKEMSUWWHWRISLGRDPPQPZBANSGDWXKNYTKMWECPMPDYSCJZXPUKPWGYI
CNGVLBSCBHRLJARWSRENGHYYQDKRATERCPEAOPAJZUMOYIDHVPDMQPKKHCBAMRBGEIEXXJALMCXKPUGXYVINRORFYURXAMOJCBZQ
YJHHAWESCLMDIHVYMLAJZQSYTDEURWYPOLJCAKIKSATGVIALBLWPPKDEGSPMRLDBQNVPPCLQXKUQLQJERMYFGAETUATEBQZUMGUN
NBWUBVXYDFPLPJYLIDFVTVKKGFWMXVINLJUDUPABTSBJAJENZSXIMUJQWPEZTAVDMBBHFYTJKYFXIXQTBTTQIKQXQDPWYNMXRQDJ
OGWLZQUBJJHAQNPVRGHGPNMMJPIDGANYEEDWYPOLKLNEPYSRTQYCJLSWFRJRRGGSNSDHIXYYSNAKKBWQDDGYYMOGPUXQEUSAPSOU
CLLSELRVFZUFYVTJQKCQHNICMERWQFQNPVRPIIYKHZWJYJAFCLNSZXUHSPOZWQUMJHLKKYJENVZOCSWCTPYWIZONUUCLSUROGAYS
AZGNIMXPLPCEPULRRBHHQOBELHJZPUQAMWUASVKDXVEWAOFMAYSJFXHCNEUXUQWUESFBRUFZQLKKWHCHKOPLECCBYSLECAEZIMMI
TUUEOCEBAUKWLTSYJJPLZTIARAOZXKYYWIOXBBTZZCSAULKNEJWVQXIKUWBIWVHGNTHVBAWAVPGLHSDJDLPVHHHUNVSFKXARXLVQ
EMVDFSLANQIAOPTLFLFRKGNUZCTXWCAXHECTZFHWUFENRGQICHTYLSHZWIEGLNVDJZOMTKAAUWOHVOVOCTUKOSINSAYIAEUYORNA
VGPRMLCAQZIPRFQOZMEFTQZYVOTVFNVOIQSJCIPPQXQKJIXICUIGMHAJJMSXENCBQFIJHNZXIQMWACKDKQSEWWKMLOAUPFHAZGRY
SQWQMRSQBGGKYKGWEZYRIHWGNXRPOUMFSFGTYDLUDWPWAVQORTMQUXWKUQVNMDPWQFIZPOIHCJATODRQGZDMQXZVNXXVEJNGWZOM
PVBGZSQPCELDIWDHOQWAUHILGLPYRIICTLFSOYKQZYZOCIZPTECSWOODGGBDTSGIMYGMVPJPRPEVWOOKYFWRGXHWUCRQNYJEMSYL
XWOFXFVDXPTHYTCEGMODCILAHYBREZVVHOUPZKCNHUEVPMKHUBNRPFMWXVQACVZCALZLYMZSBLCEASPMIEFOTGKMPGWYQADSNDPR
QPHAVLZDZLKIEISFLLVWXAVBZLZIJRHGROUVGXRDLUJAXNHBBZYNCVERJGSKLWZEKGJBCWMSMLYIHZFFMIOGVIMZQBSRHQWAADYN
MNXEGTDXCDKIUDOISQXEUJWETPELKBCYFSDNJQWNNBPYMWBUPQBAAINMYZOYCEGNLFNNHZFEMSQVXJJGWBCRAVKZFWFBKMBRVBFD
HKACSZIUWUXLWKFPKOCUQJEPQDZCMUJFLVCLIOQQRVKSWFIAKNHMRLNJTKGVNTGLCVPVMBLJANOBCXUGVWBJYSIXZQVAVFWILWFB
QWNLTPMCYHRSKVHXLONRANWKWXUTHYQLIOFKGDBMSWDRCYRKVSAGGRJMWQYQFLMUIGGCLAUQAACTYLPZEOJBHMWRKHCRXGTGRMUP
CPQKJRBLYDNPUGHCRBVYBAIRVCAWLBWVWCMKNBIRKJOUGYQEBQRHDSTWXDIWGRVMLIJFBWHLHCDAAVUDLZSCGQNOUXVUIVIZZZMD
NMHGYPFUUDWKQGTAKKGCDFJFYJFNRZVXDPGZEAMWQVQZODKTXHIYFVKJSSAWVHYCUCZMLLBPXTILDYJQEMWDRUFKISOUVPUDTYPB
FDAQUBXHUJYTAYNWVIJNUSQDTQDEMUAPWXRYUWONTBDZCHZOUEGPMWEZTQWWSHAYOBWVTDIMZYNVNZKUHOFCQKPHJXWNRCGUJEKO
WSDAUGUTVWCVHEMOIRJJGTANUWTSAIXXEVZTBDHPGSRHHVWCDZVZYRJTLONIJVXEATHQXOUKBIGZONFRSZIOGWNTYAJYLQCGEOWY
思路： DFS深搜，注意8个方向是只能选择一个一直走下去，而不是弯弯曲曲地走。
以每一个’L’字母起点，搜索有没有‘LANQIAO’
class Main {
static int ans=0 ;
static boolean vis[][];
static int[] []dir=new int[][]{{1,0},{-1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
static char[] target=new char[]{'L','A','N','Q','I','A','O'} ;
public static void main(String[] args) throws IOException {
int n=100 ;
String arr[] =new String[100] ;
char[][] map = new char[100][100] ;
vis=new boolean[n][n] ;
for(int i=0;i<n;i++){
arr[i]=Reader.nextLine() ;
}
for (int i=0;i<n;i++){
map[i] = arr[i].toCharArray();
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(map[i][j] == 'L') {
vis[i][j] =true;
for(int t = 0; t <dir.length; t++){
dfs(map,i,j,0,dir[t][0],dir[t][1]) ;
}
vis[i][j] =false;
}
}
}
System.out.println(ans);
}
static void dfs(char[][] map,int x,int y,int n,int dire1,int dire2){
if(n==6){
ans++ ;
return ;
}
int x1=dire1+x;
int y1=dire2+y ;
if(vaild(x1,y1,map) && target[n+1]== map[x1][y1] &&!vis[x1][y1]) {
vis[x1][y1]=true;
dfs(map,x1,y1,n+1,dire1,dire2);
vis[x1][y1]=false;
}
}
static boolean vaild(int x,int y,char[][]map){
return x>=0&&x<map.length&&y>=0&&y<map[0].length;
}
}
答案： 41
[2015填空]三羊献瑞
观察下面的加法算式：
祥 瑞 生 辉
- 三 羊 献 瑞
三 羊 生 瑞 气
其中，相同的汉字代表相同的数字，不同的汉字代表不同的数字。请你填写“三羊献瑞”所代表的4位数字（答案唯一），不要填写任何多余内容。
思路：dfs深搜或者9次循环，实际上就是找符合要求的8个数字
进一步思考可以发现三必定是1。在编程中可以做优化
class Main {
public static void main(String[] args) throws IOException {
int arr[]=new int[8] ; // 创建一个数组表示 三羊献瑞，祥瑞生辉
dfs(arr, 0);
}
static void dfs(int arr[],int n) {
if(n==8) {
if(ok(arr)) {
System.out.println(1+" "+arr[1]+" "+arr[2]+" "+arr[3] ) ;
for(int i:arr) {
System.out.println(i);
}
}
return ;
}
// 对每一位，逐个逐个的试
for(int i=0;i<10;i++) {
arr[n]=i ;
if(check(arr, n))
dfs(arr, n+1);
}
}
// 验证合法性，8个互不相同的数。
static boolean check(int []arr,int n) {
if(n==0 && arr[n]!=1) return false; // 如果是第一个数，必须是1
for(int i=0;i<n;i++) {
if(arr[i]==arr[n]) return false;
}
return true;
}
static boolean ok(int[] arr) {
int a = arr[0]*1000+arr[1]*100+arr[2]*10+arr[3] ; //三羊献瑞
int b = arr[4]*1000+arr[3]*100+arr[5]*10+arr[6];
int c= arr[0]*10000+ arr[1]*1000+arr[5]*100+arr[3]*10+arr[7] ;
if(a+b!=c) return false;
return true;
}
}
逗志芃的危机
问题描述
逗志芃又一次面临了危机。逗志芃的妹子是个聪明绝顶的人，相比之下逗志芃就很菜了。现在她妹子要和他玩一个游戏，这个游戏是这样的：一共有n个数（n是偶数）写成一行，然后两个人轮流取数，每次只能从最前面或者最后面取走一个数，全部取完则游戏结束，之后每个人取走的数的和就是每个人的得分。由于逗志芃妹子很厉害，但他又不想输，所以只能找到你了，你要告诉他最多可以得到多少分。（注意，妹子智商是maxlongint所以是不会犯错的，每次的策略必然最优，而且逗志芃是先手）
输入格式
第一行一个数n，表示有n个数。
第二行就是进行游戏的n个数。
输出格式
一个数，最高得分
样例输入
2
10 2
前言：我发现蓝桥杯标签有点混淆思路，这道题的标签是贪心，但目前我看到的题解都没有用纯贪心做出来的，自己试着做了一下也是错的。 （不要相信标签，相信自己）
参考1
参考2
幸运的店家
问题描述
炫炫开了一家商店，卖的货只有一个，XXX，XXX卖N元钱。有趣的是，世界上只有面值为3的幂的纸币，即纸币只有1元的、3元的、9元的。。。。，有一天，桥神来买XXX，可他没办法正好给出N元钱，而炫炫没法找零，于是他只好用他的钱凑出了一个比N大，并且最小的价值，交给了炫炫。炫炫想知道，他这次最多可以得到多少张纸币。
输入格式 一个数，N
输出格式 一个数，为答案
样例输入
4
样例输出
2
礼物
问题描述
JiaoShou在爱琳大陆的旅行完毕，即将回家，为了纪念这次旅行，他决定带回一些礼物给好朋友。
在走出了怪物森林以后，JiaoShou看到了排成一排的N个石子。
这些石子很漂亮，JiaoShou决定以此为礼物。
但是这N个石子被施加了一种特殊的魔法。
如果要取走石子，必须按照以下的规则去取。
每次必须取连续的2*K个石子，并且满足前K个石子的重量和小于等于S，后K个 石子的重量和小于等于S。
由于时间紧迫，Jiaoshou只能取一次。
现在JiaoShou找到了聪明的你，问他最多可以带走多少个石子。
输入格式
第一行两个整数N、S。
第二行N个整数，用空格隔开，表示每个石子的重量。
输出格式
第一行输出一个数表示JiaoShou最多能取走多少个石子。
样列输入
8 3
1 1 1 1 1 1 1 1
样列输出
6
解题思路：
先来理解题意：
- 连续的2k个石子 —— 实际上就是要找连续的偶数个石头
- 并且前面一半的石头的重量和后一半的重量都不能超过给定的S值。
- 最后返回的是 能取走的石头的个数！
我们不需要知道拿走石头的重量，只需要找到连续的偶数个石头个数最多有多少个
第一时间可能会想到用滑动窗口寻找连续值，但这样做的时间代价太大了，再想想有什么可以优化的。
- 在数组中寻找连续值的不仅只有滑动窗口，还有前缀和！而且使用前缀和数组记录石头重量数组也可以省下重复计算的动作。
- 注意到前缀和数组是递增的（有序），我们也是要在数组中寻找一个区间，何不考虑用 二分法呢？