2017第八届蓝桥杯省赛JAVA C组真题解析（带源码及解析）

ゝ一纸荒年。 2022-11-15 14:24 173阅读 0赞

## [蓝桥杯历年真题及解析][Link 1]. ##

### 目录： ###

*   *  蓝桥杯历年真题及解析.
     *   *  A：外星日历（难度：★）
         *   *  题目：
             *  分析：
             *  代码：
         *  B：兴趣小组（难度：★）
         *   *  题目：
             *  分析：
             *  代码：
         *  C：纸牌三角形（难度：★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  D：承压计算（难度：★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  E：杨辉三角（难度：★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  F：最大公共子串（难度：★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  G：Excell地址（难度：★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  H：拉马车（难度：★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  I：青蛙跳杯子（难度：★★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  J：图形排版（难度：★★★★★）
         *   *  题目：
             *  分析：
             *  代码：
         *  算法交流群

### A：外星日历（难度：★） ###

#### 题目： ####

某星系深处发现了文明遗迹。

他们的计数也是用十进制。  
他们的文明也有日历。日历只有天数，没有年、月的概念。  
有趣的是，他们也使用了类似“星期”的概念，  
只不过他们的一个星期包含了9天，  
为了方便，这里分别记为: A,B,C…H,I

从一些资料上看到，  
他们的23日是星期E  
他们的190日是星期A  
他们的343251日是星期I

令人兴奋的是，他们居然也预见了“世界末日”的那天，  
当然是一个很大很大的数字  
651764141421415346185

请你计算一下，这遥远的一天是该文明的星期几？

你需要提交的是一个大写字母，表示该文明的星期几，  
不要填写任何多余的内容。

#### 分析： ####

将大数对9取余数，  
对拍一下23%9=E即可  
答案=G

#### 代码： ####

import java.math.*;
    import java.util.*;
     
    public class Main { 
        public static void main(String[] args) { 
     
    // int week=5;
    // int d=23;
    // do{ 
    // week--;
    // d--;
    // if(week==0)week=9;
    // System.out.println(d+" "+(char)('A'+week-1));
    // }while(d>=0);
    // BigInteger num=new BigInteger("651764141421415346185");
    // System.out.println(num.mod(new BigInteger("9")));
            System.out.println("G");
        }
    }

### B：兴趣小组（难度：★） ###

#### 题目： ####

为丰富同学们的业余文化生活，某高校学生会创办了3个兴趣小组  
（以下称A组，B组，C组）。  
每个小组的学生名单分别在【A.txt】,【B.txt】和【C.txt】中。  
每个文件中存储的是学生的学号。

由于工作需要，我们现在想知道：  
既参加了A组，又参加了B组，但是没有参加C组的同学一共有多少人？

请你统计该数字并通过浏览器提交答案。

注意：答案是一个整数，不要提交任何多余的内容。

--------------------

笨笨有话说：  
哇塞！数字好多啊！一眼望过去就能发现相同的，好像没什么指望。  
不过，可以排序啊，要是每个文件都是有序的，那就好多了。

歪歪有话说：  
排什么序啊，这么几行数字对计算机不是太轻松了吗？  
我看着需求怎么和中学学过的集合很像啊…

#### 分析： ####

直接模拟，将所有元素取出来，  
在A组，在B组，不在C组。  
计算的结果即可。

#### 代码： ####

