刷题总计题解

最新推荐文章于 2024-06-21 17:14:10 发布

吟咏十

最新推荐文章于 2024-06-21 17:14:10 发布

阅读量1.5k

点赞数 28

分类专栏： Leetcode小白刷题文章标签：算法数据结构

本文链接：https://blog.csdn.net/qq_36012085/article/details/134411293

版权

Leetcode小白刷题专栏收录该内容

12 篇文章 0 订阅

订阅专栏

蓝桥杯题：包子凑数

题目描述
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有 N 种蒸笼，其中第 i 种蒸笼恰好能放 Ai 个包子。每种蒸笼都有非常多笼，可以认为是无限笼。每当有顾客想买 X 个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有 X个包子。比如一共有 3 种蒸笼，分别能放 3、4 和 5 个包子。当顾客想买 11 个包子时，大叔就会选 2 笼 3 个的再加 1 笼 5 个的（也可能选出 1 笼 3 个的再加 2 笼 4 个的）。当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有 3 种蒸笼，分别能放 4、5 和 6 个包子。而顾客想买 7 个包子时，大叔就凑不出来了。小明想知道一共有多少种数目是包子大叔凑不出来的。

输入描述
第一行包含一个整数 N(1≤N≤100)。
以下 N 行每行包含一个整数 Ai(1≤Ai≤100)。

输出描述
一个整数代表答案。如果凑不出的数目有无限多个，输出 INF。

解决代码

import os
import sys
# 请在此输入您的代码
n = eval(input())
f = [False]*10000
a = []
ans=0
def gcd(a,b):####公约数函数求#####
  if b==0:
    return a
  else:
    return gcd(b,a%b)
def bag(n,f,a,ans):
  for i in range(n):
      a.append(eval(input()))
      if i==0:
        g=a[i] ###初始公约数####
      else:
        g=gcd(g,a[i])
      f[0]=True
      for j in range(10000-a[i]):#####背包问题######
        if f[j]:
          f[j+a[i]]=True
  if g!=1:
        print('INF')
        return
  for i in range(10000):
      if not f[i]:
        ans+=1
  print(ans)
  return
bag(n,f,a,ans)

拓展题目：买不到的数目（dp背包基础版）

来源：第四届蓝桥杯省赛C++A组,第四届蓝桥杯省赛JAVAC组

小明开了一家糖果店。

他别出心裁：把水果糖包成4颗一包和7颗一包的两种。

糖果不能拆包卖。

小朋友来买糖的时候，他就用这两种包装来组合。

当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。

你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。

大于17的任何数字都可以用4和7组合出来。

本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。

输入格式

两个正整数 n,m，表示每种包装中糖的颗数。

输出格式

一个正整数，表示最大不能买到的糖数。

数据范围

2≤n,m≤1000，
保证数据一定有解。

输入样例：

4 7

输出样例：

以下是我的解法三个方法便于大家提高拓展延申：

暴力解：

###暴力解####
n  , m = list(map(int,input().split()))
def dfs(m,p,q):
    if m == 0:
        return True
    if m>=p and dfs(m-p,p,q): #####细节处理#####
        return True
    if m>=q and dfs(m-q,p,q):
        return True
    return False
ans = 0
for i in range(1,1000):
    if not dfs(i,n,m):
        ans = i
print(ans)

数学解：

如果知道这项公式就很简单做出来否则很吃亏

两数之间凑不出来的最大数：(n-1)*(m-1)-1

n  , m = list(map(int,input().split()))
print((n-1)*(m-1)-1)

dp解：

n  , m = list(map(int,input().split()))
dp = [False]*1000000

dp[0] =- True
for i in range(1000000-n):
    if dp[i]:
        dp[i+n] = True
for i in range(1000000-m):
    if dp[i]:
        dp[i+m] = True
print(1000000-dp[::-1].index(False)-1)

因为两个数据量在1000以内为防止数据超出所以保险起见限制在两数之乘

字母阵列

题目描述
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。
仔细寻找，会发现：在下面的 8×8 的方阵中，隐藏着字母序列：LANQIAO。

