1
00:00:07,720 --> 00:00:10,950
[Powered by Google Translate] Marahil narinig mo na ang mga tao na makipag-usap tungkol sa isang mabilis o mahusay na algorithm

2
00:00:10,950 --> 00:00:13,090
para sa pag-execute ng iyong partikular na gawain,

3
00:00:13,090 --> 00:00:16,110
ngunit kung ano eksakto ang ibig sabihin para sa isang algorithm upang maging mabilis o mahusay?

4
00:00:16,110 --> 00:00:18,580
Well, ito ay hindi pakikipag-usap tungkol sa isang pagsukat sa real time,

5
00:00:18,580 --> 00:00:20,500
tulad ng mga segundo o minuto.

6
00:00:20,500 --> 00:00:22,220
Ito ay dahil ang computer hardware

7
00:00:22,220 --> 00:00:24,260
at software ay nag-iiba lubhang.

8
00:00:24,260 --> 00:00:26,020
Aking programa ay maaaring magpatakbo ng mas mabagal kaysa sa iyo,

9
00:00:26,020 --> 00:00:28,000
dahil ako nagpapatakbo ito sa isang mas lumang computer na,

10
00:00:28,000 --> 00:00:30,110
o dahil mangyayari kong naglalaro ng isang laro sa online ng video

11
00:00:30,110 --> 00:00:32,670
sa parehong oras, na kung saan ay hoging lahat ng memory ang aking,

12
00:00:32,670 --> 00:00:35,400
o maaari kong tumatakbo ang aking programa sa pamamagitan ng ibang software

13
00:00:35,400 --> 00:00:37,550
na nakikipanayam sa ang machine naiiba sa isang mababang antas.

14
00:00:37,550 --> 00:00:39,650
Ito ay tulad ng paghahambing ng mga mansanas at dalandan.

15
00:00:39,650 --> 00:00:41,940
Dahil lang sa aking mas mabagal na computer na tumatagal na

16
00:00:41,940 --> 00:00:43,410
kaysa sa iyo upang bigyan ng sagot

17
00:00:43,410 --> 00:00:45,510
ay hindi nangangahulugan na mayroon kang mas mahusay na algorithm.

18
00:00:45,510 --> 00:00:48,830
>> Kaya, dahil hindi direktang namin maaaring ihambing ang mga ang mga runtimes ng mga programa

19
00:00:48,830 --> 00:00:50,140
sa mga segundo o minuto,

20
00:00:50,140 --> 00:00:52,310
kung paano namin ihambing ang 2 iba't ibang mga algorithm

21
00:00:52,310 --> 00:00:55,030
sa kabila ng kanilang hardware o software na kapaligiran?

22
00:00:55,030 --> 00:00:58,000
Upang lumikha ng isang mas unipormeng paraan ng pagsukat ng algorithmic kahusayan,

23
00:00:58,000 --> 00:01:00,360
computer na siyentipiko at mathematicians na gagawin

24
00:01:00,360 --> 00:01:03,830
konsepto para sa pagsukat ng asymptotic kumplikado ng isang programa

25
00:01:03,830 --> 00:01:06,110
at ang pagtatanda ng tinatawag na 'Big Ohnotation'

26
00:01:06,110 --> 00:01:08,320
para sa naglalarawan ito.

27
00:01:08,320 --> 00:01:10,820
Ang pormal na kahulugan ay na ang isang function f (x)

28
00:01:10,820 --> 00:01:13,390
tumatakbo sa ang pagkakasunod-sunod ng g (x)

29
00:01:13,390 --> 00:01:15,140
kung may umiiral ilang (x) halaga, x ₀ at

30
00:01:15,140 --> 00:01:17,630
ilang pare-pareho, C, kung saan

31
00:01:17,630 --> 00:01:19,340
f (x) ay mas mababa sa o katumbas ng

32
00:01:19,340 --> 00:01:21,230
na pare-pareho beses g (x)

33
00:01:21,230 --> 00:01:23,190
para sa lahat ng x mas malaki kaysa sa x ₀.

34
00:01:23,190 --> 00:01:25,290
>> Ngunit huwag madala ng pormal na kahulugan.

35
00:01:25,290 --> 00:01:28,020
Ano ang tunay na ibig sabihin sa mas panteorya mga tuntunin?

36
00:01:28,020 --> 00:01:30,580
Well, ito ay isa lamang paraan ng pag-aaral