import java.io.FileWriter;
    import java.io.IOException;
    import java.math.*;
    import java.util.*;
     
    public class Main { 
        public static void main(String[] args) throws IOException { 
            int a[]={ 12894792, 92774113, 59529208, 22962224, 2991600, 83340521, 87365045, 
                    40818286, 16400628, 39475245, 55933381, 76940287, 61366748, 95631228, 
                    17102313, 50682833, 61562613, 87002524, 83062019, 51743442, 61977890, 
                    32010762, 69680621, 87179571, 81761697, 32364296, 7833271, 36198035, 
                    26588918, 84046668, 43059468, 73191775, 56794101, 454780, 11141030, 
                    10008994, 35072237, 44945158, 53959980, 75758119, 18560273, 35801494, 
                    42102550, 22496415, 3981786, 34593672, 13074905, 07733442, 42374678, 
                    23452507, 98586743, 30771281, 17703080, 52123562, 5898131, 56698981, 
                    90758589, 18238802, 18217979, 4511837, 75682969, 31135682, 55379006, 
                    42224598, 98263070, 40228312, 28924663, 11580163, 25686441, 45944028, 
                    96731602, 53675990, 3854194, 14858183, 16866794, 40677007, 73141512, 
                    32317341, 56641725, 43123040, 15201174, 62389950, 72887083, 76860787, 
                    61046319, 6923746, 17874548, 46028629, 10577743, 48747364, 5328780, 
                    59855415, 60965266, 20592606, 14471207, 70896866, 46938647, 33575820, 
                    53426294, 56093931, 51326542, 94050481, 80114017, 33010503, 72971538, 
                    22407422, 17305672, 78974338, 93209260, 83461794, 41247821, 26118061, 
                    10657376, 42198057, 15338224, 50284714, 32232841, 26716521, 76048344, 
                    23676625, 62897700, 69296551, 59653393, 38704390, 48481614, 69782897, 
                    26850668, 37471053, 88720989, 51010849, 94951571, 60024611, 29808329, 
                    70377786, 13899299, 9683688, 58218284, 46792829, 97221709, 45286643, 
                    48158629, 57367208, 26903401, 76900414, 87927040, 9926730, 1508757, 
                    15101101, 62491840, 43802529};
            int b[]={ 
                    44894050, 34662733, 44141729, 92774113, 99208727, 91919833, 23727681, 
                    10003409, 55933381, 54443275, 13584702, 96523685, 50682833, 61562613, 
                    62380975, 20311684, 93200452, 23101945, 42192880, 28992561, 18460278, 
                    19186537, 58465301, 01111066, 62680429, 23721241, 20277631, 91708977, 
                    57514737, 3981786, 81541612, 07346443, 93154608, 19709455, 37446968, 
                    17703080, 72378958, 66200696, 30610382, 89586343, 33152171, 67040930, 
                    35696683, 63242065, 99948221, 96233367, 52593493, 98263070, 1418023, 
                    74816705, 89375940, 58405334, 96731602, 84089545, 16866794, 94737626, 
                    01673442, 70548494, 13638168, 8163691, 11106566, 64375392, 40267902, 
                    897705, 56447313, 54532235, 94738425, 66642634, 83219544, 40546096, 
                    66924991, 20592606, 96037590, 73434467, 70896866, 91025618, 57892091, 
                    8487641, 32500082, 84412833, 23311447, 38380409, 79957822, 72971538, 
                    69645784, 91863314, 73099909, 93209260, 83461794, 81378487, 30423273, 
                    22233715, 32232841, 26716521, 03511221, 29196547, 58263562, 56233305, 
                    52547525, 55812835, 87253244, 52484232, 80837360, 94098464, 52028151, 
                    53267501, 66381929, 84381316, 59788467, 9683688, 67082008, 71605255, 
                    80654064, 21434307, 45286643, 76556656, 82465821, 57367208, 79218980, 
                    48460468, 59170479, 46046391, 43043164, 96544490, 83340521, 70837892, 
                    18926791, 40818286, 28936302, 11489524, 51031183, 73860337, 13241219, 
                    9025448, 10718828, 76360986, 26031606, 76558053, 97726139, 46473415, 
                    48406387, 23625539, 86756012, 35164187, 49161302, 78082834, 35072237, 
                    8602486, 29815841, 56562216, 77684187, 81751704, 20160464, 50407962, 
                    27786415, 19893526, 934129, 37759498, 52636463, 25666982, 43262852, 
                    38393436, 2581136, 29323250, 56950657, 5898131, 95286262, 75574581, 
                    54057961, 6703896, 90758589, 57782642, 34492535, 41919697, 6395464, 
                    10993500, 81212949, 34017532, 69569396, 99009936, 57129610, 67401593, 
                    71044018, 62076698, 29533873, 71936325, 86874388, 26545032, 35695544, 
                    30433724, 53127345, 72887083, 25390873, 63711546, 6923746, 27783723, 
                    33199575, 35929698, 16491251, 18276792, 62744775, 92096155, 06336570, 
                    56141974, 73007273, 31416832, 00171057, 64176982, 46938647, 58460388, 
                    69972026, 73724304, 27435484, 51568616, 15531822, 47788699, 11818851, 
                    41594694, 83561325, 43107163, 56965375, 10557343, 26118061, 74650126, 
                    90076467, 10657376, 49901436, 03425162, 61164599, 15797769, 5427896, 
                    14444084, 36795868, 18079449, 59653393, 72942548, 06763077, 33895610, 
                    94892653, 12085268, 65174140, 79567366, 23020126, 74290047, 13498869, 
                    21696323, 27724594, 54941003, 38229841, 7050068
            };
            int c[]={ 
                    13404901, 39952424, 47847739, 94939581, 13809950, 70966043, 11161555, 
                    17102313, 47079425, 50682833, 74154313, 61562613, 93200452, 37103342, 
                    18479435, 32502597, 36198035, 54210010, 73191775, 48358178, 85544503, 
                    5996766, 54651623, 52113220, 27465181, 23871783, 22496415, 54107041, 
                    65899605, 56528700, 82671109, 61176034, 42374678, 51612628, 63329997, 
                    56591652, 04552733, 12789324, 89586343, 51935014, 38611966, 43916409, 
                    70996050, 98263070, 1418023, 65345049, 21734275, 76846198, 71506230, 
                    833171, 67128139, 41367555, 64769510, 44010700, 16475199, 93164325, 
                    9386162, 95324041, 80688223, 67629139, 79552617, 76219736, 50368644, 
                    45096021, 54972488, 63779011, 28862942, 73145521, 74078605, 66924991, 
                    12806850, 02171001, 70896866, 73434467, 8487641, 44415025, 32500082, 
                    84412833, 83896188, 52243759, 49191410, 38744339, 48079796, 44937032, 
                    06267501, 81866886, 38575984, 25978688, 78974338, 41247821, 12356966, 
                    64842303, 79127158, 2366944, 68000570, 12426275, 96409230, 705972, 
                    8266503, 83820884, 8831807, 43273308, 23216105, 29196547, 95160161, 
                    05553537, 52182214, 32641346, 91553427, 24436506, 77433749, 1979664, 
                    52028151, 88985343, 1761499, 76203088, 63237368, 23405334, 59788467, 
                    9683688, 67755443, 29946533, 12053603, 437479, 15200030, 45286643, 
                    93537527, 82465821, 57367208, 53899751, 15354933, 97760830, 68933762, 
                    80220545, 1892750, 39868288, 21524323, 69716610, 65083815, 78048499, 
                    3227391, 83340521, 87365045, 71720254, 51031183, 89168555, 8503028, 
                    37086236, 25103057, 87002524, 22808816, 80928090, 90741678, 15993372, 
                    99117082, 49938176, 21755083, 86903426, 87830263, 53959980, 75758119, 
                    59781354, 58679691, 25666982, 56307643, 47180521, 62776522, 78136608, 
                    44882734, 90758589, 8075999, 66303819, 23480347, 11580163, 87080118, 
                    18329165, 92514163, 89404632, 92377859, 3912329, 17499963, 59699979, 
                    79876366, 63894807, 37857001, 86003935, 90087123, 29433345, 80298948, 
                    61531153, 61046319, 37839841, 19421134, 48747364, 35196916, 62484573, 
                    59907079, 36845702, 21631642, 72739317, 26283700, 80114017, 76639390, 
                    29154110, 35159758, 47788699, 11818851, 56520669, 36396767, 36031167, 
                    83817428, 10657376, 90076467, 14676452, 11024560, 16327605, 76048344, 
                    14444084, 95452011, 99612346, 65172562, 84813675, 88618282, 38704390, 
                    27998014, 63859011, 33787505, 60024611, 16229880, 13899299, 35240335, 
                    29173227, 45036451, 66177893, 82658333, 43100730, 44520187, 74290047, 
                    85013538, 9926730, 27724594, 95148523, 20503000, 64390907, 26006953, 
                    98116293, 97457666, 29017396, 04634371, 70791589
            };
            ArrayList<Integer> A=new ArrayList<Integer>();
            ArrayList<Integer> B=new ArrayList<Integer>();
            ArrayList<Integer> C=new ArrayList<Integer>();
            for(int x:a)A.add(x);
            for(int x:b)B.add(x);
            for(int x:c)C.add(x);
            int ans=0;
            for(int x:A){ 
                if(B.contains(x)&&!C.contains(x))ans++;
            }
            System.out.println(ans);
        }
    }