SLANQIAO
ZOEXCCGB
MOAYWKHI
BCCIPLJQ
SLANQIAO
RSFWFNYA
XIFZVWAL
COAIQNAL

我们约定: 序列可以水平，垂直，或者是斜向；
并且走向不限（实际上就是有一共 888 种方向）。
上图中一共有 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

我的解决方案：

import os
import sys
# 请在此输入您的代码
data=''' ''' ###验证集数据
data=data.split()
count=0
def backtracking(x,y,s,i,n): ####定义递归函数
  global  count ###定义全局变量
  if  x<len(data) and y<len(data[0]) and x>=0 and y>=0 and data[x][y]==s[n] :
    if n==6:
      count+=1
      return 
    backtracking(x+dx[i],y+dy[i],s,i,n+1) ###递归
  else:
    return
dx=[1,1,0,-1,-1,-1,0,1] ####八个方向大大简化代码
dy=[0,1,1,1,0,-1,-1,-1]
s = 'LANQIAO'
for x in range(len(data)):
  for y in range(len(data[0])):
    for i in range(8):
      backtracking(x,y,s,i,0)

此外如果此题不一直按一个方向走，我觉得就是另一种模式，需用回溯算法

此题有个细节要注意：

if x<len(data) and y<len(data[0]) and x>=0 and y>=0 and data[x][y]==s[n] :

这里必须顺序为先判断临界范围，再判断符合条件，如果相反，则就会超出区域范围会报错

此题答案ans为：

print(41)

省赛2022 分糖果（dfs解法）

问题描述
两种糖果分别有 9 个和 16 个，要全部分给 7个小朋友，每个小朋友得到的糖果总数最少为 2个最多为 5 个，问有多少种不同的分法。糖果必须全部分完。
只要有其中一个小朋友在两种方案中分到的糖果不完全相同，这两种方案就算作不同的方案。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
运行限制

最大运行时间：1s
最大运行内存: 256M
解决代码

import os
import sys

# 请在此输入您的代码
ans=0
def dfs(depth,n,m):
  if depth==7 and : ###终止条件####
    if n==0 and m==0: 
      global ans ###设置全局变量或者设置列表，否则所设变量过了一个函数值不会变化##
      ans+=1
    return
  for i in range(6): ###点睛之笔，剪枝###
    for j in range(6):
      if 2<=i+j<=5  and i<=n and j<=m: ####限制判断条件###
        dfs(depth+1,n-i,m-j) 
dfs(0,9,16)
print(ans)

答案：

print(5067671)

小蓝的漆房

问题描述
小蓝是一位有名的漆匠，他的朋友小桥有一个漆房，里面有一条长长的走廊，走廊两旁有许多相邻的房子，每间房子最初被涂上了一种颜色。
小桥来找小蓝，想让他把整个走廊都涂成同一个颜色。小蓝告诉小桥，他每天只能涂一段长度为 k 的区间。对于每个区间，他可以选择将其中的房子重新涂上任何一种颜色，或者保持原来的颜色不变。
小桥想知道小蓝至少要涂几天，才能让整个走廊变得美丽。
请帮助小桥解决这个问题。
输入格式
第一行包含一个整数 t（1≤t≤100），表示测试用例的数量。
每个测试用例的第一行包含两个整数 n 和 k（1≤k≤n≤10^4），第二行包含 n 个整数 a1,a2,⋯,an（1≤ai≤60），分别表示每个房子最初的颜色。
保证所有测试用例中 nnn 的总和不超过 10^4。
输出格式
对于每个测试用例，输出一个整数，表示小蓝需要涂漆的最少天数。
样例输入

2
5 2
1 1 2 2 1
6 2
1 2 2 3 3 3

样例输出

1
2

答案提交:

枚举法

import os
import sys

# 请在此输入您的代码
t = int(input())
a = 0
for i in range(t):
  max_value = float('inf')
  ans = 0
  n , k = map(int,input().split())
  lis = list(map(int,input().split()))
  for j in range(1,61):
    a,ans = 0,0
    while a<len(lis):
      if lis[a] != j:
        ans+=1
        a+=k-1
      a+=1

    max_value = min(ans,max_value)
  print(max_value)

这里注意一个细节那就是while与for循环的区别