37
00:01:30,580 --> 00:01:33,580
kung gaano kabilis ang runtime ng programa ay lumalaki asymptotically.

38
00:01:33,580 --> 00:01:37,170
Iyon ay, bilang ang laki ng iyong mga input ay nagdaragdag patungo sa infinity,

39
00:01:37,170 --> 00:01:41,390
halimbawa, ikaw ay pag-uuri-uri ng isang hanay ng mga laki 1000 kumpara sa isang hanay ng mga laki 10.

40
00:01:41,390 --> 00:01:44,950
Kung paano palaguin ang runtime ng iyong programa?

41
00:01:44,950 --> 00:01:47,390
Halimbawa, isipin ang pagbibilang sa bilang ng mga character

42
00:01:47,390 --> 00:01:49,350
sa isang string ang pinakasimpleng paraan

43
00:01:49,350 --> 00:01:51,620
 sa pamamagitan ng paglalakad sa pamamagitan ng ang buong string

44
00:01:51,620 --> 00:01:54,790
sulat-by-titik na at pagdadagdag ng 1 sa isang counter para sa bawat karakter.

45
00:01:55,700 --> 00:01:58,420
Algorithm na ito ay sinabi upang tumakbo sa linear oras

46
00:01:58,420 --> 00:02:00,460
may paggalang sa bilang ng mga character,

47
00:02:00,460 --> 00:02:02,670
'N' sa string.

48
00:02:02,670 --> 00:02:04,910
Sa maikli, ito ay tumatakbo sa O (n).

49
00:02:05,570 --> 00:02:07,290
Bakit ito?

50
00:02:07,290 --> 00:02:09,539
Well, gamit ang diskarteng ito, oras kinakailangan

51
00:02:09,539 --> 00:02:11,300
pagbagtas buong string

52
00:02:11,300 --> 00:02:13,920
ay proporsyonal sa bilang ng mga character.

53
00:02:13,920 --> 00:02:16,480
Nagbibilang ang bilang ng mga character sa isang 20-character na string

54
00:02:16,480 --> 00:02:18,580
pagpunta sa dalawang beses hangga't ito ay tumatagal ng

55
00:02:18,580 --> 00:02:20,330
upang mabilang ang mga character sa isang 10-karakter na string,

56
00:02:20,330 --> 00:02:23,000
dahil mayroon kang upang tumingin sa lahat ang mga character

57
00:02:23,000 --> 00:02:25,740
at ang karakter bawat tumatagal sa parehong halaga ng oras upang tumingin sa.

58
00:02:25,740 --> 00:02:28,050
Bilang mong taasan ang bilang ng mga character,

59
00:02:28,050 --> 00:02:30,950
runtime ay taasan linearly sa input ang haba.

60
00:02:30,950 --> 00:02:33,500
>> Ngayon, isipin kung magpasya ka na linear oras,

61
00:02:33,500 --> 00:02:36,390
O (n), ay hindi mabilis sapat para sa iyo?

62
00:02:36,390 --> 00:02:38,750
Siguro ka sa pag-iimbak ng mga malaking string,

63
00:02:38,750 --> 00:02:40,450
at hindi mo kayang bayaran ang labis na oras na tumagal

64
00:02:40,450 --> 00:02:44,000
pagbagtas ang lahat ng kanilang mga character pagbibilang ng isa-by-isa.

65
00:02:44,000 --> 00:02:46,650
Kaya, nagpasya kang sumubok ng iba't ibang.

66
00:02:46,650 --> 00:02:49,270
Ano kung nais mong mangyari sa na-imbak ang bilang ng mga character

67
00:02:49,270 --> 00:02:52,690
sa string, sabihin, sa isang variable na tinatawag na 'Len,'

68
00:02:52,690 --> 00:02:54,210
sa maagang bahagi sa programa,

69
00:02:54,210 --> 00:02:57,800
bago ka kahit na naka-imbak sa unang character sa iyong string?

70
00:02:57,800 --> 00:02:59,980
Pagkatapos, ang lahat ng gusto mong gawin ngayon upang mahanap ang string haba,

71
00:02:59,980 --> 00:03:02,570
ay tingnan kung ano ang halaga ng variable ay.

72
00:03:02,570 --> 00:03:05,530
Hindi mo upang tingnan ang string na mismo sa lahat,

73
00:03:05,530 --> 00:03:08,160
at pag-access sa ang halaga ng isang variable tulad Len ay itinuturing

