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

最新推荐文章于 2022-07-28 23:11:28 发布
最新推荐文章于 2022-07-28 23:11:28 发布
阅读量9.4w 收藏 17
点赞数 1
文章标签： 算法 java 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzzlueng/article/details/123678671
版权
本文涵盖了算法和数据结构的基础知识，包括最大公因数、最小公倍数的计算，素数判断，以及解决实际问题的算法应用。详细解析了2017年和2020年的真题，涉及K倍区间问题、七段码问题、字母阵列等。通过递归、前缀和等方法展示了如何寻找有效解决方案。此外，还讨论了游戏策略，如三羊献瑞的危机和幸运的店家礼物问题，展示了如何在有限条件下找到最佳策略。
摘要由CSDN通过智能技术生成

文章目录

算法常见的考点和刷题记录

[知识点] 两个数的最小公倍数&最大公因数

约分法： 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. 如果有两个数字，那就每次固定一个数字的位置，然后看下一个怎么排（回到第一点了）
    写到这里，就明白是递归了，第一点就是全排列的终止条件，第二点就是每次递归要做的处理。

再仔细讲讲。懂了的可以直接跳过了。看这样一个例子 ：
[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值。
  • 最后返回的是 能取走的石头的个数！

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

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

  • 在数组中寻找连续值的不仅只有滑动窗口，还有前缀和！而且使用前缀和数组记录石头重量数组也可以省下重复计算的动作。
  • 注意到前缀和数组是递增的（有序），我们也是要在数组中寻找一个区间，何不考虑用 二分法呢？
三十三天天堂堡
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
蓝桥杯复习资料大全
07-22
里面是百度云链接，包含蓝桥杯考试的往届试题，还有多种算法设计题，祝你备战蓝桥杯！
蓝桥杯考前必备知识
m0_75249978的博客
02-18 1288
蓝桥杯题目分为 填空题 和 编程题注意： 填空题只输出结果，提交过程不得分！！！
蓝桥杯比赛必用知识
11-17
用于蓝桥杯比赛用的知识资料，用于蓝桥杯比赛用的知识资料，用于蓝桥杯比赛用的知识资料，用于蓝桥杯比赛用的知识资料，用于蓝桥杯比赛用的知识资料，
蓝桥杯比赛项目资料.rar
03-18
蓝桥杯作为大学比赛的项目也是被很多人知晓的，该资源里存放了我参赛前搜集的所有资料和自己的练习，可以作为参赛前使用
http://www.115ps.com/all.html,plnt-20200804
热门推荐
weixin_32389853的博客
06-19 25万+
0001637207-20-000037.txt : 202008040001637207-20-000037.hdr.sgml : 2020080420200804161432ACCESSION NUMBER:0001637207-20-000037CONFORMED SUBMISSION TYPE:8-KPUBLIC DOCUMENT COUNT:15CONFORMED PERIOD OF R...
蓝桥杯备赛：蓝桥杯备赛练习题与答案
09-14
为了有效地备赛，你需要掌握一系列关键知识点。以下是对标题和描述中提及的知识点的详细解释： 1. **开发环境**：在备赛过程中，选择一个合适的开发环境至关重要。这可能包括安装集成开发环境（IDE），如Visual ...
python蓝桥杯省赛刷题总结+真题
04-16
总的来说，蓝桥杯省赛涉及的Python知识点主要包括基础语法、数据结构（如链表、队列、栈）、图论算法（DFS、BFS、最短路径）、动态规划、回溯法、贪心算法等。通过系统学习和练习这些内容，参赛者可以提高解决问题的...
蓝桥杯历年真题(国赛+省赛)
11-21
"蓝桥杯省赛真题历年5年的"这部分资源意味着你可以系统地回顾过去五年的省赛题目，这有助于理解省赛的难度变化和重点考察的知识点。省赛题目虽然相对于国赛来说可能稍显简单，但同样具有挑战性，可以帮助参赛者在...
蓝桥杯Java c++历年习题+详解
03-18
【蓝桥杯】是中国一项知名的计算机编程竞赛，旨在提升大学生的编程能力，特别是Java和C++方面的技能。...同时，通过解压并研究这些习题和答案，学生可以了解历届比赛的难度趋势，为自己的学习和备赛提供明确的方向。
蓝桥杯嵌入式备赛相关.zip
最新发布
04-25
在"蓝桥杯嵌入式备赛相关.zip"的压缩包中，"WGT-code"可能是包含了练习代码或者往届比赛的样例代码，通过学习和分析这些代码，可以加深对以上知识点的理解，为比赛做好充分的准备。同时，要多做模拟题，提升解决问题...
Python3爬虫项目集：爬取知乎十几万张小姐姐美图
零度的博客
11-06 8231
文章目录前言注意点代码实例 前言 github：https://github.com/pasca520/Python3SpiderSet 知乎上有很多钓鱼贴，也成功的钓上了很多鱼，你懂的~~~ 这里通过 python 爬了一些图片，总共大概有十几万张，仅供练习使用： 示例 python 库 爬取模块 request 解析模块 re 存储类型 存储图片到本地&七牛云存...
通过修改hosts文件屏蔽网站的广告
liuyukuan的专栏
11-15 2万+
这个列表是逐步添加的，攒了几年了。谈不上专业，也不够全面，只是尽 量去屏蔽小说网站的广告吧。虽然有时还是无法避免页面弹出，但起码可 以阻止浏览器访问，以免弹出广告音效影响心情。   XP或Win7系统：进入C:\WINDOWS\system32\drivers\etc\   用记事本打开Hosts文件，在文件的最后加入分割线以下内容，保存即可。 ---------------
爱情来的太快就像龙卷风
qq_45717538的博客
10-19 8万+
题解 uuuu yyy uuu uuu ooo rrr rr w iii ee ww yyy ooo eee uuu rrr ee yy e 首先再26个键盘上找到u所对应一行u是第几个字母u对应第7个所以对应九宫格第7个格u有四个所以是第七个格里第四个字母s，以此类推
一些经典问题，大家学习讨论--摘自uuussseeennn
lijunuuxxx的专栏
11-07 1万+
1. 在类的普通成员函数中调用虚函数，情况是怎么样的？（对象、引用、指针） 多态， 事实上，这是 Template Method模式的关键 2. 关于成员变量初始化顺序，几个有依赖关系的成员变量要初始化，让写出构造函数。 在初始化列表中，成员变量的初始化顺序是其在类中声明顺序，而非列表中的顺序。 4. 写个is-a和has-a。 Class Pet{};
2007-2008 Summer Petrozavodsk Camp, Andrew Stankevich Contest 26 (ASC 26) Codeforces Gym 100153
deja vu
07-21 1万+
2007-2008 Summer Petrozavodsk Camp, Andrew Stankevich Contest 26 (ASC 26) 题解 Codeforces Gym 100153
＜Zhuuu_ZZ＞实时流之Apache Flink
Zhuuu_ZZ的博客
01-06 1万+
Apache Flink
YOLOV4在Windows10下训练
ty的博客
03-15 7121
YOLOV4在Windows10下训练
离散数学及其应用知识点（自用）
weixin_58677390的博客
07-03 1万+
第二章 命题逻辑 1.→，前键为真，后键为假才为假；<—>，相同为真，不同为假； 2.主析取范式：极小项(m)之和；主合取范式：极大项(M)之积； 3.求极小项时，命题变元的肯定为1，否定为0，求极大项时相反； 4.求极大极小项时，每个变元或变元的否定只能出现一次，求极小项时变元不够合取真，求极大项时变元不够析取假； 5.求范式时，为保证编码不错，命题变元最好按P,Q,R的顺序依次写； 6.真值表中值为1的项为极小项，值为0的项为极大项； 7.n个变元共有个极小项或极大项，这为(0~-1)刚好
HJ26 字符串排序（ 先提取不需要排序的非英文字母 + 冒泡排序）
sunny_xiaot的博客
07-28 1万+
输入AFamousSayingMuchAdoAboutNothing(2012/8).**规则2**同一个英文字母的大小写同时存在时，按照输入顺序排列。**规则1**英文字母从A到Z排列，不区分大小写。**规则3**非英文字母的其它字符保持原来的位置。**数据范围**输入的字符串长度满足1≤n≤1000。编写一个程序，将输入字符串中的字符按如下规则排序。如，输入Type输出epTy。如，输入BabA输出aABb。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值