举例说明

for i in range(length):

####

代码

####

i+=1

从正常人逻辑思维来说i不可能循环遍历

但结果不是这样，i不会因为循环的i值改变而改变

这时只能用while来实现

松散子序列（源自2023省赛dp）

问题描述
给定一个仅含小写字母的字符串 s，假设 s 的一个子序列 t 的第 i 个字符对应了原字符串中的第 pi 个字符。我们定义 s 的一个松散子序列为：对于 i>1 总是有 pi−pi−1≥2。设一个子序列的价值为其包含的每个字符的价值之和 (a∼z 分别为 1∼26)。
求 s 的松散子序列中的最大价值。
输入格式
输入一行包含一个字符串 s。
输出格式
输出一行包含一个整数表示答案。

样例输入

azaazaz

样例输出

解题

import os
import sys

# 请在此输入您的代码
s = input()
nums = []
if len(s)==0:
  print(0)
if len(s)==1:
  print(ord(s[0])-ord('a')+1)
else:
  for i in s:
    nums.append(ord(i)-ord('a')+1) ####将字母转化成数值，间接转化为最大偷取值####
  dp = [0]*(len(s))
  dp[0] = nums[0]
  dp[1] = max(nums[0],nums[1])
  for i in range(2,len(nums)):
    dp[i] = max(dp[i-2]+nums[i],dp[i-1])
  print(dp[-1])

个人感觉想清楚偷与不偷两种状态，一维dp较二维dp简单

串变化(dfs深搜排列)

问题描述
有两个长度为 n 的数字字符串 S,T ，下标从 0 开始。
一共有 k个操作，操作只可能是以下两种类型：

*1 x v 表示将 Sx 变为 (Sx+v) mod 10；
*2 x y 表示交换 Sx，Sy。

你可以挑选出任意个操作，以任意顺序执行，但是每个操作最多只能执行一次，如果可以将 S 串变为 T串则输出 Yes，反之输出 No。
输入格式
第一行输入一个正整数 n，表示字符串 S 和 T 的长度。
第二行输入一个长度为 n 只由数字构成的字符串 S。
第三行输入一个长度为 n只由数字构成的字符串 T。
第四行输入一个正整数 k，表示操作的数量。
接下来 k行，每行三个整数，其中第 i 行表示第 i 种操作的三个参数 opi , xi , yi 。
输出格式
一行一个字符串：

*如果可以通过操作使得 S 串与 T 串相等，则输出 Yes。
*反之输出 No。

样例输入：

样例输出：

Yes

解：

# 请在此输入您的代码
n = int(input())
s = input()
t = input()
k = int(input())
path = []
result = [False]*k
visited = []
res = False
def check():
  global s,res
  str = list(s)
  for i in visited:
    if path[i][0] == 1:
      pos,val = path[i][1],path[i][2]
      str[pos] = chr((ord(str[pos])-ord('0')+val)%10 + ord('0'))
    else:
      str[path[i][1]],str[path[i][2]] = str[path[i][2]],str[path[i][1]]
    
    if ''.join(str) == t: 
      res = True
def dfs(start):
  global result,visited
  if start == k:
    check()
    return
  for i in range(k):
    if not result[i]:
      visited.append(i)
      result[i] = True
      dfs(start+1)
      visited.pop()
      result[i] = False
  dfs(k)
for i in range(k):
  path.append(list(map(int,input().split())))
dfs(0)
print('Yes' if res else 'No')

由此题最基本的解题方法引申出深搜排列

def dfs(start):
  global result,visited
  if start == k:
    check()
    return
  for i in range(k):
    if not result[i]: ###操作只能使用一次####
      visited.append(i)
      result[i] = True
      dfs(start+1)  ###不随其他条件而改变只要是增加一个值就增加一个操作###
      visited.pop() ###回溯###
      result[i] = False
  dfs(k)

我觉得此题精妙之处踩点在于

def check():
  global s,res
  str = list(s)
  for i in visited:
    if path[i][0] == 1:
      pos,val = path[i][1],path[i][2]
      str[pos] = chr((ord(str[pos])-ord('0')+val)%10 + ord('0'))
    else:
      str[path[i][1]],str[path[i][2]] = str[path[i][2]],str[path[i][1]]
    
    if ''.join(str) == t: 
      res = True

