牛客網算法進階班筆記 包含,滑動窗口最大值維護和單調棧實現

牛客網算法進階班

 

顯然,排序+對撞指針,可是咱們老題新作.先排序而後都哈希到一個字典裏面,而後好比你給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