算法常见的考点和刷题记录
约分法: 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与该数本身两个正因数的数)
比较容易写出的代码是:
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;
}
给定一个长度为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);
}
}
最短路问题:我只会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]) ;
}
}
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角填数
题目:
上图给出了七段码数码管的一个图示,数码管中一共有 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;
}
}
仔细寻找,会发现:在下面的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
观察下面的加法算式:
祥 瑞 生 辉
三 羊 生 瑞 气
其中,相同的汉字代表相同的数字,不同的汉字代表不同的数字。请你填写“三羊献瑞”所代表的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
解题思路:
先来理解题意:
我们不需要知道拿走石头的重量,只需要找到连续的偶数个石头个数最多有多少个
第一时间可能会想到用滑动窗口寻找连续值,但这样做的时间代价太大了,再想想有什么可以优化的。