与另一种解法

def check():
   for i in visited:
     op,x,y = path[i][0],path[i][1],path[i][2]
     global s,res
     if op == 2:
        if x>y:
          s = s[:y]+s[x]+s[y+1:x]+s[y]+s[x+1:]
        else:
          s = s[:x]+s[y]+s[x+1:y]+s[x]+s[y+1:]
     if op == 1:
        s = s[:x] + str((int(s[x])+y)%10) + s[x+1:]
     if s == t:
        res = True

但其实第一种解法是√的由于int()函数将字符串转化为整数会丢失值，所以如果碰到相应巧合值则结果就不正确了

因此告诉我们为了如果以后遇到字符串数值改变或者变换顺序最好使用第一种方法

小怂爱水洼（简单dfs）

问题描述
小怂喜欢收集水洼中的水，他每到一个水量不为零的小水洼中就会收集里面的所有水。
小怂去到了一个大小为 N×M的水洼上，水洼上的每一块小水洼水量为 ai,j(i∈[1,n],j∈[1,m])。假设小怂的起始点是 (1,1)，他可以移动无数次，每次移动只能移动到当前水洼上下左右四个方向的相邻小水洼上，并且需要满足相邻小水洼水量大于 0，即如果新的小水洼水量为零，小怂就不能走到这个小水洼上。特别地，小怂可以重复走到某块小水洼，但是小水洼中的水只能被收集一次；如果起始点的水洼中有水，他会收集那些水。
值得注意的是：每块上下左右相连且水量不为 0 的小水洼会合成一块大水洼，小怂每到一块新的大水洼，他之前收集到的水量会变为 0。
求解小怂在大水洼中可以收集到的最大水量。
输入格式
第一行是两个整数 N, M，分别表示行数、列数。
接下来 N行，每行包含 M 个整数，每个整数表示当前位置的小水洼的水量。
数据范围保证：1≤N,M≤100，1≤ai,j≤ 10^6， (数据不保证起始点不为0)。
输出格式
输出共 1 行，一个整数，表示小怂在水洼中可以收集到的最大水量。

样例输入：

样例输出：

解：

import os
import sys
# 请在此输入您的代码

###四个方向####
dx = [0,0,1,-1,0]
dy = [0,1,0,0,-1]
n , m = map(int,input().split())
ans1 = 0
path = []
result = []
def dfs(x,y):
  if not result[x][y]:
    return
  for i in range(len(dx)):
    if x+dx[i]>=0 and y+dy[i]>=0 and x+dx[i]<n and y+dy[i]<m and [x+dx[i],y+dy[i]] not in path: ###判断条件####
      global ans
      ans += result[x+dx[i]][y+dy[i]]
      path.append([x+dx[i],y+dy[i]])
      dfs(x+dx[i],y+dy[i])
for i in range(n):
  result.append(list(map(int,input().split())))
for i in range(n):
    for j in range(m):
      ans = 0
      dfs(i,j)
      ans1 = max(ans1,ans)
print(ans1)

蚂蚁感冒

来源：第五届蓝桥杯省赛C++A/B组

长 100厘米的细长直杆子上有 n 只蚂蚁。

它们的头有的朝左，有的朝右。

每只蚂蚁都只能沿着杆子向前爬，速度是 1 厘米/秒。

当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

这些蚂蚁中，有 1 只蚂蚁感冒了。

并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

输入格式

第一行输入一个整数 n, 表示蚂蚁的总数。

接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。

正值表示头朝右，负值表示头朝左，数据中不会出现 0 值，也不会出现两只蚂蚁占用同一位置。

其中，第一个数据代表的蚂蚁感冒了。

输出格式

输出1个整数，表示最后感冒蚂蚁的数目。

数据范围

1<n<50,
0<|Xi|<100

输入样例：

5
-10 8 -20 12 25

输出样例：

解：