### C：纸牌三角形（难度：★★★） ###

#### 题目： ####

A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。  
下图就是一种排法。  
![在这里插入图片描述][20210402022323790.png]

这样的排法可能会有很多。

如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？

请你计算并提交该数字。

注意：需要提交的是一个整数，不要提交任何多余内容。

--------------------

笨笨有话说：  
感觉可以暴力破解哦。  
麻烦的是，对每个排法还要算出它的旋转、镜像排法，看看有没有和历史重复。

歪歪有话说：  
人家又不让你把所有情况都打印出来，只是要算种类数。  
对于每个基本局面，通过旋转、镜像能造出来的新局面数目不是固定的吗？

#### 分析： ####

全排列9个元素，对每种情况进行check，  
统计总数量，再除以6（旋转+镜像）即为结果  
答案=144

#### 代码： ####

public class C纸牌三角形{ 
    
        public static int arr[]={ 1,2,3,4,5,6,7,8,9};
        public static int count=0;
        public static void check(){ 
            if(arr[0]+arr[1]+arr[2]+arr[3]==arr[3]+arr[4]+arr[5]+arr[6]&&arr[3]+arr[4]+arr[5]+arr[6]==arr[6]+arr[7]+arr[8]+arr[0]){ 
                count++;
            }
        }
        public static void qpl(int k){ 
            if(k>=arr.length){ 
                check();
            }else
                for(int i=k;i<arr.length;i++){ 
                    int t=arr[i];arr[i]=arr[k];arr[k]=t;
                    qpl(k+1);
                    t=arr[i];arr[i]=arr[k];arr[k]=t;
                }
        }
        public static void main(String[] args) { 
            qpl(0);
            System.out.println(count/6);
        }
    }