74
00:03:08,160 --> 00:03:11,100
oras na operasyon na isang asymptotically na pare-pareho,

75
00:03:11,100 --> 00:03:13,070
o O (1).

76
00:03:13,070 --> 00:03:17,110
Bakit ito? Well, tandaan kung ano ang ibig sabihin ng asymptotic kumplikado.

77
00:03:17,110 --> 00:03:19,100
Paano gumagana ang runtime pagbabago bilang ang laki

78
00:03:19,100 --> 00:03:21,400
ng iyong input ay lumalaki?

79
00:03:21,400 --> 00:03:24,630
>> Sabihin nating ikaw ay sinusubukan upang makuha ang bilang ng mga character sa isang mas malaking string.

80
00:03:24,630 --> 00:03:26,960
Well, hindi ito ay mahalaga kung gaano kalaki ang string,

81
00:03:26,960 --> 00:03:28,690
kahit isang milyong mga character ang haba,

82
00:03:28,690 --> 00:03:31,150
lahat na nais mong gawin upang mahanap ang haba ng string na ang diskarteng ito,

83
00:03:31,150 --> 00:03:33,790
upang basahin ang halaga ng variable Len,

84
00:03:33,790 --> 00:03:35,440
kung saan ikaw ay ginawa.

85
00:03:35,440 --> 00:03:38,200
Ang haba ng input, iyon ay, ang haba ng string na sinusubukan mong mahanap,

86
00:03:38,200 --> 00:03:41,510
ay hindi nakakaapekto sa lahat kung gaano kabilis ang iyong programa ay tumatakbo.

87
00:03:41,510 --> 00:03:44,550
Ito bahagi ng iyong programa ay tatakbo pantay mabilis sa isa-character na string

88
00:03:44,550 --> 00:03:46,170
at thousand-character na string,

89
00:03:46,170 --> 00:03:49,140
at iyon ang dahilan kung bakit ang programa ito ay tinutukoy bilang tumatakbo sa pare-pareho ang oras

90
00:03:49,140 --> 00:03:51,520
may paggalang sa laki ng input.

91
00:03:51,520 --> 00:03:53,920
>> Siyempre, ang isang sagabal.

92
00:03:53,920 --> 00:03:55,710
Gumastos ka ng dagdag na espasyo ng memorya sa iyong computer

93
00:03:55,710 --> 00:03:57,380
pag-imbak ng variable

94
00:03:57,380 --> 00:03:59,270
at ang labis na oras na tumagal

95
00:03:59,270 --> 00:04:01,490
upang gawin ang mga aktwal na imbakan ng variable,

96
00:04:01,490 --> 00:04:03,390
ngunit ang punto pa rin nakatayo,

97
00:04:03,390 --> 00:04:05,060
paghahanap ng kung gaano katagal ang iyong string ay

98
00:04:05,060 --> 00:04:07,600
ay hindi depende sa haba ng string sa lahat.

99
00:04:07,600 --> 00:04:10,720
Kaya, ito ay tumatakbo sa O (1) o pare-pareho ang oras.

100
00:04:10,720 --> 00:04:13,070
Ito ay tiyak na walang ibig sabihin

101
00:04:13,070 --> 00:04:15,610
na ang iyong code ay tumatakbo sa 1 hakbang,

102
00:04:15,610 --> 00:04:17,470
ngunit hindi mahalaga kung gaano karaming mga hakbang na ito ay,

103
00:04:17,470 --> 00:04:20,019
kung hindi ito baguhin ang laki ng input,

104
00:04:20,019 --> 00:04:23,420
pa rin asymptotically pare-pareho na kumakatawan namin bilang O (1).

105
00:04:23,420 --> 00:04:25,120
>> Bilang maaari mong marahil hulaan,

106
00:04:25,120 --> 00:04:27,940
maraming iba't ibang malaking O runtimes sukatin ang mga algorithm na may.

107
00:04:27,940 --> 00:04:32,980
O (n) ² algorithm asymptotically mas mabagal kaysa sa O (n) na mga algorithm.

108
00:04:32,980 --> 00:04:35,910
Iyon ay, bilang ang bilang ng mga elemento (n) ay lumalaki,

109
00:04:35,910 --> 00:04:39,280
kalaunan O (n) ² algorithm ay mas maraming oras

110
00:04:39,280 --> 00:04:41,000
sa O (n) na mga algorithm upang tumakbo.