n = int(input())
ans = 0
ants = list(map(int,input().split()))
left,right = 0,0  ##分别表示左边向右走，右边向左走
for i in range(1,len(ants)):
    if abs(ants[i])>abs(ants[0]) and ants[i]<0:
        right+=1
    if abs(ants[i])<abs(ants[0]) and ants[i]>0:
        left+=1
if (ants[0]>0 and right==0) or (ants[0]<0 and left==0):
    print(1)
else:
    print(left+right+1)

其实就是脑筋急转弯，两个蚂蚁相遇时等价于两个互换灵魂，还是向原来的方向走，因为蚂蚁的速度相同

解题思路：分情况讨论初始感染蚂蚁向右，或向左思路都是一样的

昂贵的聘礼：

年轻的探险家来到了一个印第安部落里。

在那里他和酋长的女儿相爱了，于是便向酋长去求亲。

酋长要他用 10000 个金币作为聘礼才答应把女儿嫁给他。

探险家拿不出这么多金币，便请求酋长降低要求。

酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 8000 金币。如果你能够弄来他的水晶球，那么只要 5000 金币就行了。”

探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。

探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。

不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。

探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。

另外他要告诉你的是，在这个部落里，等级观念十分森严。

地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。

他是一个外来人，所以可以不受这些限制。

但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。

因此你需要在考虑所有的情况以后给他提供一个最好的方案。

为了方便起见，我们把所有的物品从 11 开始进行编号，酋长的允诺也看作一个物品，并且编号总是 11。

每个物品都有对应的价格 P，主人的地位等级 L，以及一系列的替代品 Ti 和该替代品所对应的”优惠” Vi。

如果两人地位等级差距超过了 M，就不能”间接交易”。

你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

输入格式

输入第一行是两个整数 M，N，依次表示地位等级差距限制和物品的总数。

接下来按照编号从小到大依次给出了 N 个物品的描述。

每个物品的描述开头是三个非负整数 P、L、X依次表示该物品的价格、主人的地位等级和替代品总数。

接下来 X 行每行包括两个整数 T 和 V，分别表示替代品的编号和”优惠价格”。

输出格式

输出最少需要的金币数。

数据范围

1≤N≤100,
1≤P≤10000,
1≤L,M≤N,
0≤X<N

输入样例：

输出样例：

解：

m,n=map(int,input().split())
N = n+1
state = [-1]*N
inf = float('inf')
d = [[inf]*N for _ in range(N)]
for i in range(1,n+1):
    w,state[i],x = map(int,input().split())
    d[0][i] = min(d[0][i],w)
    for _ in range(x):
        j,ji = map(int,input().split())
        d[j][i] = min(d[j][i],ji)
for i in range(n+1):
    d[i][i] = 0
def dijkstra(down,up):
    st = [False]*(n+1)
    dist = [inf]*(n+1)
    dist[0] = 0
    for i in range(1,n+1):
        t = -1
        for j in range(n+1):
            if not st[j] and (t==-1 or dist[t]>dist[j]):
                t = j
        st[t] = True
        for j in range(1,n+1):
            if down<=state[j]<=up and not st[j] and dist[j]>dist[t]+d[t][j]:
                dist[j] = dist[t]+d[t][j]
    return dist[1]
ans = inf
for i in range(state[1]-m,state[1]+1):
    ans = min(ans,dijkstra(i,i+m))
print(ans)

解题思路构造虚拟点，求最短路，用dijkstra算法

吟咏十

关注

28
点赞
踩
32

收藏

觉得还不错? 一键收藏
0
评论
刷题总计题解

当顾客想买 11 个包子时，大叔就会选 2 笼 3 个的再加 1 笼 5 个的（也可能选出 1 笼 3 个的再加 2 笼 4 个的）。假设小怂的起始点是 (1,1)，他可以移动无数次，每次移动只能移动到当前水洼上下左右四个方向的相邻小水洼上，并且需要满足相邻小水洼水量大于 0，即如果新的小水洼水量为零，小怂就不能走到这个小水洼上。如果起始点的水洼中有水，他会收集那些水。小蓝是一位有名的漆匠，他的朋友小桥有一个漆房，里面有一条长长的走廊，走廊两旁有许多相邻的房子，每间房子最初被涂上了一种颜色。
复制链接

扫一扫