### D：承压计算（难度：★★） ###

#### 题目： ####

X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。  
金属材料被严格地堆放成金字塔形。

7 
                                5 8 
                               7 8 8 
                              9 2 7 2 
                             8 1 4 9 1 
                            8 1 8 8 4 1 
                           7 9 6 1 4 5 4 
                          5 6 5 5 6 9 5 6 
                         5 5 4 7 9 3 5 5 1 
                        7 5 7 9 7 4 7 3 3 1 
                       4 6 4 5 5 8 8 3 2 4 3 
                      1 1 3 3 1 6 6 5 5 4 4 2 
                     9 9 9 2 1 9 1 9 2 9 5 7 9 
                    4 3 3 7 7 9 3 6 1 3 8 8 3 7 
                   3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
                  8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
                 8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
                2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 
               7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 
              9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 
             5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 
            6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 
           2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 
          7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 
         1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 
        2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 
       7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 
      7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 
     5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 
    X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X

其中的数字代表金属块的重量（计量单位较大）。  
最下一层的X代表30台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，  
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。  
电子秤的计量单位很小，所以显示的数字很大。

工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？

注意：需要提交的是一个整数，不要填写任何多余的内容。

--------------------

笨笨有话说：  
不断的除2，加到下面，除2,加到下面,… 不会浮点精度溢出吧？  
歪歪有话说：  
怕除不开还不好办， 把每个数字扩大一定的倍数不就好了。

#### 分析： ####

为了防止在不断二分的过程中出现精度损失，  
所以对每个元素乘以2的29次方。  
比较最小的数与2086458231的倍数关系。  
将最大的数除以倍数即可得解。  
答案=72665192664

#### 代码： ####

import java.util.Arrays;
    import java.util.Scanner;
    
    public class D承压计算 { 
    	public static void main(String[] args) { 
    		Scanner sc=new Scanner(System.in);
    		long arr[][]=new long [30][30];
    		for(int i=0;i<29;i++){ 
    			for(int j=0;j<=i;j++){ 
    				arr[i][j]=sc.nextLong();
    			}
    		}
    		for(int i=0;i<30;i++){ 
    			for(int j=0;j<30;j++){ 
    				arr[i][j]*=Math.pow(2,29);
    			}
    		}
    		for(int i=1;i<=29;i++){ 
    			for(int j=0;j<=i;j++){ 
    				arr[i][j]+=(j-1<0?0:arr[i-1][j-1]/2)+arr[i-1][j]/2;
    			}
    		}
    		Arrays.sort(arr[29]);
    		long t=2086458231/arr[29][0];
    		System.out.println(arr[29][29]*t);
    	}
    }

### E：杨辉三角（难度：★★） ###

#### 题目： ####

标题： 杨辉三角

杨辉三角也叫帕斯卡三角，在很多数量关系中可以看到，十分重要。

第0行： 1  
第1行： 1 1  
第2行： 1 2 1  
第3行： 1 3 3 1  
第4行： 1 4 6 4 1  
…

两边的元素都是1， 中间的元素是左上角的元素与右上角的元素和。

我们约定，行号，列号都从0计数。  
所以： 第6行的第2个元素是15，第3个元素是20

直观地看，需要开辟一个二维数组，其实一维数组也可以胜任。  
如下程序就是用一维数组“腾挪”的解法。