111
00:04:41,000 --> 00:04:43,960
Hindi ito nangangahulugan O (n) na mga algorithm palaging patakbuhin ang mas mabilis

112
00:04:43,960 --> 00:04:46,410
sa O (n) ² algorithm, kahit na sa parehong kapaligiran,

113
00:04:46,410 --> 00:04:48,080
sa parehong hardware.

114
00:04:48,080 --> 00:04:50,180
Siguro para sa maliit na mga laki ng input,

115
00:04:50,180 --> 00:04:52,900
 ang O (n) ² algorithm ay maaaring aktwal na magtrabaho nang mas mabilis,

116
00:04:52,900 --> 00:04:55,450
ngunit, kalaunan, bilang ang laki ng input ay nagdaragdag

117
00:04:55,450 --> 00:04:58,760
patungo sa infinity, ang runtime O (n) ² algorithm ng

118
00:04:58,760 --> 00:05:02,000
ay malaon Eclipse ang runtime ng algorithm O (n).

119
00:05:02,000 --> 00:05:04,230
Tulad ng anumang parisukat mathematical function na

120
00:05:04,230 --> 00:05:06,510
 kalaunan maabutan anumang linear function na,

121
00:05:06,510 --> 00:05:09,200
hindi mahalaga kung magkano ng isang ulo simulan ang linear function na ay nagsisimula off na may.

122
00:05:10,010 --> 00:05:12,000
Kung ikaw ay gumagawa na may malaking halaga ng data,

123
00:05:12,000 --> 00:05:15,510
algorithm na tumakbo sa O (n) ² oras talagang magtapos alalay ng iyong programa,

124
00:05:15,510 --> 00:05:17,770
ngunit para sa maliit na mga laki ng input,

125
00:05:17,770 --> 00:05:19,420
malamang na hindi ka kahit mapansin.

126
00:05:19,420 --> 00:05:21,280
>> Isa pang asymptotic kumplikado ay,

127
00:05:21,280 --> 00:05:24,420
logarithmic oras, O (log n).

128
00:05:24,420 --> 00:05:26,340
Isang halimbawa ng isang algorithm na tumatakbo ito mabilis

129
00:05:26,340 --> 00:05:29,060
ay ang classic na algorithm ng paghahanap ng binary,

130
00:05:29,060 --> 00:05:31,850
para sa paghahanap ng isang elemento sa isang na-pinagsunod-sunod na listahan ng mga elemento.

131
00:05:31,850 --> 00:05:33,400
>> Kung hindi mo alam kung ano ang binary paghahanap,

132
00:05:33,400 --> 00:05:35,170
Ipapaliwanag ko ito para sa iyo talagang mabilis.

133
00:05:35,170 --> 00:05:37,020
Sabihin nating na iyong hinahanap para sa numero 3

134
00:05:37,020 --> 00:05:40,200
sa hanay ng mga integer.

135
00:05:40,200 --> 00:05:42,140
Tinitingnan ang gitnang elemento ng array

136
00:05:42,140 --> 00:05:46,830
at nagtatanong, "Ang elemento Gusto kong mas malaki kaysa sa, katumbas ng, o mas mababa dito?"

137
00:05:46,830 --> 00:05:49,150
Kung ito ay katumbas, pagkatapos mahusay. Na iyong natagpuan ang sangkap, at tapos ka na.

138
00:05:49,150 --> 00:05:51,300
Kung ito ay mas malaki, at pagkatapos ay alam mo ang elemento

139
00:05:51,300 --> 00:05:53,440
ay sa kanang bahagi ng array,

140
00:05:53,440 --> 00:05:55,200
at maaari ka lamang tumingin sa na sa hinaharap,

141
00:05:55,200 --> 00:05:57,690
at kung ito ay mas maliit, pagkatapos ay alam mo ito sa kaliwang bahagi.

142
00:05:57,690 --> 00:06:00,980
Ang proseso na ito ay paulit-ulit na may mas maliit na-laki array

143
00:06:00,980 --> 00:06:02,870
hanggang sa tamang elemento ay natagpuan.

144
00:06:08,080 --> 00:06:11,670
>> Ang malakas na algorithm ay mapuputol ang laki ng array sa kalahati sa bawat operasyon.

145
00:06:11,670 --> 00:06:14,080
Kaya, upang mahanap ang isang elemento sa isang pinagsunod-sunod na hanay ng mga laki 8,

