牛客网算法进阶班笔记 包含,滑动窗口最大值维护和单调栈实现

牛客网算法进阶班

 

显然,排序+对撞指针,可是咱们老题新作.先排序而后都哈希到一个字典里面,而后好比你给target=9,那么读到2我就哈希一下字典里面有没有7便可.

效率也是O(N).而且代码更短.真心牛逼的老师.

下面我来实现一个这个题目变复杂一点的代码实现:实现的比较强大的功能了

#题目:返回list中加起来和为target的index组成的数组.为了题目复杂一点,可让list中有重复元素.
#可是咱们返回的解里面不要重复的.虽然index不一样,可是数值同样就只输出一份.
def main(list,target):
    b={}
    output=[]
    for i in range(len(list)):
        b.setdefault(list[i],i)#这命令自己就去重了.字典里面的key不可能重复
    for i in range(len(list)):
        
        if target-list[i] in b:
              new=i,b[target-list[i]]
              if new not in output and  (new[1],new[0]) not in output:

               output.append((i,b[target-list[i]]))
    return output
print(main([1,2,4,5,7,8],9))
    
    

View Code

 很是实用的课程!基本覆盖我全部作题本身想出来的思想,还有不少我没想到的.

●老师说,遇到链表题就把他放到数组里面,在数组里面调整好再next穿起来便可.(跟我平时用的方法同样.)面试必定这么答才好.

 

 

127. 单词接龙