public class A
    { 
    	// 杨辉三角形的第row行第col列
    	static long f(int row, int col){ 
    		if(row<2) return 1;
    		if(col==0) return 1;
    		if(col==row) return 1;
    		
    		long[] a = new long[row+1];
    		a[0]=1;
    		a[1]=1;
    		
    		int p = 2;
    		
    		while(p<=row){ 
    			a[p] = 1;
    			for( __________________ ) a[q] = a[q] + a[q-1];
    			p++;
    		}
    		
    		return a[col];
    	}
    	
    	public static void main(String[] args){ 
    		System.out.println(f(6,2));
    		System.out.println(f(6,3));		
    	}
    }

请仔细分析源码，并完成划线部分缺少的代码。  
注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

#### 分析： ####

观察代码可以发现，P指针表示当前所在的层数，Q指针还没有定义，那么我们就可以知道，循环内的变量一定是Q

我们通过循环体内的表达式又发现，在一次次迭代中，只有从后向前迭代，才可以保持正常的更替

所以  
答案=int q=p-1;q>=1;q–

#### 代码： ####

public class E杨辉三角
    { 
    	// 杨辉三角形的第row行第col列
    	static long f(int row, int col){ 
    		if(row<2) return 1;
    		if(col==0) return 1;
    		if(col==row) return 1;
    		
    		long[] a = new long[row+1];
    		a[0]=1;
    		a[1]=1;
    		
    		int p = 2;
    		
    		while(p<=row){ 
    			a[p] = 1;
    			for(int q=p-1;q>=1;q--) 
    				a[q] = a[q] + a[q-1];
    			p++;
    		}
    		
    		return a[col];
    	}
    	
    	public static void main(String[] args){ 
    		System.out.println(f(6,2));
    		System.out.println(f(6,3));		
    	}
    }

### F：最大公共子串（难度：★★★★） ###

#### 题目： ####

最大公共子串就是求两个串的所有子串中能够匹配上的最大长度是多少。

比如：“abcdkkk” 和 “baabcdadabc”，  
可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。

下面的程序是采用矩阵法进行求解的，这对串的规模不大的情况还是比较有效的解法。

请分析该解法的思路，并补全划线部分缺失的代码。

public class A
    { 
    	static int f(String s1, String s2)
    	{ 
    		char[] c1 = s1.toCharArray();
    		char[] c2 = s2.toCharArray();
    		
    		int[][] a = new int[c1.length+1][c2.length+1];
    		
    		int max = 0;
    		for(int i=1; i<a.length; i++){ 
    			for(int j=1; j<a[i].length; j++){ 
    				if(c1[i-1]==c2[j-1]) { 
    					a[i][j] = _______________________ ; //填空 
    					if(a[i][j] > max) max = a[i][j];
    				}
    			}
    		}
    		
    		return max;
    	}
    	
    	public static void main(String[] args){ 
    		int n = f("abcdkkk", "baabcdadabc");
    		System.out.println(n);
    	}
    }

注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。

#### 分析： ####

我们发现这是一个关于最长公共子序列的DP问题，  
需要填空的的恰是需要更新的一部分。  
当两字符相等，最大长度+1  
答案=a\[i-1\]\[j-1\]+1

#### 代码： ####

public class F最大公共子串 { 
    	static int f(String s1, String s2) { 
    		char[] c1 = s1.toCharArray();
    		char[] c2 = s2.toCharArray();
    
    		int[][] a = new int[c1.length + 1][c2.length + 1];
    
    		int max = 0;
    		for (int i = 1; i < a.length; i++) { 
    			for (int j = 1; j < a[i].length; j++) { 
    				if (c1[i - 1] == c2[j - 1]) { 
    					a[i][j] = a[i - 1][j - 1] + 1;//填空
    					if (a[i][j] > max)
    						max = a[i][j];
    				}
    			}
    		}
    
    		return max;
    	}
    
    	public static void main(String[] args) { 
    		int n = f("abcdkkk", "baabcdadabc");
    		System.out.println(n);
    	}
    }

### G：Excell地址（难度：★★★） ###

#### 题目： ####

Excel单元格的地址表示很有趣，它使用字母来表示列号。  
比如，  
A表示第1列，  
B表示第2列，  
Z表示第26列，  
AA表示第27列，  
AB表示第28列，  
BA表示第53列，  
…

当然Excel的最大列号是有限度的，所以转换起来不难。  
如果我们想把这种表示法一般化，可以把很大的数字转换为很长的字母序列呢？

本题目既是要求对输入的数字, 输出其对应的Excel地址表示方式。

例如，  
输入：  
26  
则程序应该输出：  
Z

