פ ב ר ו א ר, בעיית בניין וכדור זכוכית. יש לנו בניין של N קומות ו- 2 כדורי זכוכית.צריך למצוא את הקומה הכי נמוכה שאם נזרק את הכדור הוא ישבר. חיפ

תמליל

1 בעיית בניין וכדור זכוכית. יש לנו בניין של N קומות ו- כדורי זכוכית.צריך למצוא את הקומה הכי נמוכה שאם נזרק את הכדור הוא ישבר. חיפוש שלם)כאשר יש כדור ( - אופציה הכי פשוטה לעבור על כל הקומות אינדוקטיבית)לולאת )for אם נשבר מצאנו אם לא נעבור,אם לא. לקומה הבאה.בסיבוכיות - כאשר יש יותר מכדור אחד אפשר לחלק את הבניין לחצי אם הכדור נשבר נעבור עם הכדור השני בחיפוש שלם מ-.,סה"כ פעולות נשבר נזרוק מקומה ה- כך אפשר לחלק את הבניין ל-,ועם הכדור השני נעבור בחיפוש שלם מ- חלקים וכך הלאה...אך זה לא נכון להגיד שנחלק ל- חלקים את הבניין כי בעצם נחזור mi b b b b x x mi x x x x x x x, לסיבוכיות של. לכן השאלה היא לכמה חלקים לחלק את הבניין כך שיהיה לנו מס' פעולות מינמ'?. f x תשובה: כל פעם עושים x x כלומר נחלק את הבניין ל - חלקים.. ומס' פעולות יש להתייחס למצב כאשר יש כדורים אז אפשר. log להשתמש בחיפוש בינארי, בסיבוכיות אך מצב זה לא אפשרי בחיים האמיתיים. it Drop Bll(it X ){// X brek flse kom i while(kom <+){ if(brek = true ) retur (kom - ) + BS(kom -, kom) kom (kom + ) - i i++ BS(strt,ed){ brek flse for i strt to ed if(brek(i) = true) retur i נערך ע"י רעי סיון -

2 אלגוריתם של משחק המספרים. אסטרטגיה ראשונה היא לחשב את הסכום של האיברים הזוגיים ואי זוגיים ואת הסכום הכי גבוהה מאינדקס שלו להתחיל,השחקן הראשון מכריח את היריב לקחת כל פעם את הכי נמוך,זה אלגוריתם של מקס' לא להפסיד. האלגוריתם השני מבטיח לסיים בתוצאה טובה יותר,יש ליצור עץ אבל רק ליצור אותו זה מטריצה.קודם נמלא באלכסון את המערך הנתון ואח"כ נמלא עפ"י התנאי:,לכן נתכנת דינמי ע"י כך שנמלא F[i,j-] F[i,i] = mx F[i+,j], -ואז הרווח נמצא בפינה הימנית העליונה. נתבונן ב- קודקודים ראשונים של עץ החישובים של חיפוש שלם של המשחק.כדי למצוא פתרון אנו נחשוב בצורה רקורסיבית ונניח.,,,אנחנו מניחים שיש לנו רווח בקודקודים, i שיש פתרון.כדי לדעת רווח של שחקן בקודקוד את המימוש של האלגוריתם נעשה בצורה אינדוקטיבית. אתחול מטריצה)אתחול אינדוקציה(,וב- for i (-) to for j (i+) to F[i,j] = mx F[i+,j], F[i,j-] i j for i to F[i,i] = i j - שחקן שחקן כדי לקבל/למצוא את המסלול נשאל את השאלה הבאה: while(i<j) if([i]-f[i+,j]>[j]-f[i,j-]) syso("my choose is:"+[i]) i++ syso("my choose is:"+[j]) j--. מי שנכון לוקחים.בסיבוכיות אז סה"כ הסיבוכיות דוגמא:, mx,,, F F F בעיית תת הריבוע הגדול ביותר של אחדות. כקלט אנו מקבלים מטריצה וכפלט מחזירים גודל של תת הריבוע הגדול ביותר,ומיקום קודקוד ימני עליון,נפתור בעיה זו ע"י תכנות דינאמי ב- בעל מקדם. נעתיק את השורה והעמודה הראשונה של המטריצה המקורית ואת כל האפסים שלה ונמלא את המטריצה ע"י החוקיות הבאה: M S. f i j submtrixof(it [][] M){ העתקת הדפנות// for i to S[,i] = M[,i] S[i,] = M[i,] מילוי המטריצה // for i to for j to if(m[i,j] ) S[i][j] = mi(s[i-][j],s[i-][j-],s[i][j-])+ if(s[i,j]>mx) mx = S[i][j] imx = i,jmx = j syso("+mx+",["+imx+","+jmx+"]", נערך ע"י רעי סיון -. f = mi x, y, z כמובן יש קודם לבדוק האם