import queue
class Solution(object):
    def ladderLength(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: Set[str]
        :rtype: int
        """
        wordList=set(wordList)
        q,ans = queue.Queue(),{}
        q.put(beginWord);
        ans[beginWord] = 1
        while not q.empty():
            tmp = q.get()
            if tmp == endWord:
                return ans[endWord]
            for i in range(len(tmp)):
                part1,part2 = tmp[:i],tmp[i+1:]
                for j in 'abcdefghijklmnopqrstuvwxyz':
                    if tmp[i] != j:
                        newword = part1 + j + part2
                        if newword in wordList:
                            q.put(newword)
                            ans[newword] = ans[tmp] + 1
                            wordList.remove(newword)
        return 0

View Code

 queue的基本使用方法:

import queue
a=queue.Queue()
a.put(3)
a.put(33)
a.get()
print(a.get())

View Code

 
126. 单词接龙 II

最后2个测试用例,用记忆体也大概10秒才行.应该找一个递推的方法来代替递归.问题是如何写递推呢?

memo={}
class Solution:
    def findLadders(self, beginWord, endWord, wordList):
        """
        :type beginWord: str
        :type endWord: str
        :type wordList: List[str]
        :rtype: List[List[str]]
        """
        #先广度优先创建每一层的搜索内容
        wordList=set(wordList)
        if beginWord in wordList:
            wordList.remove(beginWord)
        xianglian={}
        def jianli(i):
            tmp_all=[]
            for j in range(len(i)):
                 for tmp in 'abcdefghijklmnopqrstuvwxyz':
                   new=i[:j]+tmp+i[j+1:]
                   if  new in wordList and new!=i and new!=endWord:
                    
                    tmp_all.append(new)
                   if  new in wordList and new!=i and new==endWord:
                    
                    tmp_all.append(new)
            xianglian[i]=tmp_all
            return tmp_all
        #若是第i层已经找到了endword就不继续bianli 了
        now=[beginWord]
        while 1:
            new=[]
            for i in now:
                new+=(jianli(i))
            if endWord in new:
                break
            if new==[]:
                return []
            now=new
            
            for i in now:
                if i in wordList:
                 wordList.remove(i)
        
        #表作好了,开始递归出答案.

        def output(word):#返回从word到endword的list全体
            if word in memo:
             return memo[word]
            if word==endWord:
                memo[word]=[[word]]
                return [[word]]#这题目初始迭代比较诡异.须要双重列表
            else:
                if word not in xianglian:
                    return []
                tmp=[]
                for i in xianglian[word]:
                    for j in output(i):
                      tmp.append([word]+j)
                memo[word]=tmp
                return memo[word]
        return output(beginWord)
a=Solution()
print(a.findLadders("charge",
"comedo",
["shanny","shinny","whinny","whiney","shiver","sharer","scarer","scaler","render","fluxes","teases","starks","clinks","messrs","crewed","donner","blurts","bettye","powell","castes","hackee","hackle","heckle","deckle","decile","defile","define","refine","repine","rapine","ravine","raving","roving","chased","roping","coping","coming","homing","pointy","hominy","homily","homely","comely","comedy","comedo","vagues","crocus","spiked","bobbed","dourer","smells","feared","wooden","stings","loafer","pleads","gaiter","meeter","denser","bather","deaves","wetted","pleats","cadger","curbed","grover","hinged","budget","gables","larked","flunks","fibbed","bricks","bowell","yonder","grimes","clewed","triads","legion","lacier","ridden","bogied","camper","damien","spokes","flecks","goosed","snorer","choked","choler","leakey","vagued","flumes","scanty","bugger","tablet","nilled","julies","roomed","ridges","snared","singes","slicks","toiled","verged","shitty","clicks","farmed","stunts","dowsed","brisks","skunks","linens","hammer","naiver","duster","elates","kooked","whacky","mather","loomed","soured","mosses","keeled","drains","drafty","cricks","glower","brayed","jester","mender","burros","arises","barker","father","creaks","prayed","bulges","heaped","called","volley","girted","forded","huffed","bergen","grated","douses","jagger","grovel","lashes","creeds","bonier","snacks","powder","curled","milker","posers","ribbed","tracts","stoked","russel","bummer","cusses","gouged","nailed","lobbed","novels","stands","caches","swanks","jutted","zinged","wigged","lunges","divers","cranny","pinter","guides","tigers","traces","berber","purges","hoaxer","either","bribed","camped","funked","creaky","noises","paused","splits","morrow","faults","ladies","dinged","smoker","calved","deters","kicker","wisher","ballad","filled","fobbed","tucker","steams","rubber","staled","chived","warred","draped","curfew","chafed","washer","tombed","basket","limned","rapped","swills","gashed","loaner","settee","layers","bootee","rioted","prance","sharps","wigner","ranted","hanker","leaden","groped","dalian","robbed","peeled","larder","spoofs","pushed","hallie","maiden","waller","pashas","grains","pinked","lodged","zipper","sneers","bootie","drives","former","deepen","carboy","snouts","fained","wilmer","trance","bugles","chimps","deeper","bolder","cupped","mauser","pagers","proven","teaser","plucky","curved","shoots","barged","mantes","reefer","coater","clotho","wanner","likens","swamis","troyes","breton","fences","pastas","quirky","boiler","canoes","looted","caries","stride","adorns","dwells","hatred","cloths","rotted","spooks","canyon","lances","denied","beefed","diaper","wiener","rifled","leader","ousted","sprays","ridged","mousey","darken","guiled","gasses","suited","drools","bloody","murals","lassie","babied","fitter","lessee","chiles","wrongs","malian","leaves","redder","funnel","broths","gushes","grants","doyens","simmer","locked","spoors","berger","landed","mosley","scorns","whiten","hurled","routed","careen","chorus","chasms","hopped","cadged","kicked","slewed","shrewd","mauled","saucer","jested","shriek","giblet","gnarls","foaled","roughs","copses","sacked","blends","slurps","cashew","grades","cramps","radius","tamped","truths","cleans","creams","manner","crimps","hauled","cheery","shells","asters","scalps","quotas","clears","clover","weeder","homers","pelted","hugged","marked","moaned","steely","jagged","glades","goshes","masked","ringer","eloped","vortex","gender","spotty","harken","hasten","smiths","mulled","specks","smiles","vainer","patted","harden","nicked","dooley","begged","belief","bushel","rivers","sealed","neuter","legged","garter","freaks","server","crimea","tossed","wilted","cheers","slides","cowley","snotty","willed","bowled","tortes","pranks","yelped","slaved","silver","swords","miners","fairer","trills","salted","copsed","crusts","hogged","seemed","revert","gusted","pixies","tamika","franks","crowed","rocked","fisher","sheers","pushes","drifts","scouts","sables","sallie","shiner","coupes","napped","drowse","traced","scenes","brakes","steele","beater","buries","turned","luther","bowers","lofted","blazer","serves","cagney","hansel","talker","warmed","flirts","braced","yukked","milken","forged","dodder","strafe","blurbs","snorts","jetted","picket","pistil","valved","pewter","crawls","strews","railed","clunks","smiled","dealer","cussed","hocked","spited","cowers","strobe","donned","brawls","minxes","philby","gavels","renter","losses","packet","defied","hazier","twines","balled","gaoled","esther","narrow","soused","crispy","souped","corned","cooley","rioter","talley","keaton","rocker","spades","billie","mattel","billet","horton","navels","sander","stoker","winded","wilder","cloyed","blazed","itched","docked","greene","boozed","ticket","temped","capons","bravos","rinded","brandi","massed","sobbed","shapes","yippee","script","lesion","mallet","seabed","medals","series","phases","grower","vertex","dented","tushed","barron","toffee","bushes","mouser","zenger","quaked","marley","surfed","harmed","mormon","flints","shamed","forgot","jailor","boater","sparer","shards","master","pistol","tooted","banned","drover","spices","gobbed","corals","chucks","kitten","whales","nickel","scrape","hosted","hences","morays","stomps","marcel","hummed","wonder","stoves","distil","coffer","quaker","curler","nurses","cabbed","jigger","grails","manges","larger","zipped","rovers","stints","nudges","marlin","exuded","storey","pester","longer","creeps","meaner","wallop","dewier","rivera","drones","valued","bugled","swards","cortes","charts","benson","wreaks","glares","levels","smithy","slater","suites","paired","fetter","rutted","levied","menses","wither","woolly","weeded","planed","censer","tested","pulled","hitter","slicer","tartar","chunky","whirrs","mewled","astern","walden","hilton","cached","geller","dolled","chores","sorter","soothe","reused","clumps","fueled","hurler","helled","packed","ripped","tanned","binder","flames","teased","punker","jerked","cannon","joists","whited","sagged","heaven","hansen","grayer","turfed","cranks","stater","bunted","horsey","shakes","brands","faints","barber","gorged","creamy","mowers","scrams","gashes","knacks","aeries","sticks","altars","hostel","pumped","reeves","litter","hoaxed","mushed","guided","ripper","bought","gelled","ranker","jennie","blares","saloon","bomber","mollie","scoops","coolie","hollis","shrunk","tattle","sensed","gasket","dodoes","mapped","strips","dodges","sailed","talked","sorted","lodges","livest","pastel","ladles","graded","thrice","thales","sagger","mellon","ganged","maroon","fluked","raised","nannie","dearer","lither","triked","dorset","clamps","lonnie","spates","larded","condor","sinker","narced","quaver","atones","farted","elopes","winger","mottle","loaned","smears","joanne","boozes","waster","digger","swoops","smokey","nation","drivel","ceased","miffed","faiths","pisses","frames","fooled","milled","dither","crazed","darryl","mulder","posses","sumter","weasel","pedals","brawny","charge","welted","spanks","sallow","joined","shaker","blocks","mattie","swirls","driver","belles","chomps","blower","roared","ratted","hailed","taunts","steamy","parrot","deafer","chewed","spaces","cuffed","molded","winked","runnel","hollow","fluted","bedded","crepes","stakes","vested","parley","burton","loiter","massey","carnap","closed","bailed","milder","heists","morale","putter","snyder","damion","conned","little","pooped","ticced","cocked","halves","wishes","francs","goblet","carlin","pecked","julius","raster","shocks","dawned","loosen","swears","buried","peters","treats","noshed","hedges","trumps","rabies","ronnie","forces","ticked","bodies","proved","dadoes","halved","warner","divest","thumbs","fettle","ponies","testis","ranked","clouts","slates","tauted","stools","dodged","chancy","trawls","things","sorrow","levies","glides","battle","sauced","doomed","seller","strove","ballet","bumper","gooses","foiled","plowed","glints","chanel","petals","darted","seared","trunks","hatter","yokels","vanned","tweedy","rubles","crones","nettie","roofed","dusted","dicker","fakers","rusted","bedder","darrin","bigger","baylor","crocks","niches","tented","cashed","splats","quoted","soloed","tessie","stiles","bearer","hissed","soiled","adored","bowery","snakes","wagers","rafter","crests","plaids","cordon","listed","lawson","scared","brazos","horded","greens","marred","mushes","hooper","halter","ration","calked","erodes","plumed","mummer","pinged","curios","slated","ranter","pillow","frills","whaled","bathos","madden","totted","reamed","bellow","golfer","seaman","barred","merger","hipped","silken","hastes","strays","slinks","hooted","convex","singed","leased","bummed","leaner","molted","naught","caters","tidied","forges","sealer","gulled","plumps","racket","fitted","rafted","drapes","nasser","tamara","winced","juliet","ledger","bettie","howell","reeved","spiced","thebes","apices","dorsey","welled","feeler","warded","reader","folded","lepers","cranky","bosses","ledges","player","yellow","lunged","mattes","confer","malign","shared","brandy","filmed","rhinos","pulsed","rouses","stones","mixers","cooped","joiner","papped","liston","capote","salvos","wicker","ciders","hoofed","wefted","locket","picker","nougat","limpid","hooter","jailer","peaces","mashes","custer","wallis","purees","trends","irater","honied","wavers","tanner","change","hinges","tatted","cookie","catnap","carton","crimed","betted","veined","surges","rumped","merlin","convey","placid","harped","dianna","hookey","nobles","carted","elided","whined","glover","bleats","stales","husker","hearer","tartan","weaker","skewer","lumbar","temper","gigged","gawked","mayors","pigged","gather","valves","mitten","largos","boreas","judges","cozens","censor","frilly","dumbed","downer","jogger","scolds","danced","floras","funded","lumped","dashes","azores","quites","chunks","washed","duller","bilges","cruels","brooks","fishes","smoked","leaped","hotter","trials","heaves","rouges","kissed","sleety","manses","spites","starts","banded","clings","titted","vetoed","mister","mildew","wailed","sheets","peeked","passer","felted","broken","lieges","ruffed","bracts","buster","muffed","lanker","breaks","coffey","sighed","charms","balded","kisser","booths","leaven","cheeps","billed","lauder","bumped","career","stocks","airier","limped","jeanie","roamed","carves","lilted","router","bonnie","denver","briggs","steeps","nerves","oinked","bucked","hooves","dancer","burris","parked","swells","collie","perked","cooler","fopped","wedder","malted","sabers","lidded","conner","rogues","fought","dapper","purled","crowds","barnes","bonner","globed","goners","yankee","probes","trains","sayers","jersey","valley","vatted","tauter","dulled","mucked","jotted","border","genres","banked","filter","hitler","dipper","dollie","sieves","joliet","tilted","checks","sports","soughs","ported","causes","gelded","mooter","grills","parred","tipped","placer","slayer","glided","basked","rinses","tamper","bunged","nabbed","climbs","faeces","hanson","brainy","wicket","crowns","calmed","tarred","spires","deanne","gravel","messes","snides","tugged","denier","moslem","erased","mutter","blahed","hunker","fasten","garbed","cracks","braked","rasped","ravens","mutton","tester","tories","pinker","titled","arisen","softer","woolen","disses","likest","dicier","nagged","lipton","plumbs","manged","faulty","sacred","whiter","erases","padres","haired","captor","metals","cardin","yowled","trusts","revels","boxers","toured","spouts","sodded","judged","holley","figged","pricey","lapses","harper","beaned","sewers","caused","willie","farmer","pissed","bevies","bolled","bugler","votive","person","linton","senses","supped","mashed","pincer","wetter","tangos","sticky","lodger","loader","daunts","peaked","moused","sleeps","lasted","tasked","awards","lovely","gushed","spurts","canter","mantis","coaled","groans","dannie","oopses","sneaky","vogues","mobile","plumes","chides","theses","marcia","parser","flexed","stayed","fouler","tusked","quartz","daubed","clancy","rouged","flaked","norton","dunner","corded","shelly","hester","fucker","polled","rodger","yeager","zinced","livens","browne","gonged","pubbed","sapped","thrive","placed","jensen","moises","scopes","stumpy","stocky","heller","levers","morals","wheres","gasped","jobber","leaved","champs","rosier","pallet","shooed","parses","bender","closet","pureed","routes","verges","bulled","foster","rummer","molten","condos","better","cotter","lassos","grafts","vendor","thrace","codded","tinker","bullet","beaker","garden","spiels","popper","skills","plated","farrow","flexes","esters","brains","handel","puller","dickey","creeks","ballot","singer","sicker","spayed","spoils","rubier","missed","framed","bonnet","molder","mugger","waived","taster","robles","tracks","nearer","lister","horsed","drakes","lopped","lubber","busied","button","eluded","ceases","sought","realer","lasers","pollen","crisps","binned","darrel","crafty","gleams","lonely","gordon","harley","damian","whiles","wilton","lesser","mallow","kenyon","wimped","scened","risked","hunter","rooter","ramses","inches","goaded","ferber","freaky","nerved","spoken","lovers","letter","marrow","bulbed","braver","sloped","breads","cannes","bassos","orated","clever","darren","bredes","gouger","servos","trites","troths","flunky","jammed","bugged","watter","motive","humped","writer","pestle","rilled","packer","foists","croats","floury","napier","floors","scotty","sevens","harrow","welter","quacks","daybed","lorded","pulses","pokier","fatten","midges","joints","snoopy","looter","monies","canted","riffed","misses","bunker","piston","yessed","earner","hawked","wedged","brewer","nested","graver","hoaxes","slaves","pricks","magpie","bernie","rapier","roster","poohed","corner","trysts","rogers","whirls","bathed","teasel","opener","minced","sister","dreamy","worker","rinked","panted","triton","mervin","snowed","leafed","thinks","lesson","millet","larson","lagged","likely","stormy","fortes","hordes","wovens","kinked","mettle","seated","shirts","solver","giants","jilted","leaded","mendez","lowers","bidder","greats","pepped","flours","versus","canton","weller","cowper","tapped","dueled","mussed","rubies","bonged","steals","formed","smalls","sculls","docket","ouster","gunned","thumps","curred","withes","putted","buttes","bloats","parsed","galley","preses","tagged","hanger","planes","chords","shafts","carson","posits","zinger","solves","tensed","tastes","rinsed","kenned","bitten","leslie","chanty","candor","daises","baggie","wedded","paints","moored","haloed","hornet","lifted","fender","guiles","swifts","flicks","lancer","spares","pellet","passed","finked","joanna","bidden","swamps","lapped","leered","served","shirrs","choker","limper","marker","nudged","triter","thanks","peered","bruins","loaves","fabled","lathes","pipers","hooped","orates","burned","swines","sprats","warder","colder","crazes","reined","prized","majors","darrow","waifed","rooked","rickey","patter","shrive","gropes","gassed","throve","region","weaken","hettie","walton","galled","convoy","wesson","exudes","tinted","clanks","blinks","slacks","stilts","franny","socket","wished","kidded","knotty","turves","cashes","geared","sunned","glowed","sadden","harlem","testes","sweets","becket","blazes","batter","fellow","clovis","copier","shaped","husked","gimlet","rooney","taints","sashes","bossed","cootie","franck","probed","bagged","smocks","batten","spared","chills","relics","meyers","grader","tromps","dimmer","pasted","pepper","capped","played","junket","easier","palmed","pander","vaguer","bulged","dissed","borges","raises","wallow","jigged","bogged","burped","neater","rammed","fibers","castor","skirts","cancer","tilled","spored","dander","denims","budges","trucks","sowers","yapped","cadges","wrists","hacker","graved","vipers","noshes","minted","lessor","cassia","wrecks","hidden","brando","honeys","chilli","ragged","breded","punier","stacey","sisses","jocked","croaks","dinned","walker","heston","flares","coined","cannot","chocks","leases","wander","balder","warmer","bawled","donnie","damson","header","chilly","models","simper","watery","milked","poises","combed","toilet","gallop","sonnet","loosed","yawned","splays","pauses","bother","graphs","shrews","scones","manuel","milers","hotels","bennie","flores","spells","grimed","tenses","staged","puffer","posies","motion","fudged","fainer","tatter","seraph","nansen","months","muppet","tamera","shaman","falser","becker","lisbon","clefts","weeper","mendel","girder","takers","torsos","forked","dances","stated","yelled","scants","frothy","rolled","yodels","listen","craned","brooms","suffer","easter","shills","craves","bleeps","belled","dished","bordon","zither","jacket","lammer","kirked","shaved","atoned","frumpy","nosier","vender","graced","clingy","chants","wrests","cursed","prunes","tarter","stripe","coffee","veiled","tweeds","shrine","spines","kegged","melvin","gasser","market","marten","peeped","sanger","somber","spider","netted","radium","slings","scarfs","mended","creels","shaves","payers","bunked","movers","beings","conked","cozies","benton","codger","prints","gusset","longed","burner","jambed","mullet","fogged","scores","carbon","sleeks","helped","waxier","gilded","harlot","winces","tenser","lowell","ramsey","kennan","booted","beaver","rested","shouts","hickey","looped","swings","wonted","dilled","defers","lolled","pupped","cruets","solved","romper","defter","chokes","kithed","garnet","bookie","stared","stares","latter","lazies","fanned","wagged","dunces","corked","cloned","prided","baxter","pusses","boomed","masses","warren","weaves","delves","handed","merton","lusher","hepper","gibber","sender","parsec","snares","masher","seamed","sweats","welles","gagged","curter","mother","beeped","vealed","shoved","slaver","hacked","gutted","ranged","bashed","closer","storks","meshed","cortex","copper","severn","gripes","carlos","scares","crates","boiled","ginned","mouses","raided","greyed","verier","slopes","fenced","sniper","priced","flawed","buffed","spacey","favors","platen","miller","walled","cutter","skated","holier","beamed","waiter","drowns","clomps","quarks","bested","frisks","purged","scalds","marian","flower","howled","plover","bikers","trails","hagged","smirks","sitter","carmen","lanced","plants","nobler","yakked","thesis","lassen","margin","wagner","sifter","houses","screws","booker","dormer","meters","padded","loaded","cartel","sutton","willis","chatty","dunked","dreamt","dalton","fables","coveys","muller","shanty","adders","tailor","helper","liters","butted","maiman","hollie","gallon","xavier","shrank","mickey","rather","powers","keened","doused","kisses","flanks","dotted","phased","dumped","linger","kramer","spaced","soften","strife","rowers","hovers","crimes","crooks","carrel","braces","lander","shrove","skulks","banker","itches","dropsy","misted","pulped","cloche","fawned","states","teared","beeper","raider","groves","livery","aerier","keenan","severe","sabres","bogies","coated","harlow","tanked","mellow","cozier","shanks","spooky","blamed","tricks","sleets","punted","jumped","caxton","warped","halley","frisky","shines","skater","lumber","truces","sliced","gibbet","narked","chives","graves","gummed","holler","glazes","nieves","hushed","nought","prated","chored","cloudy","kidder","huston","straws","twined","gifted","rodney","haloes","france","wirier","mercia","rubbed","coaxed","sumner","snipes","nipper","leiden","madman","margie","footed","firmed","budded","froths","senior","hoover","tailed","glider","straps","stalks","billow","racked","javier","zoomed","shades","whores","braids","roused","sudden","dogies","fencer","snaked","flings","traded","gunner","snider","staten","levees","lathed","sailor","waited","muster","clothe","lulled","cargos","revved","sooths","flamed","borers","feller","bladed","oliver","collin","wusses","murder","parted","jailed","frayed","doored","cheeks","misled","belted","winter","merges","shaven","fudges","tabbed","forget","sloths","cachet","mealed","sassed","salter","haunts","ranger","rivets","deeded","reaped","damped","crated","youths","whacks","tamers","misery","seeped","eerier","tiller","busses","gloved","hushes","cronus","pruned","casket","direst","guilds","motley","spools","fevers","snores","greece","elides","waists","rattle","trader","juster","rashes","stoney","pipped","solder","sinner","prides","rugged","steers","gnarly","titter","cities","walter","stolen","steaks","hawker","weaned","jobbed","jacked","pikers","hipper","spoilt","beeves","craved","gotten","balked","sherry","looney","crisis","callie","swiped","fished","rooted","bopped","bowler","escher","chumps","jerrod","lefter","snooty","fillet","scales","comets","lisped","decked","clowns","horned","robber","bottle","reeled","crapes","banter","martel","dowels","brandt","sweeps","heeled","tabled","manors","danger","dionne","prayer","decker","millie","boated","damned","horses","globes","failed","lammed","nigher","joyner","sobers","chided","tipper","parcel","flakes","fugger","elated","hinder","hopper","crafts","wipers","badder","jessie","matted","wafted","pealed","cheats","elites","torres","bushed","sneaks","tidies","brings","stalls","payees","zonked","danker","poshes","smelts","stoops","warden","chicks","ramsay","budged","firmer","glazed","heated","slices","hovels","belied","shifts","pauper","tinges","weston","casted","titles","droves","roomer","modals","seamen","wearer","blonde","berlin","libbed","tensor","hokier","lambed","graped","headed","copped","eroses","fagged","filler","keener","stages","civets","spills","tithed","sullen","sucked","briton","whaler","hooded","tittle","bucket","furled","darned","planet","clucks","batted","dagger","brides","severs","pathos","grainy","relied","carpel","makers","lancet","slowed","messed","ravels","faster","gabbed","chance","grayed","santos","spends","chinos","saints","swirly","dories","wilson","milton","clangs","manual","nodded","signer","stript","etched","vaster","wastes","stored","minces","purred","marvin","pinned","skulls","heaved","wadded","fowled","hashed","mullen","relief","hatted","primed","chaffs","canned","lackey","showed","shandy","chases","maggie","deafen","bussed","differ","worked","marted","ducked","socked","fussed","greyer","herder","trusty","follow","samson","babies","whorls","stanks","manson","cranes","murrow","shrink","genius","holder","lenses","yucked","termed","ruined","junker","belies","joshed","cooled","basted","greeks","fuller","healer","carver","havens","drunks","sucker","lotion","glared","healed","pocked","rifles","weaved","canoed","punter","hinton","settle","boobed","hinted","scored","harder","status","sloven","hayden","golfed","scoots","bloods","slaked","jugged","louses","cassie","shaded","rushed","pitied","barked","honked","rasher","forced","shaver","vowels","holden","pelvis","blades","chests","preyer","floods","deanna","cation","mapper","falter","dabbed","mocker","nestle","shucks","heeded","ticker","binges","summer","slumps","lusted","scampi","crofts","gorges","pardon","torses","smokes","lashed","bailey","jabbed","calmer","preset","forbes","hasted","wormed","winged","minors","banner","grazed","hewers","kernel","jolted","sniped","clunky","ratios","blinds","ganges","misers","spikes","riders","hallow","grumpy","barren","summed","infers","places","jarred","killer","plaint","goofed","subbed","prudes","sipped","kookie","whines","droopy","palled","cherry","proves","mobbed","spaded","cheese","pluses","bathes","motels","spewed","soaked","howler","puffed","malled","shrike","slided","fulled","pouted","shames","lessen","ringed","teemed","grands","linked","wooten","feuded","deaden","scents","flutes","salton"]))#print(a.findLadders("log","cog", ["hot","dot","dog","lot","log","cog"]))
        

View Code

 

这个题目真新超难.难在边界判断.一堆.很黏腻的一道题.可是确实很牛逼,对这个题目自己的作了一下拓展,获得这样一个问题.

找到一个数字最近的回文数这个list.包括比他大比他小.

import numpy as np
'''
这个题目比较难,因此我把他拆成3个部分,1:找一个数字(数位不是1)的,比他大的最近的回文数,不能经过本身对称生成
2.本身对称生成  3.比他小的,不能本身对称生成
'''

def findBighuiwen(n):
    if n<9:
        return n+1
    if n==9:
        return 11
    #高位补0
    n=str(n)
    n='0'+n
    #找中间的index
    zhong=len(n)//2
    first=n[:zhong+1]
    #差几位,这个计算免去了基偶的麻烦,很是实用
    cha=len(n)-len(first)
    first=int(first)+1
    first=str(first)

    
    out=first+first[cha-1::-1]
    return int(out)
def ziduichen(n):
    n=str(n)
    #找中间的index
    zhong=(len(n)-1)//2
    first=n[:zhong+1]
    #差几位,这个计算免去了基偶的麻烦,很是实用
    cha=len(n)-len(first)
   
    out=first+first[cha-1::-1]
    return int(out)


def findsmallhuiwen(n):
    if n<=9:
        return n-1
    if n==11 or n==10:
        return 9

    n=str(n)

    #找中间的index
    zhong=len(n)//2
    first=n[:zhong+1]
    #差几位,这个计算免去了基偶的麻烦,很是实用
    cha=len(n)-len(first)
    first=int(first)-1
    first=str(first)

    
    out=first+first[cha-1::-1]
    return int(out)
def find_all_near_huiwen(n):
    return [findBighuiwen(n),findsmallhuiwen(n),ziduichen(n)]
print(find_all_near_huiwen(9993))

View Code

 为何老用i,j作变量.由于变量名短,程序也会变快!

无后效性:我调用P(1,1)这个函数,不关是从5来调用,仍是从3来调用,P(1,1)这个值跟谁调用他无关,他已是一个肯定的值了,这就叫作无后效性.

这种特性的问题就能够用动态规划来解决.另一个经常使用的术语是最优子结构.

真是遇到最好的算法课程

 335. 路径交叉          思路很trivial,就是这个棋盘大小取多少呢?

class Solution:
    def isSelfCrossing(self, x):
        """
        :type x: List[int]
        :rtype: bool
        """
        if x==[]:
            return False
        chang=2*max(x) #关键是这个棋盘的长度应该取多大?我瞎b试一个2*max竟然ac了!!!!!
        a=[0]*chang
        matrix=[]
        for i in range(chang):
            matrix.append(a.copy())
        zhong=chang//2
        matrix[zhong][zhong]=1
        hang=zhong
        lie=zhong
        for i in range(len(x)):
            if i%4==0:
                for j in range(1,x[i]+1):
                     if matrix[hang-j][lie]==1:
                            return True
                     matrix[hang-j][lie]=1
                hang=hang-x[i]
            if i%4==1:
               for j in range(1,x[i]+1):
                     if matrix[hang][lie-j]==1:
                            return True
                     matrix[hang][lie-j]=1
               lie=lie-x[i]
            if i%4==2:
                for j in range(1,x[i]+1):
                     if matrix[hang+j][lie]==1:
                            return True
                     matrix[hang+j][lie]=1
                hang=hang+x[i]
            if i%4==3:
                for j in range(1,x[i]+1):
                     if matrix[hang][lie+j]==1:
                            return True
                     matrix[hang][lie+j]=1
                lie=lie+x[i]
        return False

        

View Code

 正确解法就太复杂了.用递推来写的

这个老师说很难.

 写思路:

须要找到的答案是:0.先扔字典里面

1.把word1 本身作逆序,在字典里面找

2.把word2 里面首字母从word2首开始的回文子串的所有,而后分别差他在word2中剩余部分的逆序是否在字典中存在

3.上面改为从最后开始的回文子串相似找一遍.

最后123组合起来就是答案.

●窗口内最大值和最小值的更新结构.

最大值:

应该用堆,把一个窗口创建成为一个堆.大根堆.也就是优先队列.而后你进入一个数,堆就加一个,可是你堆无法删除!

老师说是双端队列来实现.在队列里面排序.而后插入排序吧.

●双端队列用双链表结构便可.

代码实现滑动窗口里面找max和min(只写了max)

'''
一个数组
滑动窗口里面如何维护一个数组片断的max or min
用双端队列来实现

什么叫滑动窗口,一个L指针,一个R指针.
要保证L只能向右最多滑到R,R只能向右滑动.(若是可让R向左滑动,下面算法就有错误了,可是通常算法题
都符合这个要求)
chuangkou里面存的是index值,为了不a里面相同元素在不一样位置会出现冲突
'''
a=[2,4,5,76,8]
from collections import deque 

chuangkou=deque([])

L=-1
R=-1
#chuangkou维护从L到R的这些数的max值.包含R不包含L.L=R时候为空
def L_move_max():#返回L_move一下以后窗口的max值
        global L
        L+=1
        if L>R:
            print('不能这么作')
            raise NameError 
        if L==R:
            chuangkou.clear()
            return None
        while 1:
            if chuangkou[0]==L:
                chuangkou.popleft()
                break
            else:
                break
        return a[chuangkou[0]]
def R_move_max():#返回L_move一下以后窗口的max值
        global R
        R+=1
        if R==len(chuangkou)-1:
            print('不能这么作')
            raise NameError 
        while 1:
            if len(chuangkou)==0:
                chuangkou.append(R)
                break
            if a[chuangkou[-1]]>a[R]:
                chuangkou.append(R)
                break
            else:
                chuangkou.pop()
        return a[chuangkou[0]]

print(R_move_max())
print(R_move_max())
print(R_move_max())
print(R_move_max())
print(R_move_max())
print('开始左滑动')
print(L_move_max())
print(L_move_max())
print(L_move_max())
print(L_move_max())
print(L_move_max())
'''
效果出来了:
2
4
5
76
76
开始左滑动
76
76
76
8
None         最后一次把8也弹出来了.因此为空了.
'''

View Code

 

这就是这个题目的彻底形态了,可是找了半天没找到这个题目在哪一个题库里面的.想ac一下试试.

我思路是:按照上的滑动窗口已经写好了,而后对L锁定一个在-1位置.而后遍历一遍R位置.返回符合要求的.

               而后L右移一个,而后R继续遍历.返回符合要求的.

               一直到L到最后就中止.效率N^2

 暴力就是n^3*logn.

上面方法都没分.

左神说这题目O(N)

具体更细的分析知道:

若是一个数组他达标了.那么R右移,这样max队列返回值会变大,min返回值会变小.因此结果会变大.因此

当咱们如今滑动窗口>target那么L右移. 反之R右移.这样O(N)便可.若是达标了随意移动,动R或者动L都行.

●至关精彩的一个题目.上一题.固然上一个题目我作的其实是=num这个题.对于<=num这个题其实更简单

●左神是牛逼啊,给的题目都是leecode里面的hard,虽然写过也是很是吃力的题目

●前序,中序,后序,按层这些2叉树的遍历很重要.用途是在作文件处理时候使用.

好比咱们用的序列化.seralize.把一个文件存到内存里面,而后电脑从新启动后从新获得内存里面这个状态.

用一种遍历就能把2叉树的结构保存起来.来从新创建以前的二叉树.

2叉树序列化和反序列化:深刻理解递归.反序列化里面用列表来作递归,就死活出不来.目测列表不如queue是动态更新的.每一次递归他会锁定list的值.

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
import  Queue #用queue来作全局变量,用list在递归里面无法作全局变量.
#妈的shi都写出来了,各类无法用全局变量!虽然list能够作用全局变量效果.可是在递归里面他有记忆锁定效果.达不到动态效果.
#只能用queue来实现.
class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if root==None:
            return '#_'
        #前序遍历获得数组
        a=str(root.val)+'_'
        a+=self.serialize(root.left)
        a+=self.serialize(root.right)
        return a
        
        
        

    def deserialize(self, data):
        
        def mydecode(data):
            

            
            """Decodes your encoded data to tree.

            :type data: str
            :rtype: TreeNode
            """
            a=data.get()#由于这里面每一次都须要更新data
            if a=='#':
                
                return None
            print(a)
            a=TreeNode(int(a))
            
            a.left=mydecode(data)
            a.right=mydecode(data)#可是这里面的data会锁定,只能用queue来强制修改data
            return a
        tmp=Queue.Queue()
        print(data)
        #须要用下划线来拆分,组成原始数据
        i=0
        j=0
        while j<len(data):
            if data[j]=='_':
                tmp.put((data[i:j]))
                i=j+1
            j+=1
        
        return mydecode(tmp)
        

# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

View Code

 仍是上面那个题目:深刻理解下局部变量,赋值,=这些应该如何避免冲突.

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """
        if root==None:
            return '#_'
        #前序遍历获得数组
        a=str(root.val)+'_'
        a+=self.serialize(root.left)
        a+=self.serialize(root.right)
        return a
        
        
        

    def deserialize(self, data):
        
        def mydecode(data):
            

            
            """Decodes your encoded data to tree.

            :type data: str
            :rtype: TreeNode
            """
            tmp2=data[0]
            data.pop(0)
            
            
            
            
            
            
            
            
            #这个地方写data=data[1:]就是严重的错误!!!!!!!!!
         #data=data[1:] 不能用这样的赋值来修改data.这样修改本质是作一个新data,而不是在原来data上修改
        #必定要深刻的理解=这个含义!
        #=在python里面不是地址更新.不如a=a[1:],他表示的不是原来的a我切去第一个元素,而是我新创建一个变量
        #他他妈b的也碰巧了叫a,可是他不是原来的a,妈的:这东西虽然理解了可是说清楚真他妈困难.下面开始长篇累牍
            '''
            only for explanation of above
            ●1.首先python 里面变量有这个特性,按照值来给地址.为了节省相同值的存储空间.可是这点没卵用,由于他仍是用一个门牌号来作区别的.而后一句废话是python里面变量区域的问题.当一个量他不再被使用了就会被析构掉.可是这个函数里面他下面还有递归a.left=mydecode(data).这里面的data就是函数赋值的形参data这个地址所表示的内容.因此data是不会在你写data=data[1:]时候被析构吊的.这时候实际上是产生了2个data.一个是新创建的元素个数-1的data.一个是原始地址的data.递归时候利用的是原始地址!(递归的本质是原始地址取值)
            ●写一下错误代码运行时发生的一切:
其实把这个运行细节写清楚就看清楚了.
运行a.left=mydecode(data).时候data此时为['#', '#', '3', '4', '#', '#', '5', '#', '#']
而后递归进入这个函数mydecode这个函数,他生成了一个局部变量data也是一个list.可是关键来了.虽然他是一个list,是comumutate的可是,他是经过=获得的.而不是pop获得的.因此他只是跟开始的data名字同样.这时候显然会发生变量覆盖问题.就是说你在大范围定义一个a,小范围定义一个a.那么在小范围内自动用这个a,而后到大范围里面再使用大a.(由于大data,后面还会被使用,因此他不会被析构,这个是python本身扫描代码本身知道的内容,不用人去管).知道这些以后,a.left=mydecode(data).运行完,内部小data赋值好了,可是a.right=mydecode(data)使用的亦然大的data,由于他在大范围里面不在a.left代码里面.
这就致使了a.left里面的data更新对a.right没用.
            那么如何让更新起做用?直接写global其实就能够了,可是这个leetcode操蛋不让这么用.
            因此用pop也能够.他是远地址修改,根本不残生新的变量.那么你a.right取data值得时候只能取这个修改后的.
            最后贴个代码体会一下便可:
            
            
            data=[3,34,34,34,3]
            def main(data):
                data=data[1:]
                return data
            print(main(data))
            print(data)
            
            [34, 34, 34, 3]
            [3, 34, 34, 34, 3]
            Press any key to continue 



            







            ●2.在递归时候就会发生很是很是严重的bug.须要仔细分析.
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            
            '''
            if tmp2 =='#':
                return None
            a=TreeNode(int(tmp2))
            
            a.left=mydecode(data)
            a.right=mydecode(data)#!!!!!!!!!!!
            return a
        tmp=[]
        i=0
        j=0
        while j<len(data):
            if data[j]=='_':
                tmp.append((data[i:j]))
                i=j+1
            j+=1
        
        print(tmp)
        return mydecode(tmp)
        

# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.deserialize(codec.serialize(root))

View Code

 ●斐波那契数列:这种没有状态转移的能够用矩阵解

算矩阵幂便可.理论就是,这种递推式的通项公式是线性的.

算幂:

 

 

 

 答案:就是斐波那契数列.简单推理一下便可.分末尾取1,0对N长作概括便可.

 

 

题目最后是x的k次方.

条件几率,作屡次,呗

他没说返回的这个函数是否须要在[0,1]上等几率

 答案是:random(0,x)跑k次,而后取k个数里面最大的作返回便可.确实他也不是0,1上等几率的.

个人方法是:random(0,x)跑k次,而后第2次到第n次的结果若是都小于x,那么我就返回第一次结果,不然返回1.

测试一下个人方法,正确

import random
def main():#对于这个函数返回一个数0到0.3的几率是0.3**k
    count=0
    k=4
    for i in range(10000):
        tmp=[]
        for j in range(k):
            tmp.append(random.uniform(0,1))
        if max(tmp[1:])<=0.5:
            jjj=max(tmp[1:])
            output=tmp[0]
        else:
            output=1
        if output <=0.5:
            count+=1
    return count/10000


print(main())

View Code

 

感受是用堆,可是这里面数组是不少个.

暴力方法:

把每个数组最后K个数都放到一个堆里面.而后pop k次,因此效率kN log(KN) .N特别大的时候效率差不少.

左神说:答案是对堆的代码改写来实现这个程序.没想出来.

●我想法是把堆里面的元素都用一个数组来替换.而后堆的维护法则是用数组的最后一个元素来作比较来维护大根堆.

创建堆的时间是NlogN,搜索时间每一次是logN,因此弹出k个复杂度是klogN.可是问题是创建时间太长了.

 

●算错了,创建堆的时间精确来讲是O(N).

下面先证实这个结论:

第一个数扔进去:1

第二个数和第三个数扔进去:2 *2

第4,5,6,7 扔进去 4*3

因此 把1+2+4+....2^n个数扔进去须要时间是1+2*2+4*3+....+2^n*n获得的是nlogn

可是实际上,堆是用一个list来表示的.你给我一个list我直接转化为堆便可.不须要读数据这个时间.直接在list中调整便可.

真正创建堆的时间:

list先给好,而后,第一行的数经过逐级swap须要时间1*H(H为树高,也就是log(len(list)))

第二行是2*(H-1),由于你第一层已经不会变了,因此每一个数只须要比较H-1次

因此答案是1*H+2*(h-1)+....+2^n*(1) 这显然是O(N)的时间复杂度.

●有了这个复杂度,那么咱们讨论一个list中返回最大的k个元素用堆来实现是多少复杂度.

创建堆O(N),弹出须要k(logn)当k比n小不少时候,基本是O(N),比排序算法快一些.由于排序算法是nlogn复杂度.

为何说一些.好比N是2^30次幂.那么久快30倍.只能说确实快了基本一个数量级.也就是说算法少一个logn,基本少一个数量级.由于数据量基本是千万级别的.

●2018-06-05妈的修完风扇后，独立显卡不识别了。

妈的，上个题目老师果真是创建一个大小为N的堆。再操做，而后他说算法复杂度是klogn。由于弹出k次每一次logn。

这显然错误，你创建堆的时间O（N）你没有考虑在内。当N比K超级大的时候呢。而且这是一个常态。你N很是少那直接KN也跟KlogN差很少了。

因此N很是大的时候，K很小，时间应该是O（N）才对。其实老夫早就预测到了最差你也是O（N）的，由于一共N个数组，之间都无关。

你连数据都不扫一遍，O（N）都不消耗，怎么可能计算他们之间的大小值！返回top

●还须要计算的一种创建堆的方法是一个一个的insert进去。好比我把5,4,3,2,1放堆里面创建一个小根堆。这个创建过程显然O（nlogn），由于你最后创建一个数就须要复杂度加logn，。。

 

●双重堆结构.来解决上面问题:pmi都是一个堆,把Pm1到pmn的最喜欢的都给sde,而后sde,sde再创建一个堆,而后按照他的cost来写堆.

 用位,&,| ^来作加减乘除运算.

#'''
#写一个用位来实现整数加减乘除的算法
#'''
#def add(a,b):
#    #思想就是位运算,and,or运算.也就是&,|,^异或.
#    #先获得进位信息

#    tmp=(a&b)<<1
#    #不进位信息
#    tmp2=a^b
#    #而后继续算tmp+tmp2,又拆成进位信息和非进位信息.这尼玛这么难想的东西.
#    while tmp!=0:#上面不走循环便可
#        oldtmp=tmp
#        tmp=(tmp&tmp2)<<1            #位的运算级别比&高,因此必定要加括号
#        tmp2=oldtmp^tmp2
#    return tmp2
def addd(a,b):
    sum=a
    while b!=0:
        sum=a^b
        b=(a&b)<<1
        a=sum
    return sum
#https://blog.csdn.net/weilexuexia/article/details/52332368

def minus(a,b):
    tmp=addd(~b,1)
    print(tmp)
    return addd(a,tmp)#减法出不来,代码跟老师同样,也不行.

print(minus(4,3))

View Code

 

●这不是显然bitmap么.

扫描一次放一个2进制里面,而后再对2进制作位运算找到哪一个数位是0便可.效率O(N)

 

●首先遍历全部的正方形子矩阵.他的效率是O(N^3).

而后咱们作2个辅助矩阵都是n*n的,也叫作矩阵预处理.一个矩阵叫down,他表示原来矩阵i,j位置的下方有多少个连续的1.那么down[i][j]就写几.

第二个矩阵叫right.他表示原来矩阵i,j位置的右方有多少个连续的1.那么down[i][j]就写几.从而对获得的矩阵是否是边长都是1的矩阵的判断就快多了.\

  这个技巧叫预处理,在面试中很是实用.

●再给你举一个矩阵预处理的题:

给一个矩阵,求里面一个长方形小块的累加和.

给你小块的坐标.问你累加和多少.

我感受就是创建一个一样大小矩阵.矩阵[i][j]表示原矩阵sum[i1][j]  ,i1从1到i.

有了这个东西.你好比求左上角坐标3,5右下角坐标8,9的这个子矩阵的里面的元素的累加和.

那么显然我就在上面新创建的矩阵里面找[3][9]元素-[3][4]元素+......[8][9]元素-[8][4]元素.

预处理虽然是O(N^2)可是给定坐标再返回和的速度是O(N).

●上面的方法弱爆了,答案是生成的辅助矩阵应该表示[i][j]表示原矩阵的子矩阵[0][0]到[i][j]点这个子矩阵的累加和.

这样每一次给一个index求这个index表示的子矩阵的累加和就是一个O(1)的时间复杂度!

●

相似背包问题.写一下试试.

'''
sum给定.返回他拆分后伺机最大的值,
还给定全部的牌,是一个list
#显然就是背包思路便可,处理好边界值便可.
'''
memo={}#记忆体
def main(list1,index,sum):#返回牌只能用0到index(包含index)这么多个list1中数,和为sum的最大伺机.
    if (tuple(list1),index,sum)in memo:#由于list,unhashable ,因此tuple一下便可.
        return memo[(tuple(list1),index,sum)]
    if index==0 and sum!=0: #这个边界表示到了开始可是sum还不是0,还须要取数,那么久判断便可
        if sum ==list1[0]:
            return list1[0]
        else:
            return 0
    if sum==0:#这个边界表示到了其中一步,sum已经到0了,那么不须要取数了.因此返回1
        return 1


    #case1:选择index这个元素
    case1=main(list1,index-1,sum-list1[index])*list1[index]

    #case2:bu 选择index这个元素
    case2=main(list1,index-1,sum)
    memo[(tuple(list1),index,sum)]=max(case1,case2)
    return memo[(tuple(list1),index,sum)]
print(main([1,2,3,4,5,78,78,456,4325],8,83))

View Code

 

'''

其实上面的代码里面list1始终是不变的.因此记忆体不必加入list1这个变量.就能够
获得区分,因此能够修改为下面的,这样速度和空间都快了不少



sum给定.返回他拆分后伺机最大的值,
还给定全部的牌,是一个list
#显然就是背包思路便可,处理好边界值便可.
'''
memo={}#记忆体
def main(list1,index,sum):#返回牌只能用0到index(包含index)这么多个list1中数,和为sum的最大伺机.
    if (index,sum)in memo:#由于list,unhashable ,因此tuple一下便可.
        return memo[(index,sum)]
    if index==0 and sum!=0: #这个边界表示到了开始可是sum还不是0,还须要取数,那么久判断便可
        if sum ==list1[0]:
            return list1[0]
        else:
            return 0
    if sum==0:#这个边界表示到了其中一步,sum已经到0了,那么不须要取数了.因此返回1
        return 1


    #case1:选择index这个元素
    case1=main(list1,index-1,sum-list1[index])*list1[index]

    #case2:bu 选择index这个元素
    case2=main(list1,index-1,sum)
    memo[(index,sum)]=max(case1,case2)
    return memo[(index,sum)]
print(main([1,2,3,4,5,78,78,456,4325],8,83))

View Code

 

 递归的精髓:把大象装冰箱里面总共须要几步.

●经典的递归问题,背包问题的一个变种.虽然很是简单,可是必定要练好,特别是边界值的判断.这些细节问题.

●我在想一个问题,若是题目里面的list1里面的数能够是负数,那么如何写!应该很难!

●背包问题,第一次作很是难,卡了一天.最后也写出来的很差.多练才能习惯这个重要套路题型.

 

●

感受就是对龙的数量作规划便可.第一次是3,那么我用5, 第二次是3,8 那么我用5+10 第三次再加10.

这样扫描效率是mn.因此预处理一下便可.把龙和骑士的数组都排序.而后2个指针.这样来扫描须要哪一个骑士配哪一个龙.就更快了.

效率基本是O(M)  or O(n)

●进阶难度,算协力:这叫作矩阵压缩技巧.

●递归的找到内层,内层的返回值跟这一层拼起来就好了.

 

def main(huajian):#给3{d}2{bc{tt}} 返回他的原始字符
    #找到huajain字符的拆分index,用栈来实现
    #没有括号就直接返回
    if '{' not in huajian:
        return huajian
    #有括号就找到括号,而后递归.
    tmp=[]
    for i in range(len(huajian)):
        if huajian[i]=='{':
            tmp.append(('{',i))
        if huajian[i]=='}':
            qiefen_left=tmp.pop(-1)
            if tmp==[]:
             qiefen_right=i
             break
    #找到了1,3

    #找到数字跟字母混排的index
    tmp=huajian[:qiefen_left[1]]#就喜欢用这个tmp,temporory临时工这个单词.
    for i in range(len(tmp)):
        if tmp[i] in '0123456789':
            a=int(huajian[i:qiefen_left[1]])
            a=main(huajian[:i])+main(huajian[qiefen_left[1]+1:qiefen_right])*a+main(huajian[qiefen_right+1:])

            break
    else:
        a=huajian[:qiefen_left[1]]+main(huajian[qiefen_left[1]+1:qiefen_right])+main(huajian[qiefen_right+1:])



    return a
print(main('2{efg8{!!!!{o2{??}}}}3{cd}ef'))
'''
efg!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????efg!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????!!!!o????cdcdcdef
Press any key to continue . . .

输出结果还不错.这题目递归挺难的.须要对str进行分解.
这么多级嵌套都能出来,相信本身写对了.


'''

View Code

●高阶形式.讨论上个题目的逆,feichjang 难!

左老师的檫黑板太尼玛搞笑了.电子的也用一个鼠标橡皮来回搽.不是直接画一个白框删除就好了么,哈哈

●算法就是递归,递归就是算法.不用递归,算法题就不多了.

左神,国内最好的讲师.

老师说这个题很秒.

●本身想一个暴力方法.创建一个大矩阵,包含全部坐标.给一个矩形就把矩形内部和边缘的点都弄成1.而后继续插矩阵,若是重复就false.最后判断都是1的是否是一个矩阵.

标准答案:

每个rect就是一个矩阵的2个坐标,0,1,2,3里面的数值.把这2个坐标都放set里面.

x1表示的是全部矩阵的左上角的最小值................

而我set里面只存储全部的组合对.很是有可能x1,y1分别是最小值,可是他们不是一组里面的,因此他(x1,y1)不在set里面.

若是他不在set里面那么就表示

这个图形.他的(x1,y1)就不在set里面.

 

而这个图形就显然符合在set里面

其余3个判断同理,最后set的大小若是!=4那么set里面表示的是全部的端点.最后4是由于,若是拼成功了.那么必定中间的点都抵消了.(语句说若是set无法插入,也就是说已经存在了,那么咱们就删除他).

●总结.上面的算法实在是太妙了.看过的第一妙的题目.

 

●递归很好写.好比字符xyxyxyxy  x表示0,1 y表示逻辑运算.那么分类便可;

1.最后xy括起来.那么结果是xyxyxy的结果和最后的y作x运算,看他何时是desired.递归便可.

2.而后吧xyxy括起来继续讨论.

3....一直到xyxyxyxy总体加括号,

开始就想到了,感受效率很慢,后来发现答案就是这么作的.

 

●子数组是连续的.

牛客上记得作过这个题目:

显然就是从i=1开始加,若是和<=0了,那么i就移动到当前位置开始加.前面都不要了.(由于若是子数组从前面任意一个位置开始到如今的话已经小于0了,会对

后面的数据形成累赘,因此扔了便可.)随便写.

'''

'''
def main(list1):
    i=0
    j=len(list1)-1
    tmp=-float('inf')
    tmpsum=0
    while i<=j:
        tmpsum+=list1[i]
        if tmpsum>tmp:
            tmp=tmpsum
        if tmpsum<=0:
            
            tmpsum=0
        i+=1
    return tmp
print(main([1,-2,3,5,-2,6,-1]))

View Code

●补充题目:不相容就是不重合.也就是说这回能够断开一次.

●暴力方法就是把断点作遍历.而后每一次调用2次上面的找最大子数组便可.效率N^2

●正确方法:用数组的预处理.

先创建一个数组,他的每个index表示原始数组[:index]这个数组上的最大子数组的和.这个简单修改上门代码便可

而后咱们算总体的.仍是一个扫描一次新创建的数组.效率O(N).解决.

很是常常的预处理数组题目.15年阿里原题

'''
用数组预处理方法来解决这个进阶问题.
用2个预处理数组来作.
'''
def main(list1):
    i=0
    j=len(list1)-1
    tmp=-float('inf')
    tmpsum=0
    pre=[]
    while i<=j:
        tmpsum+=list1[i]
        if tmpsum>tmp:
            tmp=tmpsum
            
        if tmpsum<=0:
            
            tmpsum=0
        pre.append(tmp)#就是每一次扫描的时候把最大的这个tmp记录下来便可.
        i+=1
    return tmp,pre
def newmain(list1):
    a=main(list1)[1]
    b=main(list1[::-1])[1]   #第二个预处理数组是逆过来再求一次.
               #b表示的是b[i]表示原来数组list1从最后往前加一直加到i位置(包含i)的最大数组的累加和.
    max=-float('inf')
    for i in range(len(a)-1):
        first=a[i]
        second=b[len(a)-2-i]
        if first+second>max:
             max=first+second
    return max
print(newmain([1,-2,3,5,-2,6,-1]))#效率O(N)

View Code

 

●个人思路是预处理矩阵.作一个矩阵跟原来矩阵同样大.

新矩阵[i][j] 表示原来矩阵的行小于等于i,列小于等于j的子矩阵的最大子矩阵的累加和.(跟上一个题目很类似,只是多了一个dimension)

而后,咱们发现第一行,第一列都跟上个题目相似.

而后动态规划作i,j  显然就是i-1,j和i,j-1这2个已经算完的取max 再砍时候加上原来矩阵的元素[i][j]便可.简单就完成了.

效率N^2.N是矩阵的维数.(而且显然不能继续优化了,由于你扫描一次数据的时间就是N^2)

●上面思路错误.想了好久.只想到一个N^3的

遍历没有种i<=j. i,j属于0到n

而后对于每一种表示子矩阵行必须取i到j.而后动态规划列的取法.

系数k.表示子矩阵i行到j行.列从0到k.这个子矩阵的最大子矩阵元素和.

这个规划就是.k的状况=k-1的状况+i行到j行列为k的这个子矩阵的元素和.若是加完小于0.那么就置0.而后继续加.

(也就是跟上面一个数组的状况相似.只不过他每一次加一个数,这里面每一次加一个列.)

这样就获得了最后的答案,可是效率N^3.N是矩阵dimenson

●不是道左神有没有更好的算法:左神说他的效率也是N^3.鄙人不才,正号上面方法就是左神方法.

懂打1,不懂打2.又是  这个题目太经典了,必须代码实现细扣一下.

方法懂了,代码无脑写.

'''
矩阵的最大子数组的累加和问题
'''
import copy
def big_of_list(list1):#求一个数组的最大累加和问题.
    output=-float('inf')
    sum=0
    for i in range(len(list1)):
        sum+=list1[i]
        if sum<=0:
            sum=0
        if sum>output:
            output=sum
    return output



def main(mat):
    big=-float('inf')
    for i in range(len(mat)):
        #求只取第i行的累加和
        out1=big_of_list(mat[i])
        if out1>big:
            big=out1
        tmp=mat[i].copy()
        for j in range(i+1,len(mat)):#每一次拓展一行.这个for循环跑完就输出了
            #行只取i行,取i,i+1行,....取i到n行的全部这些行取法对应的最大的子矩阵的最大和.
            
            for ii in range(len(tmp)):
                tmp[ii]+=mat[j][ii]
            out2=big_of_list(tmp)
            if out2>big:
                    big=out2
    return big
print(main([[-90,48,78],[64,-40,64],[-81,-7,66]]))
#209 #写起来很无脑.就是分析难.

View Code

 

感受仍是辅助数组.

●真实的是，这个题目叫单调栈。求一个数列中任意一项的最近的比他小or大的index。

●暴力方法,确定是N^6

●相似上面一个题目求矩阵的最大子矩阵的和.那么咱们相似仍是遍历i,j 让他们造成选择i,j行这个概念.而后对这写个行组成的子大矩阵,进行对列N的现行规划便可.

效率显然N^3.(这个动态规划是,若是加入的新列都是1,那么原来就能够继续加,不然归0,从头开始算1便可.都他妈太相似了.写起来没意思.)

●左神说的最牛逼的题目.好吧.我leetcode是经过import re 里面matchfull 来狗过去的.代码量不操做5行....

下面关注这个题目正面硬钢的算法.比较复杂,可是代码很短.

 

 ●2个被火车撞了也不能忘的问题：

1.滑动窗口内的最大值

2.单调栈。用来求一个数组里面任意位置上的数，哪一个数是离他最近的比他小的数。

我来把他实现：

'''
左神的成名之算法：（又名：被火车撞了也不能忘了的算法）
1.滑动窗口内的最大值

2.单调栈。用来求一个数组里面任意位置上的数，哪一个数是离他最近的比他小的数。
下面实现第二个，第一个在博文上面已经实现了
'''
#好比咱们计算6535677这个矩阵，他的每个位置的数的最近的比他小的数的左右坐标
#就是，（null，1）（null,2）,(null,null),(2，null)，（3，null），（4，null），（4，null）
#这个算法在求条形图最大子矩阵的面积上很是核心的算法。
def main(list1):
      tmp=[]#是单调栈
      output=['kong']*len(list1)
      tmp.append([0])
      for i in range(1,len(list1)):
        if len(tmp)==0:
                      tmp.append([i])
                      continue
        if list1[i] >  list1[tmp[-1][-1]]:
             tmp.append([i])
             continue
        if list1[i] ==  list1[tmp[-1][-1]]:
              tmp[-1]+=[i]
              continue
        if list1[i] <  list1[tmp[-1][-1]]:
              while len(tmp)>0 and list1[i] <  list1[tmp[-1][-1]]:
                a=tmp.pop()
                #根据弹出的交表来写入output
                for ii in a:
                       if len(tmp)>0:
                        output[ii]=(tmp[-1][-1],i)
                       else:
                                   output[ii]=(None,i)
              #弹到最后一个,就按照以前的规则append便可.
              if len(tmp)==0:
                      tmp.append([i])
                      continue
              if list1[i] >  list1[tmp[-1][-1]]:
                   tmp.append([i])
                   continue
              if list1[i] ==  list1[tmp[-1][-1]]:
                  tmp[-1]+=[i]
                  continue
           
      #继续弹出剩余元素
      while len(tmp)>0:
                      a=tmp.pop()
                      last=a[0]
                      for ii in a:
                                      if len(tmp)>0:
                                                      output[ii]=(tmp[-1][-1],None)
                                      else:
                                                      output[ii]=(None,None)
      return output
print(main([6,5,3,5,6,7,7]))

print(main([6,50,35,51,6,7,7]))

print(main([6,500,3005,5451,86,8,8,8,8,788,77]))
#测试了3个效果不错,可是写的是比较丑陋,有些代码重复率高,不知道怎么优化,可是问题不大.
#下面来作应用.输出条形图的最大矩阵大小.好比3,5,8,3,3 输出应该是3*5=15
def area(list1):
    tmp=main(list1)
    area=['kong']*len(list1)#area[i]表示i条左右扩成的最大面积
    for i in range(len(area)):
            if tmp[i][0]==None and tmp[i][1]==None:
                #左右都扩不了
                area[i]=list1[i]*len(list1)
                continue
            if tmp[i][0]==None and tmp[i][1]!=None:
                  area[i]=list1[i]*(tmp[i][1])
            elif tmp[i][0]!=None and tmp[i][1]==None:
                  area[i]=list1[i]*(len(list1)-tmp[i][0]-1)
            else:
                 area[i]=list1[i]*(tmp[i][1]-tmp[i][0]-1)
    return tmp,area,max(area)
print(area([3,5,8,3,3])) #成功获得15
print(area([30,5,8,30,30])) #成功获得60!
'''
很是精彩的一个题目,感受能够被火车撞一下.
'''

View Code

 

●感受像背包问题。

第一个画家若是画第一个，那么等价于其余画匠画后面的，而后num-1.再跟第一个取max便可。这就是转移方程。简单过了。

 

'''
画匠问题:
'''
def main(list1,num):
      if list1==[]:
            return 0
      output=sum(list1)
      if num==1:
            return sum(list1)
      for i in range(1,len(list1)):

            time1=sum(list1[:i])
            time2=main(list1[i:],num-1)
            out=max(time1,time2)
            
            if out<output:
                  output=out
      return output
print(main([1,1,1,4,3],3))

View Code

 

'''
切回文问题:
'''

def main(str):
      
      if str==str[::-1]:
            return 0
      output=float('inf')
      for i in range(1,len(str)):
            a=str[:i]
            b=str[i:]
            out= main(a)+main(b)+1
            if out<output:
                  output=out
      return output
print(main('acdcdcdad')) #2

View Code

'''
切回文问题:
'''

def main(str):
      
      if str==str[::-1]:
            return 0
      output=float('inf')
      for i in range(1,len(str)):
            a=str[:i]
            b=str[i:]
            if a!=a[::-1]:#开始段不是回文就不用作了.

                  continue
            out= main(b)+1
            if out<output:
                  output=out
      return output
print(main('acdcdcdad')) #2

View Code  优化

 预处理版本:先作一个矩阵,矩阵[i][j]表示的是切片[i:j]是否是回文.

左神真拼啊.随后一节课第八次.直接4个小时

'''
判断平衡二叉树
'''
'''
须要先求全部节点的高
'''
def height(node):
      if node==None:
            return 0
      return max(height(node.left),height(node.right))+1
def balance(head):
      if head==None:
            return True
      return balance(head.left) and balance(head.right) and abs(height(head.left)-height(head.right))<=1
class node():
  def __init__(self,val):
      node.val=val
      node.left=None
      node.right=None
a=node(3)
a.left=node(3242)
a.right=node(435)
a.left.left=node(32423)
a.left.left.left=node(32423)
print(height(a))

print(balance(a))

View Code

'''
对于链表题,树的题目太烦了,就是由于无法创建本身的测试数据.测试数据创建很麻烦,
就喜欢数组题目,随便本身给测试数据
'''
'''
公司开会问题.
'''
def main(list1,i):#i表示到下表i
##      case1:下表为i的来,下表i的直接上司不来.
      if i==0:
            return list1[0][1]
      if list1==[]:
            return 0
      tmp=list1[i][0]

      case1=main(list1[:tmp],tmp-1)+main(list1[tmp+1:i+1],i-tmp-1)
      #case2:下表为i的不来
      case2=main(list1,i-1)
      return max(case1,case2)
print(main([[1,8],[0,9],[1,180]],2))

View Code

●感受是哈希表.可是空间不符合要求,要求空间O(1).bitmap应该能够.读一次.遇到一个数就把这个数对应的数位给从1变0,或者从0变1.

那么最后剩下基数词的数就是数位上为1的数.

●可是没有使用到题目中的特殊条件.

●利用异或的性质.知足交换律和结合律.因此第一个答案就是用异或串起来所有数便可.

 

 ●第二个:

●第三个问题:把全部数都转化成k进制.而后加起来,就获得了须要的那个支出线一次的数的k进制了.再随便转便可.

俄罗斯套娃问题.

 

'''
套娃问题
'''
def main(list1,i):#返回只用[i:]进行套娃的最大个数
    list1.sort(reverse=True)
    out=1
    if i==len(list1)-1:
        return 1
    #case1:使用套娃i号
    for j in range(i+1,len(list1)):
        if list1[j][0]<=list1[i][0] and list1[j][1]<=list1[i][1]:
            a=main(list1,j)+1
        else:
            a=main(list1,j)
        if a>out:
                out=a
    return out



print(main([[4,5],[6,7],[9,3],[8,9],[1,1],[1,1]],0))

View Code

 python 多维数组的排序

从图中就能够看出来,他排序是按照字典升序排列.也就是若是第一位置若是同样,那么就自动按照第二个位置进行V排列.

这点很方便.上面俄罗斯套娃问题.就会使用到这个技巧.若是两个套娃a,b 的第一列,是同样的,那么就自动按照第二列进行排列.!

 NlogN解决数组的最长子序列长度问题:

'''
求一个数组的最长上升序列的长度.左神说他的方法效率NlogN
'''
def main(list1):#创建一个数组b:b[i]表示长度为i+1的上升序列的末尾一个数最小是b[i]
    b=[]
    for i in list1:
        if b==[]:
            b.append(i)
        else:
            if i>b[-1]:
                b.append(i)
            else:#二分查找进行替换便可
                #bzhong 找到比i大的第一个数替换他.
                if len(b)==1:
                    if i<b[-1]:
                        b[0]=i
                    
                else:
                    start=1
                    end=len(b)-1
                    while start!=len(b)-1:
                        if b[0]>i:
                            b[0]=i
                        if b[start]==i:
                            break
                        if b[start]>=i and b[start-1]<i:
                            b[start]=i
                            break
                        if b[start-1]>=i:
                            end=(start+end+1)//2  #二分经常使用的分开数:(start+end+1)//2 注意要加1
                                             #否则死循环了.
                        if b[start]<i:
                            start=(start+end+1)//2
    return len(b)
print(main([51,5,6,6,6,6]))

    

View Code