再例如，  
输入：  
2054  
则程序应该输出：  
BZZ

我们约定，输入的整数范围\[1,2147483647\]

--------------------

笨笨有话说：  
这有点像进制关系，又不完全是。好像末2位是以1当26，末3位是以1当26\*26

歪歪有话说：  
要是从字母序列转数字还好点，倒过来有点麻烦，不过计算机跑得快啊。

#### 分析： ####

![在这里插入图片描述][20210402082724455.png]

解法1  
模拟进制关系的题目，我们可以稍微改一下进制转换的方式，在用字符串处理一下逆序即可，

解法2  
也可以用不同位置代表不同的权值来进行计算。

#### 代码： ####

解法1

import java.util.Scanner;
    public class GExcel地址 { 
    	public static void main(String[] args) { 
    		Scanner sc=new Scanner(System.in);
    		long n=sc.nextLong();
    		StringBuilder ans=new StringBuilder("");
    		while(n>0){ 
    			ans.append((char)('A'+(n-1)%26));
    			n--;
    			n/=26;
    		}
    		System.out.println(ans.reverse());
    	}
    }

解法2

import java.io.FileWriter;
    import java.io.IOException;
    import java.math.*;
    import java.util.*;
     
    public class Main { 
        public static long bit[]={ 0,26,26*26,26*26*26,26*26*26*26,26*26*26*26*26,26*26*26*26*26*26,26*26*26*26*26*26*26};
        public static void main(String[] args) throws IOException { 
            Scanner sc=new Scanner(System.in);
            while(sc.hasNext()){ 
                long n=sc.nextLong();
                StringBuilder  sb=new StringBuilder();
                while(n!=0){ 
                    if(n%26==0){ 
                        n-=26;
                        sb.append("Z");
                    }else{ 
                        sb.append((char)('A'+(n%26-1)));
                    }
                    n/=26;
                }
                System.out.println(sb.reverse());
            }
        }
    }

### H：拉马车（难度：★★★★） ###

#### 题目： ####

小的时候，你玩过纸牌游戏吗？  
有一种叫做“拉马车”的游戏，规则很简单，却很吸引小朋友。

其规则简述如下：  
假设参加游戏的小朋友是A和B，游戏开始的时候，他们得到的随机的纸牌序列如下：  
A方：\[K, 8, X, K, A, 2, A, 9, 5, A\]  
B方：\[2, 7, K, 5, J, 5, Q, 6, K, 4\]

其中的X表示“10”，我们忽略了纸牌的花色。

从A方开始，A、B双方轮流出牌。

当轮到某一方出牌时，他从自己的纸牌队列的头部拿走一张，放到桌上，并且压在最上面一张纸牌上（如果有的话）。

此例中，游戏过程：  
A出K，B出2，A出8，B出7，A出X，此时桌上的序列为：

K,2,8,7,X

当轮到B出牌时，他的牌K与桌上的纸牌序列中的K相同，则把包括K在内的以及两个K之间的纸牌都赢回来，放入自己牌的队尾。注意：为了操作方便，放入牌的顺序是与桌上的顺序相反的。  
此时，A、B双方的手里牌为：  
A方：\[K, A, 2, A, 9, 5, A\]  
B方：\[5, J, 5, Q, 6, K, 4, K, X, 7, 8, 2, K\]

赢牌的一方继续出牌。也就是B接着出5，A出K，B出J，A出A，B出5，又赢牌了。  
5,K,J,A,5  
此时双方手里牌：  
A方：\[2, A, 9, 5, A\]  
B方：\[Q, 6, K, 4, K, X, 7, 8, 2, K, 5, A, J, K, 5\]

注意：更多的时候赢牌的一方并不能把桌上的牌都赢走，而是拿走相同牌点及其中间的部分。但无论如何，都是赢牌的一方继续出牌，有的时候刚一出牌又赢了，也是允许的。
    
    当某一方出掉手里最后一张牌，但无法从桌面上赢取牌时，游戏立即结束。
    
    对于本例的初始手牌情况下，最后A会输掉，而B最后的手里牌为：

9K2A62KAX58K57KJ5

本题的任务就是已知双方初始牌序，计算游戏结束时，赢的一方手里的牌序。当游戏无法结束时，输出-1。

输入为2行，2个串，分别表示A、B双方初始手里的牌序列。  
输出为1行，1个串，表示A先出牌，最后赢的一方手里的牌序。

例如，  
输入：  
96J5A898QA  
6278A7Q973

则程序应该输出：  
2J9A7QA6Q6889977