3 m,כיוון שאנו שהיא בסדר למסלול קצר. בעיית המטוס המסלול הקצר ביותר. ישנן שתי שיטות לפתרון: ע"י חיפוש שלם אך בסיבוכיות של במקרה זה נבצע חישוב ביניים ונראה מה המסלול העדיף בכול תנועה.סיבוכיות המילוי של המטריצה היא - כל פעם מתקדמים במסלול אחד,אך עוברים על כל הנקודות של המטריצה. m,כי בכול מסלול חזרה שנבחר אנו נעבור ב-,m צלעות. סיבוכיות החזרה היא - נפתור זאת ע"י מטריצה שכל איבר בה הוא מסוג Node,המכיל שדות.etry,x,y נמלא את השורה התחתונה והעמודה השמאלית. נמלא את שאר הטבלה ע"י התנאי הנ"ל,התשובה תהיה מס' המסלולים האופטימאליים בפינה הימנית העליונה. על מנת למצוא את המסלול,נחזור מהפינה הימנית העליונה ע"י נכונות התנאי.)עפ"י התוצאה הנמוכה ביותר(. clss Node { it _x,_y,_etry public Node(it x,it y) _x = x _y = y _etry= priceofcheepestpths(){// = mtrix.legth mtrix[,]._etry = for i to // mx m, M[,i]._etry M[,i-]._etry + M[,i-]._x; M[i,]._etry M[i-,]._etry + M[i-,]._y מילוי המטריצה// for i to // for j to m // m M[i-,j]._etry + M[i-,j]._x b M[i,j-]._etry + M[i,j-]. y M[i,j]._etry Mth.mi(, b) retur mtrix[-,-]._etry מחזיר את המסלול הקצר ביותר // pritpth() Strig Strig S "("++","++")" i - j - while(i> && j>){ = mtrix[i][j-]._etiry; b = mtrix[i-][j]._etiry; if(>b) S = S+"-->["+(i-)+","+j+"]"; i--; S = S+"-->["+i+","+(j-)+"]"; j--; retur S+"-->[,]";.. אם מבקשים את מס' המסלולים המינמ' או המקס' בעצם נוסיף ל - Node עוד משתנה it dis דיפולטיבי)שווה ל (, ותנאי חזרה לפי בקשת השאלה מינמ' או מקס'. שהוא בעצם אורך המסלול שהוא if( = b) mtrix[i][j].dis mtrix[i-][j].dis + mtrix[i][j-].dis if( < b) mtrix[i][j].dis mtrix[i-][j].dis mtrix[i][j].dis mtrix[i][j-].dis. m m m סה"כ הסיבוכיות היא - נערך ע"י רעי סיון -

4 mi Mth.mi(rr[],rr[]) mix Mth.mx(rr[],rr[]) for i to rr.legth-//i=+ if(rr[i]>rr[i+]) if(rr[i]>mx) mx rr[i] if(rr[i+]<mi) mi rr[i+] if(rr[i+]>mx) mix rr[i+] if(rr[i]<mi) mi rr[i] retur {mi,mx בעיית.MiMx נשווה את שני האברים הראשוניים ונחלק אותם ל.mi,mx i i mx mx i. i mi mi i i, השוואות נחלק את המערך לזוגות וכל פעם נבדוק זוג - זוג ואם גדול מהמקס' נחליף למקס' וכך גם ההפך למינמ' - במקרה שהמערך ממוין אז זה לכן לא חשוב מה הסיבוכיות היא -,במקרה שלא זה השוואות. - בעיית.MxMx קיימים פתרונות אינדוקטיבי והשוואות.. אינדוקטיבי נקבל מערך ונהפוך אותו לרשימה מקושרת שבה נבדוק בין צמודים,כל איבר בה יהיה מסוג Node המורכב מ- שדות: it,כל um,ext אובייקט מחזיק מס' שהוא המקס' שלו וגם מחסנית שבה יש אברים פוטנציאלים להיות מקס'. נחלק לזוגות ונבדוק מי יותר גדול,את הקטן מבניהם נכניס למחסנית של הגדול ונמחק אותו מהרשימה ובסופו של דבר יהיה לנו איבר ברשימה שהוא.Mx נעשה חיפוש שלם על המחסנית שלו) Mx ( ונמצא את. Mx Iductio List list; for i to rr.legth list.dd(rr[i]) while(list.size()>) if(list.get[i]>list.get[i+]) list[i].s.push[i+].um remove list[i+] list[i+].s.push[i].um remove list[i] i++ if(i==list.size() i==list.size()-) i = ; Mx list[].um syso("mx is"+mx) Mx list[].s.pop while(!list[].s.isempty){ if(list[].s.pop>mx) Mx list[].s.pop syso("mx is:"+mx) סיבוכיות הכנסת אברי המערך לרשימה היא.. log השוואת האברים היא -. log Recursio לכן it mxmx(it low, it high){ if (low < high) idex middle (low + high)/ i mxmx(low, middle) j mxmx(middle+, high) if(rr[i].um>rr[j].um) rr[i].st.push(rr[j].um) idex i rr[j].st.push(rr[i].um) idex j retur idex retur low רקורסיבי גם כאן הופכים את המערך לרשימה מקושרת ולכל איבר בה מסוג Node שיש לו מחסנית ההבדל הוא רק בצורת החילוק.. נערך ע"י רעי סיון -

5 if(rr[]>rr[]) mx rr[] mx rr[] mx rr[],mx rr[] for i to rr.legth //i=+ if(rr[i]>rr[i-]) if(rr[i]>mx) if(rr[i-]>mx) mx rr[i] mx rr[i-] mx mx mx rr[i] //rr[i]<mx if(rr[i]>mx) mx rr[i] //rr[i]<rr[i-] if(rr[i]>mx) if(rr[i-]>mx) mx rr[i-] mx rr[i] mx mx mx rr[i-] //rr[i-]<mx if(rr[i-]>mx) mx rr[i-] retur mx,mx,ישנן דרכים רקורסיבי ואינדוקטיבי. נעביר את הדוגמא של mi/mx לשלנו ניקח שני אברים. i i i,,ונבדוק את היחס בניהם i ראשוניים mx i.. X x x x... x, השוואות שזו סיבוכיות של X X or X X... for exmple: 8 X X X /** * O(log) * Recursio */ double powerrecursio(double x, it ){ double result ; if( == ){// exit of recursio retur ; if(% == ){// is eve retur powerrecursio(x*x, /); {// is odd retur x*powerrecursio(x*x, ( - )/); mx i. ונבצע השוואות לזוג מספרים. ולכן יש לנו כאן חישוב חזקה. השיטה הפרימיטיבית היא ב - העיקרון לשיטה החכמה הוא: /** * O(log) * Iductive */ double poweriductive(double x, it ){ double result ; while(!=) if(% == ) result result*x; x x*x; /; retur result; נערך ע"י רעי סיון -

6 . it mx(it rr[],it k){ mx rr[] for i to k if(rr[i]>mx) mx rr[i] retur mx; it HELF(it []rr){ Arrys.sort(rr); HF rr[rr.legth/] retur HF; בעיית החציון. כאשר נבדוק את המערך ה- ההסתברות שהחציון הוא המס' ה mx היא %. במקרה שלנו בחרנו במספר =K. ישנו מצב מעניין שההסתברות לטעות במידה והמערך רנדומאלי היא / k הסתברות להצלחה =k / = / (/*/) = / k / יותר קטן מטווח הטעות של המחשב.. k הסיבוכיות - if(==)retur s for i to s s*i retur s. חישוב עצרת באינדוקציה. ברקורסיבי חישוב עצרת עולה לנו חישוב מספרי פיבונצ'י.,לכן עדיף להשתמש האינדוקציה שהסיבוכיות של היא /** * Recursive * O[log()] */ public sttic it FibFibRecursio(it ){ it[][]m {{,,{,; it[][]s FibRecursio(m,); retur s[][]; public sttic it[][] FibRecursio(it M [][], it ){ it [][] result {{,,{,; if ( == ){// exit of recursio retur result; if (% == ){// is eve retur FibRecursio(M X M, /); {// is odd retur M X FibRecursio(M X M,(-)/); בעצם כדי להגיע לסיבוכיות זו אנו לוקחים A,וכשנכפיל אותה מטריצה F F ב- פעמים נקבל,שזוהי F F בעצם נוסחת פיבונצ'י. נוכיח באינדוקציה הנחת האינדוקציה : F F F F F F F F נערך ע"י רעי סיון -

7 /** * Iductive * O[log()] */ public sttic it Fib(it ){ it[][]m = {{,,{,; it [][]result = ew it[][]; result[][] = ; result[][] = ; result[][] = ; result[][] = ; while (!=) if(%!= ) result = result X M M = M X M = /; שלב האינדוקציה: F F F F F F F F F F F F F F. log מ.ש.ל. סיבוכיות - retur result[][]; בעיית החניון. נתון לנו מערך מעגלי של מכוניות איך נספור את כמות המכוניות במערך? נתחיל לספור )נשמור את האינדקס שממנו התחלנו(,עד שהגענו לאותו ערך)נשמור את מס' הצעדים(. נשנה את אותו ערך לסימון שמוכר לנו.ואז נחזור חזרה כמס' הצעדים שלנו. אם הגענו לערך שממנו התחלנו נחזור חזרה מאיפה שהפסקנו ונמשיך לספור,אם הגענו לסימון שלנו מכאן שעשינו הקפה שלמה. void robot(it strt,it rr[]){ cout Mrk - for i strt+ to rr.legth if(rr[i]==rr[strt]) rr[strt] Mrk; if(rr[i]==rr[i-(cout%rr.legth)]) brek cout++; if(i>rr.legth-) strt Mrk System.out.pritl(cout) PritArry(rr,cout). הסיבוכיות - נערך ע"י רעי סיון - 7

8 LCS המחרוזת המשותפת הארוכה ביותר. בעצם אנחנו מחפשים את מידת ההתאמה בין מחרוזות.ישנן שיטות חיפוש שלם,אלגוריתם חמדני,ותכנות דינאמי.. חיפוש שלם כאן נסרוק את כל תתי המחרוזות בראשונה ובשנייה ומשווה כל פעם שיש התאמה.אבל יש מחרוזות בעלות אברים ולהן יש תתי קבוצות,)כי לאות אחת יש תתי קבוצות האות עצמה וקבוצה ריקה ולכן כל אות שנוסיף תיצור פי תתי m, m mi,אלגוריתם זה טוב למחרוזות באורך,לא יותר. קבוצות(,ולכן נגיע לסיבוכיות של - אלגוריתם חמדני כאן נעבור על המחרוזות הקצרה ביותר וניצור מערך שבו כל אינדקס מסמל אות מה ABC ובכול תא כזה יופיע m m,במקרה הגרוע ביותר. מס' הפעמים שאותה אות מופיעה במחרוזות.סיבוכיות של -. Strig greedy(strig X, Strig Y){ Strig res ""; it id, idex, beg ; while (id < X.legth()){ idex fidelemet(beg,y,x.chrat(id)); if(idex!= -){ res res + X.chrAt(id); beg idex+; id id + ; retur res; b c d דוגמא להרצת האלגוריתם: X b c b d b 7 help x help x help x help x help x help x help x help x help x help x help x help x help x7 help x אם בממוצע החמדני לא יקטין את היעילות לכן נבחר שיטה אחרת. תכנות דינאמי נבנה מטריצה נמלא את השורה והעמודה הראשונה באפסים ונבצע השוואות בין האותיות עפ"י התנאים הבאים:.,,, mx,,, F i j F i j b. F i j F i j F i j b בניית המטריצה: // build mtrix of umbers it[][] buildmtrix(chr[]x,chr[]y){// X, Y m +,m+ כי מוסיפים שורות אפסים // row + col m + M[][] ew it[row][col] מילוי שורה ראשונה באפסים // for i to row M[i][]= מילוי עמודה ראשונה באפסים // for j to col M[][j]= מילוי המטריצה עפ " י החוקיות // for i to row // for j to col // m if(x[i-]==y[j-]) M[i][j] M[i-][j-] + אם. m. הסיבוכיות היא - M[i][j] Mth.mx(M[i-][j],M[i][j-] retur M נערך ע"י רעי סיון - 8

9 מחזיר את המחרוזת המשותפת הארוכה ביותר: returs mx commo sequece legth it mxseqlegth(chr[]x,chr[]y){// X, Y m M[][] buildmtrix(x,y) retur M[][m] returs mx commo sequece chr[]mxsequece(chr[]x,chr[]y) M[][] buildmtrix(x, Y); seqlegth M[-][m-] result[] ew chr[seqlegth] i - j m- cout seqlegth- while(i>&&j>) if(x[i-]==y[j-]) result[cout--] X[i-] i-- j-- if(m[i][j]== M[i-][j]) i-- j-- retur result X F X b c b d 7 b i i+ Y F " "," b" דוגמא למימוש האלגוריתם: Y b j j+ b d c b b, b, mx seq le = b, d,, b whe x(i)=y(j) F()+= whe x(i)!=y(j) mx(,)= Vector<Strig> combitios(strig s, it k) { Vector<Strig> vec = ew Vector<Strig>() combitios(s, "", k, vec) retur vec void combitios(strig s,strig prefix,it k,vector<strig>vec) if (s.legth()<k) retur; if(k == )vec.dd(prefix) combitios(s.substrig(),prefix + s.chrat(),k-,vec) combitios(s.substrig(),prefix,k,vec) אלגוריתם רקורסיבי למציאת כל תתי קבוצות בגודל K. נערך ע"י רעי סיון - 9

10 d - LIS חיפוש של תת המערך הממוין הארוך ביותר. נפתור זאת ע"י תכנות דינאמי. legth. M.,ומערך נבנה מטריצה בגודל legth שהוא האלכסון של המטריצה. נעתיק את האיבר הראשון מהמערך למטריצה ול - d,עוברים על כל איבר ב - שיפור מכניסים אותו לאלכסון ומשמאלו מעתיקים את השורה שמתחתיו. דוגמא לרצת האלגוריתם:,ומחפשים מה אפשר לשפר באלכסון d,אחרי שמוצאים = {,,,,,,,,7,8 it[] LIS(it [] A){// A //copy M[][] ew it[][] d[] ew it[] M[][] A[] d[] A[] ed for i to // מחזיר את האינדקס של האיבר מהמערך למערך - d //. מחזיר LIS בסיבוכיות idex biryserchbetwee(d,ed,a(i))// log M[idex][idex] rr[i] for j to idex// M[idex][j] M[idex-][j] d[idex] A(i); if(idex>ed) ed++ it s[] ew it[ed+]; for j to ed s[j] M[ed][j] retur s נערך ע"י רעי סיון -

11 אם נרצה רק את הגודל נעשה חיפוש על המערך אבל המערך ממוין לכן נעשה חיפוש בינארי שזה. log log פונקצית עזר בבעיית.LIS מחזיר את האורך של LIS בסיבוכיות it LISLegth(it[]rr){ size rr.legth d[] ew it[size] d[] rr[] ed for i to size// idex biryserchbetwee(d, ed, rr[i])// log if(idex<=ed) d[idex] rr[i]; { ed++; d[ed] rr[i]; retur ed+; /*ממוין מערך בתוך המספר מיקום של בינארי חיפוש **/ it biryserchbetwee(it []rr, it ed, it vlue){ it low =, high = ed; if (vlue<rr[]) retur ; if (vlue>rr[ed]) retur ed+; while (low <=high){ it middle = (low + high)/; if (low == high) { if (rr[low] == vlue) retur low; retur low; { if (rr[middle] == vlue){//vlue ws foud retur middle; // vlue suppose to be left if (vlue < rr[middle]){ high = middle; // vlue suppose to be right { low = middle+; retur -; נערך ע"י רעי סיון -

12 .Y, LIS C. LCS A B בעיית LCS בעזרת.LIS המטרה קיימות מחרוזות ואנו צריכים לייצור איזו סדרה C במטרה לשפר את הסיבוכיות, האלגוריתם מחולק לכמה חלקים: ראשית ניצור מערך עזר שהוא מערך של מחסניות)לפי,b,c סה"כ אברים(, שמייצג אינדקסים של כל אות במערך )כל אות ב.),b,c שנית ניצור מערך A.עוברים על כל אות במערך X ל.A אנו מפעילים LIS על מערך A. ומוציאים את כל האינדקסים שהאות שלהם מופיעה במערך עזר ומוסיפים אותם For i to Z Y i push i Z: b c d e f A :,,,,,,,,.... X :, b,, c, u, X m Y : b,,, b, c,, Y..... הסבר של הקוד: עוברים על כל איבר במערך Y,ומכניסים את האינדקסים של האות למחסנית המתאימה במערך עזר Z. u... z A[] r For i to m rlog r ANS if! Z X i. empty( ) A A Z X i LISLegth A עוברים על כל איבר במערך X ניגשים למקום הנכון במערך מחסניות Z ומוסיפים את כל האברים של אותה מחסנית למערך A. מפעילים LIS על Aומקבלים תוצאה)המספרים שיוצאים הם האינדקסים שיוצרים LCS ביו המחרוזות(. m r r r r r. mi, log log הסיבוכיות היא - נערך ע"י רעי סיון -

13 מערך עזר() buildhelpz -- בניית // O(Y.legth) it idex for i to //i-- idex Y[i]-'' Z[idex].st.push(i) buildclustera //() O( A *log A ) מערך אשכולות -- בניית it idex, cout for i to m idex X[i]-'' if (!Z[idex].st.empty()) for j to Z[idex].st.size() A[cout] Z[idex].st.get(j) System.out.prit(A[cout]+",") cout++ It LogestCommSeq(A){ המחרוזת המשותפת הארוכה ביותר --חישוב rlog r buildhelpy(); buildclusterarr(); S LIS(A) retur S. legth r שברים עשרוניים אינסופיים מחזוריים. נכתוב פונקציה שמקבלת שבר פשוט כשני מספרים שלמים, כך שהראשון m הוא מונה והשני הוא מכנה. הפונקציה מחזירה מחרוזת של שבר עשרוני עם =N ספרות אחרי נקודה עשרונית. הנחה: המונה קטן ממכנה. Strig Frctio(Strig s,it m,it ){. הסיבוכיות - idex s "" moe m* N shrit m s "." for i to N if(moe>=) shrit moe% s s+shrit idex++ moe moe/ s s+moe moe shrit moe moe* retur s shrit moe % s s+shrit idex++ moe shrit moe moe* s s+"" נערך ע"י רעי סיון -

14 A,,...,,ועפ"י חוקיות נתונה בעיית בדיקת מיון המערך ע"י חוקיות מסוימת. נתונה לי סדרה מסוימת ממוינת יש לבנות סדרה חדשה ולבדוק האם היא ממוינת. Check(A){ סיבוכיות -. B A[] temp B s true; for i to B B + if(temp<b) temp B s flse brek ed for retur s fuctio it smllest/bigest(it[]x){// x it strt x[] it fiish it middle הסבר: - temp תמיד משתנה שבעל ערך קודם ל B. B משתנה שמקבל כל פעם את האיבר הבא בחישוב. As משתנה המראה אם הסדרה ממויינת. אנחנו סוכמים כל פעם את המשתנה B ובודקים אם הוא יותר גדול מ temp.. boole flg flse while(flg==flse) if(x[midle-]>x[midle]<x[midle+]) flg true s x[midle] for mi s x[midle-] for mx if(x[midle]<x[]) fiish midle- if(x[midle]>x[]) strt midle+ midle (strt+fiish)/ ed while retur s ed fuctio log הוצאת mi/mx הסיבוכיות ממערך מעגלי ב סיבוכיות של באה כי אנו log משתמשים באלגוריתם חיפוש בינארי. הרעיון של השימוש הוא כי הסדרה ממוינת מעגלית שזה אומר של איבר שבא אחרי X i הוא יותר גדול וההפך. העוגן שלנו הוא תמיד לכיוון של מהקטן ביותר לגדול ביותר או להפך. נערך ע"י רעי סיון -

15 בעיית המטבעות. בעיה זו דומה מאוד לבעיית המטוס,אנו נבנה מטריצה ונמלא רק חצי,כל צעד יכול להיות למעלה או שמאלה)לא ימינה(. ולאחר שנמלא אותה נחזיר את המסלול המקס' במקום המינמ'. עבור = נבנה מטריצה X ונמלא רק חצי שלכל איבר בה יש את סכום המטבע ואת ה etry של הסכום שצבר עד כה. for i to,כי ממלאים את ה etry בכול הסיבוכיות היא - for j to [i-][j].etry + [i-][j] איבר במטריצה. b [i-][j-].etry + [i][j] if(>b) the [i][j] = [i][j] = b retur [i][j].etry בשביל לקבל את במסלול הולכים לקודקוד העליון ובודקים עפ"י התנאי הבא: p p + "["++","++"]" i j if(([i][j].etry - [i][j])== [i][j-]) p p + "->["+(i)+","+(j-)+"[" j-- p p + "->["+(i-)+","+(j-)+"]" j--,i-- syso("the mx pth:"+p) 7 8 נערך ע"י רעי סיון -

16 פ ב ר ו א ר, משחק המספרים במערך מעגלי. בעצם לשחק הראשון יש אפשר לבחור בין כל אחד מהמספרים מהמערך ולכן לכל מס' שייקח השחקן הראשון יש מערך משחק שונה, לכן שי מערכי משחקים. לכן נכניס את כל ה מערכי משחקים למטריצה: GeerteSubGmes(A) Mtrix[][]SubGmeArry כל שורה במטריצה מציינת מערך של משחק. ולכל מערך משחק כזה יש מטריצת משחק משלו,לכן יש מטריצות בגודל [-][-],נכניס למערך תלת מימדי. Arry[][][]GmeMtrix ew Arry[][-][-] יש מערכי משחקים שלכל משחק יש מטריצת המשחק בגודל.[-][-] profit secod plyer: profit first plyer: - לאחר מכן נבנה את מטריצות המשחק לכל תתי המשחקים,ונבנה מערך של רווחים ונכניס אליו את כל הרווחים מכל המשחקים. הרווחים הם של השחקן השני. for i to GmeMtrix [i][][] BuildMtrix(SubGmeArry[i][]) profitarry[i] GmeMtrix[i][][-] ed for אבל אנחנו רוצים את הרווח של השחקן הראשון לכן נמצא את הרווחים של השחקן הראשון. for i to profitarry[i] A[i] profitarry[i] ed for לאחר מכן נמצא ממערך הרווחים של השחקן הראשון את הרווח המקס'. idex GetMx(profitArry) Prit(A[Idex]) // prit plyer choose pritgmestrtegy(gmemtrix[idex][][]) נערך ע"י רעי סיון -

17 Numbers Gme i Circle Arry : ונדפיס את הדרך האופטימאלית לניצחון של השחקן הראשון. Fuctio CircleNumbersGme(it[]A) it A.legth // crete rrys of ll subgmes Mtrix [][] SubGmeArry GeerteSubGmes (A) //crete D rry. Mes rry of gme mtrices. Arry [][][] GmeMtrix ew Arry [][-][-] Arry [] ProfitArry ew Arry[] fill the gme mtrices. For mx differece i profit d stck ll profits i profitarry for i to GmeMtrix [i][][] BuildMtrix(SubGmeArry[i][]) profitarry[i] GmeMtrix[i][][-] ed for // evlute totl profit for ll subgmes for i to i profitarry[i] ed for //fid the mx profit idex. It would be our strtegy. idex GetMx(profitArry) Prit(A[Idex]) // prit plyer choose pritgmestrtegy(gmemtrix[idex][][])prit the whole gme strtegy fter first move ed fuctio profitarry[i] בניית המטריצה מתבצעת עפ " י הכללים שלמדנו // Fuctio BuildMtrix(Arry[]A) Mtrix [][] M ew Mtrix[][] for i to A.legth M [i][i] for i (-) to for j (i+) to retur M Ed BuildMtrix i M[i][j] Mx( -M[i+][j], Fuctio pritgmestrtegy( Mtrix M [][] ) i, j M[].legth for k to X [i]-f[i+,j] Y [i]-f[i,j-] if(x>y) prit A[i] i i+ prit A[j] j j- ed for Ed pritgmestrtegy i j M[i][j-] ) נערך ע"י רעי סיון - 7