蓝桥杯| 备赛练习题+知识点合集

文章目录

      • [知识点] 两个数的最小公倍数&最大公因数
      • [判断一个数是否为素数]
      • [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填空]路径

蓝桥杯| 备赛练习题+知识点合集_第1张图片
最短路问题:我只会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计算)。要求每个边的和相等。
下图就是一种排法
蓝桥杯| 备赛练习题+知识点合集_第2张图片
这样的排法可能会有很多。
如果考虑旋转、镜像后相同的算同一种,一共有多少种不同的排法呢?
请你计算并提交该数字。
注意:需要提交的是一个整数,不要提交任何多余内容。


解题思路

这是一类全排列的题目, 本题就是将9个数字全排列,然后看哪一种组合符合要求。

如何求一组数字的全排列

C++是有全排列的函数的 next_permutation ,我们java党就自己造一个把!

  1. 如果只有一个数字,全排列就是他自己。
  2. 如果有两个数字,那就每次固定一个数字的位置,然后看下一个怎么排(回到第一点了)
    写到这里,就明白是递归了,第一点就是全排列的终止条件,第二点就是每次递归要做的处理。

再仔细讲讲。懂了的可以直接跳过了。看这样一个例子 :
[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 七段码]

题目:

小蓝要用七段码数码管来表示一种特殊的文字。
蓝桥杯| 备赛练习题+知识点合集_第3张图片

上图给出了七段码数码管的一个图示,数码管中一共有 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值。
  • 最后返回的是 能取走的石头的个数!

我们不需要知道拿走石头的重量,只需要找到连续的偶数个石头个数最多有多少个

第一时间可能会想到用滑动窗口寻找连续值,但这样做的时间代价太大了,再想想有什么可以优化的。

  • 在数组中寻找连续值的不仅只有滑动窗口,还有前缀和!而且使用前缀和数组记录石头重量数组也可以省下重复计算的动作。
  • 注意到前缀和数组是递增的(有序),我们也是要在数组中寻找一个区间,何不考虑用 二分法呢?

你可能感兴趣的:(算法,java,蓝桥杯)