再比如，  
输入：  
25663K6X7448  
J88A5KJXX45A

则程序应该输出：  
6KAJ458KXAX885XJ645

我们约定，输入的串的长度不超过30

--------------------

笨笨有话说：  
不断删除前边的，又要后边添加… 如果用数组，需要开一个大点的，请佛祖保佑在游戏结束前，不会用到数组的边缘。

歪歪有话说：  
反正串也不长，不如每次操作都返回一个新的串。

默默有话说：  
我一般都不吱声，这是典型的队列结构，动态数组最好，没有？自己造一个呗！

#### 分析： ####

![在这里插入图片描述][20210402083101520.png]

字符串处理问题，通过三个字符串模拟牌序运算过程即可。  
模拟题。

也可以通过容器装字符来实现。

#### 代码： ####

import java.util.Scanner;
    
    public class H拉马车 { 
    	public static void main(String[] args) { 
    		Scanner sc=new Scanner(System.in);
    		while(sc.hasNext()){ 
    			int op=0;
    			String A=sc.next();
    			String B=sc.next();
    			String s="";
    			while(A.length()!=0&&B.length()!=0){ 
    				if(op==0){ 
    					if(s.indexOf(""+A.charAt(0))>=0){ 
    						A+=A.charAt(0)+new StringBuilder(s.substring(s.indexOf(""+A.charAt(0)))).reverse().toString();
    						s=s.substring(0,s.indexOf(""+A.charAt(0)));
    						A=A.substring(1);
    						op=1-op;
    					}else{ 
    						s+=A.charAt(0);
    						A=A.substring(1);
    					}
    				}else{ 
    					if(s.indexOf(""+B.charAt(0))>=0){ 
    						B+=B.charAt(0)+new StringBuilder(s.substring(s.indexOf(""+B.charAt(0)))).reverse().toString();
    						s=s.substring(0,s.indexOf(""+B.charAt(0)));
    						B=B.substring(1);
    						op=1-op;
    					}else{ 
    						s+=B.charAt(0);
    						B=B.substring(1);
    					}
    				}
    				op=1-op;
    			}
    			if(A.length()==0||B.length()==0){ 
    				System.out.println(A.length()>B.length()?A:B);
    			}else{ 
    				System.out.println(-1);
    			}
    		}
    	}
    }

### I：青蛙跳杯子（难度：★★★★★） ###

#### 题目： ####

X星球的流行宠物是青蛙，一般有两种颜色：白色和黑色。  
X星球的居民喜欢把它们放在一排茶杯里，这样可以观察它们跳来跳去。  
如下图，有一排杯子，左边的一个是空着的，右边的杯子，每个里边有一只青蛙。

\*WWWBBB

其中，W字母表示白色青蛙，B表示黑色青蛙，*表示空杯子。
    
    X星的青蛙很有些癖好，它们只做3个动作之一：
    1. 跳到相邻的空杯子里。
    2. 隔着1只其它的青蛙（随便什么颜色）跳到空杯子里。
    3. 隔着2只其它的青蛙（随便什么颜色）跳到空杯子里。
    
    对于上图的局面，只要1步，就可跳成下图局面：

WWW\*BBB

本题的任务就是已知初始局面，询问至少需要几步，才能跳成另一个目标局面。

输入为2行，2个串，表示初始局面和目标局面。  
输出要求为一个整数，表示至少需要多少步的青蛙跳。

例如：  
输入：  
*WWBB  
WWBB*

则程序应该输出：  
2

再例如，  
输入：  
WWW*BBB  
BBB*WWW

则程序应该输出：  
10

我们约定，输入的串的长度不超过15

--------------------

笨笨有话说：  
我梦见自己是一棵大树，  
青蛙跳跃，  
我就发出新的枝条，  
春风拂动那第 5 层的新枝,  
哦，我已是枝繁叶茂。

#### 分析： ####

![在这里插入图片描述][20210402083514659.png]

这是一个典型的BFS问题，我们可以把初始状态不断向其他状态进行转换，直到遇到目标状态为止。

#### 代码： ####