146
00:06:14,080 --> 00:06:16,170
hindi hihigit sa (log ₂ 8),

147
00:06:16,170 --> 00:06:18,450
o 3 sa mga pagpapatakbo,

148
00:06:18,450 --> 00:06:22,260
sa pagsusuri sa gitna elemento, na-cut ang array sa kalahati ay kailangan,

149
00:06:22,260 --> 00:06:25,670
kung saan ang isang hanay ng mga laki 16 tumatagal (log ₂ 16),

150
00:06:25,670 --> 00:06:27,480
o 4 pagpapatakbo.

151
00:06:27,480 --> 00:06:30,570
Na lamang 1 pang operasyon para sa Dinoble-laki array.

152
00:06:30,570 --> 00:06:32,220
Pagdodoble ang laki ng array

153
00:06:32,220 --> 00:06:35,160
pinatataas ang runtime pamamagitan lamang ng 1 tipak ng ang code na ito.

154
00:06:35,160 --> 00:06:37,770
Muli, check sa gitna elemento ng listahan, pagkatapos ay paghahati ng.

155
00:06:37,770 --> 00:06:40,440
Kaya, ito ay sinabi na nagpapatakbo sa logarithmic oras,

156
00:06:40,440 --> 00:06:42,440
O (log n).

157
00:06:42,440 --> 00:06:44,270
Ngunit maghintay, sabihin mo,

158
00:06:44,270 --> 00:06:47,510
ay hindi ito depende sa kung saan sa listahan ang sangkap na hinahanap mo ay?

159
00:06:47,510 --> 00:06:50,090
Paano kung ang unang elemento na tumingin ka sa mangyayari ang tamang?

160
00:06:50,090 --> 00:06:52,040
Pagkatapos, ito lamang ay tumatagal ng 1 pagpapatakbo,

161
00:06:52,040 --> 00:06:54,310
hindi mahalaga kung gaano kalaki ang listahan.

162
00:06:54,310 --> 00:06:56,310
>> Well, na kung bakit ang computer na siyentipiko ay may higit pang mga term

163
00:06:56,310 --> 00:06:58,770
para sa asymptotic kumplikado na sumasalamin sa pinakamahusay na-case

164
00:06:58,770 --> 00:07:01,050
at pinakamalala-case performance ng isang algorithm.

165
00:07:01,050 --> 00:07:03,320
Mas maayos, itaas at mas mababang mga hangganan

166
00:07:03,320 --> 00:07:05,090
sa runtime.

167
00:07:05,090 --> 00:07:07,660
Sa pinakamahusay na kaso para sa paghahanap ng binary, ang aming elemento ay

168
00:07:07,660 --> 00:07:09,330
doon sa gitna,

169
00:07:09,330 --> 00:07:11,770
at makakakuha ka ng ito sa pare-pareho ang oras,

170
00:07:11,770 --> 00:07:14,240
kahit gaano kalaki ang ibang bahagi ng array ay.

171
00:07:15,360 --> 00:07:17,650
Ang simbolo na ginamit para sa Ω.

172
00:07:17,650 --> 00:07:19,930
Kaya, ito algorithm ay sinabi upang tumakbo sa Ω (1).

173
00:07:19,930 --> 00:07:21,990
Sa ang pinakamahusay na kaso, nakakahanap ng mga elemento mabilis,

174
00:07:21,990 --> 00:07:24,200
hindi mahalaga kung gaano kalaki ang array,

175
00:07:24,200 --> 00:07:26,050
ngunit sa ang pinakamasama kaso,

176
00:07:26,050 --> 00:07:28,690
upang isagawa (log n) tseke split

177
00:07:28,690 --> 00:07:31,030
ng array upang mahanap ang karapatan na elemento.

178
00:07:31,030 --> 00:07:34,270
Pinakamahina-case itaas na hangganan ay tinutukoy na may malaking "O" na alam mo na.

179
00:07:34,270 --> 00:07:38,080
Kaya, O (log n), ngunit Ω (1).

180
00:07:38,080 --> 00:07:40,680
>> Isang linear paghahanap, sa pamamagitan ng kaibahan,

181
00:07:40,680 --> 00:07:43,220
kung saan ituturo sa iyo sa pamamagitan ng bawat elemento ng array

182
00:07:43,220 --> 00:07:45,170
upang mahanap ang isa na nais mong,

183
00:07:45,170 --> 00:07:47,420
sa pinakamahusay Ω (1).