import java.util.HashSet;
    import java.util.LinkedList;
    import java.util.Scanner;
    
    public class I青蛙跳杯子 { 
    	public static HashSet<String> set=new HashSet<String>();
    	public static LinkedList<String> arr=new  LinkedList<String>();
    	public static void find(String s){ 
    		char c[]=s.toCharArray();
    		for(int i=0;i<s.length();i++){ 
    			for(int j=-3;j<4;j++){ 
    				if(j==0)continue;
    				if(i+j>=0&&i+j<s.length()&&c[i+j]=='*'){ 
    					boolean deep=true;
    					int begin=Math.min(i+j, i);
    					int end=Math.max(i+j, i);
    					for(int k=begin+1;k<end;k++){ 
    						if(c[k]=='*')deep=false;
    					}
    					if(deep){ 
    						c[i+j]=c[i];
    						c[i]='*';
    						String ss="";
    						for(int x=0;x<c.length;x++){ 
    							ss=ss+c[x];
    						}
    						if(!set.contains(ss)){ 
    							set.add(ss);
    							arr.add(ss);
    						}
    						c[i]=c[i+j];
    						c[i+j]='*';
    					}
    				}
    			}
    		}
    	}
    	public static void main(String[] args) { 
    		Scanner sc=new Scanner(System.in);
    		String from=sc.next(),to=sc.next();
    		set.add(from);
    		arr.add(from);
    		int count=0;
    		while(!set.contains(to)){ 
    			int len=arr.size();
    			for(int i=0;i<len;i++){ 
    				find(arr.get(0));
    				arr.remove(0);
    			}
    			count++;
    		}
    		System.out.println(count);
    	}
    }

### J：图形排版（难度：★★★★★） ###

#### 题目： ####

小明需要在一篇文档中加入 N 张图片，其中第 i 张图片的宽度是 Wi，高度是 Hi。  
假设纸张的宽度是 M，小明使用的文档编辑工具会用以下方式对图片进行自动排版：

1. 该工具会按照图片顺序，在宽度 M 以内，将尽可能多的图片排在一行。该行的高度是行内最高的图片的高度。例如在 M=10 的纸张上依次打印 3x4, 2x2, 3x3 三张图片，则效果如下图所示，这一行高度为4。(分割线以上为列标尺，分割线以下为排版区域；数字组成的矩形为第x张图片占用的版面)

![20210402083647849.png][]

2. 如果当前行剩余宽度大于0，并且小于下一张图片，则下一张图片会按比例缩放到宽度为当前行剩余宽度(高度向上取整)，然后放入当前行。例如再放入一张4x9的图片，由于剩余宽度是2，这张图片会被压缩到2x5，再被放入第一行的末尾。此时该行高度为5：

![在这里插入图片描述][20210402083743690.png]

3. 如果当前行剩余宽度为0，该工具会从下一行开始继续对剩余的图片进行排版，直到所有图片都处理完毕。此时所有行的总高度和就是这 N 张图片的排版高度。例如再放入11x1, 5x5, 3x4 的图片后，效果如下图所示，总高度为11：

![在这里插入图片描述][20210402083808401.png]

现在由于排版高度过高，图片的先后顺序也不能改变，小明只好从 N 张图片中选择一张删除掉以降低总高度。他希望剩余N-1张图片按原顺序的排版高度最低，你能求出最低高度是多少么？

输入：  
第一行包含两个整数 M 和 N，分别表示纸张宽度和图片的数量。  
接下来 N 行，每行2个整数Wi, Hi，表示第 i 个图大小为 Wi\*Hi。

对于30%的数据，满足1<=N<=1000  
对于100%的数据，满足1<=N<=100000，1<=M, Wi, Hi<=100

输出：  
一个整数，表示在删除掉某一张图片之后，排版高度最少能是多少。

样例输入：  
4 3  
2 2  
2 3  
2 2

样例输出：  
2

另一个示例，  
样例输入：  
2 10  
4 4  
4 3  
1 3  
4 5  
2 1  
2 3  
5 4  
5 3  
1 5  
2 4

样例输出：  
17

#### 分析： ####

#### 代码： ####

### 算法交流群 ###

![在这里插入图片描述][20210402083841665.png]

[Link 1]: https://blog.csdn.net/qq_43652327/article/details/104899994
[20210402022323790.png]: /images/20221022/720f28bc2c5c48bf9313de3383a06ef5.png
[20210402082724455.png]: https://img-blog.csdnimg.cn/20210402082724455.png
[20210402083101520.png]: https://img-blog.csdnimg.cn/20210402083101520.png
[20210402083514659.png]: https://img-blog.csdnimg.cn/20210402083514659.png
[20210402083647849.png]: https://img-blog.csdnimg.cn/20210402083647849.png
[20210402083743690.png]: https://img-blog.csdnimg.cn/20210402083743690.png
[20210402083808401.png]: https://img-blog.csdnimg.cn/20210402083808401.png
[20210402083841665.png]: https://img-blog.csdnimg.cn/20210402083841665.png