184
00:07:47,420 --> 00:07:49,430
Muli, ang unang elemento gusto mo.

185
00:07:49,430 --> 00:07:51,930
Kaya, hindi mahalaga kung gaano kalaki ang array.

186
00:07:51,930 --> 00:07:54,840
Sa pinakamasama kaso, ang huling elemento sa array.

187
00:07:54,840 --> 00:07:58,560
Kaya, mayroon kang maglakad sa lahat n mga elemento sa array upang hanapin ito,

188
00:07:58,560 --> 00:08:02,170
bang kung ikaw ay naghahanap para sa isang 3.

189
00:08:04,320 --> 00:08:06,030
Kaya, tumatakbo sa O (n) oras

190
00:08:06,030 --> 00:08:09,330
dahil ito ay proporsyonal sa bilang ng mga elemento sa array.

191
00:08:10,800 --> 00:08:12,830
>> Isa pang simbolo na ginamit ay Θ.

192
00:08:12,830 --> 00:08:15,820
Na ito ay maaaring gamitin upang ilarawan ang mga algorithm kung saan ang pinakamahusay at pinakamasama kaso

193
00:08:15,820 --> 00:08:17,440
ay pareho.

194
00:08:17,440 --> 00:08:20,390
Ito ay ang kaso sa string-length na algorithm usapan natin ang tungkol mas maaga.

195
00:08:20,390 --> 00:08:22,780
Iyon ay, kung namin iimbak ito sa isang variable bago

196
00:08:22,780 --> 00:08:25,160
imbak ng namin ang string at ma-access ang mga ito sa ibang pagkakataon sa pare-pareho ang oras.

197
00:08:25,160 --> 00:08:27,920
Kahit na ano bilang

198
00:08:27,920 --> 00:08:30,130
namin ang pag-iimbak sa na variable, makikita namin upang tingnan ito.

199
00:08:33,110 --> 00:08:35,110
Ang pinakamahusay na kaso ay, tinitingnan namin dito

200
00:08:35,110 --> 00:08:37,120
at hanapin ang haba ng string.

201
00:08:37,120 --> 00:08:39,799
Kaya Ω (1) o pinakamahusay na kaso na pare-pareho ang oras.

202
00:08:39,799 --> 00:08:41,059
Ang pinakamasama kaso ay,

203
00:08:41,059 --> 00:08:43,400
tinitingnan namin ito at hanapin ang haba ng string.

204
00:08:43,400 --> 00:08:47,300
Kaya, O (1) o pare-pareho ang oras sa pinakamalala kaso.

205
00:08:47,300 --> 00:08:49,180
Kaya, dahil ang pinakamahusay na kaso at pinakamalala kaso ay pareho,

206
00:08:49,180 --> 00:08:52,520
ito ay maaaring sinabi upang tumakbo sa Θ (1) oras.

207
00:08:54,550 --> 00:08:57,010
>> Sa buod, mayroon kaming magandang paraan sa dahilan tungkol sa mga code ng kahusayan

208
00:08:57,010 --> 00:09:00,110
nang hindi alam ng anumang tungkol sa real-world na oras na tumagal sila upang tumakbo,

209
00:09:00,110 --> 00:09:02,270
na apektado ng maraming labas kadahilanan,

210
00:09:02,270 --> 00:09:04,190
kabilang ang magkakaibang hardware, software,

211
00:09:04,190 --> 00:09:06,040
o ang mga pagtutukoy ng iyong code.

212
00:09:06,040 --> 00:09:08,380
Gayundin, ito ay nagbibigay-daan sa amin upang dahilan na rin tungkol sa kung ano ang mangyayari

213
00:09:08,380 --> 00:09:10,180
kapag ang laki ng pagtaas ng input.

214
00:09:10,180 --> 00:09:12,490
>> Kung nagpapatakbo ka sa O (n) ² algorithm,

215
00:09:12,490 --> 00:09:15,240
o mas masahol pa, isang O (2 ⁿ) algorithm,

216
00:09:15,240 --> 00:09:17,170
isa sa pinakamabilis na lumalagong uri,

217
00:09:17,170 --> 00:09:19,140
mo ba talagang simulan upang mapansin ang paghina

218
00:09:19,140 --> 00:09:21,220
kapag nagsimula ka nagtatrabaho na may mas malaking halaga ng data.

219
00:09:21,220 --> 00:09:23,590
>> Na asymptotic kumplikado. Salamat.