API tools faq
paste
a53

CPPREFERANCE

a53
May 21st, 2022 (edited)
114
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 211.56 KB | None | 0 0
raw download clone embed print report
  1. ITSF `  ²V2b ý|ª{О  É"æìý|ª{О  É"æì`  x T` Ì` þ a( ITSP T
  2.      ÿÿÿÿ  j’].!Нù  É"æìT ÿÿÿÿࠃࠃࠃࠃࠃࠃࠐMGL^ ÿÿÿÿ / /#IDXHDR„„q  /#ITBITS /#STRINGS†²Ô/#SYSTEM …N¡5/#TOPICS„¤qË /#URLSTR…¨M‰G/#URLTBL„ð¸< /#WINDOWSö¿kL /$FIftiMainøÅY‹¿ /$OBJINSTø°•?/$WWAssociativeLinks/ /$WWAssociativeLinks/Propertyø°/$WWKeywordLinks/ /$WWKeywordLinks/BTreeöÁ7ÀL/$WWKeywordLinks/Dataø‚­/$WWKeywordLinks/Mapø¯Z/$WWKeywordLinks/Propertyø¯v
  3. /ascii.htmŠÉF˜-/c/
  4. /c/all.htm‹ás±/c/date/ /c/date/asctime.htm’x
  5. /c/date/clock.htm£‹ /c/date/ctime.htm®ŽR/c/date/datime.htm¼`‰m/c/date/difftime.htmÆMŠ)/c/date/gmtime.htmÐv`/c/date/localtime.htmÞV” /c/date/mktime.htmòVŒH/c/date/setlocale.htmÿ’2/c/date/start.htmŽ‘P”:/c/date/strftime.htmŽ¦
  6. £V/c/date/time.htmŽÉ`Žj/c/io/ /c/io/clearerr.htmŽØJŠm/c/io/fclose.htmŽã7‹/c/io/feof.htmŽîSŠl/c/io/ferror.htmŽù?ŠY/c/io/fflush.htm„—/c/io/fgetc.htm›)Œv/c/io/fgetpos.htm¨Œ/c/io/fgets.htm´ Ž
  7. /c/io/fopen.htmÂ-Ÿ/c/io/fprintf.htmá5“Z/c/io/fpurge.htmõ•/c/io/fputc.htmŠ"X/c/io/fputs.htm—zŒ0/c/io/fread.htm¤*4/c/io/freopen.htm´^/c/io/fscanf.htmÁoŽ/c/io/fseek.htmÏ~’P/c/io/fsetpos.htmâN‹C/c/io/ftell.htmî‰j/c/io/fwrite.htm÷{"/c/io/getc.htm‘…”t/c/io/getchar.htm‘šŠR/c/io/gets.htm‘¤c-/c/io/perror.htm‘²”|/c/io/printf.htm‘Ç Ãx/c/io/putc.htm’‹—
  8. /io/flags.htm§Òs‰\
  9. /io/flush.htm§ÜO‹d/io/gcount.htm§è3‰D /io/get.htm§ñwa/io/getline.htm¨XŸ
  10. /io/good.htm¨®e/io/ignore.htm¨½}/io/io_flags.htm¨Íè /io/open.htm©µ6’M /io/peek.htm©È‰a/io/precision.htm©Ñd( /io/put.htm©á ‰?/io/putback.htm©êK‰U/io/rdstate.htm©ô Š /io/read.htm©þ(”K
  11. /io/seekg.htmª’s‹n
  12. /io/seekp.htmªža‹
  13. /io/setf.htmª©k™A /io/sstream/ /io/sstream/constructors.htmªÃ, !/io/sstream/operators.htmªãMŒ?/io/sstream/rdbuf.htmªð ‰/io/sstream/start.htmªù“/io/sstream/str.htm«ž1
  14. /io/start.htm««J¶G/io/sync_with_stdio.htm«â‰r
  15. /io/tellg.htm«ì‰3
  16. /io/tellp.htm«õ6•U/io/unsetf.htm¬‹ ‰
  17. /io/width.htm¬”
  18. /io/write.htm¬£.Š-
  19. ¬W÷ ~@Œ•S;ía±{7Òß«ÖýƒM#k´ï¨dý™+Ò«©w=UÒŠM+Åø°X`3>¥Ã yhяvÐ9ñnVâ†Mçª"Ø%?z/:1ˆ<êÊkÓ
  20. ^í ZÓ«rAÄcœGy_±à:Šø7
  21. ª)ÖŒ€ëÀ Ï „&Àn
  22. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  23. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  24. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  25. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  26. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  27. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT
  28. Z:ß
  29. j*þsŽ
  30. ë5×"zòsnˆ|g(‹sV :‚¹“+>PÒÉî+’æÁ~¼]•ù¥|ác¦õÖ
  31. ¯•" q^ì´ž„ýÆœ2E<iÚüÄØÙ wuþÍ÷÷$Ävˍ{ÁÝèÐKÙ >åš=YN&ƒ]¶Ñp'"ÃØÑœð] Öɇë%ø:EϐcÅP¾¹EZ[nÖ(‹ï „\¤ `]—: Ó}}@¡÷ã/?/œ)r¶
  32. «JË´ð_þD,pß^¬;áÞ1ÏpË¡iÎŽªâ~Õ.çf³¬ÔA«KçŽæ.ÙN'bfàž®Žõ%«é¢@kOp]-½#‘%Ƚ€\Æ…™4û˜Ô“NæOF®‹ÉùùÀ²,V¯ýù¥5Hú5ÃLõŒó}H~Ÿ©¶(¯É·w-¬¹úãÕ0@î×9[€Ú—…Ó*å§.ÌÐ Z/탯X]Ro\æ
  33. ê^´-}íBÐÑi¼*ø\ áÀDZŸNO'¡š³TéóÚDz`ÖA‰I”
  34. ¸îxø£Â{s—¨s ë'íGcjÆ'ÆK"€Ùãe5fƒ¹RÀ”-ÂóÏǸÙGã"zr¢‹R ¸ª“œ£³.[fz›?ˆõÆÂ#b
  35. ÿÓ;×uÁØÍ©£šx}ŒJ÷¯ÎÇ9Íûø^Õ{ßÊí9Æ+õs•g>)ì~‡3ÈèM
  36. k`Eå3r~u¸9þÉ3Ô4½ÏVÜ#ÓÿGÉØ£¼<WYsà’?yk‘ŠgÈΏcÌ
  37.  
  38. Z:ß
  39. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  40. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  41. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  42. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  43. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  44. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT"
  45. ITSF `  ²V2b ý|ª{О  É"æìý|ª{О  É"æì`  x T` Ì` þ a( ITSP T
  46.      ÿÿÿÿ  j’].!Нù  É"æìT ÿÿÿÿÿÿÿÿÿÿÿÿPMGL^ ÿÿÿÿ / /#IDXHDR„„q  /#ITBITS /#STRINGS†²Ô/#SYSTEM …N¡5/#TOPICS„¤qË /#URLSTR…¨M‰G/#URLTBL„ð¸< /#WINDOWSö¿kL /$FIftiMainøÅY‹¿ /$OBJINSTø°•?/$WWAssociativeLinks/ /$WWAssociativeLinks/Propertyø°/$WWKeywordLinks/ /$WWKeywordLinks/BTreeöÁ7ÀL/$WWKeywordLinks/Dataø‚­/$WWKeywordLinks/Mapø¯Z/$WWKeywordLinks/Propertyø¯v
  47. /ascii.htmŠÉF˜-/c/
  48. /c/all.htm‹ás±/c/date/ /c/date/asctime.htm’x
  49. /c/date/clock.htm£‹ /c/date/ctime.htm®ŽR/c/date/datime.htm¼`‰m/c/date/difftime.htmÆMŠ)/c/date/gmtime.htmÐv`/c/date/localtime.htmÞV” /c/date/mktime.htmòVŒH/c/date/setlocale.htmÿ’2/c/date/start.htmŽ‘P”:/c/date/strftime.htmŽ¦
  50. £V/c/date/time.htmŽÉ`Žj/c/io/ /c/io/clearerr.htmŽØJŠm/c/io/fclose.htmŽã7‹/c/io/feof.htmŽîSŠl/c/io/ferror.htmŽù?ŠY/c/io/fflush.htm„—/c/io/fgetc.htm›)Œv/c/io/fgetpos.htm¨Œ/c/io/fgets.htm´ Ž
  51. /c/io/fopen.htmÂ-Ÿ/c/io/fprintf.htmá5“Z/c/io/fpurge.htmõ•/c/io/fputc.htmŠ"X/c/io/fputs.htm—zŒ0/c/io/fread.htm¤*4/c/io/freopen.htm´^/c/io/fscanf.htmÁoŽ/c/io/fseek.htmÏ~’P/c/io/fsetpos.htmâN‹C/c/io/ftell.htmî‰j/c/io/fwrite.htm÷{"/c/io/getc.htm‘…”t/c/io/getchar.htm‘šŠR/c/io/gets.htm‘¤c-/c/io/perror.htm‘²”|/c/io/printf.htm‘Ç Ãx/c/io/putc.htm’‹—
  52. /io/flags.htm§Òs‰\
  53. /io/flush.htm§ÜO‹d/io/gcount.htm§è3‰D /io/get.htm§ñwa/io/getline.htm¨XŸ
  54. /io/good.htm¨®e/io/ignore.htm¨½}/io/io_flags.htm¨Íè /io/open.htm©µ6’M /io/peek.htm©È‰a/io/precision.htm©Ñd( /io/put.htm©á ‰?/io/putback.htm©êK‰U/io/rdstate.htm©ô Š /io/read.htm©þ(”K
  55. /io/seekg.htmª’s‹n
  56. /io/seekp.htmªža‹
  57. /io/setf.htmª©k™A /io/sstream/ /io/sstream/constructors.htmªÃ, !/io/sstream/operators.htmªãMŒ?/io/sstream/rdbuf.htmªð ‰/io/sstream/start.htmªù“/io/sstream/str.htm«ž1
  58. /io/start.htm««J¶G/io/sync_with_stdio.htm«â‰r
  59. /io/tellg.htm«ì‰3
  60. /io/tellp.htm«õ6•U/io/unsetf.htm¬‹ ‰
  61. /io/width.htm¬”
  62. /io/write.htm¬£.Š-
  63. ¬W÷ ~@Œ•S;ía±{7Òß«ÖýƒM#k´ï¨dý™+Ò«©w=UÒŠM+Åø°X`3>¥Ã yhяvÐ9ñnVâ†Mçª"Ø%?z/:1ˆ<êÊkÓ
  64. ^í ZÓ«rAÄcœGy_±à:Šø7
  65. ª)ÖŒ€ëÀ Ï „&Àn
  66. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  67. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  68. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  69. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  70. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  71. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT
  72. Z:ß
  73. j*þsŽ
  74. ë5×"zòsnˆ|g(‹sV :‚¹“+>PÒÉî+’æÁ~¼]•ù¥|ác¦õÖ
  75. ¯•" q^ì´ž„ýÆœ2E<iÚüÄØÙ wuþÍ÷÷$Ävˍ{ÁÝèÐKÙ >åš=YN&ƒ]¶Ñp'"ÃØÑœð] Öɇë%ø:EϐcÅP¾¹EZ[nÖ(‹ï „\¤ `]—: Ó}}@¡÷ã/?/œ)r¶
  76. «JË´ð_þD,pß^¬;áÞ1ÏpË¡iÎŽªâ~Õ.çf³¬ÔA«KçŽæ.ÙN'bfàž®Žõ%«é¢@kOp]-½#‘%Ƚ€\Æ…™4û˜Ô“NæOF®‹ÉùùÀ²,V¯ýù¥5Hú5ÃLõŒó}H~Ÿ©¶(¯É·w-¬¹úãÕ0@î×9[€Ú—…Ó*å§.ÌÐ Z/탯X]Ro\æ
  77. ê^´-}íBÐÑi¼*ø\ áÀDZŸNO'¡š³TéóÚDz`ÖA‰I”
  78. ¸îxø£Â{s—¨s ë'íGcjÆ'ÆK"€Ùãe5fƒ¹RÀ”-ÂóÏǸÙGã"zr¢‹R ¸ª“œ£³.[fz›?ˆõÆÂ#b
  79. ÿÓ;×uÁØÍ©£šx}ŒJ÷¯ÎÇ9Íûø^Õ{ßÊí9Æ+õs•g>)ì~‡3ÈèM
  80. k`Eå3r~u¸9þÉ3Ô4½ÏVÜ#ÓÿGÉØ£¼<WYsà’?yk‘ŠgÈΏcÌ
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.  
  143.  
  144. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  145. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  146. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  147. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  148. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  149. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT
  150. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  151. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  152. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  153. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  154. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  155. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT
  156. Z:ß
  157. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  158. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  159. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  160. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  161. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  162. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT"
  163. #define nume ""
  164.  
  165. #include<cmath>
  166. #include<cstdio>
  167. #include<cstdlib>
  168. #include<cstring>
  169. #include<ctime>
  170.  
  171. #include<algorithm>
  172. #include<iostream>
  173. #include<fstream>
  174. #include<vector>
  175.  
  176. using namespace std;
  177.  
  178. #ifndef INFOARENA
  179. #define DBG
  180. #endif
  181. #ifndef ONLINE_JUDGE
  182. ifstream fin (nume ".in");
  183. ofstream fout(nume ".out");
  184. #endif
  185. #ifdef DBG
  186. #define fout cout
  187. #endif
  188. //using namespace __gnu_cxx;
  189. //#include<ext/hash_map>
  190. //hash_multimap<int,int> H;
  191. //hash_map<char*,int> H;
  192.  
  193. //using namespace tr1;
  194. //#include<tr1/unordered_set>
  195.  
  196. //const double PI = M_PI;
  197. //const double EPS = 1e-9;
  198. #define foreach(it, v) for (typeof((v).begin()) it = (v).begin(),stop=(v).end(); it != stop; ++it)
  199. #define foreach_r(it, v) for (typeof((v).rbegin()) it = (v).rbegin(),stop=(v).rend(); it != stop; ++it)
  200. template<class T> inline void getmin(T& a,T& b){a=min(a,b);};
  201. template<class T> inline T min(T& a,T& b,T& c){return min(a,min(b,c));};
  202. template<class T>void dbg(T x, bool newline=false){
  203. #ifdef DBG
  204. cerr<<x<<((newline)?'\n':' ');
  205. #endif
  206. }
  207. template<class T>void dbg(T v[], int n, bool p=false){for(int i=p;i<n+p;++i)dbg(v[i]);dbg("",true);dbg("",true);}
  208. template<class T>void dbg(T* a, int n, int m, bool p=false){for(int i=p;i<n+p;++i,dbg("",true))for(int j=p;j<m+p;++j)dbg(a[i][j]);dbg("",true);}
  209.  
  210.  
  211.  
  212. #define NMAX
  213.  
  214. int n;
  215.  
  216.  
  217.  
  218.  
  219.  
  220. int main()
  221. {
  222.  
  223. return 0;
  224. }
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233. /////////////////////////////////////////////
  234. /////////////////////////////////////////////
  235. //OLD
  236. /////////////////////////////////////////////
  237. /////////////////////////////////////////////
  238. #ifndef INFOARENA
  239. #define DBG
  240. #endif
  241. #define nume "password"
  242.  
  243. #include<cstdio>
  244. #include<iostream>
  245. #include<fstream>
  246. #include<vector>
  247. #include<cstring>
  248. #include<string>
  249. #include<sstream>
  250. #include<cstdlib>
  251. #include<cmath>
  252. #include<queue>
  253. #include<set>
  254. #include<map>
  255. #include<cassert>
  256. #include<ctime>
  257. #include<list>
  258. #include<algorithm>
  259.  
  260. using namespace std;
  261. using namespace __gnu_cxx;
  262.  
  263. //#define _PARSARE_
  264. #ifdef _PARSARE_
  265. #define DIM 8192
  266. char ax[DIM+16];
  267. int _idx;
  268. template<class T>
  269. inline void cit(T& x)
  270. {
  271. x=0;
  272. while((ax[_idx]<'0' || ax[_idx]>'9') && (ax[_idx]!='-'))
  273. if(++_idx==DIM)fread(ax, 1, DIM, stdin), _idx=0;
  274.  
  275. int neg=0;
  276. if(ax[_idx]=='-') {
  277. neg=1;
  278. if(++_idx==DIM)fread(ax, 1, DIM, stdin),_idx=0;
  279. }
  280.  
  281. while(ax[_idx]>='0' && ax[_idx]<='9') {
  282. x=x*10+ax[_idx]-'0';
  283. if(++_idx==DIM)fread(ax,1, DIM, stdin),_idx=0;
  284. }
  285. if(neg) x=-x;
  286. }
  287. #else
  288. #ifndef ONLINE_JUDGE
  289. ifstream fin (nume ".in");
  290. #endif
  291. #endif //_PARSARE_
  292. #ifndef ONLINE_JUDGE
  293. ofstream fout(nume ".out");
  294. #endif
  295. #ifdef DBG
  296. #define fout cout
  297. #ifdef ONLINE_JUDGE
  298. #define fin cin
  299. #endif
  300. #endif
  301. //// hash-uri
  302. //#include<ext/hash_map>
  303. //hash_multimap<int,int> H;
  304. //hash_map<char*,int> H;
  305. //const double PI = acos(-1.0);
  306. //const double EPS = 1e-9;
  307. #define foreach(it, v) for (typeof((v).begin()) it = (v).begin(),stop=(v).end(); it != stop; ++it)
  308. #define foreach_r(it, v) for (typeof((v).rbegin()) it = (v).rbegin(),stop=(v).rend(); it != stop; ++it)
  309. template<class T> inline void Swap(T& a,T& b){a^=b,b^=a,a^=b;}
  310.  
  311. int n,m;
  312.  
  313.  
  314. int main()
  315. {
  316. #ifdef _PARSARE_
  317. #ifndef ONLINE_JUDGE
  318. freopen(nume ".in","r",stdin);
  319. #endif
  320. cit(n);
  321. #endif
  322.  
  323.  
  324.  
  325. #ifndef DBG
  326. #ifndef ONLINE_JUDGE
  327. fout.close();
  328. #endif
  329. #endif
  330. return 0;
  331. }
  332.  
  333.  
  334.  
  335.  
  336. ////////////////////////////////////////////////
  337. //OJI
  338.  
  339. #define nume ""
  340.  
  341. #include<cstdio>
  342. #include<iostream>
  343. #include<fstream>
  344. #include<vector>
  345. #include<queue>
  346. #include<algorithm>
  347.  
  348. using namespace std;
  349.  
  350.  
  351. //ofstream fout(nume ".out");
  352.  
  353. #define foreach(it, v) for (typeof((v).begin()) it = (v).begin(),stop=(v).end(); it != stop; ++it)
  354.  
  355. int n;
  356.  
  357.  
  358. int main()
  359. {
  360. freopen(nume ".in","r",stdin);
  361. freopen(nume ".out","w",stdout);
  362. #ifdef _PARSARE_
  363. cit(n);
  364. #endif
  365. scanf("%d",&n);
  366.  
  367.  
  368.  
  369. // printf("%I64d",sol);
  370. // printf("%lld",sol);
  371. // printf("%u",sol);//unsigned
  372. // printf("%h",sol);//short
  373. return 0;
  374. }
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382.  
  383.  
  384.  
  385. /*
  386. #include<set>
  387. #include<map>
  388. #include<ctime>
  389. #include<list>
  390. #include<cstring>
  391. #include<string>
  392. #include<sstream>
  393. #include<cstdlib>
  394. //#define _PARSARE_
  395. #ifdef _PARSARE_
  396. #define DIM 8192
  397. char ax[DIM+16];
  398. int _idx;
  399. template<class T>
  400. inline void cit(T &x)
  401. {
  402. x=0;
  403. while((ax[_idx]<'0' || ax[_idx]>'9') && (ax[_idx]!='-'))
  404. if(++_idx==DIM)fread(ax, 1, DIM, stdin), _idx=0;
  405.  
  406. int neg=0;
  407. if(ax[_idx]=='-') {
  408. neg=1;
  409. if(++_idx==DIM)fread(ax, 1, DIM, stdin),_idx=0;
  410. }
  411.  
  412. while(ax[_idx]>='0' && ax[_idx]<='9') {
  413. x=x*10+ax[_idx]-'0';
  414. if(++_idx==DIM)fread(ax,1, DIM, stdin),_idx=0;
  415. }
  416. if(neg) x=-x;
  417. }
  418. #else
  419. //ifstream fin (nume ".in");
  420. #endif //_PARSARE_
  421. inline void bellmanford()
  422. {
  423. memset(d,0x3f,sizeof(d));
  424. d[1]=0;
  425. Q.clear();
  426. Q.push(1);
  427. in_queue[1]=true;
  428. cnt_in_queue[1]=1;
  429. while(!Q.empty()) {
  430. int nod=Q.front();
  431. Q.pop();
  432. in_queue[nod]=false;
  433. foreach(it,G[nod]) {
  434. if( d[it->first]>d[nod]+it->second ) {
  435. d[it->first]=d[nod]+it->second;
  436.  
  437. if(!in_queue[it->first]){
  438. Q.push(it->first);
  439. in_queue[it->first]=true;
  440.  
  441. if(cnt_in_queue[it->first]++>n) {
  442. fout<<"Ciclu negativ!\n";
  443. exit(0);
  444. }
  445. }
  446. }
  447. }
  448. }
  449. }
  450. */
  451.  
  452. //////////////////////////////////////////////////////////////
  453. //////////////////////////////////////////////////////////////
  454. //////////////////////////////////////////////////////////////
  455. //memoizarea unei functii recursive cu map
  456. //////////////////////////////////////////////////////////////
  457. //////////////////////////////////////////////////////////////
  458. //////////////////////////////////////////////////////////////
  459. Un map este foarte util pentru a memoiza o functie recursiva.
  460.  
  461. int my_func(int t)
  462. {
  463. // e recursiva si pura (rezultatul depinde doar de parametri)
  464. return result;
  465. }
  466.  
  467. Se transforma in:
  468.  
  469.  
  470. map <int, int> cache;
  471.  
  472. int my_func(int t)
  473. {
  474. map <int, int> :: const_iterator it = cache.find(t);
  475. if(it != cache.end())
  476. return it->second;
  477. // corpul vechi
  478. return cache[t] = result;
  479. }
  480. //(in loc de int poate sa fie orice tip)
  481.  
  482.  
  483.  
  484. //////////////////////////////////////////////////////////////
  485. //////////////////////////////////////////////////////////////
  486. //////////////////////////////////////////////////////////////
  487. //binary search (fast)
  488. //////////////////////////////////////////////////////////////
  489. //////////////////////////////////////////////////////////////
  490. //////////////////////////////////////////////////////////////
  491.  
  492.  
  493. int binary_search(int[] A, int x)
  494. {
  495. int i, step, N = A.length;
  496. for (step = 1; step < N; step <<= 1)
  497. ;
  498. for (i = 0; step; step >>= 1)
  499. if (i + step < N && A[i + step] <= x)
  500. i += step;
  501. if (A[i] == x)
  502. return i;
  503. else
  504. return -1;
  505. }
  506.  
  507. //////////////////////////////////////////////////////////////
  508. //binary search (very good)
  509. //////////////////////////////////////////////////////////////
  510.  
  511. int binary_search(int[] A, int x)
  512. {
  513. int dr = A.length, st = -1, mid; //initializare!!! setam pe dr si st inafara sirului, astfel invariantul e indeplinit si nu trebuie sa tratam cazuri speciale.
  514. while (dr - st > 1) { //conditia de continuare a buclei e dr - st > 1. Invariantul ales face ca dr si st sa fie tot timpul distincte. La fiecare pas distanta intre dr si st se injumatateste, iar cand dr si st ajung consecutive ca pozitii in sir putem lua o decizie.
  515. mid = st + (dr - st) / 2; //((unsigned int)st + (unsigned int)dr)) >> 1; //mid va fi tot timpul intre st si dr.
  516. if (A[mid] < x)
  517. st = mid;
  518. else // if(A[mid] >= x)
  519. dr = mid;
  520. }
  521. if (dr == A.length || A[dr] != x) // cand ultimul element din sir e mai mic decat x, st = A.length - 1 si dr = A.length
  522. return -1; // sau cand dr este undeva in interiorul sirului, A[st] < x < A[dr]
  523. else //x e in sir
  524. return dr;
  525. }
  526.  
  527.  
  528.  
  529.  
  530.  
  531. //////////////////////////////////////////////////////////////
  532. //////////////////////////////////////////////////////////////
  533. //////////////////////////////////////////////////////////////
  534. //scmax O(NlgN)
  535. //////////////////////////////////////////////////////////////
  536. //////////////////////////////////////////////////////////////
  537. //////////////////////////////////////////////////////////////
  538.  
  539.  
  540.  
  541.  
  542. int n, v[100003], best[100003], poz[100003], maxim, k, L[100003], nr;
  543.  
  544. void afis(int i)
  545. {
  546. if (poz[i] > 0) afis(poz[i]);
  547. printf("%d ",v[i]);
  548. }
  549.  
  550. int caut_bin(int x)
  551. {
  552. int st, dr, m;
  553. st = 0;
  554. dr = nr;
  555. while (st <= dr) {
  556. m = ((unsigned int)st + (unsigned int)dr)>>1;
  557. if (v[L[m]] < x && v[L[m+1]] >= x)
  558. return m;
  559. else if (v[L[m+1]] < x)
  560. st = m + 1;
  561. else
  562. dr = m - 1;
  563. }
  564. return nr;
  565. }
  566.  
  567. int main()
  568. {
  569. //...
  570. nr = 1;
  571. L[0] = 0;
  572. L[1] = 1;
  573. best[1] = 1;
  574.  
  575. for(i=2; i<=n; ++i) {
  576. int p = caut_bin(v[i]);
  577. best[i] = p+1;
  578. poz [i] = L[p];
  579. L [p+1] = i;
  580.  
  581. if(best[i]>nr) {
  582. nr=best[i];
  583. pozmax=i;
  584. }
  585. }
  586. printf("%d\n",nr);
  587. afis(pozmax);
  588. //...
  589. }
  590.  
  591.  
  592.  
  593. //////////////////////////////////////////////////////////////
  594. //////////////////////////////////////////////////////////////
  595. //scmax O(N lg K) -- algorithmist
  596. //////////////////////////////////////////////////////////////
  597. //////////////////////////////////////////////////////////////
  598.  
  599.  
  600. #include <vector>
  601. using namespace std;
  602.  
  603. /* Finds longest strictly increasing subsequence. O(n log k) algorithm. */
  604. void find_lis(vector<int> &a, vector<int> &b)
  605. {
  606. vector<int> p(a.size());
  607. int u, v;
  608.  
  609. if (a.empty()) return;
  610.  
  611. b.push_back(0);
  612.  
  613. for (size_t i = 1; i < a.size(); i++) {
  614. // If next element a[i] is greater than last element of current longest subsequence a[b.back()], just push it at back of "b" and continue
  615. if (a[b.back()] < a[i]) {
  616. p[i] = b.back();
  617. b.push_back(i);
  618. continue;
  619. }
  620.  
  621. // Binary search to find the smallest element referenced by b which is just bigger than a[i]
  622. // Note : Binary search is performed on b (and not a). Size of b is always <=k and hence contributes O(log k) to complexity.
  623. for (u = 0, v = b.size()-1; u < v;) {
  624. int c = (u + v) / 2;
  625. if (a[b[c]] < a[i]) u=c+1;
  626. else v=c;
  627. }
  628.  
  629. // Update b if new value is smaller then previously referenced value
  630. if (a[i] < a[b[u]]) {
  631. if (u > 0) p[i] = b[u-1];
  632. b[u] = i;
  633. }
  634. }
  635.  
  636. for (u = b.size(), v = b.back(); u--; v = p[v]) b[u] = v;
  637. }
  638.  
  639. /* Example of usage: */
  640. #include <cstdio>
  641. int main()
  642. {
  643. int a[] = { 1, 9, 3, 8, 11, 4, 5, 6, 4, 19, 7, 1, 7 };
  644. vector<int> seq(a, a+sizeof(a)/sizeof(a[0])); // seq : Input Vector
  645. vector<int> lis; // lis : Vector containing indexes of longest subsequence
  646.  
  647. find_lis(seq, lis);
  648.  
  649. //Printing actual output
  650. for (size_t i = 0; i < lis.size(); i++)
  651. printf("%d ", seq[lis[i]]);
  652.  
  653. printf("\n");
  654.  
  655. return 0;
  656. }
  657.  
  658.  
  659.  
  660.  
  661. //////////////////////////////////////////////////////////////
  662. //////////////////////////////////////////////////////////////
  663. //scmax O(N lg N) -- AIB
  664. //////////////////////////////////////////////////////////////
  665. //////////////////////////////////////////////////////////////
  666.  
  667. #include <stdio.h>
  668. #include <algorithm>
  669.  
  670. using namespace std;
  671.  
  672. #define NMax 100005
  673.  
  674. int N, Res[NMax], v[NMax], lst[NMax], D[NMax], AIB[NMax], bst, up[NMax];
  675.  
  676. void update(int x, int ind)
  677. {
  678. for (; x <= N; x += x^(x-1) & x)
  679. if (D[ind] > D[AIB[x]])
  680. AIB[x] = ind;
  681. }
  682.  
  683. int query(int x)
  684. {
  685. int mx = 0;
  686.  
  687. for (; x; x -= x^(x-1) & x)
  688. if (D[AIB[x]] > D[mx])
  689. mx = AIB[x];
  690. return mx;
  691. }
  692.  
  693. int main(void)
  694. {
  695. int i, h = 1;
  696.  
  697. freopen("scmax.in", "r", stdin);
  698. freopen("scmax.out", "w", stdout);
  699.  
  700. scanf("%d", &N);
  701. for (i = 1; i <= N; ++i) {
  702. scanf("%d", &v[i]);
  703. Res[i] = lst[i] = v[i];
  704. }
  705.  
  706. sort(lst+1, lst+N+1);
  707. for (i = 2; i <= N; ++i)
  708. if (lst[i] != lst[h])
  709. lst[++h] = lst[i];
  710.  
  711. for (i = 1; i <= N; ++i)
  712. v[i] = lower_bound(lst+1, lst+h+1, v[i])-lst;
  713.  
  714. for (i = 1; i <= N; ++i) {
  715. up[i] = query(v[i]-1);
  716. D[i] = D[up[i]] + 1;
  717. update(v[i], i);
  718. }
  719.  
  720. for (i = 1; i <= N; ++i)
  721. if (D[bst] < D[i])
  722. bst = i;
  723.  
  724. printf("%d\n", D[bst]);
  725. for (h = 0, i = bst; i; i = up[i])
  726. lst[++h] = Res[i];
  727.  
  728. for (i = h; i; --i)
  729. printf("%d ", lst[i]);
  730. printf("\n");
  731.  
  732. return 0;
  733. }
  734.  
  735.  
  736.  
  737. //////////////////////////////////////////////////////////////
  738. //////////////////////////////////////////////////////////////
  739. //////////////////////////////////////////////////////////////
  740. //scmax O(N lg K) -- by me, Laur Ion :>
  741. //////////////////////////////////////////////////////////////
  742. //////////////////////////////////////////////////////////////
  743. //////////////////////////////////////////////////////////////
  744.  
  745.  
  746.  
  747. //scmax cu/fara upper_bound by Laur Ion
  748. //Complexitate: O(N lg K) | unde K e lungimea scmax (cautarea binara este facuta pe Q (nu v) a carui lungime este mereu <= K => O(lg K) complexitate)
  749. #include<cstdio>
  750. #include<iostream>
  751. #include<fstream>
  752. #include<vector>
  753. #include<cstring>
  754. #include<string>
  755. #include<sstream>
  756. #include<iterator>
  757. #include<cstdlib>
  758. #include<queue>
  759. #include<set>
  760. #include<map>
  761. #include<algorithm>
  762. #include<cassert>
  763.  
  764. #define filein "scmax.in"
  765. #define fileout "scmax.out"
  766.  
  767. using namespace std;
  768.  
  769. ifstream fin(filein);
  770. ofstream fout(fileout);
  771.  
  772. int n;
  773. //vector<int> G[100000+10];
  774. #define NMax 100005
  775.  
  776. int v[NMax], prev[NMax];
  777. vector<int> Q; //vector de pozitii ale scmax
  778.  
  779. bool cmp(int val, int poz)
  780. {
  781. return val < v[poz];
  782. }
  783. inline void afis(int poz)
  784. {
  785. if(poz == 0) {
  786. return;
  787. }
  788. afis(prev[poz]);
  789. fout<<v[poz]<<' ';
  790. }
  791. inline int bin_search (int val)
  792. {
  793. int st=-1,dr=Q.size()-1,m;
  794. while(dr-st>1) {
  795. m = ((unsigned int)st + (unsigned int)dr) >> 1;
  796. if(v[Q[m]] < val)
  797. st=m;
  798. else
  799. dr=m;
  800. }
  801. return dr;
  802. }
  803. int main()
  804. {
  805. fin>>n;
  806. for(int i=1; i<=n; ++i)
  807. fin>>v[i];
  808.  
  809. Q.push_back(1);
  810. // memset(prev,0xff,sizeof(prev));
  811. for(int i=2; i<=n; ++i) {
  812. if (v[i] > v[Q.back()]) { //daca elementul curent e mai mare decat ultimul element a scmax curente (v[Q.back])
  813. prev[i] = Q.back(); //se adauga la capatul lui Q si se continua
  814. Q.push_back(i);
  815. continue;
  816. }
  817. //cauta cel mai mic element referentiat de Q care e mai mare decat v[i]
  818. int p = bin_search(v[i]);
  819. assert(p>=0);
  820.  
  821. if (v[i] < v[Q[p]]) {
  822. if (p > 0)
  823. prev[i] = Q[p-1];
  824. Q[p] = i;
  825. }
  826. //varianta cu upper_bound: //problema e ca upper bound merge doar pt subsir crescator (nestrict, cu <=)
  827. // vector<int>::iterator it = upper_bound(Q.begin(), Q.end(), v[i], cmp); //
  828. // if(it != Q.begin() && v[*(it-1)] == v[i]) //upper_bound face <= cumva deci trebuie sa verificam si sa nu fie elemente egale
  829. // continue;
  830. // int _pit=it-Q.begin();
  831. // if(v[i]<v[*it]) {
  832. // if(it != Q.begin())
  833. // prev[i] = *(it-1);
  834. // *it = i;
  835. // }
  836. }
  837.  
  838. fout<<Q.size()<<'\n';
  839.  
  840. afis(Q.back());
  841. fout<<'\n';
  842.  
  843. fout.close();
  844. return 0;
  845. }
  846.  
  847.  
  848.  
  849.  
  850.  
  851.  
  852.  
  853.  
  854. //////////////////////////////////////////////////////////////
  855. //////////////////////////////////////////////////////////////
  856. //////////////////////////////////////////////////////////////
  857. //NUMERE MARI
  858. //////////////////////////////////////////////////////////////
  859. //////////////////////////////////////////////////////////////
  860. //////////////////////////////////////////////////////////////
  861.  
  862.  
  863. inline void suma( short* A, short* B, short* C)
  864. {
  865. int i,t=0;
  866.  
  867. for(i=1; i<=A[0]||i<=B[0]||t; ++i,t/=10) {
  868. C[i]=(t+=A[i]+B[i])%10;
  869. }
  870. C[0]=i-1;
  871.  
  872. }
  873. inline void scadere(short A[], short B[])
  874. {
  875. int i, t = 0;
  876. for (i = 1; i <= A[0]; i++) {
  877. A[i] -= ((i <= B[0]) ? B[i] : 0);
  878. A[i] -= t;
  879. if(A[i]<0) { //in loc de: A[i] += (t = A[i] < 0) * 10;
  880. t=1;
  881. A[i]+=10;
  882. } else
  883. t=0;
  884.  
  885. while( A[0] > 1 && !A[A[0]] ) //scap de zero-uri
  886. A[0]--;
  887. }
  888. }
  889. inline void impartire(short* A, int B) {
  890. int i,t=0;
  891. for(i=A[0]; i>0; --i,t%=B)//in reverse
  892. A[i]=(t=t*10 + A[i])/B;
  893.  
  894. while( A[0] > 1 && !A[A[0]] ) //scap de zero-uri
  895. A[0]--;
  896. }
  897. inline int modulo(short* A, int B) {
  898. int i,t=0;
  899. for(i=A[0]; i>0; --i)//in reverse
  900. t=(t*10 + A[i])%B;
  901. return t;
  902. }
  903. inline void inmultire(short* A, int B) {
  904. int i,t=0;
  905. for(i=1; i<=A[0] || t; ++i,t/=10)
  906. A[i]=(t+=A[i]*B)%10;
  907. A[0]=i-1;
  908. }
  909. inline void inmultire(short* A, short* B) {
  910. short C[50000];
  911. int i,j,t;
  912. memset(C,0,sizeof(C));
  913. for(i=1; i<=A[0]; ++i) {
  914. for(j=1; j<=B[0] || t; ++j,t/=10)
  915. C[i+j-1]=(t+=C[i+j-1]+A[i]*B[j])%10;
  916.  
  917. C[0]=max(C[0],i+j-2);//dimensiunea rezultatului creste
  918. }
  919. memcpy(A,C,sizeof(C));
  920. }
  921.  
  922.  
  923.  
  924.  
  925.  
  926.  
  927.  
  928.  
  929.  
  930. //////////////////////////////////////////////////////////////
  931. //////////////////////////////////////////////////////////////
  932. //////////////////////////////////////////////////////////////
  933. Librarie numere mari (trimbitas)
  934. //////////////////////////////////////////////////////////////
  935. //////////////////////////////////////////////////////////////
  936. //////////////////////////////////////////////////////////////
  937.  
  938.  
  939.  
  940.  
  941.  
  942.  
  943. #include <iostream>
  944. using namespace std;
  945.  
  946. int n;
  947.  
  948.  
  949. #include <stdio.h>
  950. #include <string.h>
  951.  
  952. class Huge {
  953. public:
  954. int Semn;
  955. int Cont;
  956. int V[10000];
  957.  
  958. Huge() {
  959. *this = 0;
  960. }
  961.  
  962. Huge& operator =(long long Val) {
  963. this->V[0] = this->Cont = 0;
  964. if (Val < 0) {
  965. Val = -Val;
  966. this->Semn = -1;
  967. } else {
  968. this->Semn = 1;
  969. }
  970. for (; Val; ) {
  971. this->V[this->Cont++] = (int)(Val % 100000000);
  972. Val -= Val % 100000000;
  973. Val /= 100000000;
  974. }
  975. if (this->Cont) --this->Cont;
  976. return *this;
  977. }
  978.  
  979. Huge& operator =(const Huge& B) {
  980. this->Cont = B.Cont;
  981. this->Semn = B.Semn;
  982. memcpy(this->V, B.V, sizeof(int) * (this->Cont + 1));
  983. return *this;
  984. }
  985.  
  986. /*returneaza 1 daca A>B
  987. * 0 daca A=B
  988. * -1 daca A<B
  989. */
  990. int Comparare(const Huge &A, const Huge &B) const {
  991. if (A.Semn != B.Semn) {
  992. if (A.Semn==1) return 1;
  993. else return -1;
  994. } else {
  995. if (A.Cont > B.Cont) {
  996. if (A.Semn == 1) return 1;
  997. else return -1;
  998. } else if (A.Cont < B.Cont) {
  999. if (A.Semn == 1) return -1;
  1000. else return 1;
  1001. } else {
  1002. int i;
  1003. for (i = A.Cont; A.V[i] == B.V[i] && i >= 0; --i);
  1004. if (i >= 0) {
  1005. if (A.V[i] > B.V[i]) {
  1006. if (A.Semn == 1) return 1;
  1007. else return -1;
  1008. } else {
  1009. if (A.Semn == 1) return -1;
  1010. else return 1;
  1011. }
  1012. } else {
  1013. return 0;
  1014. }
  1015. }
  1016. }
  1017. }
  1018.  
  1019. bool operator >(const Huge& B) const {
  1020. return Comparare(*this, B) == 1;
  1021. }
  1022.  
  1023. bool operator <(const Huge& B) const {
  1024. return Comparare(*this, B) == -1;
  1025. }
  1026.  
  1027. bool operator >=(const Huge& B) const {
  1028. return Comparare(*this, B) != -1;
  1029. }
  1030.  
  1031. bool operator <=(const Huge& B) const {
  1032. return Comparare(*this, B) != 1;
  1033. }
  1034.  
  1035. bool operator ==(const Huge& B) const {
  1036. return Comparare(*this, B) == 0;
  1037. }
  1038.  
  1039. bool operator !=(const Huge& B) const {
  1040. return Comparare(*this, B) != 0;
  1041. }
  1042.  
  1043. bool operator >(const long long& b) const {
  1044. Huge B;
  1045. B = b;
  1046. return Comparare(*this, B) == 1;
  1047. }
  1048.  
  1049. bool operator <(const long long& b) const {
  1050. Huge B;
  1051. B = b;
  1052. return Comparare(*this, B) == -1;
  1053. }
  1054.  
  1055. bool operator >=(const long long& b) const {
  1056. Huge B;
  1057. B = b;
  1058. return Comparare(*this, B) != -1;
  1059. }
  1060.  
  1061. bool operator <=(const long long& b) const {
  1062. Huge B;
  1063. B = b;
  1064. return Comparare(*this, B) != 1;
  1065. }
  1066.  
  1067. bool operator ==(const long long& b) const {
  1068. Huge B;
  1069. B = b;
  1070. return Comparare(*this, B) == 0;
  1071. }
  1072.  
  1073. bool operator !=(const long long& b) const {
  1074. Huge B;
  1075. B = b;
  1076. return Comparare(*this, B) != 0;
  1077. }
  1078.  
  1079. Huge operator +() const {
  1080. return *this;
  1081. }
  1082.  
  1083. Huge operator -() const {
  1084. Huge A = *this;
  1085. A.Semn = -A.Semn;
  1086. return A;
  1087. }
  1088.  
  1089. Huge operator -(Huge C);
  1090. Huge operator +(Huge C);
  1091.  
  1092. Huge operator -(long long c) {
  1093. Huge C;
  1094. C = c;
  1095. return *this - C;
  1096. }
  1097.  
  1098. Huge operator +(long long c) {
  1099. Huge C;
  1100. C = c;
  1101. return *this + C;
  1102. }
  1103.  
  1104. Huge& operator ++() {
  1105. int i;
  1106. if (this->Semn == 1) {
  1107. ++this->V[0];
  1108. for (i = 0; this->V[i] == 100000000; ++i) {
  1109. this->V[i] = 0;
  1110. ++this->V[i + 1];
  1111. }
  1112. if (this->Cont < i) {
  1113. this->Cont = i;
  1114. }
  1115. } else {
  1116. --this->V[0];
  1117. for (i = 0; this->V[i] == -1; ++i) {
  1118. this->V[i] += 100000000;
  1119. --this->V[i + 1];
  1120. }
  1121. if (this->V[this->Cont] == 0) {
  1122. --this->Cont;
  1123. }
  1124. if (this->Cont == -1) {
  1125. this->Semn = 1;
  1126. this->Cont = 0;
  1127. }
  1128. }
  1129. return *this;
  1130. }
  1131.  
  1132. Huge& operator --() {
  1133. int i;
  1134. if (this->Semn == -1) {
  1135. ++this->V[0];
  1136. for (i = 0; this->V[i] == 100000000; ++i) {
  1137. this->V[i] = 0;
  1138. ++this->V[i + 1];
  1139. }
  1140. if (this->Cont < i) {
  1141. this->Cont = i;
  1142. }
  1143. } else {
  1144. if (this->Cont == 0 && this->V[0] == 0) {
  1145. this->Semn = -1;
  1146. this->V[0] = 1;
  1147. } else {
  1148. --this->V[0];
  1149. for (i = 0; this->V[i] == -1; ++i) {
  1150. this->V[i] += 100000000;
  1151. --this->V[i + 1];
  1152. }
  1153. if (this->V[this->Cont] == 0) {
  1154. --this->Cont;
  1155. }
  1156. if (this->Cont == -1) {
  1157. this->Cont = 0;
  1158. }
  1159. }
  1160. }
  1161. return *this;
  1162. }
  1163.  
  1164. Huge operator *(int Val) const {
  1165. Huge A;
  1166. if (Val < 0) {
  1167. Val = -Val;
  1168. if (this->Semn == -1) A.Semn = 1;
  1169. else A.Semn = -1;
  1170. } else {
  1171. A.Semn = this->Semn;
  1172. }
  1173. int i;
  1174. long long tmp;
  1175. for (i = 0; i <= this->Cont + 1; ++i) {
  1176. A.V[i] = 0;
  1177. }
  1178. for (i = 0; i <= this->Cont; ++i) {
  1179. tmp = (long long)this->V[i] * Val + A.V[i];
  1180. A.V[i] = (int)(tmp % 100000000);
  1181. //A.V[i + 1] = (tmp - A.V[a]) / 100000000;
  1182. A.V[i + 1] = (int)(tmp / 100000000);
  1183. }
  1184. if (A.V[this->Cont + 1]) {
  1185. A.Cont = this->Cont + 1;
  1186. } else {
  1187. A.Cont = this->Cont;
  1188. }
  1189. return A;
  1190. }
  1191.  
  1192. Huge operator *(const Huge& C) const {
  1193. Huge A;
  1194. if (this->Semn == 1) {
  1195. A.Semn = C.Semn;
  1196. } else {
  1197. if (C.Semn == -1) A.Semn = 1;
  1198. else A.Semn = -1;
  1199. }
  1200. Huge Tmp;
  1201. int i, j;
  1202. for (i = 0; i <= this->Cont + C.Cont + 1; ++i) {
  1203. A.V[i] = 0;
  1204. }
  1205. for (i = 0; i <= C.Cont; ++i) {
  1206. Tmp = (*this) * C.V[i];
  1207. for(j = 0; j <= Tmp.Cont; ++j) {
  1208. A.V[i + j] += Tmp.V[j];
  1209. A.Cont = i + j;
  1210. if (A.V[i + j] >= 100000000) {
  1211. A.V[i + j] -= 100000000;
  1212. ++A.V[i + j + 1];
  1213. A.Cont = i + j + 1;
  1214. }
  1215. }
  1216. }
  1217. return A;
  1218. }
  1219.  
  1220. Huge operator /(int Val) const {
  1221. Huge A;
  1222. if (Val < 0) {
  1223. Val = -Val;
  1224. if (this->Semn == -1) A.Semn = 1;
  1225. else A.Semn = -1;
  1226. } else {
  1227. A.Semn = this->Semn;
  1228. }
  1229. int i;
  1230. long long tmp1, tmp2;
  1231. tmp1 = this->V[this->Cont];
  1232. for (i = this->Cont; i >= 0; --i) {
  1233. tmp2 = tmp1 % Val;
  1234. tmp1 -= tmp2;
  1235. A.V[i] = (int)(tmp1 / Val);
  1236. if (i) tmp1 = tmp2 * 100000000 + this->V[i - 1];
  1237. }
  1238. if (A.V[this->Cont]) {
  1239. A.Cont = this->Cont;
  1240. } else {
  1241. A.Cont = this->Cont - 1;
  1242. }
  1243. return A;
  1244. }
  1245.  
  1246. int operator %(int Val) const {
  1247. long long tmp = 0;
  1248. int i;
  1249. for(i = this->Cont; i >= 0; --i) {
  1250. tmp *= 100000000;
  1251. tmp += this->V[i];
  1252. tmp %= Val;
  1253. }
  1254. return (int)tmp;
  1255. }
  1256.  
  1257. Huge& operator +=(Huge B) {
  1258. *this = *this + B;
  1259. return *this;
  1260. }
  1261.  
  1262. Huge& operator -=(Huge B) {
  1263. *this = *this - B;
  1264. return *this;
  1265. }
  1266.  
  1267. Huge& operator +=(long long B) {
  1268. *this = *this + B;
  1269. return *this;
  1270. }
  1271.  
  1272. Huge& operator -=(long long B) {
  1273. *this = *this - B;
  1274. return *this;
  1275. }
  1276.  
  1277. Huge& operator *=(Huge& B) {
  1278. *this = *this * B;
  1279. return *this;
  1280. }
  1281.  
  1282. Huge& operator *=(int B) {
  1283. *this = *this * B;
  1284. return *this;
  1285. }
  1286.  
  1287. Huge& operator /=(int B) {
  1288. *this = *this / B;
  1289. return *this;
  1290. }
  1291.  
  1292. void afisare(FILE *output) {
  1293. int i;
  1294. if (this->Semn == -1) fprintf(output, "-");
  1295. fprintf(output, "%d", this->V[this->Cont]);
  1296. for(i = this->Cont - 1; i >= 0; --i) {
  1297. fprintf(output, "%.8d", this->V[i]);
  1298. }
  1299. }
  1300.  
  1301. void afisare() {
  1302. afisare(stdout);
  1303. }
  1304.  
  1305. void citire(FILE *input) {
  1306. int Nr0;
  1307. char Nr[1000];
  1308. int stop;
  1309. int i, j;
  1310. int tmp, tmpc;
  1311. fscanf(input, "%s", Nr);
  1312. Nr0 = strlen(Nr);
  1313. if (Nr[0] == '-') {
  1314. stop = 1;
  1315. this->Semn = -1;
  1316. } else {
  1317. stop = 0;
  1318. this->Semn = 1;
  1319. }
  1320. this->V[this->Cont = 0] = 0;
  1321. for(i = Nr0 - 1; i >= stop; ) {
  1322. tmp = 0;
  1323. tmpc = 0;
  1324. for(j = 1; j <= 8 && i >= stop; ++j) {
  1325. tmp *= 10;
  1326. tmp += Nr[i] - '0';
  1327. --i;
  1328. ++tmpc;
  1329. }
  1330. for(j = 1; j <= tmpc; ++j) {
  1331. this->V[this->Cont] *= 10;
  1332. this->V[this->Cont] += tmp % 10;
  1333. tmp /= 10;
  1334. }
  1335. this->V[++this->Cont] = 0;
  1336. }
  1337. if (this->V[this->Cont] == 0) {
  1338. --this->Cont;
  1339. }
  1340. if (this->Cont == 0 && this->V[0] == 0 && this->Semn == -1) this->Semn = 0;
  1341. }
  1342.  
  1343. void citire() {
  1344. citire(stdin);
  1345. }
  1346. };
  1347.  
  1348. Huge Huge::operator +(Huge C) {
  1349. Huge A;
  1350. if ((this->Semn == -1 && C.Semn== -1) ||
  1351. (this->Semn == 1 && C.Semn== 1)) {
  1352. A.Semn = this->Semn;
  1353. int i;
  1354. int tmp;
  1355. int MAX = this->Cont + 1;
  1356. if (MAX < C.Cont + 1) {
  1357. MAX = C.Cont + 1;
  1358. }
  1359. for (i = 0; i <= MAX; ++i) {
  1360. A.V[i] = 0;
  1361. }
  1362. for(i = this->Cont + 1; i <= MAX; ++i) {
  1363. this->V[i] = 0;
  1364. }
  1365. for(i = C.Cont + 1; i <= MAX; ++i) {
  1366. C.V[i] = 0;
  1367. }
  1368. for(i = 0; i <= MAX - 1; ++i) {
  1369. tmp = A.V[i] + this->V[i] + C.V[i];
  1370. //A.V[i] = tmp % 100000000;
  1371. //A.V[i + 1] = tmp / 100000000;
  1372. if (tmp < 100000000) {
  1373. A.V[i] = tmp;
  1374. } else {
  1375. A.V[i] = tmp - 100000000;
  1376. A.V[i + 1] = 1;
  1377. }
  1378. }
  1379. if (A.V[MAX]){
  1380. A.Cont = MAX;
  1381. } else {
  1382. A.Cont = MAX - 1;
  1383. }
  1384. } else {
  1385. if (this->Semn == -1) {
  1386. this->Semn = 1;
  1387. A = C - *this;
  1388. this->Semn = -1;
  1389. } else {
  1390. C.Semn = 1;
  1391. A = *this - C;
  1392. C.Semn = -1;
  1393. }
  1394. }
  1395. return A;
  1396. }
  1397.  
  1398. Huge Huge::operator -(Huge C) {
  1399. Huge A;
  1400. if (this->Semn == -1 && C.Semn == -1) {
  1401. this->Semn = 1;
  1402. C.Semn = 1;
  1403. A = C - *this;
  1404. this->Semn = -1;
  1405. C.Semn = -1;
  1406. } else if (this->Semn == -1 && C.Semn == 1) {
  1407. this->Semn = 1;
  1408. A = *this + C;
  1409. this->Semn = -1;
  1410. A.Semn = -1;
  1411. } else if (this->Semn == 1 && C.Semn == -1) {
  1412. C.Semn = 1;
  1413. A = *this + C;
  1414. C.Semn = -1;
  1415. } else if (this->Semn == 1 && C.Semn == 1) {
  1416. if (*this >= C) {
  1417. A.Semn = 1;
  1418. int i;
  1419. int tmp;
  1420. int MAX = this->Cont + 1;
  1421. if (MAX < C.Cont + 1) {
  1422. MAX = C.Cont + 1;
  1423. }
  1424. for (i = 0; i <= MAX; ++i) {
  1425. A.V[i] = 0;
  1426. if (i > this->Cont) this->V[i] = 0;
  1427. if (i > C.Cont) C.V[i] = 0;
  1428. }
  1429. for (i = 0; i <= MAX - 1; ++i) {
  1430. tmp = A.V[i] + this->V[i] - C.V[i];
  1431. if (tmp >= 0) {
  1432. A.V[i] = tmp;
  1433. } else {
  1434. A.V[i] = tmp + 100000000;
  1435. A.V[i + 1] = -1;
  1436. }
  1437. }
  1438. for (A.Cont = MAX; !A.V[A.Cont] && A.Cont; --A.Cont);
  1439. } else {
  1440. A = C - *this;
  1441. A.Semn = -1;
  1442. }
  1443. }
  1444. return A;
  1445. }
  1446.  
  1447. Huge r;
  1448. int fr[2000005];
  1449.  
  1450. int gcd(int a,int b) {
  1451. for(int c;b;c=a%b,a=b,b=c);
  1452. return a;
  1453. }
  1454.  
  1455. static inline Huge put(int n) {
  1456. Huge r,b;
  1457. b=2;r=1;
  1458. if(n==0) {
  1459. r=1;
  1460. return r;
  1461. }
  1462. if(n==1) return b;
  1463. for(;n;) {
  1464. if(n&1)r*=b;
  1465. b*=b;
  1466. n>>=1;
  1467. }
  1468. return r;
  1469. }
  1470.  
  1471. int main() {
  1472. //freopen("asd.in","r",stdin);
  1473. cin>>n;
  1474. for(int i=1; i<=n; ++i) ++fr[gcd(i,n)];
  1475. for(int i=1; i<=n; ++i) if(fr[i]) {
  1476. r+=(put(i)*fr[i]);
  1477. }
  1478. r/=n;
  1479. r.afisare();
  1480. return 0;
  1481. }
  1482.  
  1483.  
  1484.  
  1485.  
  1486. //////////////////////////////////////////////////////////////
  1487. //////////////////////////////////////////////////////////////
  1488. Clasa numere mari (SpiderMan) 1
  1489. //////////////////////////////////////////////////////////////
  1490. //////////////////////////////////////////////////////////////
  1491.  
  1492. /*
  1493. Colectia personala de operatii pe numere mari - C++ ( classes )
  1494. Implementate de Robert Simoiu
  1495. Incluzand extragerea radacinii patrate cu oricate zecimale
  1496. */
  1497.  
  1498. # include <cmath>
  1499. # include <cstdio>
  1500. # include <cstring>
  1501. # include <vector>
  1502. using namespace std ;
  1503.  
  1504. /*
  1505. precizare :
  1506. 1. Daca vreti sa faceti a = b + c, in loc de a += b , trebuie in loc de void operator += ( ... )
  1507. sa faceti Mare operator + ( ... ) , si sa returnati un vector Mare ( exemplu prima functie, Mare operator + ( Mare& ) )
  1508. 2. Pentru comparari, se poate face usor > si >=, doar schimband returnurile ( fals cu adevarat, si invers ), dar
  1509. e de preferabil ca a > b sa se faca ca si b < a ( pentru a nu mai fi nevoie de introducerea unei noi comparari )
  1510. */
  1511.  
  1512. # define MAX 1000 // numarul de cifre
  1513. # define verf( X, i ) ( i <= X[0] ? X[i] : 0 )
  1514. # define A ( *this )
  1515.  
  1516. class Mare : protected vector < int > {
  1517. public :
  1518. Mare ( ) ;
  1519. Mare ( int ) ;
  1520. Mare operator + ( Mare& ) ;
  1521. void operator += ( Mare& ) ;
  1522. void operator *= ( int ) ;
  1523. void operator *= ( Mare& ) ;
  1524. void operator -= ( Mare& ) ;
  1525. bool operator < ( Mare& ) ;
  1526. bool operator <= ( Mare& ) ;
  1527. const Mare& operator = ( int ) ;
  1528. const Mare& operator = ( Mare& ) ;
  1529. void operator <<= ( int ) ;
  1530. void operator >>= ( int ) ;
  1531. void operator /= ( int ) ;
  1532. void operator /= ( Mare& ) ;
  1533. void radical_normal ( Mare&, int ) ;
  1534. void radical_cb ( Mare& ) ;
  1535. void afis_rad ( int ) ;
  1536. } ;
  1537.  
  1538. Mare :: Mare () { // A = 0
  1539. this -> resize ( MAX ) ;
  1540. }
  1541.  
  1542. Mare :: Mare ( int X ) { // A = X
  1543. this -> resize ( MAX ) ;
  1544. for ( A[0] = 0; X ; X /= 10 ) {
  1545. A[ ++A[0] ] = X % 10 ;
  1546. }
  1547. }
  1548.  
  1549. Mare Mare :: operator + ( Mare &B ) { // C = A + B
  1550. int i, t = 0; Mare C ;
  1551. for ( i = 1; i <= A[0] || i <= B[0] || t; ++i, t /= 10 )
  1552. C[i] = ( t += verf ( A, i ) + verf ( B, i ) ) % 10 ;
  1553. C[0] = i - 1;
  1554.  
  1555. return C ;
  1556. }
  1557.  
  1558. void Mare :: operator += ( Mare &B ) { // A += B
  1559. int i, t = 0;
  1560. for ( i = 1; i <= A[0] || i <= B[0] || t; ++i, t /= 10 )
  1561. A[i] = ( t += verf ( A, i ) + verf ( B, i ) ) % 10 ;
  1562. A[0] = i - 1;
  1563. }
  1564.  
  1565. void Mare :: operator *= ( int B ) { // A *= B
  1566. int i, t = 0;
  1567. for ( i = 1; i <= A[0] || t; ++i, t /= 10 )
  1568. A[i] = ( t += verf ( A, i ) * B ) % 10 ;
  1569. A[0] = i - 1;
  1570. }
  1571.  
  1572. const Mare& Mare :: operator = ( int X ) { // A = X
  1573. for ( A[0] = 0; X ; X /= 10 )
  1574. A[ ++A[0] ] = X % 10 ;
  1575. return A ;
  1576. }
  1577.  
  1578. const Mare& Mare :: operator = ( Mare &B ) { // A = B
  1579. for ( int i = 0; i <= B[0]; ++i )
  1580. A[i] = B[i] ;
  1581. return A ;
  1582. }
  1583.  
  1584. void Mare :: operator -= ( Mare &B ) { // A -= B, ∀ A ≥ B
  1585. int t = 0;
  1586. for ( int i = 1; i <= A[0]; ++i ) {
  1587. t = ( A[i] -= verf ( B, i ) + t ) < 0 ;
  1588. A[i] += t * 10 ;
  1589. }
  1590. for ( ; A[0] > 1 && !A[A[0]]; --A[0] ) ;
  1591. }
  1592.  
  1593.  
  1594. bool Mare :: operator < ( Mare &B ) { // A < B ?
  1595. for ( ; A[0] && !A[ A[0] ] ; --A[0] ) ;
  1596. for ( ; B[0] && !B[ B[0] ] ; --B[0] ) ;
  1597.  
  1598. if ( A[0] < B[0] ) return true;
  1599. else if ( A[0] > B[0] ) return false;
  1600.  
  1601. for ( int i = A[0]; i > 0; --i )
  1602. if ( A[i] < B[i] ) return true;
  1603. else if ( A[i] > B[i] ) return false;
  1604.  
  1605. return false;
  1606. }
  1607.  
  1608. bool Mare :: operator <= ( Mare &B ) { // A <= B ?
  1609. for ( ; A[0] && !A[ A[0] ] ; --A[0] ) ;
  1610. for ( ; B[0] && !B[ B[0] ] ; --B[0] ) ;
  1611.  
  1612. if ( A[0] < B[0] ) return true;
  1613. else if ( A[0] > B[0] ) return false;
  1614.  
  1615. for ( int i = A[0]; i > 0; --i )
  1616. if ( A[i] < B[i] ) return true;
  1617. else if ( A[i] > B[i] ) return false;
  1618.  
  1619. return true;
  1620. }
  1621.  
  1622.  
  1623. void Mare :: operator *= ( Mare &B ) { // A *= B
  1624. int i, j, t ; Mare C ;
  1625. for ( i = 1; i <= A[0]; ++i ) {
  1626. for (t = 0, j = 1; j <= B[0] || t; j++, t /= 10)
  1627. C[i + j - 1] = ( t += C[i + j - 1] + verf ( A, i ) * verf ( B, j ) ) % 10;
  1628. if ( i + j - 2 > C[0] )
  1629. C[0] = i + j - 2;
  1630. }
  1631.  
  1632. A = C ;
  1633. }
  1634.  
  1635. void Mare :: operator <<= ( int Count ) { // A *= ( Count * 10 )
  1636. for ( int i = A[0]; i ; --i )
  1637. A[i + Count] = A[i] ;
  1638. for ( int i = 1; i <= Count; ++i )
  1639. A[i] = 0 ;
  1640.  
  1641. A[0] += Count ;
  1642. }
  1643.  
  1644. void Mare :: operator >>= ( int Count ) { // A /= ( Count * 10 )
  1645. for ( int i = Count + 1; i <= A[0]; ++i ) {
  1646. A[i - Count] = A[i] ;
  1647. }
  1648.  
  1649. A[0] -= Count ;
  1650. }
  1651.  
  1652.  
  1653. void Mare :: operator /= ( int B ) { // A /= B
  1654. int t = 0;
  1655. for ( int i = A[0]; i > 0; i--, t %= B )
  1656. A[i] = ( t = t * 10 + A[i] ) / B ;
  1657. for ( ; A[0] > 1 && !A[ A[0] ]; --A[0] ) ;
  1658. }
  1659.  
  1660. void Mare :: operator /= ( Mare &B ) { // A /= B
  1661. Mare R ;
  1662.  
  1663. for ( int i = A[0]; i ; --i ) {
  1664. R <<= 1, R[1] = A[i] ;
  1665.  
  1666. for ( A[i] = 0; B <= R ; ++A[i], R -= B ) ;
  1667. }
  1668.  
  1669. for ( ; !A[ A[0] ] && A[0] > 1 ; --A[0] ) ;
  1670. }
  1671.  
  1672. void Mare :: radical_cb ( Mare &B ) { // B = sqrt ( A ) ; doar parte intreaga
  1673. Mare cnt, X ;
  1674.  
  1675. for ( cnt = 1; cnt < A; cnt *= 2 ) ;
  1676.  
  1677. for ( B[0] = 1 ; ! ( cnt[1] == 0 && cnt[0] == 1 ) ; cnt /= 2 ) {
  1678. X = cnt, X += B, X *= X ;
  1679. if ( X <= A )
  1680. B += cnt ;
  1681. }
  1682. }
  1683.  
  1684. void Mare :: radical_normal ( Mare &B, int nrzecimale ) {
  1685. int AUX = 0, i, j = 1 ;
  1686. Mare C, D, E, F, U ( 9 ), Z ( 1 ) ;
  1687.  
  1688. if ( A[0] & 1 ) AUX = A[ A[0] ], i = A[0] - 1;
  1689. else AUX = A[A[0]] * 10 + A[ A[0] - 1 ], i = A[0] - 2;
  1690.  
  1691. int aux = static_cast < int > ( sqrt ( AUX ) ) ;
  1692.  
  1693. B = aux ;
  1694.  
  1695. if ( A[0] > 2 ) {
  1696. AUX -= aux * aux;
  1697.  
  1698. E = AUX, E <<= 1, F = A[i], E += F ;
  1699.  
  1700. E <<= 1, F = A[i - 1], E += F ;
  1701.  
  1702. C = E, F = B, F *= 2, E = F ;
  1703.  
  1704. D = C, D >>= 1, D /= E ;
  1705.  
  1706. if ( U < D ) {
  1707. D = 9 ;
  1708. }
  1709.  
  1710. E <<= 1, E += D, E *= D ;
  1711.  
  1712. while ( C < E )
  1713. D -= Z, F = B, F *= 2, E = F, E <<= 1, E += D, E *= D ;
  1714.  
  1715.  
  1716. C -= E ;
  1717.  
  1718. B <<= 1, B += D ;
  1719. } else {
  1720. C = AUX - ( aux * aux ) ;
  1721. }
  1722.  
  1723. for ( i = i - 2; i > 0 || j <= nrzecimale ; i -= 2 ) {
  1724. if ( i > 0 ) {
  1725. E = A[i], F = 0, F <<= 1, F += E ;
  1726. E = A[i - 1], F <<= 1, F += E ;
  1727. } else {
  1728. ++j, F = 0 ;
  1729. }
  1730. C <<= 2, C += F, F = B, F *= 2, E = F ;
  1731. D = C, D >>= 1, D /= E ;
  1732.  
  1733. if ( U < D ) {
  1734. D = 9 ;
  1735. }
  1736.  
  1737. E <<= 1, E += D, E *= D ;
  1738.  
  1739. while ( C < E )
  1740. D -= Z, F = B, F *= 2, E = F, E <<= 1, E += D, E *= D ;
  1741.  
  1742. C -= E ;
  1743.  
  1744. B <<= 1, B += D ;
  1745. }
  1746. }
  1747.  
  1748. void Mare :: afis_rad ( int nrzecimale ) { // afisarea radicalului
  1749. for ( int i = A[0] ; i > nrzecimale ; --i )
  1750. printf ( "%d", A[i] ) ;
  1751. printf ( "." ) ;
  1752. for ( int i = nrzecimale ; i ; --i ) {
  1753. printf ( "%d", A[i] ) ;
  1754. }
  1755. }
  1756.  
  1757. int main ( void ) {
  1758. int a, b ;
  1759. fscanf ( fopen ( "adunare.in", "r" ), "%d %d", &a, &b ) ;
  1760. fprintf ( fopen ( "adunare.out", "w" ), "%d\n", a + b ) ;
  1761. }
  1762.  
  1763.  
  1764.  
  1765.  
  1766.  
  1767.  
  1768. //////////////////////////////////////////////////////////////
  1769. //////////////////////////////////////////////////////////////
  1770. Clasa numere mari (SpiderMan) 2
  1771. //////////////////////////////////////////////////////////////
  1772. //////////////////////////////////////////////////////////////
  1773. /*
  1774. Colectia personala de operatii pe numere mari - C++ ( classes )
  1775. Implementate de Robert Simoiu
  1776. Incluzand extragerea radacinii patrate cu un numar finit de zecimale
  1777. */
  1778.  
  1779. # include <cmath>
  1780. # include <cstdio>
  1781. # include <cstring>
  1782. # include <vector>
  1783. using namespace std ;
  1784.  
  1785. /*
  1786. precizare :
  1787. 1. Daca vreti sa faceti a = b + c, in loc de a += b , trebuie pus in loc de void operator += ( ... )
  1788. Mare operator + ( ... ) , si sa returnati un vector Mare ( exemplu prima functie, Mare operator + ( Mare& ) )
  1789. 2. Base inseamna baza si nbase numarul maxim de cifre al unui numar din baza base
  1790. */
  1791.  
  1792. # define MAX 100 // * nbase = numarul de cifre
  1793. # define verf( X, i ) ( i <= X[0] ? X[i] : 0 )
  1794. # define A ( *this )
  1795.  
  1796. class Mare : protected vector < int > {
  1797. static const int base = 1000000000, nbase = 9 ;
  1798. public :
  1799. Mare ( ) ;
  1800. Mare ( int ) ;
  1801.  
  1802. void operator = ( char* ) ;
  1803. void operator += ( Mare& ) ;
  1804. void operator *= ( int ) ;
  1805. void operator *= ( Mare& ) ;
  1806. void operator -= ( Mare& ) ;
  1807. void operator <<= ( int ) ;
  1808. void operator >>= ( int ) ;
  1809. void operator /= ( int ) ;
  1810. void operator /= ( Mare& ) ;
  1811. void operator %= ( int ) ;
  1812. void operator %= ( Mare& ) ;
  1813. void operator ++ ( void ) ;
  1814. void operator ++ ( int ) ;
  1815. void operator -- ( void ) ;
  1816. void operator -- ( int ) ;
  1817.  
  1818. Mare operator + ( Mare& ) ;
  1819.  
  1820. int zero ( void ) ;
  1821. int comparare ( Mare& ) ;
  1822.  
  1823. bool operator < ( Mare& ) ;
  1824. bool operator <= ( Mare& ) ;
  1825. bool operator > ( Mare& ) ;
  1826. bool operator >= ( Mare& ) ;
  1827. bool operator == ( Mare& ) ;
  1828. bool operator != ( Mare& ) ;
  1829.  
  1830. void operator |= ( Mare& ) ;
  1831. void operator &= ( Mare& ) ;
  1832. void operator ^= ( Mare& ) ;
  1833.  
  1834. void afis ( void ) ;
  1835. void afis_rad ( int ) ;
  1836. void obtain ( int, int* ) ;
  1837. void pow ( int ) ;
  1838. void radical_cb ( Mare& ) ;
  1839. void radical_normal ( Mare&, int ) ;
  1840. void transform_2 ( int* ) ;
  1841. void transform_10 ( int* ) ;
  1842. void transform_210 ( int* ) ;
  1843.  
  1844. } ;
  1845.  
  1846. Mare :: Mare () { // A = 0
  1847. this -> resize ( MAX ) ;
  1848. }
  1849.  
  1850. Mare :: Mare ( int X ) { // A = X
  1851. this -> resize ( MAX ) ;
  1852. for ( A[0] = 0; X ; X /= base ) {
  1853. A[ ++A[0] ] = X % base ;
  1854. }
  1855. }
  1856.  
  1857. void Mare :: operator = ( char *X ) { // A = X ( sir )
  1858. A[0] = 0;
  1859. if ( X ) {
  1860. for ( int h = strlen ( X ) ; h > 0 ; h -= nbase ) {
  1861. ++A[0] ;
  1862. for ( int i = max ( 0, h - nbase ) ; i < h; ++i ) {
  1863. A[ A[0] ] = A[ A[0] ] * 10 + X[i] - '0' ;
  1864. }
  1865. }
  1866. }
  1867. }
  1868.  
  1869. void Mare :: operator += ( Mare &B ) { // A += B
  1870. int i, t = 0;
  1871. for ( i = 1; i <= A[0] || i <= B[0] || t; ++i, t /= base )
  1872. A[i] = ( t += verf ( A, i ) + verf ( B, i ) ) % base ;
  1873. A[0] = i - 1;
  1874. }
  1875.  
  1876. void Mare :: operator *= ( int B ) { // A *= B
  1877. int i = 1;
  1878. for ( long long t = 0; i <= A[0] || t; ++i, t /= base )
  1879. A[i] = ( t += 1LL * verf ( A, i ) * B ) % base ;
  1880. A[0] = i - 1;
  1881. }
  1882.  
  1883. void Mare :: operator *= ( Mare &B ) { // A *= B
  1884. Mare C ;
  1885. for ( int i = 1, j; i <= A[0]; ++i ) {
  1886. long long t = 0 ;
  1887. for ( j = 1; j <= B[0] || t; ++j, t /= base)
  1888. C[i + j - 1] = ( t += C[i + j - 1] + 1LL * verf ( A, i ) * verf ( B, j ) ) % base;
  1889. if ( i + j - 2 > C[0] )
  1890. C[0] = i + j - 2;
  1891. }
  1892.  
  1893. A = C ;
  1894. }
  1895.  
  1896. void Mare :: operator -= ( Mare &B ) { // A -= B, ∀ A ≥ B
  1897. int t = 0;
  1898. for ( int i = 1; i <= A[0]; ++i ) {
  1899. t = ( A[i] -= verf ( B, i ) + t ) < 0 ;
  1900. A[i] += t * base ;
  1901. }
  1902. for ( ; A[0] > 1 && !A[A[0]]; --A[0] ) ;
  1903. }
  1904.  
  1905. void Mare :: operator <<= ( int Count ) { // A *= 10^Count
  1906. if ( Count ) {
  1907. if ( A.zero () ) A = 1 ;
  1908. Mare sol = 10 ;
  1909. sol.pow ( Count ), A *= sol ;
  1910. }
  1911. }
  1912.  
  1913. void Mare :: operator >>= ( int Count ) { // A /= 10^Count
  1914. if ( Count ) {
  1915. Mare sol = 10 ;
  1916. sol.pow ( Count ), A /= sol ;
  1917. }
  1918. }
  1919.  
  1920. void Mare :: operator /= ( int B ) { // A /= B
  1921. long long t = 0;
  1922. for ( int i = A[0]; i > 0; i--, t %= B )
  1923. A[i] = ( t = 1LL * t * base + A[i] ) / B ;
  1924. for ( ; A[0] > 1 && !A[ A[0] ]; --A[0] ) ;
  1925. }
  1926.  
  1927. # define ck ( i / nbase + ( i % nbase != 0 ) )
  1928.  
  1929. void Mare :: operator /= ( Mare &B ) { // A /= B
  1930. int X[MAX * nbase];
  1931. Mare R = 0, T ;
  1932.  
  1933. A.transform_10 ( X ) ;
  1934. fill_n ( A.begin () + 1, A[0], 0 ) ;
  1935. for ( int i = X[0]; i ; --i ) {
  1936. R *= R.zero () ? 0 : 10, T = X[i], R += T ;
  1937. for ( A[ ck ] *= 10; B <= R ; ++A[ ck ], R -= B ) ;
  1938. }
  1939.  
  1940. for ( ; !A[ A[0] ] && A[0] > 1 ; --A[0] ) ;
  1941. }
  1942.  
  1943. void Mare :: operator %= ( int B ) { // A %= B
  1944. long long t = 0;
  1945. for ( int i = A[0]; i ; --i )
  1946. t = ( 1LL * t * base + A[i] ) % B ;
  1947. A = t ;
  1948. }
  1949.  
  1950. void Mare :: operator %= ( Mare &B ) { // A %= B
  1951. int X[MAX * nbase] ; Mare R = 0, T, C ;
  1952.  
  1953. A.transform_10 ( X ) ;
  1954. fill_n ( C.begin () + 1, A[0], 0 ) ;
  1955. for ( int i = X[0]; i ; --i ) {
  1956. R *= R.zero () ? 0 : 10, T = X[i], R += T ;
  1957. for ( C[ ck ] *= 10; B <= R ; ++C[ ck ], R -= B ) ;
  1958. }
  1959.  
  1960. A = R ;
  1961. }
  1962.  
  1963. # undef ck
  1964.  
  1965. void Mare :: operator ++ ( void ) { // ++A
  1966. Mare B = 1 ;
  1967. A += B ;
  1968. }
  1969.  
  1970. void Mare :: operator ++ ( int ) { // A++
  1971. ++A ;
  1972. }
  1973.  
  1974. void Mare :: operator -- ( void ) { // --A
  1975. Mare B = 1 ;
  1976. A -= B ;
  1977. }
  1978.  
  1979. void Mare :: operator -- ( int ) { // A--
  1980. --A ;
  1981. }
  1982.  
  1983. Mare Mare :: operator + ( Mare &B ) { // C = A + B
  1984. int i, t = 0; Mare C ;
  1985.  
  1986. for ( i = 1; i <= A[0] || i <= B[0] || t; ++i, t /= base )
  1987. C[i] = ( t += verf ( A, i ) + verf ( B, i ) ) % base ;
  1988. C[0] = i - 1;
  1989.  
  1990. return C ;
  1991. }
  1992.  
  1993. int Mare :: zero ( void ) { // A == 0 ?
  1994. return A[0] == 0 || A[0] == 1 && A[1] == 0 ;
  1995. }
  1996.  
  1997. int Mare :: comparare ( Mare &B ) {
  1998. for ( ; A[0] && !A[A[0]] ; --A[0] ) ;
  1999. for ( ; B[0] && !B[B[0]] ; --B[0] ) ;
  2000.  
  2001. if ( A[0] < B[0] ) return -1;
  2002. else if ( A[0] > B[0] ) return 1;
  2003.  
  2004. for ( int i = A[0]; i > 0; --i )
  2005. if ( A[i] < B[i] ) return -1;
  2006. else if ( A[i] > B[i] ) return 1;
  2007.  
  2008. return 0;
  2009. }
  2010.  
  2011. bool Mare :: operator < ( Mare &B ) { // A < B ?
  2012. return A.comparare ( B ) == -1 ;
  2013. }
  2014.  
  2015. bool Mare :: operator <= ( Mare &B ) { // A <= B ?
  2016. return A.comparare ( B ) != 1 ;
  2017. }
  2018.  
  2019. bool Mare :: operator > ( Mare &B ) { // A > B ?
  2020. return A.comparare ( B ) == 1 ;
  2021. }
  2022.  
  2023. bool Mare :: operator >= ( Mare &B ) {// A >= B ?
  2024. return A.comparare ( B ) != -1 ;
  2025. }
  2026.  
  2027. bool Mare :: operator == ( Mare &B ) {// A == B ?
  2028. return A.comparare ( B ) == 0 ;
  2029. }
  2030.  
  2031. bool Mare :: operator != ( Mare &B ) {// A != B ?
  2032. return A.comparare ( B ) != 0 ;
  2033. }
  2034.  
  2035. void Mare :: operator |= ( Mare &B ) { // A |= B
  2036. int X[MAX * nbase], Y[MAX * nbase] ;
  2037. A.transform_2 ( X ) , B.transform_2 ( Y ) ;
  2038. for ( int i = 1; i <= X[0] && i <= Y[0]; ++i )
  2039. X[i] |= Y[i] ;
  2040. if ( X[0] < Y[0] ) {
  2041. for ( int i = X[0] + 1 ; i <= Y[0] ; ++i )
  2042. X[i] = Y[i] ;
  2043. X[0] = Y[0] ;
  2044. }
  2045. A.transform_210 ( X ) ;
  2046. }
  2047.  
  2048. void Mare :: operator &= ( Mare &B ) { // A &= B
  2049. int X[MAX * nbase], Y[MAX * nbase] ;
  2050. A.transform_2 ( X ) , B.transform_2 ( Y ) ;
  2051. for ( int i = 1; i <= X[0] && i <= Y[0]; ++i )
  2052. X[i] &= Y[i] ;
  2053. X[0] = min ( X[0], Y[0] ) ;
  2054. A.transform_210 ( X ) ;
  2055. }
  2056.  
  2057. void Mare :: operator ^= ( Mare &B ) { // A ^= B
  2058. int X[MAX * nbase], Y[MAX * nbase] ;
  2059. A.transform_2 ( X ) , B.transform_2 ( Y ) ;
  2060. for ( int i = 1; i <= X[0] && i <= Y[0]; ++i )
  2061. X[i] ^= Y[i] ;
  2062.  
  2063. if ( X[0] < Y[0] ) {
  2064. for ( int i = X[0] + 1 ; i <= Y[0] ; ++i )
  2065. X[i] = Y[i] ;
  2066. X[0] = Y[0] ;
  2067. }
  2068. A.transform_210 ( X ) ;
  2069. }
  2070.  
  2071. void Mare :: radical_cb ( Mare &B ) { // B = sqrt ( A ) ; doar parte intreaga
  2072. Mare cnt, X ;
  2073.  
  2074. for ( cnt = 1; cnt < A; cnt *= 2 ) ;
  2075. for ( B[0] = 1 ; ! cnt.zero () ; cnt /= 2 ) {
  2076. X = cnt, X += B, X *= X ;
  2077. if ( X <= A )
  2078. B += cnt ;
  2079. }
  2080. }
  2081.  
  2082. void Mare :: afis ( void ) { // afisarea
  2083. printf ( "%d", A[ A[0] ] ) ;
  2084. for ( int i = A[0] - 1; i ; --i ) {
  2085. printf ( "%09d", A[i] ) ;
  2086. }
  2087. }
  2088.  
  2089. void Mare :: afis_rad ( int nrzecimale ) { // afisarea radicalului
  2090. int X[MAX * nbase] ;
  2091.  
  2092. A.transform_10 ( X ) ;
  2093. for ( int i = X[0]; i > nrzecimale ; --i )
  2094. printf ( "%d", X[i] ) ;
  2095. printf ( "." ) ;
  2096. for ( int i = nrzecimale ; i ; --i ) {
  2097. printf ( "%d", X[i] ) ;
  2098. }
  2099. }
  2100.  
  2101. void Mare :: obtain ( int x, int *X ) {
  2102. int S[10] = { 0 } ;
  2103. for ( int i = A[x]; i ; i /= 10 )
  2104. S[ ++S[0] ] = i % 10 ;
  2105. for ( int i = 1; i <= S[0] ; ++i )
  2106. X[ ++X[0] ] = S[i] ;
  2107. if ( x != A[0] )
  2108. for ( int i = S[0]; i < nbase; ++i )
  2109. X[ ++X[0] ] = 0 ;
  2110. }
  2111.  
  2112. void Mare :: pow ( int P ) { // A = A^P
  2113. Mare B = 1 ;
  2114. for ( ; P ; P >>= 1 ) {
  2115. if ( P & 1 )
  2116. B *= A ;
  2117. A *= A ;
  2118. }
  2119. A = B ;
  2120. }
  2121.  
  2122. void Mare :: transform_2 ( int *X ) { // baza 'base' -> baza 2
  2123. Mare B = A ;
  2124. X[0] = 0 ;
  2125. for ( ; !B.zero () ; X[ ++X[0] ] = B[ 1 ] & 1, B /= 2 ) ;
  2126. }
  2127.  
  2128. void Mare :: transform_10 ( int *X ) { // baza 'base' -> baza 10
  2129. X[0] = 0 ;
  2130. for ( int i = 1; i <= A[0]; ++i )
  2131. obtain ( i, X ) ;
  2132. }
  2133.  
  2134. void Mare :: transform_210 ( int *X ) { // baza 2 -> baza 'base'
  2135. Mare B = 1 ; A = 0 ;
  2136. for ( int i = 1; i <= X[0]; ++i, B *= 2 ) {
  2137. if ( X[i] == 1 ) A += B ;
  2138. }
  2139. }
  2140.  
  2141. void Mare :: radical_normal ( Mare &B, int nrzecimale ) {
  2142. int AUX = 0, i , j = 0 ; int X[MAX * nbase] ;
  2143. Mare C, D, E, F, U = 9 , Z = 1 ;
  2144.  
  2145. A.transform_10 ( X ), i = X[0] ;
  2146. X[0] & 1 ? AUX = X[i--] : ( AUX = X[i--], AUX *= 10, AUX += X[i--] ) ;
  2147.  
  2148. int aux = static_cast < int > ( sqrt ( AUX ) ) ;
  2149.  
  2150. B = aux ;
  2151.  
  2152. if ( X[0] > 2 ) {
  2153. AUX -= aux * aux;
  2154.  
  2155. E = AUX, E <<= 1, F = X[i--] ;
  2156.  
  2157. if ( AUX ) E += F, E <<= 1 ;
  2158. else E = F ;
  2159.  
  2160. if ( AUX == 0 && X[i + 1] ) E <<= 1 ;
  2161.  
  2162. F = X[i--], E += F, C = E, F = B, F *= 2, E = F ;
  2163.  
  2164. D = C, D >>= 1, D /= E, U < D ? D = 9 : 0 ;
  2165. E <<= 1, E += D, E *= D ;
  2166.  
  2167. while ( C < E )
  2168. D -= Z, F = B, F *= 2, E = F, E <<= 1, E += D, E *= D ;
  2169.  
  2170. C -= E, B <<= 1, B += D ;
  2171. } else {
  2172. C = AUX - ( aux * aux ) ;
  2173. }
  2174.  
  2175. if ( !C.zero () || i > 0 ) {
  2176. for ( i = i; i > 0 || j < nrzecimale ; ) {
  2177. if ( i > 0 ) {
  2178. E = X[i--], F = 0, F <<= 1, F = E, E = X[i--];
  2179. if ( X[i + 2] ) F <<= 1, F += E ;
  2180. else F = E ;
  2181. } else {
  2182. ++j, F = 0 ;
  2183. if ( j == 1 && C.zero () ) {
  2184. for ( int i = 1; i <= nrzecimale ; ++i )
  2185. B <<= 1 ;
  2186. return ;
  2187. }
  2188. }
  2189. if ( !C.zero () || i == 3 + ( X[0] % 2 == 0 ) && AUX ) {
  2190. C <<= 2, C += F ;
  2191. } else {
  2192. C = F ;
  2193. }
  2194.  
  2195. F = B, F *= 2, E = F ;
  2196. D = C, D >>= 1, D /= E, U < D ? D = 9 : 0 ;
  2197. E <<= 1, E += D, E *= D ;
  2198.  
  2199. while ( C < E )
  2200. D -= Z, F = B, F *= 2, E = F, E <<= 1, E += D, E *= D ;
  2201.  
  2202. C -= E, B <<= 1, B += D ;
  2203. }
  2204. } else {
  2205. for ( int i = 1; i <= nrzecimale ; ++i )
  2206. B <<= 1 ;
  2207. }
  2208. }
  2209.  
  2210. # undef A
  2211.  
  2212. int main ( void ) {
  2213. int a, b ;
  2214. fscanf ( fopen ( "adunare.in", "r" ), "%d %d", &a, &b ) ;
  2215. fprintf ( fopen ( "adunare.out", "w" ), "%d\n", a + b ) ;
  2216. }
  2217.  
  2218.  
  2219.  
  2220.  
  2221. //////////////////////////////////////////////////////////////
  2222. //////////////////////////////////////////////////////////////
  2223. //////////////////////////////////////////////////////////////
  2224. //evaluare expresii
  2225. //////////////////////////////////////////////////////////////
  2226. //////////////////////////////////////////////////////////////
  2227. //////////////////////////////////////////////////////////////
  2228.  
  2229.  
  2230.  
  2231.  
  2232.  
  2233.  
  2234. inline int factor() {
  2235. int r=0;
  2236. if(*p=='(') {
  2237. ++p;
  2238. r=eval();
  2239. ++p;
  2240. } else
  2241. while(*p>='0' && *p<='9') {
  2242. r=r*10+*p-'0';
  2243. ++p;
  2244. }
  2245. return r;
  2246. }
  2247. inline int termen() {
  2248. int r=factor();
  2249. while(*p=='*'||*p=='/') {
  2250. if(*(p++)=='*')
  2251. r*=factor();
  2252. else
  2253. r/=factor();
  2254. }
  2255. return r;
  2256. }
  2257. inline int eval() {
  2258. int r=termen();
  2259. while(*p=='+' || *p=='-') {
  2260. if(*(p++) =='+')
  2261. r+=termen();
  2262. else
  2263. r-=termen();
  2264. }
  2265. return r;
  2266. }
  2267.  
  2268.  
  2269.  
  2270.  
  2271.  
  2272.  
  2273.  
  2274. //////////////////////////////////////////////////////////////
  2275. //////////////////////////////////////////////////////////////
  2276. //////////////////////////////////////////////////////////////
  2277. //KMP (Laur)
  2278. //////////////////////////////////////////////////////////////
  2279. //////////////////////////////////////////////////////////////
  2280. //////////////////////////////////////////////////////////////
  2281.  
  2282.  
  2283.  
  2284.  
  2285. vector<int> matches;
  2286. string sir, subsir;
  2287. int pi[2000000+10];
  2288.  
  2289. getline(fin, subsir);
  2290. getline(fin, sir );
  2291. subsir.insert(subsir.begin(),'-');//incepem de la 1, nu de la 0 //TODO
  2292. sir.insert(sir.begin(),'-'); //incepem de la 1, nu de la 0 //TODO
  2293.  
  2294. if (sir.size()<subsir.size()) {
  2295. fout<<0<<'\n';
  2296. return 0;
  2297. }
  2298.  
  2299. int k=0;
  2300. pi[1]=0;
  2301. for(int i=2; i<subsir.length(); ++i) { //incepem de la al 2-lea caracter
  2302. while(k>0 && subsir[i] != subsir[k+1])
  2303. k=pi[k];
  2304. if(subsir[i] == subsir[k+1])
  2305. k++;
  2306. pi[i]=k;
  2307. }
  2308.  
  2309. k=0;
  2310. int nr=0;
  2311. for(int i=1; i<sir.length(); ++i) { //de la 1 pana la length-1, deoarece am inserat un caracter '-' inainte
  2312. while(k>0 && sir[i] != subsir[k+1])
  2313. k=pi[k];
  2314. if(sir[i] == subsir[k+1])
  2315. k++;
  2316. if(k==subsir.length()-1) { //match
  2317. matches.push_back(i-subsir.length()+1);
  2318. }
  2319. }
  2320.  
  2321.  
  2322.  
  2323.  
  2324. //////////////////////////////////////////////////////////////
  2325. //KMP (Laur) -- sir ce incepe de la 0
  2326. //////////////////////////////////////////////////////////////
  2327.  
  2328.  
  2329. //sirul de la 0 la n-1, dar pi de la 1 la n
  2330. vector<int> matches;
  2331. string sir, subsir;
  2332. int pi[2000000+10];
  2333.  
  2334. getline(fin, subsir);
  2335. getline(fin, sir );
  2336.  
  2337. // subsir.insert(subsir.begin(),'-');//incepem de la 1, nu de la 0 //TODO
  2338. // sir.insert(sir.begin(),'-'); //incepem de la 1, nu de la 0 //TODO
  2339.  
  2340. if (sir.size()<subsir.size()) {
  2341. fout<<0<<'\n';
  2342. return 0;
  2343. }
  2344.  
  2345. int k=0;
  2346. pi[1]=0;
  2347. for(int i=1; i<subsir.length(); ++i) {
  2348. while(k>0 && subsir[i] != subsir[k])
  2349. k=pi[k];
  2350. if(subsir[i] == subsir[k])
  2351. k++;
  2352. pi[i+1]=k; //!!! important
  2353. }
  2354.  
  2355. k=0;
  2356. int nr=0;
  2357. for(int i=0; i<sir.length(); ++i) {
  2358. while(k>0 && sir[i] != subsir[k])
  2359. k=pi[k];
  2360. if(sir[i] == subsir[k])
  2361. k++;
  2362. if(k==subsir.length()) { //match
  2363. matches.push_back(i-subsir.length()+1);
  2364. }
  2365. }
  2366.  
  2367.  
  2368.  
  2369.  
  2370. //////////////////////////////////////////////////////////////
  2371. //////////////////////////////////////////////////////////////
  2372. //////////////////////////////////////////////////////////////
  2373. //euclid extins
  2374. //////////////////////////////////////////////////////////////
  2375. //////////////////////////////////////////////////////////////
  2376. //////////////////////////////////////////////////////////////
  2377.  
  2378.  
  2379.  
  2380.  
  2381.  
  2382. inline int euclid(int a, int b, int& x, int& y) {
  2383. if(b==0) {
  2384. x=1;
  2385. y=0;
  2386. return a;
  2387. }
  2388.  
  2389. int x0,y0,D;
  2390. D=euclid(b,a%b,x0,y0);
  2391. x=y0;
  2392. y=x0 - (a/b) * y0;
  2393.  
  2394. return D;
  2395. }
  2396.  
  2397.  
  2398.  
  2399.  
  2400. //////////////////////////////////////////////////////////////
  2401. //////////////////////////////////////////////////////////////
  2402. //////////////////////////////////////////////////////////////
  2403. //hashuri
  2404. //////////////////////////////////////////////////////////////
  2405. //////////////////////////////////////////////////////////////
  2406. //////////////////////////////////////////////////////////////
  2407.  
  2408. #include<ext/hash_map>
  2409. using namespace __gnu_cxx;
  2410.  
  2411. hash_multimap<int,int> H;
  2412. hash_map<char*,int> H;
  2413.  
  2414. //////////////////////////////////////////
  2415.  
  2416. #include<tr1/unordered_map>
  2417. using namespace tr1;
  2418.  
  2419. unordered_map<string,int> H;//unordered_map merge doar in code blocks, nu in mingw!!
  2420.  
  2421. //////////////////////////////////////////
  2422.  
  2423. #include <vector>
  2424. #include <cmath>
  2425. #include <cstdio>
  2426.  
  2427. #define MOD 666013
  2428. const double CST = (sqrt(5)-1)/(double)2;
  2429. using namespace std;
  2430. int N;
  2431. vector<int> G[MOD];
  2432.  
  2433. inline vector<int>::iterator find_value(int x) {
  2434. int list = x % MOD;
  2435. // double tmp;
  2436. // int list = floor(MOD*(double)modf((double)x*CST,&tmp));
  2437. vector<int>::iterator it;
  2438.  
  2439. for (it = G[list].begin(); it != G[list].end(); ++it)
  2440. if (*it == x)
  2441. return it;
  2442. return G[list].end();
  2443. }
  2444.  
  2445. inline void insert_value(int x) {
  2446. int list = x % MOD;
  2447. // double tmp;
  2448. // int list = floor(MOD*(double)modf((double)x*CST,&tmp));
  2449. if (find_value(x) == G[list].end())
  2450. G[list].push_back(x);
  2451. }
  2452.  
  2453. inline void erase_value(int x) {
  2454. int list = x % MOD;
  2455. // double tmp;
  2456. // int list = floor(MOD*(double)modf((double)x*CST,&tmp));
  2457. vector<int>::iterator it = find_value(x);
  2458.  
  2459. if (it != G[list].end())
  2460. G[list].erase(it);
  2461. }
  2462.  
  2463. int main() {
  2464. int op, x;
  2465.  
  2466. freopen("hashuri.in", "r", stdin);
  2467. freopen("hashuri.out", "w", stdout);
  2468.  
  2469. for (scanf("%d", &N); N; --N) {
  2470. scanf("%d %d", &op, &x);
  2471. if (op == 1) { // inserare
  2472. insert_value(x);
  2473. continue;
  2474. }
  2475. if (op == 2) { // stergere
  2476. erase_value(x);
  2477. continue;
  2478. }
  2479. int list = x % MOD;
  2480. // double tmp;
  2481. // int list = floor(MOD*(double)modf((double)x*CST,&tmp));
  2482.  
  2483. printf("%d\n", find_value(x) != G[list].end());
  2484. }
  2485.  
  2486. return 0;
  2487. }
  2488.  
  2489.  
  2490.  
  2491. //////////////////////////////////////////////////////////////
  2492. //////////////////////////////////////////////////////////////
  2493. //////////////////////////////////////////////////////////////
  2494. // radix sort
  2495. //////////////////////////////////////////////////////////////
  2496. //////////////////////////////////////////////////////////////
  2497. //////////////////////////////////////////////////////////////
  2498.  
  2499.  
  2500. #include<cstring>//pt memset
  2501.  
  2502. int A[MAX_N], N, K, B[MAX_N];
  2503.  
  2504. //#define a_de_i ((A[i]>>byte)&255)
  2505.  
  2506. inline void rad(int N, int byte, int A[], int B[]) {
  2507. int cnt[256], ind[256],i;
  2508. memset(cnt, 0, sizeof(cnt));
  2509. for(i=1; i <= N; ++i) ++cnt[(A[i]>>byte)&255];
  2510. ind[0]=1;
  2511. for(i=1; i < 256; ++i) ind[i]=ind[i-1]+cnt[i-1];
  2512. for(i=1; i <= N; ++i) B[ind[(A[i]>>byte)&255]++]=A[i];
  2513. }
  2514.  
  2515. inline void radix(int A[], int N) {
  2516. rad(N, 0, A, B);//sortez dupa primii 8 biti (1-8)
  2517. rad(N, 8, B, A);//urmatorii 8 biti (9-16)
  2518. rad(N, 16, A, B);//urmatorii 8 biti (17-24)
  2519. rad(N, 24, B, A);//urmatorii 8 biti (25-32)
  2520. }
  2521.  
  2522. int main() {
  2523. fin >> N >> K;
  2524.  
  2525. for(int i = 1; i <= N; ++i)
  2526. fin >> A[i];
  2527.  
  2528. radix(A, N);
  2529.  
  2530. fout << A[K] << "\n";
  2531. }
  2532.  
  2533.  
  2534.  
  2535.  
  2536. //////////////////////////////////////////////////////////////
  2537. //////////////////////////////////////////////////////////////
  2538. //////////////////////////////////////////////////////////////
  2539. //treapuri (by me) - not tested!
  2540. //////////////////////////////////////////////////////////////
  2541. //////////////////////////////////////////////////////////////
  2542. //////////////////////////////////////////////////////////////
  2543.  
  2544.  
  2545.  
  2546. struct treapNode {
  2547. int val, priority;
  2548. //int din;//nr de noduri din subarborii nodului x
  2549. treapNode *left, *right;
  2550.  
  2551. }*r, *nil;
  2552. void rotright(treapNode*& x) {
  2553. treapNode* tmp=x->left;
  2554. x->left=tmp->right,tmp->right=x;
  2555. //x->din=x->left->din+x->right->din+1;
  2556. //tmp->din=tmp->left->din+tmp->right->din+1;
  2557. x = tmp;
  2558. }
  2559. void rotleft(treapNode*& x) {
  2560. treapNode* tmp=x->right;
  2561. x->right=tmp->left,tmp->left=x;
  2562. //x->din=x->left->din+x->right->din+1;
  2563. //tmp->din=tmp->left->din+tmp->right->din+1;
  2564. x = tmp;
  2565. }
  2566. void balance(treapNode*& x) {
  2567. if(x->left->priority>x->priority)
  2568. rotright(x);
  2569. else if(x->right->priority<x->priority)
  2570. rotleft(x);
  2571. //x->din=x->left->din+x->right->din+1;
  2572. }
  2573. void insert(treapNode*& x,int& val, int& priority) {
  2574. if(x==nil) {
  2575. x=new treapNode();
  2576. x->val=val;
  2577. x->priority=priority;
  2578. x->left=x->right=nil;
  2579. //x->din=1;
  2580. return;
  2581. }
  2582. if(x->val<val)
  2583. insert(x->left, val, priority);
  2584. else
  2585. insert(x->right, val, priority);
  2586. balance(x);
  2587. }
  2588. void erase(treapNode*& x, int& val) {
  2589. if(x==nil)
  2590. return;
  2591. if(x->val==val) {
  2592. if(x->left==nil && x->right==nil)
  2593. delete x,x=nil;
  2594. else {
  2595. if(x->left->priority<x->priority)
  2596. rotright(x);
  2597. else if(x->right->priority>x->priority)
  2598. rotleft(x);
  2599. erase(x, val);
  2600. }
  2601.  
  2602. } else if(x->val<val)
  2603. erase(x->left,val);
  2604. else
  2605. erase(x->right, val);
  2606. }
  2607. /*
  2608. void query(treapNode *t)
  2609. {
  2610. if(k==t->left->din+1)
  2611. {
  2612. printf("%d\n",t->key);
  2613. return;
  2614. }
  2615. if(k>t->left->din)
  2616. {
  2617. k=k-t->left->din-1;
  2618. query(t->right);
  2619. }
  2620. else
  2621. query(t->left);
  2622. }
  2623. */
  2624. treapNode* find(treapNode*& x, int& val) {
  2625. if(x->val==val)
  2626. return x;
  2627. if(x->val<val)
  2628. return find(x->left, val);
  2629. else
  2630. return find(x->right, val);
  2631.  
  2632. }
  2633. int main() {
  2634. nil=new treapNode();
  2635. nil->val=0;
  2636. nil->priority=0;
  2637. nil->left=NULL;
  2638. nil->right=NULL;
  2639. //nil->din=0;
  2640. r=nil;
  2641. srand(time(0));
  2642. /*
  2643. freopen("treapuri.in","r",stdin);
  2644. freopen("treapuri.out","w",stdout);
  2645. scanf("%d",&m);
  2646. int i,tip,val;
  2647. for(i=1;i<=m;i++)
  2648. {
  2649. scanf("%d %d",&tip,&val);
  2650. if(tip==1)
  2651. r=insert(r,val,rand()+1);
  2652. if(tip==2)
  2653. {
  2654. k=val;
  2655. query(r);
  2656. }
  2657. if(tip==3)
  2658. erase(r,val);
  2659. }
  2660. */
  2661. return 0;
  2662. }//treapuri (by me)
  2663.  
  2664.  
  2665.  
  2666.  
  2667.  
  2668. //////////////////////////////////////////////////////////////
  2669. //////////////////////////////////////////////////////////////
  2670. //////////////////////////////////////////////////////////////
  2671. //parsarea citirii
  2672. //////////////////////////////////////////////////////////////
  2673. //////////////////////////////////////////////////////////////
  2674. //////////////////////////////////////////////////////////////
  2675.  
  2676.  
  2677. #ifdef _PARSARE_
  2678. #define DIM 8192
  2679. char buff[DIM+16];
  2680. int idx;
  2681.  
  2682. //numere NATURALE:
  2683. inline void cit_uint(int &x) {
  2684. x=0;
  2685. while(buff[idx]<'0' || buff[idx]>'9')
  2686. if(++idx==DIM)fread(buff, 1, DIM, stdin), idx=0;
  2687. while(buff[idx]>='0' && buff[idx]<='9') {
  2688. x=x*10+buff[idx]-'0';
  2689. if(++idx==DIM)fread(buff,1, DIM, stdin),idx=0;
  2690. }
  2691. }
  2692.  
  2693. //numere INTREGI:
  2694. inline void cit_int(int &x) {
  2695. x=0;
  2696. while((buff[idx]<'0' || buff[idx]>'9') && (buff[idx]!='-'))
  2697. if(++idx==DIM)fread(buff, 1, DIM, stdin), idx=0;
  2698.  
  2699. int neg=0;
  2700. if(buff[idx]=='-') {
  2701. neg=1;
  2702. if(++idx==DIM)fread(buff, 1, DIM, stdin),idx=0;
  2703. }
  2704.  
  2705. while(buff[idx]>='0' && buff[idx]<='9') {
  2706. x=x*10+buff[idx]-'0';
  2707. if(++idx==DIM)fread(buff,1, DIM, stdin),idx=0;
  2708. }
  2709. if(neg) x=-x;
  2710. }
  2711. #endif //_PARSARE_
  2712.  
  2713.  
  2714.  
  2715.  
  2716.  
  2717. //////////////////////////////////////////////////////////////
  2718. //////////////////////////////////////////////////////////////
  2719. //////////////////////////////////////////////////////////////
  2720. //subsecventa de suma maxima
  2721. //////////////////////////////////////////////////////////////
  2722. //////////////////////////////////////////////////////////////
  2723. //////////////////////////////////////////////////////////////
  2724.  
  2725.  
  2726.  
  2727. //////////VARIANTA MEA (BOSS)://////////
  2728.  
  2729. //daca avem cel putin un nr pozitiv:
  2730.  
  2731. int best=0,maxSum=-0x3f3f3f3f;
  2732. for(int i=0; i<n; ++i) {
  2733. scanf("%d ",&x);
  2734. if(best>0)
  2735. best=x+best;
  2736. else
  2737. best=x,i1=i;
  2738. if(maxSum<best)
  2739. maxSum=best,begin=i1+1,end=i+1;
  2740. }
  2741. printf("%d %d %d\n",maxSum,begin,end);
  2742.  
  2743.  
  2744.  
  2745.  
  2746. //cu vectori (inutili): (scop didactic)
  2747.  
  2748. bestSum = a[1];
  2749. for (i = 1; i <= N; ++ i) {
  2750. best[i] = a[i];
  2751. if (best[i] < best[i-1] + a[i])
  2752. best[i] = best[i-1] + a[i];
  2753. if (bestSum < best[i])
  2754. bestSum = best[i];
  2755. }
  2756. //formula de recurenta: best[i] = max(a[i], best[i-1] + a[i])
  2757.  
  2758. //fara vectori (care erau inutili)
  2759.  
  2760. bestSum=a[0];
  2761. for(int i=0; i<n; ++i) {
  2762. best=a[i];
  2763. if(best<bestOld+a[i])
  2764. best=bestOld+a[i];
  2765. if(bestSum<best)
  2766. bestSum=best;
  2767. }
  2768.  
  2769.  
  2770. //cu sume partiale, mai slow (cred)
  2771.  
  2772. sum[0] = 0;
  2773. for (i = 1; i <= N; i++) sum[i] = a[i] + sum[i-1];
  2774. min = sum[0];
  2775. bestSum = -INF;
  2776. for (i = 1; i <= N; i++) {
  2777. best[i] = sum[i] - min;
  2778. if (min > sum[i]) min = sum[i];
  2779. if (bestSum < best[i]) bestSum = best[i];
  2780. }
  2781.  
  2782.  
  2783. //daca avem cel putin un nr pozitiv: // not tested!
  2784. sum = 0, bestSum = -INF;
  2785. for (i = 1; i <= N; i++) {
  2786. sum += a[i];
  2787. if (sum < 0)
  2788. sum = 0;
  2789. else if (sum > bestSum)
  2790. bestSum = sum;
  2791. }
  2792.  
  2793.  
  2794.  
  2795.  
  2796.  
  2797.  
  2798.  
  2799. //////////////////////////////////////////////////////////////
  2800. //////////////////////////////////////////////////////////////
  2801. //////////////////////////////////////////////////////////////
  2802. //AVL-uri (Radu Berinde)
  2803. //////////////////////////////////////////////////////////////
  2804. //////////////////////////////////////////////////////////////
  2805. //////////////////////////////////////////////////////////////
  2806.  
  2807.  
  2808.  
  2809.  
  2810. #define max(a, b) ((a) > (b) ? (a) : (b))
  2811. #define geth(n) (n->h = 1 + max(n->l->h, n->r->h))
  2812.  
  2813. struct AVLnode {
  2814. int key, h;
  2815. struct AVLnode *l, *r;
  2816. } *R, *NIL;
  2817. typedef struct AVLnode AVLnode;
  2818.  
  2819. void init(void) {
  2820. R = NIL = (AVLnode *) malloc(sizeof(AVLnode));
  2821. NIL->key = NIL->h = 0,
  2822. NIL->l = NIL->r = NULL;
  2823. }
  2824.  
  2825. AVLnode* rotleft(AVLnode *n) {
  2826. AVLnode *t = n->l;
  2827.  
  2828. n->l = t->r, t->r = n,
  2829. geth(n), geth(t);
  2830. return t;
  2831. }
  2832.  
  2833. AVLnode* rotright(AVLnode *n) {
  2834. AVLnode *t = n->r;
  2835.  
  2836. n->r = t->l, t->l = n,
  2837. geth(n), geth(t);
  2838. return t;
  2839. }
  2840.  
  2841. AVLnode* balance(AVLnode *n) {
  2842. geth(n);
  2843. if (n->l->h > n->r->h + 1) {
  2844. if (n->l->r->h > n->l->l->h)
  2845. n->l = rotright(n->l);
  2846. n = rotleft(n);
  2847. } else if (n->r->h > n->l->h + 1) {
  2848. if (n->r->l->h > n->r->r->h)
  2849. n->r = rotleft(n->r);
  2850. n = rotright(n);
  2851. }
  2852. return n;
  2853. }
  2854.  
  2855. AVLnode* insert(AVLnode *n, int key) {
  2856. if (n == NIL) {
  2857. n = (AVLnode *) malloc(sizeof(AVLnode));
  2858. n->key = key, n->h = 1, n->l = n->r = NIL;
  2859. return n;
  2860. }
  2861. if (key < n->key)
  2862. n->l = insert(n->l, key);
  2863. else
  2864. n->r = insert(n->r, key);
  2865. return balance(n);
  2866. }
  2867.  
  2868. AVLnode* erase(AVLnode *n, int key) {
  2869. AVLnode *t;
  2870. if (n == NIL) return n;
  2871. if (n->key == key) {
  2872. if (n->l == NIL || n->r == NIL) {
  2873. t = n->l == NIL ? n->r : n->l;
  2874. free(n);
  2875. return t;
  2876. } else {
  2877. for (t = n->r; t->l != NIL; t = t->l);
  2878. n->key = t->key,
  2879. n->r = erase(n->r, t->key);
  2880. return balance(n);
  2881. }
  2882. }
  2883. if (key < n->key)
  2884. n->l = erase(n->l, key);
  2885. else
  2886. n->r = erase(n->r, key);
  2887. return balance(n);
  2888. }
  2889.  
  2890. int search(AVLnode *n, int key) {
  2891. if (n == NIL) return 0;
  2892. if (n->key == key) return 1;
  2893. if (key < n->key)
  2894. return search(n->l, key);
  2895. else
  2896. return search(n->r, key);
  2897. }
  2898.  
  2899.  
  2900.  
  2901.  
  2902. //////////////////////////////////////////////////////////////
  2903. //////////////////////////////////////////////////////////////
  2904. //////////////////////////////////////////////////////////////
  2905. //Ciurul lui Eratostene
  2906. //////////////////////////////////////////////////////////////
  2907. //////////////////////////////////////////////////////////////
  2908. //////////////////////////////////////////////////////////////
  2909.  
  2910. //bool ciur[maxsize];
  2911. bitset<maxsize> ciur;
  2912.  
  2913. void sieve() {
  2914. long long i, j;
  2915. //memset(ciur,0,sizeof(ciur));
  2916. for (i = 4; i <= maxsize; i += 2)
  2917. ciur[i] = 1;
  2918. for (i = 3; i <= maxsize; i += 2)
  2919. if (!ciur[i]) {
  2920. //daca vreau sa retin toate nr prime intr-un vector:
  2921. //prime[++k]=i;
  2922. for (j = i * i; j <= maxsize; j += i + i)
  2923. ciur[j] = 1;
  2924. }
  2925. }
  2926.  
  2927.  
  2928. //////////////////////////////////////////
  2929. //varianta cu spatiu optim (de 16 ori mai mic): //NETESTAT!
  2930. //////////////////////////////////////////
  2931.  
  2932.  
  2933. #define maxsize 10000000
  2934.  
  2935. char at[maxsize / 16];
  2936. int n;
  2937.  
  2938. int isPrime(int x) {
  2939. if (!(x & 1))
  2940. if (x == 2) return 0 ;
  2941. else return 1 ;
  2942. else return (at[((x - 3) >> 1) >> 8] & (1 << (((x - 3) >> 1) & 7))) ;
  2943. }
  2944.  
  2945. void sieve() {
  2946. int i, j;
  2947. memset(at, 0, sizeof(at)) ;
  2948. for (i = 3; i <= maxsize; i += 2)
  2949. if (!at[((i - 3) >> 1) >> 8] & (1 << (((i - 3) >> 1) & 7)))
  2950. for (j = i * i ; j <= maxsize ; j += i + i)
  2951. at[((i - 3) >> 1) >> 8] |= (1 << (((i - 3) >> 1) & 7))) ;
  2952. }
  2953.  
  2954. //////////////////////////////////////////////////////////////
  2955. //////////////////////////////////////////////////////////////
  2956. //////////////////////////////////////////////////////////////
  2957. diverse clase si templateuri:
  2958. //////////////////////////////////////////////////////////////
  2959. //////////////////////////////////////////////////////////////
  2960. //////////////////////////////////////////////////////////////
  2961. #include <set>
  2962. #include <bitset>
  2963. #include <queue>
  2964. #include <deque>
  2965. #include <stack>
  2966. #include <sstream>
  2967. #include <iostream>
  2968. #include <iomanip>
  2969.  
  2970. #include <cstdio>
  2971. #include <cstdlib>
  2972. #include <cmath>
  2973. #include <ctime>
  2974. #include <cstring>
  2975. #include <string>
  2976. #include <cassert>
  2977.  
  2978. #include <vector>
  2979. #include <list>
  2980. #include <map>
  2981. #include <algorithm>
  2982. #include <functional>
  2983. #include <numeric>
  2984. #include <utility>
  2985.  
  2986. using namespace std;
  2987.  
  2988. typedef vector<int> vi;
  2989. typedef vector<vi> vvi;
  2990. typedef pair<int, int> ii;
  2991. typedef long long int64; //NOTES:int64
  2992. typedef unsigned long long uint64; //NOTES:uint64
  2993. const double pi = acos(-1.0); //NOTES:pi
  2994. const double eps = 1e-11; //NOTES:eps
  2995. const int MAXI = 2 << 29;
  2996.  
  2997. #define FORN(i,a,b) for (int i=(a),_b=(b); i<_b; i++)
  2998. #define RFORN(i,b,a) for (int i=(b)-1,_a=(a); i>=_a; i--)
  2999. #define RESET(a,b) memset((a),(b),sizeof(a))
  3000.  
  3001. #define SC(x) scanf("%d",&x)
  3002. #define SC2(x,y) scanf("%d%d",&x,&y)
  3003. #define PR(x) printf("%d ",x)
  3004. #define PR2(x,y) printf("%d %d ",x,y)
  3005. #define PRS(x) printf("%s",x)
  3006. #define END printf("\n")
  3007. #define EXIT(x) {PRS(x);return 0;}
  3008. #define DBG(x) {cerr << "--> " << #x << " = " << x << endl;}
  3009.  
  3010. #define fi first
  3011. #define se second
  3012. #define PB push_back
  3013. #define ALL(x) (x).begin(),(x).end()
  3014. #define MP(X,Y) make_pair(X,Y)//NOTES:MP(
  3015. #define TR(c, i) for(typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
  3016. #define present(c, x) ((c).find(x) != (c).end())
  3017.  
  3018. int compare (const void *a, const void *b) {
  3019. return (*(int*)a-*(int*)b);
  3020. }
  3021.  
  3022. void startDBG() {
  3023. PRS("------------------- Start Debug -------------------\n\n");
  3024. }
  3025.  
  3026. void endDBG() {
  3027. PRS("\n\n------------------- End Debug -------------------\n");
  3028. }
  3029.  
  3030. template<class T> inline void DebM(T A[], T ii, T jj) { //Debug sequence
  3031. END;
  3032. PRS("----------------DEBUG----------------");
  3033. END;
  3034. FORN (i,ii,jj) cout<<A[i]<<" ";
  3035. END;
  3036. PRS("-------------------------------------");
  3037. END;
  3038. }
  3039. //Template code by ACRush
  3040. template<class T> inline bool isPrimeNumber(T n) { //NOTES:isPrimeNumber(
  3041. if (n <= 1)return false;
  3042. for (T i = 2; i * i <= n; i++) if (n % i == 0) return false;
  3043. return true;
  3044. }
  3045.  
  3046. template<class T> inline void checkmin(T &a, T b) {
  3047. if (b < a) a = b;
  3048. }//NOTES:checkmin(
  3049.  
  3050. template<class T> inline void checkmax(T &a, T b) {
  3051. if (b > a) a = b;
  3052. }//NOTES:checkmax(
  3053.  
  3054. template<class T> inline T sqr(T x) {
  3055. return x*x;
  3056. }//NOTES:sqr
  3057.  
  3058. template<class T> inline T lowbit(T n) {
  3059. return (n^(n - 1))&n;
  3060. }//NOTES:lowbit(
  3061.  
  3062. template<class T> inline int countbit(T n) {
  3063. return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
  3064. }//NOTES:countbit(
  3065. //Numberic Functions
  3066.  
  3067. template<class T> inline T gcd(T a, T b) { //NOTES:gcd(
  3068. if (a < 0)return gcd(-a, b);
  3069. if (b < 0)return gcd(a, -b);
  3070. return (b == 0) ? a : gcd(b, a % b);
  3071. }
  3072.  
  3073. template<class T> inline T lcm(T a, T b) { //NOTES:lcm(
  3074. if (a < 0)return lcm(-a, b);
  3075. if (b < 0)return lcm(a, -b);
  3076. return a * (b / gcd(a, b));
  3077. }
  3078.  
  3079. template<class T> inline T euclide(T a, T b, T &x, T &y) { //NOTES:euclide(
  3080. if (a < 0) {
  3081. T d = euclide(-a, b, x, y);
  3082. x = -x;
  3083. return d;
  3084. }
  3085. if (b < 0) {
  3086. T d = euclide(a, -b, x, y);
  3087. y = -y;
  3088. return d;
  3089. }
  3090. if (b == 0) {
  3091. x = 1;
  3092. y = 0;
  3093. return a;
  3094. } else {
  3095. T d = euclide(b, a % b, x, y);
  3096. T t = x;
  3097. x = y;
  3098. y = t - (a / b) * y;
  3099. return d;
  3100. }
  3101. }
  3102.  
  3103. template<class T> inline vector<pair<T, int> > factorize(T n) { //NOTES:factorize(
  3104. vector<pair<T, int> > R;
  3105. for (T i = 2; n > 1;) {
  3106. if (n % i == 0) {
  3107. int C = 0;
  3108. for (; n % i == 0; C++, n /= i);
  3109. R.push_back(make_pair(i, C));
  3110. }
  3111. i++;
  3112. if (i > n / i) i = n;
  3113. }
  3114. if (n > 1) R.push_back(make_pair(n, 1));
  3115. return R;
  3116. }
  3117.  
  3118. template<class T> inline T eularFunction(T n) { //NOTES:eularFunction(
  3119. vector<pair<T, int> > R = factorize(n);
  3120. T r = n;
  3121. for (int i = 0; i < R.size(); i++)r = r / R[i].first * (R[i].first - 1);
  3122. return r;
  3123. }
  3124.  
  3125. //Matrix Operations
  3126. const int MaxMatrixSize = 40; //NOTES:MaxMatrixSize
  3127.  
  3128. template<class T> inline void showMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) { //NOTES:showMatrix(
  3129. for (int i = 0; i < n; i++) {
  3130. for (int j = 0; j < n; j++)cout << A[i][j];
  3131. cout << endl;
  3132. }
  3133. }
  3134.  
  3135. template<class T> inline T checkMod(T n, T m) {
  3136. return (n % m + m) % m;
  3137. }//NOTES:checkMod(
  3138.  
  3139. template<class T> inline void identityMatrix(int n, T A[MaxMatrixSize][MaxMatrixSize]) { //NOTES:identityMatrix(
  3140. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) A[i][j] = (i == j) ? 1 : 0;
  3141. }
  3142.  
  3143. template<class T> inline void addMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize], T A[MaxMatrixSize][MaxMatrixSize], T B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:addMatrix(
  3144. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) C[i][j] = A[i][j] + B[i][j];
  3145. }
  3146.  
  3147. template<class T> inline void subMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize], T A[MaxMatrixSize][MaxMatrixSize], T B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:subMatrix(
  3148. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) C[i][j] = A[i][j] - B[i][j];
  3149. }
  3150.  
  3151. template<class T> inline void mulMatrix(int n, T C[MaxMatrixSize][MaxMatrixSize], T _A[MaxMatrixSize][MaxMatrixSize], T _B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:mulMatrix(
  3152. T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
  3153. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
  3154. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) for (int k = 0; k < n; k++) C[i][j] += A[i][k] * B[k][j];
  3155. }
  3156.  
  3157. template<class T> inline void addModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize], T A[MaxMatrixSize][MaxMatrixSize], T B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:addModMatrix(
  3158. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] + B[i][j], m);
  3159. }
  3160.  
  3161. template<class T> inline void subModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize], T A[MaxMatrixSize][MaxMatrixSize], T B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:subModMatrix(
  3162. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) C[i][j] = checkMod(A[i][j] - B[i][j], m);
  3163. }
  3164.  
  3165. template<class T> inline T multiplyMod(T a, T b, T m) {
  3166. return (T) ((((int64) (a)*(int64) (b) % (int64) (m))+(int64) (m)) % (int64) (m));
  3167. }//NOTES:multiplyMod(
  3168.  
  3169. template<class T> inline void mulModMatrix(int n, T m, T C[MaxMatrixSize][MaxMatrixSize], T _A[MaxMatrixSize][MaxMatrixSize], T _B[MaxMatrixSize][MaxMatrixSize]) { //NOTES:mulModMatrix(
  3170. T A[MaxMatrixSize][MaxMatrixSize], B[MaxMatrixSize][MaxMatrixSize];
  3171. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) A[i][j] = _A[i][j], B[i][j] = _B[i][j], C[i][j] = 0;
  3172. for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) for (int k = 0; k < n; k++) C[i][j] = (C[i][j] + multiplyMod(A[i][k], B[k][j], m)) % m;
  3173. }
  3174.  
  3175. template<class T> inline T powerMod(T p, int e, T m) { //NOTES:powerMod(
  3176. if (e == 0)return 1 % m;
  3177. else if (e % 2 == 0) {
  3178. T t = powerMod(p, e / 2, m);
  3179. return multiplyMod(t, t, m);
  3180. } else return multiplyMod(powerMod(p, e - 1, m), p, m);
  3181. }
  3182. //Point&Line
  3183.  
  3184. double dist(double x1, double y1, double x2, double y2) {
  3185. return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
  3186. }//NOTES:dist(
  3187.  
  3188. double distR(double x1, double y1, double x2, double y2) {
  3189. return sqr(x1 - x2) + sqr(y1 - y2);
  3190. }//NOTES:distR(
  3191.  
  3192. template<class T> T cross(T x0, T y0, T x1, T y1, T x2, T y2) {
  3193. return (x1 - x0)*(y2 - y0)-(x2 - x0)*(y1 - y0);
  3194. }//NOTES:cross(
  3195.  
  3196. int crossOper(double x0, double y0, double x1, double y1, double x2, double y2) { //NOTES:crossOper(
  3197. double t = (x1 - x0)*(y2 - y0)-(x2 - x0)*(y1 - y0);
  3198. if (fabs(t) <= eps) return 0;
  3199. return (t < 0) ? -1 : 1;
  3200. }
  3201.  
  3202. bool isIntersect(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) { //NOTES:isIntersect(
  3203. return crossOper(x1, y1, x2, y2, x3, y3) * crossOper(x1, y1, x2, y2, x4, y4) < 0 && crossOper(x3, y3, x4, y4, x1, y1) * crossOper(x3, y3, x4, y4, x2, y2) < 0;
  3204. }
  3205.  
  3206. bool isMiddle(double s, double m, double t) {
  3207. return fabs(s - m) <= eps | fabs(t - m) <= eps | (s < m) != (t < m);
  3208. }//NOTES:isMiddle(
  3209. //Translator
  3210.  
  3211. bool isUpperCase(char c) {
  3212. return c >= 'A' && c <= 'Z';
  3213. }//NOTES:isUpperCase(
  3214.  
  3215. bool isLowerCase(char c) {
  3216. return c >= 'a' && c <= 'z';
  3217. }//NOTES:isLowerCase(
  3218.  
  3219. bool isLetter(char c) {
  3220. return c >= 'A' && c <= 'Z' | c >= 'a' && c <= 'z';
  3221. }//NOTES:isLetter(
  3222.  
  3223. bool isDigit(char c) {
  3224. return c >= '0' && c <= '9';
  3225. }//NOTES:isDigit(
  3226.  
  3227. char toLowerCase(char c) {
  3228. return (isUpperCase(c)) ? (c + 32) : c;
  3229. }//NOTES:toLowerCase(
  3230.  
  3231. char toUpperCase(char c) {
  3232. return (isLowerCase(c)) ? (c - 32) : c;
  3233. }//NOTES:toUpperCase(
  3234.  
  3235. template<class T> string toString(T n) {
  3236. ostringstream ost;
  3237. ost << n;
  3238. ost.flush();
  3239. return ost.str();
  3240. }//NOTES:toString(
  3241.  
  3242. int toInt(string s) {
  3243. int r = 0;
  3244. istringstream sin(s);
  3245. sin >> r;
  3246. return r;
  3247. }//NOTES:toInt(
  3248.  
  3249. int64 toInt64(string s) {
  3250. int64 r = 0;
  3251. istringstream sin(s);
  3252. sin >> r;
  3253. return r;
  3254. }//NOTES:toInt64(
  3255.  
  3256. double toDouble(string s) {
  3257. double r = 0;
  3258. istringstream sin(s);
  3259. sin >> r;
  3260. return r;
  3261. }//NOTES:toDouble(
  3262.  
  3263. template<class T> void stoa(string s, int &n, T A[]) {
  3264. n = 0;
  3265. istringstream sin(s);
  3266. for (T v; sin >> v; A[n++] = v);
  3267. }//NOTES:stoa(
  3268.  
  3269. template<class T> void atos(int n, T A[], string &s) {
  3270. ostringstream sout;
  3271. for (int i = 0; i < n; i++) {
  3272. if (i > 0)sout << ' ';
  3273. sout << A[i];
  3274. }
  3275. s = sout.str();
  3276. }//NOTES:atos(
  3277.  
  3278. template<class T> void atov(int n, T A[], vector<T> &vi) {
  3279. vi.clear();
  3280. for (int i = 0; i < n; i++) vi.push_back(A[i]);
  3281. }//NOTES:atov(
  3282.  
  3283. template<class T> void vtoa(vector<T> vi, int &n, T A[]) {
  3284. n = vi.size();
  3285. for (int i = 0; i < n; i++)A[i] = vi[i];
  3286. }//NOTES:vtoa(
  3287.  
  3288. template<class T> void stov(string s, vector<T> &vi) {
  3289. vi.clear();
  3290. istringstream sin(s);
  3291. for (T v; sin >> v; vi.push_bakc(v));
  3292. }//NOTES:stov(
  3293.  
  3294. template<class T> void vtos(vector<T> vi, string &s) {
  3295. ostringstream sout;
  3296. for (int i = 0; i < vi.size(); i++) {
  3297. if (i > 0)sout << ' ';
  3298. sout << vi[i];
  3299. }
  3300. s = sout.str();
  3301. }//NOTES:vtos(
  3302. //Fraction
  3303.  
  3304. template<class T> struct Fraction {
  3305. T a, b;
  3306. Fraction(T a = 0, T b = 1);
  3307. string toString();
  3308. }; //NOTES:Fraction
  3309.  
  3310. template<class T> Fraction<T>::Fraction(T a, T b) {
  3311. T d = gcd(a, b);
  3312. a /= d;
  3313. b /= d;
  3314. if (b < 0) a = -a, b = -b;
  3315. this->a = a;
  3316. this->b = b;
  3317. }
  3318.  
  3319. template<class T> string Fraction<T>::toString() {
  3320. ostringstream sout;
  3321. sout << a << "/" << b;
  3322. return sout.str();
  3323. }
  3324.  
  3325. template<class T> Fraction<T> operator+(Fraction<T> p, Fraction<T> q) {
  3326. return Fraction<T > (p.a * q.b + q.a * p.b, p.b * q.b);
  3327. }
  3328.  
  3329. template<class T> Fraction<T> operator-(Fraction<T> p, Fraction<T> q) {
  3330. return Fraction<T > (p.a * q.b - q.a * p.b, p.b * q.b);
  3331. }
  3332.  
  3333. template<class T> Fraction<T> operator*(Fraction<T> p, Fraction<T> q) {
  3334. return Fraction<T > (p.a * q.a, p.b * q.b);
  3335. }
  3336.  
  3337. template<class T> Fraction<T> operator/(Fraction<T> p, Fraction<T> q) {
  3338. return Fraction<T > (p.a * q.b, p.b * q.a);
  3339. }
  3340. //Template code by ACRush
  3341.  
  3342.  
  3343.  
  3344. //////////////////////////////////////////////////////////////
  3345. //////////////////////////////////////////////////////////////
  3346. //////////////////////////////////////////////////////////////
  3347. alte define-uri si chestii:
  3348. //////////////////////////////////////////////////////////////
  3349. //////////////////////////////////////////////////////////////
  3350. //////////////////////////////////////////////////////////////
  3351.  
  3352. /** Repeat **/
  3353.  
  3354. #define REP(I, N) for (int I=0;I<int(N);++I)
  3355. #define FOR(I, A, B) for (int I=int(A);I<int(B);++I)
  3356. #define DWN(I, B, A) for (int I=int(B-1);I>=int(A);--I)
  3357. #define REP_1(I, N) for (int I=1;I<=int(N);++I)
  3358. #define FOR_1(I, A, B) for (int I=int(A);I<=int(B);++I)
  3359. #define DWN_1(I, B, A) for (int I=int(B);I>=int(A);--I)
  3360. #define REP_C(I, N) for (int N____=int(N),I=0;I<N____;++I)
  3361. #define FOR_C(I, A, B) for (int B____=int(B),I=A;I<B____;++I)
  3362. #define DWN_C(I, B, A) for (int A____=int(A),I=B-1;I>=A____;--I)
  3363. #define REP_1_C(I, N) for (int N____=int(N),I=1;I<=N____;++I)
  3364. #define FOR_1_C(I, A, B) for (int B____=int(B),I=A;I<=B____;++I)
  3365. #define DWN_1_C(I, B, A) for (int A____=int(A),I=B;I>=A____;--I)
  3366. #define DO(N) while(N--)
  3367. #define DO_C(N) int N____ = N; while(N____--)
  3368. #define TO(i, a, b) int s_=a<b?1:-1,b_=b+s_;for(int i=a;i!=b_;i+=s_)
  3369. #define TO_1(i, a, b) int s_=a<b?1:-1,b_=b;for(int i=a;i!=b_;i+=s_)
  3370. #define SQZ(I, J, A, B) for (int I=int(A),J=int(B)-1;I<J;++I,--J)
  3371. #define SQZ_1(I, J, A, B) for (int I=int(A),J=int(B);I<=J;++I,--J)
  3372.  
  3373.  
  3374. /** Micro Mezzo Macro Flation -- Overheated Economy **/
  3375.  
  3376. #define ALL(A) A.begin(), A.end()
  3377. #define CPY(A, B) memcpy(A, B, sizeof(A))
  3378. #define INS(A, P, B) A.insert(A.begin() + P, B)
  3379. #define ERS(A, P) A.erase(A.begin() + P)
  3380. #define SRT(A) sort(ALL(A))
  3381. #define BSC(A, X) find(ALL(A), X) // != A.end()
  3382. #define SZ(A) int(A.size())
  3383. #define PB push_back
  3384. #define MP(A, B) make_pair(A, B)
  3385.  
  3386. #define Rush int T____; RD(T____); DO(T____)
  3387. // the size of the stack is set to be ~36 MB
  3388. #pragma comment(linker, "/STACK:36777216")
  3389. #define Ruby system("ruby main.rb")
  3390. #define Haskell system("runghc main.hs")
  3391. #define Pascal system("fpc main.pas")
  3392.  
  3393. /** Typedef **/
  3394.  
  3395. typedef long long LL;
  3396. typedef double DB;
  3397.  
  3398. typedef vector<int> VI;
  3399. typedef vector<string> VS;
  3400. typedef vector<LL> VL;
  3401. typedef vector<DB> VD;
  3402. typedef set<int> SI;
  3403. typedef set<string> SS;
  3404. typedef set<LL> SL;
  3405. typedef set<DB> SD;
  3406. typedef map<int, int> MI;
  3407. typedef map<string, int> MS;
  3408. typedef map<LL, int> ML;
  3409. typedef map<DB, int> MD;
  3410. typedef pair<int, int> PII;
  3411. typedef pair<int, bool> PIB;
  3412. typedef vector<PII> VII;
  3413. typedef set<PII> SII;
  3414. typedef map<PII, int> MII;
  3415. typedef vector<VI> VVI;
  3416. typedef vector<VII> VVII;
  3417.  
  3418.  
  3419. //////////////////////////////////////////////////////////////
  3420. //////////////////////////////////////////////////////////////
  3421. //////////////////////////////////////////////////////////////
  3422. dijkstra cu heapuri
  3423. //////////////////////////////////////////////////////////////
  3424. //////////////////////////////////////////////////////////////
  3425. //////////////////////////////////////////////////////////////
  3426.  
  3427. #include <cstdio>
  3428.  
  3429. const int maxn = 50001;
  3430. const int inf = 1 << 30;
  3431.  
  3432. FILE *in = fopen("dijkstra.in","r"), *out = fopen("dijkstra.out","w");
  3433.  
  3434. struct graf {
  3435. int nod, cost;
  3436. graf *next;
  3437. };
  3438.  
  3439. int n, m;
  3440. graf *a[maxn];
  3441. int d[maxn], h[maxn], poz[maxn], k;
  3442.  
  3443. void add(int where, int what, int cost) {
  3444. graf *q = new graf;
  3445. q->nod = what;
  3446. q->cost = cost;
  3447. q->next = a[where];
  3448. a[where] = q;
  3449. }
  3450.  
  3451. void read() {
  3452. fscanf(in, "%d %d", &n, &m);
  3453.  
  3454. int x, y, z;
  3455. for ( int i = 1; i <= m; ++i ) {
  3456. fscanf(in, "%d %d %d", &x, &y, &z);
  3457. add(x, y, z);
  3458. }
  3459. }
  3460.  
  3461. void swap(int x, int y) {
  3462. int t = h[x];
  3463. h[x] = h[y];
  3464. h[y] = t;
  3465. }
  3466.  
  3467. void upheap(int what) {
  3468. int tata;
  3469. while ( what > 1 ) {
  3470. tata = what >> 1;
  3471.  
  3472. if ( d[ h[tata] ] > d[ h[what] ] ) {
  3473. poz[ h[what] ] = tata;
  3474. poz[ h[tata] ] = what;
  3475.  
  3476. swap(tata, what);
  3477.  
  3478. what = tata;
  3479. } else
  3480. what = 1;
  3481. }
  3482. }
  3483.  
  3484. void downheap(int what) {
  3485. int ui;
  3486. while ( what <= k ) {
  3487. ui = what;
  3488. if ( (what<<1) <= k ) {
  3489. ui = what << 1;
  3490. if ( ui + 1 <= k )
  3491. if ( d[ h[ui + 1] ] < d[ h[ui] ] )
  3492. ++ui;
  3493. } else
  3494. return;
  3495.  
  3496. if ( d[ h[what] ] > d[ h[ui] ] ) {
  3497. poz[ h[what] ] = ui;
  3498. poz[ h[ui] ] = what;
  3499.  
  3500. swap(what, ui);
  3501.  
  3502. what = ui;
  3503. } else
  3504. return;
  3505. }
  3506. }
  3507.  
  3508. void dijkstra_heap() {
  3509. for ( int i = 2; i <= n; ++i )
  3510. d[i] = inf, poz[i] = -1;
  3511. poz[1] = 1;
  3512.  
  3513. h[++k] = 1;
  3514.  
  3515. while ( k ) {
  3516. int min = h[1];
  3517. swap(1, k);
  3518. poz[ h[1] ] = 1;
  3519. --k;
  3520.  
  3521. downheap(1);
  3522.  
  3523. graf *q = a[min];
  3524.  
  3525. while ( q ) {
  3526. if ( d[q->nod] > d[min] + q->cost ) {
  3527. d[q->nod] = d[min] + q->cost;
  3528.  
  3529. if ( poz[q->nod] != -1 )
  3530. upheap( poz[q->nod] );
  3531. else {
  3532. h[++k] = q->nod;
  3533. poz[ h[k] ] = k;
  3534. upheap( k );
  3535. }
  3536. }
  3537. q = q->next;
  3538. }
  3539. }
  3540. }
  3541.  
  3542. int main() {
  3543. read();
  3544. dijkstra_heap();
  3545.  
  3546. for ( int i = 2; i <= n; ++i )
  3547. fprintf(out, "%d ", d[i] == inf ? 0 : d[i]);
  3548. fprintf(out, "\n");
  3549.  
  3550. return 0;
  3551. }
  3552.  
  3553.  
  3554. //////////////////////////////////////////////////////////////
  3555. //////////////////////////////////////////////////////////////
  3556. //////////////////////////////////////////////////////////////
  3557. dijkstra cu set
  3558. //////////////////////////////////////////////////////////////
  3559. //////////////////////////////////////////////////////////////
  3560. //////////////////////////////////////////////////////////////
  3561. inline void dijkstra() {
  3562. memset(d,0x3f,sizeof(d));
  3563. set<pair<int,int> > S;
  3564.  
  3565. d[1]=0;
  3566. S.insert(make_pair(0,1));
  3567. while(!S.empty()) {
  3568. int nod=S.begin()->second,cost=S.begin()->first;
  3569. S.erase(S.begin());
  3570. for(vector<muchie>::iterator it=G[nod].begin(),stop=G[nod].end(); it<stop; ++it) {
  3571. if( d[it->vec] > cost + it->cost ) {
  3572. //S.insert( make_pair( d[it->vec], it->vec ) );//teoretic mai repede, practic nu
  3573. d[it->vec] = cost + it->cost;
  3574. S.insert( make_pair( d[it->vec], it->vec ) );
  3575. }
  3576. }
  3577. }
  3578.  
  3579. }
  3580.  
  3581.  
  3582.  
  3583. //////////////////////////////////////////////////////////////
  3584. //////////////////////////////////////////////////////////////
  3585. //////////////////////////////////////////////////////////////
  3586. dijkstra cu priority_queue
  3587. //////////////////////////////////////////////////////////////
  3588. //////////////////////////////////////////////////////////////
  3589. //////////////////////////////////////////////////////////////
  3590. //dijkstra cu priority_queue
  3591. #include<cstdio>
  3592. #include<iostream>
  3593. #include<fstream>
  3594. #include<algorithm>
  3595. #include<set>
  3596. #include<queue>
  3597. #include<cstring>
  3598. #include<vector>
  3599. using namespace std;
  3600.  
  3601. ifstream fin("dijkstra.in");
  3602. ofstream fout("dijkstra.out");
  3603.  
  3604. struct muchie {
  3605. int vec,cost;
  3606. };
  3607.  
  3608. vector <muchie> G[50000+10];
  3609. int viz[50000+10],d[50000+10];
  3610. bool cmp(const pair<int,int> &a, const pair<int,int> &b)
  3611. {
  3612. if(a.first == b.first)
  3613. return a.second<b.second;
  3614. return a.first<b.first;
  3615. }
  3616. inline void dijkstra()
  3617. {
  3618. memset(d,0x3f,sizeof(d));
  3619. priority_queue < pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > Q;
  3620.  
  3621. d[1]=0;
  3622. Q.push(make_pair(0,1));
  3623. while(!Q.empty()) {
  3624. int nod=Q.top().second,cost=Q.top().first;
  3625. Q.pop();
  3626. for(vector<muchie>::iterator it=G[nod].begin(),stop=G[nod].end(); it<stop; ++it) {
  3627. if( d[it->vec] > cost + it->cost ) {
  3628. d[it->vec] = cost + it->cost;
  3629. Q.push( make_pair( d[it->vec], it->vec ) );
  3630. }
  3631. }
  3632. }
  3633.  
  3634. }
  3635. int main()
  3636. {
  3637. int n,m;
  3638.  
  3639. fin>>n>>m;
  3640.  
  3641. for(int i=1; i<=m; ++i) {
  3642. int from,to,cost;
  3643. fin>>from>>to>>cost;
  3644. G[from].push_back((muchie) {
  3645. to,cost
  3646. });
  3647. }
  3648. dijkstra();
  3649.  
  3650. for(int i=2; i<=n; ++i)
  3651. fout<<((d[i]==0x3f3f3f3f)?0:d[i])<<' ';
  3652. fout<<'\n';
  3653.  
  3654. return 0;
  3655. }
  3656.  
  3657.  
  3658.  
  3659. //////////////////////////////////////////////////////////////
  3660. //////////////////////////////////////////////////////////////
  3661. //////////////////////////////////////////////////////////////
  3662. dijkstra cu make_heap
  3663. //////////////////////////////////////////////////////////////
  3664. //////////////////////////////////////////////////////////////
  3665. //////////////////////////////////////////////////////////////
  3666.  
  3667. //dijkstra cu make_heap
  3668. #include<cstdio>
  3669. #include<iostream>
  3670. #include<fstream>
  3671. #include<algorithm>
  3672. #include<set>
  3673. #include<queue>
  3674. #include<cstring>
  3675. #include<vector>
  3676. using namespace std;
  3677.  
  3678. ifstream fin("dijkstra.in");
  3679. ofstream fout("dijkstra.out");
  3680.  
  3681. struct muchie {
  3682. int vec,cost;
  3683. };
  3684.  
  3685. vector <muchie> G[50000+10];
  3686. int viz[50000+10],d[50000+10];
  3687. bool cmp(const pair<int,int> &a, const pair<int,int> &b)
  3688. {
  3689. if(a.first == b.first)
  3690. return a.second<b.second;
  3691. return a.first<b.first;
  3692. }
  3693. inline void dijkstra()
  3694. {
  3695. memset(d,0x3f,sizeof(d));
  3696. // priority_queue < pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > Q;
  3697. vector<pair<int,int> > V;
  3698. d[1]=0;
  3699. V.push_back(make_pair(0,1));
  3700. while(!V.empty()) {
  3701. int nod=V[0].second,cost=V[0].first;
  3702. pop_heap(V.begin(),V.end(),greater<pair<int,int> >());
  3703. V.pop_back();
  3704. for(vector<muchie>::iterator it=G[nod].begin(),stop=G[nod].end(); it<stop; ++it) {
  3705. if( d[it->vec] > cost + it->cost ) {
  3706. d[it->vec] = cost + it->cost;
  3707. V.push_back( make_pair( d[it->vec], it->vec ) );
  3708. push_heap(V.begin(),V.end(),greater<pair<int,int> >());
  3709. }
  3710. }
  3711. }
  3712.  
  3713. }
  3714. int main()
  3715. {
  3716. int n,m;
  3717.  
  3718. fin>>n>>m;
  3719.  
  3720. for(int i=1; i<=m; ++i) {
  3721. int from,to,cost;
  3722. fin>>from>>to>>cost;
  3723. G[from].push_back((muchie) {
  3724. to,cost
  3725. });
  3726. }
  3727. dijkstra();
  3728.  
  3729. for(int i=2; i<=n; ++i)
  3730. fout<<((d[i]==0x3f3f3f3f)?0:d[i])<<' ';
  3731. fout<<'\n';
  3732.  
  3733. return 0;
  3734. }
  3735.  
  3736.  
  3737.  
  3738.  
  3739.  
  3740.  
  3741.  
  3742.  
  3743. //////////////////////////////////////////////////////////////
  3744. //////////////////////////////////////////////////////////////
  3745. //////////////////////////////////////////////////////////////
  3746. Bellman Ford
  3747. //////////////////////////////////////////////////////////////
  3748. //////////////////////////////////////////////////////////////
  3749. //////////////////////////////////////////////////////////////
  3750. vector<pair<int,int> > G[50000+10];
  3751. queue<int> Q;
  3752. int cnt_in_queue[50000+10];
  3753. bool in_queue[50000+10];
  3754. int d[50000+10];
  3755.  
  3756. inline void bellmanford()
  3757. {
  3758. memset(d,0x3f,sizeof(d));
  3759. d[1]=0;
  3760. Q.push(1);
  3761. in_queue[1]=true;
  3762. cnt_in_queue[1]=1;
  3763. while(!Q.empty()) {
  3764. int nod=Q.front();
  3765. Q.pop();
  3766. in_queue[nod]=false;
  3767. foreach(it,G[nod]) {
  3768. if( d[it->first]>d[nod]+it->second ) {
  3769. d[it->first]=d[nod]+it->second;
  3770.  
  3771. if(!in_queue[it->first]){
  3772. Q.push(it->first);
  3773. in_queue[it->first]=true;
  3774.  
  3775. if(cnt_in_queue[it->first]++>n) {
  3776. fout<<"Ciclu negativ!\n";
  3777. exit(0);
  3778. }
  3779. }
  3780. }
  3781. }
  3782. }
  3783. }
  3784.  
  3785.  
  3786.  
  3787. //////////////////////////////////////////////////////////////
  3788. //////////////////////////////////////////////////////////////
  3789. //////////////////////////////////////////////////////////////
  3790. Johnson -> all pairs shortest paths
  3791. //////////////////////////////////////////////////////////////
  3792. //////////////////////////////////////////////////////////////
  3793. //////////////////////////////////////////////////////////////
  3794.  
  3795. JOHNSON(G)
  3796. 1 compute G′, where V[G′] = V[G] ∪ {s},
  3797. E[G′] = E[G] ∪ {(s, v) : v ∈ V[G]}, and
  3798. w(s, v) = 0 for all v ∈ V[G]
  3799. 2 if BELLMAN-FORD(G′, w, s) = FALSE
  3800. 3 then print "the input graph contains a negative-weight cycle"
  3801. 4 else for each vertex v ∈ V[G′]
  3802. 5 do set h(v) to the value of δ(s, v)
  3803. computed by the Bellman-Ford algorithm
  3804. 6 for each edge (u, v) ∈ E[G′]
  3805. 7 do
  3806. 8 for each vertex u ∈ V[G]
  3807. 9 do run DIJKSTRA(G, , u) to compute for all v ∈ V[G]
  3808. 10 for each vertex v ∈ V[G]
  3809. 11 do
  3810. 12 return D
  3811.  
  3812.  
  3813.  
  3814.  
  3815.  
  3816. //////////////////////////////////////////////////////////////
  3817. //////////////////////////////////////////////////////////////
  3818. //////////////////////////////////////////////////////////////
  3819. Roy Floyd Warshall
  3820. //////////////////////////////////////////////////////////////
  3821. //////////////////////////////////////////////////////////////
  3822. //////////////////////////////////////////////////////////////
  3823.  
  3824.  
  3825. scanf("%d",&n);
  3826. for(int i=0; i<n; ++i)
  3827. for(int j=0; j<n; ++j) {
  3828. scanf("%d",&a[i][j]);
  3829. if(a[i][j]==0 && i!=j)
  3830. a[i][j]=0x3f3f3f3f;
  3831. }
  3832. for(int k=0; k<n; ++k)
  3833. for(int i=0; i<n; ++i)
  3834. for(int j=0; j<n; ++j)
  3835. a[i][j]=std::min(a[i][k]+a[k][j],a[i][j]);
  3836. for(int i=0; i<n; ++i,putchar('\n'))
  3837. for(int j=0; j<n; ++j)
  3838. printf("%d ",(a[i][j]==0x3f3f3f3f)?0:a[i][j]);
  3839.  
  3840.  
  3841.  
  3842.  
  3843.  
  3844.  
  3845.  
  3846. //////////////////////////////////////////////////////////////
  3847. //////////////////////////////////////////////////////////////
  3848. //////////////////////////////////////////////////////////////
  3849. arbori indexati binar
  3850. //////////////////////////////////////////////////////////////
  3851. //////////////////////////////////////////////////////////////
  3852. //////////////////////////////////////////////////////////////
  3853. void update(int i,int j ,int val) {
  3854. for (int ii=i; ii <= n; ii+=(ii&-ii))
  3855. for(int jj=j; jj<=n; jj+=(jj&-jj))
  3856. aib[ii][jj] = (aib[ii][jj]+ val)%MOD;
  3857. }
  3858. int q(int i,int j) {
  3859. int sum = 0;
  3860. for (int ii=i; ii; ii-=(ii&-ii))
  3861. for(int jj=j; jj; jj-=jj&-jj)
  3862. sum = (sum+aib[ii][jj])%MOD;
  3863. return sum;
  3864. }
  3865. int query(int x1,int y1, int x2, int y2) {
  3866. return q(x2,y2)-q(x1-1,y2)-q(x2,y1-1)+q(x1-1,y1-1);
  3867. }
  3868.  
  3869.  
  3870. /*
  3871. int now=(1+query(a[k].i+1,a[k].i+1,a[k].j-1,a[k].j-1))%MOD;//(1+q(n-a[k].i,a[k].j-1))%MOD;
  3872. s=(s+d[a[k].i][a[k].j])%MOD;
  3873. s=(s+now)%MOD;
  3874. update(a[k].i,a[k].j,now);
  3875. */
  3876. /*
  3877. int now=(1+q(n-a[k].i,a[k].j-1))%MOD;
  3878. s=(s+now)%MOD;
  3879. update(n-a[k].i+1,a[k].j,now);
  3880. */
  3881.  
  3882.  
  3883.  
  3884.  
  3885.  
  3886. //////////////////////////////////////////////////////////////
  3887. //////////////////////////////////////////////////////////////
  3888. //////////////////////////////////////////////////////////////
  3889. arbori de intervale
  3890. //////////////////////////////////////////////////////////////
  3891. //////////////////////////////////////////////////////////////
  3892. //////////////////////////////////////////////////////////////
  3893.  
  3894. #include <stdio.h>
  3895. #include <fstream>
  3896. #include <assert.h>
  3897. using namespace std;
  3898.  
  3899. #define in "arbint.in"
  3900. #define out "arbint.out"
  3901. #define dim 100001
  3902.  
  3903. int N, M;
  3904. int MaxArb[4*dim+66];
  3905. int start, finish, Val, Pos, maxim;
  3906.  
  3907. inline int Maxim(int a, int b) {
  3908. if ( a > b ) return a;
  3909. return b;
  3910. }
  3911.  
  3912. void Update(int,int,int);
  3913. void Query(int,int,int);
  3914.  
  3915. int main() {
  3916. int X, A, B;
  3917. freopen(in,"r",stdin);
  3918. freopen(out,"w",stdout);
  3919.  
  3920. scanf("%d%d", &N, &M);
  3921. for ( int i = 1; i <= N; i++ ) {
  3922. scanf("%d", &X);
  3923. Pos = i, Val = X;
  3924. Update(1,1,N);
  3925. }
  3926.  
  3927. for ( int i = 1; i <= M; i++ ) {
  3928. scanf("%d%d%d", &X, &A, &B);
  3929. if ( X == 0 ) {
  3930. maxim = -1;
  3931. start = A, finish = B;
  3932. Query(1,1,N);
  3933.  
  3934. printf("%d\n", maxim);
  3935. } else {
  3936. Pos = A, Val = B;
  3937. Update(1,1,N);
  3938. }
  3939. }
  3940. }
  3941.  
  3942. void Update(int nod, int left, int right) {
  3943. if ( left == right ) {
  3944. MaxArb[nod] = Val;
  3945. return;
  3946. }
  3947.  
  3948. int div = (left+right)/2;
  3949. if ( Pos <= div ) Update(2*nod,left,div);
  3950. else Update(2*nod+1,div+1,right);
  3951.  
  3952. MaxArb[nod] = Maxim( MaxArb[2*nod], MaxArb[2*nod+1] );
  3953. }
  3954.  
  3955. void Query(int nod, int left, int right) {
  3956. if ( start <= left && right <= finish ) {
  3957. if ( maxim < MaxArb[nod] ) maxim = MaxArb[nod];
  3958. return;
  3959. }
  3960.  
  3961. int div = (left+right)/2;
  3962. if ( start <= div ) Query(2*nod,left,div);
  3963. if ( div < finish ) Query(2*nod+1,div+1,right);
  3964. }
  3965.  
  3966.  
  3967.  
  3968.  
  3969.  
  3970.  
  3971.  
  3972.  
  3973.  
  3974.  
  3975. //////////////////////////////////////////////////////////////
  3976. //////////////////////////////////////////////////////////////
  3977. //////////////////////////////////////////////////////////////
  3978. Infasuratoare convexa (Convex Hull)
  3979. //////////////////////////////////////////////////////////////
  3980. //////////////////////////////////////////////////////////////
  3981. //////////////////////////////////////////////////////////////
  3982.  
  3983.  
  3984. #include <stdio.h>
  3985. #include <algorithm>
  3986.  
  3987. using namespace std;
  3988.  
  3989. #define INF 1000000000
  3990. #define EPS 1e-12
  3991. #define PDD pair<double, double>
  3992. #define x first
  3993. #define y second
  3994.  
  3995. int N, H;
  3996. PDD v[120005], P[120005];
  3997.  
  3998. inline int cmp(double a, double b) {
  3999. if (a + EPS < b) return -1;
  4000. if (b + EPS < a) return +1;
  4001. return 0;
  4002. }
  4003.  
  4004. int cmp_PDD(const PDD &a, const PDD& b) {
  4005. int r = cmp(a.x, b.x);
  4006. if (r != 0) return r == -1;
  4007. return cmp(a.y, b.y) == -1;
  4008. }
  4009.  
  4010. int semn(PDD a, PDD b, PDD c) {
  4011. double A = a.y-b.y, B = b.x-a.x, C = a.x*b.y - b.x*a.y;
  4012. return cmp(A * c.x + B * c.y + C, 0);
  4013. }
  4014.  
  4015. int st[120005], uz[120005];
  4016. void ConvexHull() {
  4017. int i, pas = +1, k;
  4018.  
  4019. sort(v+1, v+N+1, cmp_PDD);
  4020.  
  4021. uz[2] = 1;
  4022. st[1] = 1;
  4023. st[2] = 2;
  4024. k = 2;
  4025. i = 3;
  4026. while (!uz[1]) {
  4027. while (uz[i]) {
  4028. if (i == N)
  4029. pas = -1;
  4030. i += pas;
  4031. }
  4032. while (k >= 2 && semn(v[st[k-1]], v[st[k]], v[i]) == -1)
  4033. uz[st[k--]] = 0;
  4034. st[++k] = i;
  4035. uz[i] = 1;
  4036. }
  4037. H = k-1;
  4038. for (i = 1; i <= H; ++i)
  4039. P[i] = v[st[i]];
  4040. P[H+1] = P[1];
  4041. }
  4042.  
  4043. int main() {
  4044. int i;
  4045.  
  4046. freopen("infasuratoare.in", "r", stdin);
  4047. freopen("infasuratoare.out", "w", stdout);
  4048.  
  4049. scanf("%d", &N);
  4050. for (i = 1; i <= N; ++i)
  4051. scanf("%lf %lf", &v[i].x, &v[i].y);
  4052.  
  4053. ConvexHull();
  4054. printf("%d\n", H);
  4055. for (i = 1; i <= H; ++i)
  4056. printf("%.6lf %.6lf\n", P[i].x, P[i].y);
  4057.  
  4058. return 0;
  4059. }
  4060.  
  4061.  
  4062.  
  4063.  
  4064.  
  4065. //////////////////////////////////////////////////////////////
  4066. //////////////////////////////////////////////////////////////
  4067. //////////////////////////////////////////////////////////////
  4068. //Cele mai apropiate puncte din plan (cmap)
  4069. //distanta minima dintre oricare 2 puncte
  4070. //divide et impera O(n*lgn)
  4071. //////////////////////////////////////////////////////////////
  4072. //////////////////////////////////////////////////////////////
  4073. //////////////////////////////////////////////////////////////
  4074.  
  4075.  
  4076.  
  4077. #include <iostream>
  4078. #include <fstream>
  4079. #include <vector>
  4080. #include <algorithm>
  4081. #include <cassert>
  4082. #include <cmath>
  4083. #include <iomanip>
  4084. using namespace std;
  4085.  
  4086. const char iname[] = "cmap.in";
  4087. const char oname[] = "cmap.out";
  4088.  
  4089. typedef long long i64;
  4090.  
  4091. const int MAX_N = 100005;
  4092. const i64 INF = 4e18;
  4093.  
  4094. vector < pair <i64, i64> > V(MAX_N), X, Y;
  4095.  
  4096. i64 dist(const pair <i64, i64>& a, const pair <i64, i64>& b) {
  4097. return (a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second);
  4098. }
  4099.  
  4100. i64 go(int st, int dr, vector < pair <i64, i64> >& X, vector < pair <i64, i64> >& Y) {
  4101. if (st >= dr - 1)
  4102. return INF;
  4103. else if (dr - st == 2) {
  4104. if (Y[st] > Y[st + 1])
  4105. swap(Y[st], Y[st + 1]);
  4106. return dist(X[st], X[st + 1]);
  4107. }
  4108. int mid = (st + dr) / 2;
  4109. i64 best = min(go(st, mid, X, Y), go(mid, dr, X, Y));
  4110.  
  4111. merge(Y.begin() + st, Y.begin() + mid, Y.begin() + mid, Y.begin() + dr, V.begin());
  4112. copy(V.begin(), V.begin() + (dr - st), Y.begin() + st);
  4113.  
  4114. int v_size = 0;
  4115. for (int i = st; i < dr; ++ i) if (abs(Y[i].second - X[mid].first) <= best)
  4116. V[v_size ++] = Y[i];
  4117. for (int i = 0; i < v_size - 1; ++ i) {
  4118. for (int j = i + 1; j < v_size && j - i < 8; ++ j)
  4119. best = min(best, dist(V[i], V[j]));
  4120. }
  4121. return best;
  4122. }
  4123.  
  4124. int main(void) {
  4125. int n;
  4126. ifstream in(iname);
  4127. assert(in >> n);
  4128. assert(1 <= n && n <= 100000);
  4129.  
  4130. X.resize(n), Y.resize(n);
  4131. for (int i = 0; i < (int) X.size(); ++ i) {
  4132. assert(in >> X[i].first >> X[i].second);
  4133. assert(-1000000000 <= X[i].first && X[i].first <= +1000000000);
  4134. assert(-1000000000 <= X[i].second && X[i].second <= +1000000000);
  4135. }
  4136. in.close();
  4137.  
  4138. sort(X.begin(), X.end());
  4139. for (int i = 0; i < (int) X.size(); ++ i)
  4140. Y[i] = make_pair(X[i].second, X[i].first);
  4141.  
  4142. ofstream out(oname);
  4143. out << fixed << setprecision(6) << sqrt(go(0, (int) X.size(), X, Y)) << "\n";
  4144. out.close();
  4145. return 0;
  4146. }
  4147.  
  4148.  
  4149.  
  4150.  
  4151.  
  4152.  
  4153.  
  4154.  
  4155. //////////////////////////////////////////////////////////////
  4156. //////////////////////////////////////////////////////////////
  4157. Paduri de multimi disjuncte
  4158. //////////////////////////////////////////////////////////////
  4159. //////////////////////////////////////////////////////////////
  4160. //////////////////////////////////////////////////////////////
  4161.  
  4162. int root[100000+10];
  4163.  
  4164. int find(int x) {
  4165. int r = x;
  4166. while(root[r]!=r)
  4167. r=root[r];
  4168.  
  4169. //compresia drumurilor
  4170. while(root[x]!=x) {
  4171. int tmp;
  4172. tmp=root[x];
  4173. root[x]=r;
  4174. x=tmp;
  4175. }
  4176. return r;
  4177. }
  4178.  
  4179. void join(int x, int y) {
  4180. //unim radacinile
  4181. x=find(x);
  4182. y=find(y);
  4183.  
  4184. if(rand()%2)
  4185. root[y]=x;
  4186. else
  4187. root[x]=y;
  4188. }
  4189.  
  4190.  
  4191.  
  4192.  
  4193.  
  4194.  
  4195.  
  4196. //////////////////////////////////////////////////////////////
  4197. //////////////////////////////////////////////////////////////
  4198. //////////////////////////////////////////////////////////////
  4199. Rabin-Karp (by me)
  4200. //////////////////////////////////////////////////////////////
  4201. //////////////////////////////////////////////////////////////
  4202. //////////////////////////////////////////////////////////////
  4203.  
  4204.  
  4205. #define baza 73
  4206. #define mod1 100007
  4207. #define mod2 100021
  4208.  
  4209. vector<int> matches;
  4210. string sir, subsir;
  4211. int hashSir1=0,hashSir2=0,hashSubsir1=0,hashSubsir2=0,baza_n1=1,baza_n2=1;
  4212.  
  4213. getline(fin,subsir);
  4214. getline(fin,sir);
  4215.  
  4216. if (sir.size()<subsir.size()) {
  4217. fout<<0<<'\n';
  4218. return 0;
  4219. }
  4220.  
  4221. for(int i=0; i<subsir.length(); ++i) {
  4222. hashSubsir1 = (hashSubsir1 * baza + subsir[i]) % mod1;
  4223. hashSubsir2 = (hashSubsir2 * baza + subsir[i]) % mod2;
  4224. hashSir1 = (hashSir1 * baza + sir[i] ) % mod1;
  4225. hashSir2 = (hashSir2 * baza + sir[i] ) % mod2;
  4226. if(i>0) {
  4227. baza_n1 = (baza_n1 * baza) % mod1;
  4228. baza_n2 = (baza_n2 * baza) % mod2;
  4229. }
  4230. }
  4231.  
  4232. if(hashSir1 == hashSubsir1 && hashSir2 == hashSubsir2)
  4233. matches.push_back(0);
  4234.  
  4235. for(int i=subsir.length(); i<sir.length(); ++i) {
  4236. hashSir1 = ((hashSir1 - (sir[i - subsir.length()] * baza_n1) % mod1 + mod1) * baza + sir[i]) % mod1;
  4237. hashSir2 = ((hashSir2 - (sir[i - subsir.length()] * baza_n2) % mod2 + mod2) * baza + sir[i]) % mod2;
  4238. if(hashSir1 == hashSubsir1 && hashSir2 == hashSubsir2)
  4239. matches.push_back(i-subsir.length()+1);
  4240. }
  4241.  
  4242.  
  4243.  
  4244.  
  4245. //////////////////////////////////////////////////////////////
  4246. //////////////////////////////////////////////////////////////
  4247. //////////////////////////////////////////////////////////////
  4248. ciclu eulerian
  4249. //////////////////////////////////////////////////////////////
  4250. //////////////////////////////////////////////////////////////
  4251. //////////////////////////////////////////////////////////////
  4252.  
  4253.  
  4254.  
  4255. #include <fstream>
  4256. #include <list>
  4257. #include <stack>
  4258. #include <queue>
  4259.  
  4260. using namespace std;
  4261.  
  4262. #define TR( C, it ) \
  4263. for( typeof(C.begin()) it = C.begin(); it != C.end(); it++ )
  4264. #define pb push_back
  4265.  
  4266. #define NX 100010
  4267.  
  4268. list< int > G[ NX ], L;
  4269. stack< int > S;
  4270. queue< int > Q;
  4271.  
  4272. int N, M, deg[ NX ], col[ NX ];
  4273.  
  4274. void cit() {
  4275. int u, v;
  4276.  
  4277. scanf( "%d%d", &N, &M );
  4278.  
  4279. while( M-- ) {
  4280. scanf( "%d%d", &u, &v );
  4281. G[u].pb( v );
  4282. deg[u]++;
  4283. G[v].pb( u );
  4284. deg[v]++;
  4285. }
  4286. }
  4287.  
  4288. void BFS( int v ) {
  4289. Q.push( v );
  4290. col[v] = 1;
  4291. while( !Q.empty() ) {
  4292. v = Q.front();
  4293. Q.pop();
  4294. TR( G[v], w )
  4295. if( col[ *w ] == 0 )
  4296. Q.push( *w ), col[ *w ] = 1;
  4297. }
  4298. }
  4299.  
  4300. int este_conex() {
  4301. BFS( 1 );
  4302. for( int v = 2; v <= N; v++ )
  4303. if( col[ v ] == 0 )
  4304. return 0;
  4305. return 1;
  4306. }
  4307.  
  4308. int eulerian() {
  4309. if( este_conex() == 0 )
  4310. return 0;
  4311.  
  4312. for( int v = 1; v <= N; v++ )
  4313. if( deg[ v ] % 2 == 1 )
  4314. return 0;
  4315. return 1;
  4316. }
  4317.  
  4318. void sterge( int v, int w ) {
  4319. deg[v]--, deg[w]--;
  4320. G[v].pop_front();
  4321. TR( G[w], it )
  4322. if( *it == v ) {
  4323. G[w].erase( it );
  4324. break;
  4325. }
  4326. }
  4327.  
  4328. void euler( int v ) {
  4329. while( true ) {
  4330. if( G[v].empty() )
  4331. break;
  4332. int w = G[v].front();
  4333. S.push( v );
  4334. sterge( v, w );
  4335. v = w;
  4336. }
  4337. }
  4338.  
  4339. int rez() {
  4340. int v = eulerian();
  4341. if( v == 0 )
  4342. return -1;
  4343. do {
  4344. euler( v );
  4345. v = S.top();
  4346. S.pop();
  4347. L.pb( v );
  4348. } while( !S.empty() );
  4349.  
  4350. return 1;
  4351. }
  4352.  
  4353. void scr( int x ) {
  4354. if( x == -1 )
  4355. printf( "-1\n" );
  4356. else {
  4357. TR( L, v )
  4358. printf( "%d ", *v );
  4359. printf( "\n" );
  4360. }
  4361. }
  4362.  
  4363. int main() {
  4364. freopen( "ciclueuler.in", "r", stdin );
  4365. freopen( "ciclueuler.out", "w", stdout );
  4366.  
  4367. cit();
  4368. scr( rez() );
  4369.  
  4370. return 0;
  4371. }
  4372.  
  4373.  
  4374.  
  4375.  
  4376.  
  4377.  
  4378.  
  4379.  
  4380.  
  4381.  
  4382.  
  4383.  
  4384. //////////////////////////////////////////////////////////////
  4385. //////////////////////////////////////////////////////////////
  4386. //////////////////////////////////////////////////////////////
  4387. ciclu hamiltonian de cost minim (eu)
  4388. //////////////////////////////////////////////////////////////
  4389. //////////////////////////////////////////////////////////////
  4390. //////////////////////////////////////////////////////////////
  4391.  
  4392.  
  4393.  
  4394.  
  4395.  
  4396.  
  4397.  
  4398.  
  4399. #include<iostream>
  4400. #include<algorithm>
  4401. #include<cstdio>
  4402. #include<vector>
  4403. using namespace std;
  4404.  
  4405. int dp[(1<<19)+10][20],cost[20][20],n,m;
  4406. vector<int> G[20];
  4407.  
  4408. #define INF 0x3f3f3f3f
  4409.  
  4410. int main() {
  4411. freopen("hamilton.in","rt",stdin);
  4412. freopen("hamilton.out","wt",stdout);
  4413.  
  4414. cin>>n>>m;
  4415.  
  4416. for (int i=0; i<n; ++i)
  4417. for (int j=0; j<n; ++j)
  4418. cost[i][j] = INF;
  4419.  
  4420. for (int i=1; i<=m; ++i) {
  4421. int x, y;
  4422. cin>>x>>y;
  4423. G[y].push_back(x);
  4424. cin>>cost[x][y];
  4425. }
  4426.  
  4427. for (int i=0; i< 1<<n; ++i)
  4428. for (int j=0; j<n; ++j)
  4429. dp[i][j] = INF;
  4430. dp[1][0] = 0;
  4431.  
  4432. for(int i=0; i< 1<<n; ++i) {
  4433. for(int j=0; j<n; ++j) {
  4434. if(i&(1<<j)) {
  4435. for(int k=0; k<G[j].size(); ++k) {
  4436. if(i&(1<<G[j][k])) { //daca vecinul lui j este in configuratie (bitul de pe poz lui in configuratia i este 1)
  4437. //cerr<<G[j][k]<<' ';
  4438. dp[i][j]=min(dp[i][j],dp[i^(1<<j)][G[j][k]] + cost[G[j][k]][j]);//
  4439. }
  4440. }
  4441. }
  4442. }
  4443. }
  4444. int minim=INF;
  4445. for(int i=0; i<G[0].size(); ++i) {
  4446. minim=min(minim,dp[(1<<n)-1][G[0][i]]+cost[G[0][i]][0]);
  4447. }
  4448.  
  4449. if(minim==INF)
  4450. cout<<"Nu exista solutie"<<'\n';
  4451. else
  4452. cout<<minim<<'\n';
  4453.  
  4454.  
  4455.  
  4456. return 0;
  4457. }
  4458.  
  4459.  
  4460.  
  4461.  
  4462.  
  4463.  
  4464.  
  4465.  
  4466.  
  4467.  
  4468.  
  4469.  
  4470.  
  4471.  
  4472.  
  4473.  
  4474.  
  4475.  
  4476.  
  4477.  
  4478.  
  4479. //////////////////////////////////////////////////////////////
  4480. //////////////////////////////////////////////////////////////
  4481. //////////////////////////////////////////////////////////////
  4482. parantezare optima de matrici
  4483. //////////////////////////////////////////////////////////////
  4484. //////////////////////////////////////////////////////////////
  4485. //////////////////////////////////////////////////////////////
  4486. /*
  4487. Din fericire, principiul optimalităţii al metodei programării dinamice se poate aplica la această problemă. Dacă cel mai bun mod de a înmulţi toate matricele presupune o tăietură între a i-a şi a i + 1 a matrice a produsului, atunci subprodusele M1M2...Mi şi Mi+1Mi+2...Mn trebuie calculate la rândul lor într-un mod optim.
  4488.  
  4489. Vom construi tabloul m[1..n, 1..n], unde m[i, j] este numărul minim de înmulţiri scalare necesare pentru a calcula partea MiMi+1...Mj a produsului iniţial. Soluţia problemei iniţiale va fi m[1, n]. Presupunem că tabloul d[0..n] conţine dimensiunile matricilor, astfel încât matricea Mi este de dimensiuni (d[i-1], d[i]), 1 ≤ i ≤ n. Construcţia tabloului se face diagonală cu diagonală:
  4490.  
  4491. */
  4492.  
  4493.  
  4494. #include <iostream>
  4495. #include <fstream>
  4496. using namespace std;
  4497.  
  4498. const char iname[] = "podm.in";
  4499. const char oname[] = "podm.out";
  4500.  
  4501. #define MAXN 505
  4502. #define Min(a, b) ((a) < (b) ? (a) : (b))
  4503. #define FOR(i, a, b) for (int i = (a); i <= (b); ++ i)
  4504. #define INF 100000000000000000LL
  4505.  
  4506. typedef long long i64;
  4507.  
  4508. i64 bst[MAXN][MAXN], d[MAXN]; int n;
  4509.  
  4510. int main(void)
  4511. {
  4512. ifstream in(iname);
  4513. in >> n;
  4514. FOR (i, 0, n) in >> d[i];
  4515. in.close();
  4516.  
  4517. ofstream out(oname);
  4518. FOR (i, 1, n) bst[i][i] = 0;
  4519. FOR (i, 1, n - 1) bst[i][i + 1] = d[i - 1] * d[i] * d[i + 1];
  4520. FOR (w, 2, n - 1)
  4521. FOR (i, 1, n - w) {
  4522. int j = i + w;
  4523. bst[i][j] = INF;
  4524. FOR (k, i, j - 1)
  4525. bst[i][j] = Min(bst[i][j], bst[i][k] + bst[k + 1][j] + d[i - 1] * d[k] * d[j]);
  4526. }
  4527. out << bst[1][n];
  4528. out.close();
  4529. return 0;
  4530. }
  4531.  
  4532.  
  4533.  
  4534.  
  4535.  
  4536.  
  4537.  
  4538.  
  4539.  
  4540.  
  4541.  
  4542.  
  4543.  
  4544.  
  4545.  
  4546.  
  4547.  
  4548.  
  4549.  
  4550.  
  4551.  
  4552.  
  4553.  
  4554. //////////////////////////////////////////////////////////////
  4555. //////////////////////////////////////////////////////////////
  4556. //////////////////////////////////////////////////////////////
  4557. dinamica.doc
  4558. //////////////////////////////////////////////////////////////
  4559. //////////////////////////////////////////////////////////////
  4560. //////////////////////////////////////////////////////////////
  4561.  
  4562.  
  4563.  
  4564.  
  4565. Metoda programării dinamice
  4566. Prof. Emanuela Cerchez
  4567. Liceul de Informatica „Grigore Moisil” Iasi
  4568. Prezentare generală
  4569. Programarea dinamică este o metodă de elaborare a algoritmilor care se aplică în general problemelor pentru care se cere determinarea unui optim în urma adoptării unor decizii.
  4570. Nu există un criteriu pe baza căruia să identificăm cu siguranţă o problemă pentru rezolvarea căreia trebuie să utilizăm metoda programării dinamice, dar putem formula două proprietăţi care sugerează o soluţie prin programare dinamică.
  4571. Substructură optimală
  4572. Problema dată poate fi descompusă în subprobleme şi soluţia optimă a problemei depinde de soluţiile optime ale subproblemelor sale.
  4573. Acest criteriu nu indică neapărat o soluţie prin programare dinamică, ar putea fi şi un indiciu că se poate aplica metoda Greedy sau metoda „Divide et Impera”.
  4574. Subprobleme superpozabile
  4575. Subproblemele problemei date nu sunt independente, ci se suprapun.
  4576. Datorită faptului că subproblemele problemei date se suprapun, deducem că o abordare prin metoda „Divide et Impera” ar fi dezastruoasă din punctul de vedere al timpului de execuţie (datorită faptului că problemele se suprapun se ajunge la rezolvarea repetată a aceleiaşi subprobleme). Prin urmare, vom rezolva subproblemele o singură, dată, reţinând rezultatele într-o structură de date suplimentară (de obicei un tablou).
  4577. Rezolvarea unei probleme prin programare dinamică presupune următorii paşi:
  4578. Se identifică subproblemele problemei date.
  4579. Se alege o structură de date suplimentară, capabilă să reţină soluţiile subproblemelor.
  4580. Se caracterizează substructura optimală a problemei printr-o relaţie de recurenţă.
  4581. Pentru a determina soluţia optimă, se rezolvă relaţia de recurenţă în mod bottom-up (se rezolvă subproblemele în ordinea crescătoare a dimensiunii lor).
  4582. În cele ce urmează vom exemplifica pas cu pas modul de rezolvare a problemelor prin metoda programării dinamice.
  4583. 1. Înmulţirea optimală a matricelor
  4584. Fie n matrice A1, A2, ..., An, de dimensiuni d0xd1, d1xd2, ..., dn-1xdn. Produsul A1xA2x...xAn se poate calcula în diverse moduri, aplicând asociativitatea operaţiei de înmulţire a matricelor. Numim înmulţire elementară înmulţirea a două elemente. În funcţie de modul de parantezare diferă numărul de înmulţiri elementare necesare pentru calculul produsului A1xA2x...xAn. Determinaţi o parantezare optimală a produsului A1xA2x...xAn (costul parantezării, adică numărul total de înmulţiri elementare să fie minim).
  4585. Exemplu
  4586. Pentru n=3 matrice cu dimensiunile (10,1000), (1000,10) şi (10,100), produsul A1xA2xA3 se poate calcula în două moduri:
  4587. (A1xA2)xA3 necesitând 1000000+10000=1010000 înmulţiri elementare
  4588. A1x(A2xA3), necesitând 1000000+1000000=2000000 înmulţiri.
  4589. Reamintim că numărul de înmulţiri elementare necesare pentru a înmulţi o matrice A cu n linii şi m coloane şi B o matrice cu m linii şi p coloane este nmp (vezi problema 8 de la capitolul „Structuri elementare de date”).
  4590. Solutie
  4591. Pentru a calcula A1xA2x...xAn, în final trebuie să înmulţim două matrice, deci vom paranteza produsul astfel: (A1xA2x...xAk)x(Ak+1x...xAn ). Această observaţie se aplică şi produselor dintre paranteze. Prin urmare, subproblemele problemei iniţiale constau în determinarea parantezării optimale a produselor de matrice de forma AixAi+1x...xAj, 1ijn. Observăm că subproblemele nu sunt independente. De exemplu, calcularea produsului AixAi+1x...xAj şi calcularea produsului Ai+1xAi+2x...xAj+1, au ca subproblemă comună calcularea produsului Ai+1x...xAj.
  4592. Pentru a reţine soluţiile subproblemelor, vom utiliza o matrice M, cu n linii şi n coloane, cu semnificaţia:
  4593. M[i][j] = numărul minim de înmulţiri elementare necesare pentru a calcula
  4594. produsul AixAi+1x...xAj, 1ijn.
  4595. Evident, numărul minim de înmulţiri necesare pentru a calcula A1xA2x...xAn este M[1][n].
  4596. Pentru ca parantezarea să fie optimală, parantezarea produselor A1xA2x...xAk şi Ak+1x...xAn trebuie să fie de asemenea optimală. Prin urmare elementele matricei M trebuie să satisfacă următoarea relaţie de recurenţă:
  4597. M[i][i]=0, i{1,2,..., n}.
  4598. M[i][j]=min{M[i][k] + M[k+1][j] + d[i-1]*d[k]*d[j]}
  4599. ik<j
  4600. Cum interpretăm această relaţie de recurenţă? Pentru a determina numărul minim de înmulţiri elementare pentru calculul produsului AixAi+1x...xAj, fixăm poziţia de parantezare k în toate modurile posibile (între i şi j-1), şi alegem varianta care ne conduce la minim. Pentru o poziţie k fixată, costul parantezării este egal cu numărul de înmulţiri elementare necesare pentru calculul produsului AixAi+1x...xAk, la care se adaugă numărul de înmulţiri elementare necesare pentru calculul produsului Ak+1x...xAj şi costul înmulţirii celor două matrice rezultate (di-1dkdj).
  4601. Observăm că numai jumătatea de deasupra diagonalei principale din M este utilizată. Pentru a construi soluţia optimă este utilă şi reţinerea indicelui k, pentru care se obţine minimul. Nu vom considera un alt tablou, ci-l vom reţine, pe poziţia simetrică faţă de diagonala principală (M[j][i]).
  4602. Rezolvarea recursivă a relaţiei de recurenţă de mai sus este ineficientă, datorită faptului că subproblemele de suprapun, deci o abordare recursivă ar conduce la rezolvarea aceleiaşi subprobleme de mai multe ori. Prin urmare vom rezolva relaţia de recurenţă în mod bottom-up: (determinăm parantezarea optimală a produselor de două matrice, apoi de 3 matrice, 4 matrice, etc).
  4603. long M[NMax][NMax];
  4604. void dinamic()
  4605. { int nr, i, j, k, kmin;
  4606. long min, Infinit=1000000000;
  4607. for (nr=2; nr<=n; nr++) //nr=cate matrice se inmultesc
  4608. for (i=1; i<=n-nr+1; i++)
  4609. {j=i+nr-1;
  4610. //se inmultesc nr matrice, de la Ai la Aj
  4611. for (k=i, min=Infinit; k<j; k++)
  4612. //determin minimul si pozitia sa
  4613. if (min>M[i][k]+M[k+1][j]+d[i-1]*d[k]*d[j])
  4614. {min=M[i][k]+M[k+1][j]+d[i-1]*d[k]*d[j];
  4615. kmin=k;}
  4616. M[i][j]=min; M[j][i]=kmin; }
  4617. }
  4618. Reconstituirea soluţiei optime se face foarte uşor în mod recursiv, utilizând informaţiile reţinute sub diagonala principală în matricea M:
  4619. void afisare(int i, int j)
  4620. {//afiseaza parantezarea optimala a produsului Aix...xAj
  4621. if (i==M[j][i]) cout<<"A"<<i;
  4622. else {cout<<"("; afisare(i,M[j][i]); cout<<")";}
  4623. cout<<"x";
  4624. if (j==M[j][i]+1) cout<<"A"<<j;
  4625. else {cout<<"("; afisare(M[j][i]+1,j); cout<<")";}
  4626. }
  4627.  
  4628. 2. Subşir crescător maximal
  4629. Fie un şir A=(a1, a2, ..., an). Numim subşir al şirului A o succesiune de elemente din A, în ordinea în care acestea apar în A: ai1, ai2, ..., aik, unde 1i1<i2<...<ikn. Determinaţi un subşir crescător al şirului A, de lungime maximă.
  4630. Exemplu
  4631. Pentru A=(8,3,6,50,10,8,100,30,60,40,80) o soluţie poate fi:
  4632. ( 3,6, 10, 30,60, 80).
  4633. Soluţie
  4634. Fie Ai1=(ai1ai2 ...aik) cel mai lung subşir crescător al lui şirului A. Observăm că el coincide cu cel mai lung subşir crescător al şirului (ai1, ai1+1, ..., an). Evident Ai2=(ai2ai3 ...aik) este cel mai lung subşir crescător al lui (ai2, ai2+1, ..., an), etc. Prin urmare, o subproblemă a problemei iniţiale constă în determinarea celui mai lung subşir crescător care începe cu ai,i{1,.., n}. Subproblemele nu sunt independente: pentru a determina cel mai lung subşir crescător care incepe cu ai, este necesar să determinăm cele mai lungi subşiruri crescătoare care încep cu aj, aiaj, j{i+1,.., n}.
  4635. Pentru a reţine soluţiile subproblemelor vom considera doi vectori suplimentari l şi poz, fiecare cu câte n componente, având semnificaţia:
  4636. l[i]=lungimea celui mai lung subşir crescător care începe cu a[i];
  4637. poz[i]=poziţia elementului care urmează după a[i] în cel mai lung subşir crescător care începe cu a[i], dacă un astfel de element există, sau -1 dacă un astfel de element nu există.
  4638. Relaţia de recurenţă care caracterizează substructura optimală a problemei este:
  4639. l[n]=1; poz[n]=-1;
  4640. l[i]=max{1+l[j]|a[i]a[j]}
  4641. j=i+1,n
  4642. poz[i]= indicele j pentru care se obţine maximul l[i].
  4643. Rezolvăm relaţia de recurenţă în mod bottom-up:
  4644. int i, j;
  4645. l[n]=1; poz[n]=-1;
  4646. for (i=n-1; i>0; i--)
  4647. for (l[i]=1, poz[i]=-1, j=i+1; j<=n; j++)
  4648. if (a[i] <= a[j] && l[i]<1+l[j])
  4649. {l[i]=1+l[j]; poz[i]=j;}
  4650. Pentru a determina soluţia optimă a problemei, determinăm maximul din vectorul l, apoi afişăm soluţia, începând cu poziţia maximului şi utilizând informaţiile memorate în vectorul poz:
  4651. //determin maximul din vectorul l
  4652. int max=l[1], pozmax=1;
  4653. for (int i=2; i<=n; i++)
  4654. if (max<l[i]) {max=l[i]; pozmax=i;}
  4655. cout<<"Lungimea celui mai lung subsir crescator: " <<max;
  4656. cout<<"\nCel mai lung subsir:\n";
  4657. for (i=pozmax; i!=-1; i=poz[i])
  4658. cout<<a[i]<<' ';
  4659. 3. Sumă în triunghi
  4660. Sa considerăm un triunghi format din n linii (1<n100), fiecare linie conţinând numere întregi din domeniul [1,99], ca în exemplul următor:
  4661. 7
  4662. 3 8
  4663. 8 1 0
  4664. 2 7 4 4
  4665. 4 5 2 6 5
  4666. Problema constă în scrierea unui program care să determine cea mai mare sumă de numere aflate pe un drum între numărul de pe prima linie şi un număr de pe ultima linie. Fiecare număr din acest drum este situat sub precedentul, la stânga sau la dreapta acestuia. (IOI, Suedia 1994)
  4667. Soluţie
  4668. Vom reţine triunghiul într-o matrice pătratică T, de ordin n, sub diagonala principală. Subproblemele problemei date constau în determinarea sumei maxime care se poate obţine din numere aflate pe un drum între numărul T[i][j], până la un număr de pe ultima linie, fiecare număr din acest drum fiind situat sub precedentul, la stânga sau la dreapta sa. Evident, subproblemele nu sunt independente: pentru a calcula suma maximă a numerelor de pe un drum de la T[i][j] la ultima linie, trebuie să calculăm suma maximă a numerelor de pe un drum de la T[i+1][j] la ultima linie şi suma maximă a numerelor de pe un drum de la T[i+1][j+1] la ultima linie.
  4669. Pentru a reţine soluţiile subproblemelor, vom utiliza o matrice suplimentară S, pătratică de ordin n, cu semnificaţia
  4670. S[i][j]= suma maximă ce se poate obţine pe un drum de la T[i][j] la un element de pe ultima linie, respectand condiţiile problemei.
  4671. Evident, soluţia problemei va fi S[1][1].
  4672. Relaţia de recurenţă care caracterizează substructura optimală a problemei este:
  4673. S[n][i]=T[n][i], i{1,2,...,n}
  4674. S[i][j]=T[i][j]+max{S[i+1][j], S[i+1][j+1]}
  4675. Rezolvăm relaţia de recurenţă în mod bottom-up:
  4676. int i, j;
  4677. for (i=1; i<=n; i++) S[n][i]=T[n][i];
  4678. for (i=n-1; i>0; i--)
  4679. for (j=1; j<=i; j++)
  4680. {S[i][j]=T[i][j]+S[i+1][j];
  4681. if (S[i+1][j]<S[i+1][j+1])
  4682. S[i][j]=T[i][j]+S[i+1][j+1]);}
  4683. Exerciţiu
  4684. Afişaţi şi drumul în triunghi pentru care se obţine soluţia optimă.
  4685. 4. Subşir comun maximal
  4686. Fie X=(x1, x2, ..., xn) şi Y=(y1, y2, ..., ym) două şiruri de n, respectiv m numere întregi. Determinaţi un subşir comun de lungime maximă.
  4687. Exemplu
  4688. Pentru X=(2,5,5,6,2,8,4,0,1,3,5,8) şi Y=(6,2,5,6,5,5,4,3,5,8) o soluţie posibilă este: Z=(2,5,5,4,3,5,8)
  4689. Soluţie
  4690. Notăm cu Xk=(x1, x2, ..., xk) (prefixul lui X de lungime k) şi cu Yh=(y1, y2, ..., yh) prefixul lui Y de lungime h. O subproblemă a problemei date constă în determinarea celui mai lung subşir comun al lui Xk, Yh. Notăm cu LCS(Xk,Yh) lungimea celui mai lung subşir comun al lui Xk, Yh. Utilizând aceste notaţii, problema cere determinarea LCS(Xn,Ym), precum şi un astfel de subşir.
  4691. Observaţie
  4692. 1. Dacă Xk=Yh atunci LCS(Xk,Yh)=1+LCS(Xk-1,Yh-1).
  4693. 2. Dacă XkYh atunci LCS(Xk,Yh)=max(LCS(Xk-1,Yh), LCS(Xk,Yh-1)).
  4694. Din observaţia precedentă deducem că subproblemele problemei date nu sunt independente şi că problema are substructură optimală.
  4695. Pentru a reţine soluţiile subproblemelor vom utiliza o matrice cu n+1 linii şi m+1 coloane, denumită lcs. Linia şi coloana 0 sunt utilizate pentru iniţializare cu 0, iar elementul lcs[k][h] va fi lungimea celui mai lung subşir comun al şirurilor Xk şi Yh.
  4696. Vom caracteriza substructura optimală a problemei prin următoarea relaţie de recurenţă:
  4697. lcs[k][0]=lcs[0][h]=0, k{1,2,..,n}, h{1,2,..,m}
  4698. lcs[k][h]=1+lcs[k-1][h-1], dacă x[k]=y[h]
  4699. max{lcs[k][h-1], lcs[k-1][h]}, dacă x[k]y[h]
  4700. Rezolvăm relaţia de recurenţă în mod bottom-up:
  4701. for (int k=1; k<=n; k++)
  4702. for (int h=1; h<=m; h++)
  4703. if (x[k]==y[h])
  4704. lcs[k][h]=1+lcs[k-1][h-1];
  4705. else
  4706. if (lcs[k-1][h]>lcs[k][h-1])
  4707. lcs[k][h]=lcs[k-1][h];
  4708. else
  4709. lcs[k][h]=lcs[k][h-1];
  4710. Deoarece nu am utilizat o structură de date suplimentară cu ajutorul căreia să memorăm soluţia opţimă, vom reconstitui soluţia optimă pe baza rezultatelor memorate în matricea lcs. Prin reconstituire vom obţine soluţia în ordine inversă, din acest motiv vom memora soluţia într-un vector, pe care îl vom afişa de la sfârşit către început:
  4711. cout<<"Lungimea subsirului comun maximal: " <<lcs[n][m];
  4712. int d[100];
  4713. cout<<"\nCel mai lung subsir comun este: \n";
  4714. for (int i=0, k=n, h=m; lcs[k][h]; )
  4715. if (x[k]==y[h])
  4716. {d[i++]=x[k];k--; h--;}
  4717. else
  4718. if (lcs[k][h]==lcs[k-1][h])
  4719. k--;
  4720. else
  4721. h--;
  4722. for (k=i-1;k>=0; k--)cout<<d[k]<<' ';
  4723. 5. Stivă de jetoane
  4724. Un joc este constituit dintr-o stivă de n (n1000) jetoane, de două culori. Jetoanele sunt numerotate de la 1 la n, jetonul cu numărul 1 fiind cel de la vârful stivei. Cei doi jucători (să-i numim Ana şi Barbu) mută alternativ. La o mutare, un jucător poate lua din stivă oricâte jetoane (cel puţin unul), cu condiţia ca toate jetoanele luate să fie de aceeaşi culoare. Câştigă jucătorul care ia ultimul jeton. Să presupu nem că întotdeauna Ana face prima mutare.
  4725. Scrieţi un program care să determine dacă Ana are strategie sigură de câştig şi dacă da, să afişeze pe ecran mutările Anei (câte jetoane ia din stivă atunci când îi vine rândul). Programul va citi de la tastatură mutările lui Barbu.
  4726. Soluţie
  4727. Vom reţine culorile jetoanelor într-un vector c[]. Iniţializarea configuraţiei de joc constă din citirea numărului de jetoane şi generarea aleatoare a culorilor acestora, codificând prima culoare cu 0 şi cea de a doua culoare cu 1.
  4728. #define NMax 1002
  4729. int n, c[NMax];
  4730. void Init()
  4731. {cout<<"n="; cin>>n;
  4732. randomize();
  4733. for (int i=1; i<=n; i++) c[i]=random(2);
  4734. cout<<"Stiva de jetoane este ";
  4735. for (i=1; i<=n; i++) cout<<c[i];
  4736. cout<<endl; }
  4737. Subproblemele problemei date constau în determinarea existenţei unei strategii sigure de câştig pentru jucătorul care face prima mutare pentru o stivă constituită din jetoanele i..n.
  4738. Pentru a reţine soluţiile subproblemelor, vom utiliza un vector S[], având următoarea semnificaţie: S[i]=1, dacă jucătorul care extrage jetonul i are strategie sigură de câştig şi 0 altfel. Evident, dacă S[1]=1, deducem că Ana are strategie sigură de câştig.
  4739. Caracterizăm substructura optimale a soluţiei prin următoarea relaţie de recurenţă:
  4740. S[n]=1;
  4741. Dacă c[i]c[i+1], atunci S[i]=1-S[i+1].
  4742. Dacă c[i]=c[i+1], atunci S[i]=1 (în cazul în care S[i+1]=1, jucătorul va lua şi jetonul i pe lângă jetoanele care îî asigură câştigul pentru i+1..n; dacă S[i+1]=0, atunci jucătorul va lua numai jetonul i).
  4743. Rezolvăm această relaţie de recurenţă în mod bottom-up:
  4744. int S[NMax];
  4745. void Dinamic()
  4746. {S[n]=1;
  4747. for (int i=n-1; i>0; i--)
  4748. if (c[i+1]!=c[i]) S[i]=1-S[i+1];
  4749. else S[i]=1; }
  4750. În cazul în care Ana are strategie sigură de câştig, pentru a vizualiza şi mutările care conduc la câştigarea jocului, utilizăm informaţiile deja memorate în S[]:
  4751. if (!S[1])
  4752. {cout<<"Ana nu are strategie sigura de castig!";
  4753. return;}
  4754. cout<<"Ana are strategie sigura de castig! Sa jucam!\n";
  4755. for (int i=1; i<=n; )
  4756. {for (int k=i; k<=n && S[k]; k++);
  4757. //Ana ia jetoanele de la i la k
  4758. cout<<"Ana ia: "<<k-i<<" jetoane\n";
  4759. if (k>n)
  4760. {cout<<"Ana a castigat!\n"; return;}
  4761. //citim mutarea lui Barbu
  4762. cout<<"Stiva ";
  4763. for (int j=k; j<=n; j++) cout<<c[j];
  4764. cout<<"\nBarbu muta: "; cin>>nr;
  4765. //validez mutarea lui Barbu
  4766. for (j=k+1; j<k+nr; j++)
  4767. if (c[j]!=c[j-1])
  4768. {cout<<"Mutare gresita! Barbu pierde!\n";
  4769. return;}
  4770. i=k+nr; }
  4771. 7. Laser
  4772. Se consideră o placă dreptunghiulară cu dimensiunile mn. Această placă trebuie tăiată în mn bucăţi mai mici, fiecare bucată fiind un pătrat cu dimensiunile 11. Întrucât placa este neomogenă, pentru fiecare bucată se indică densitatea dxy, unde x, y sunt coordonatele colţului stânga-jos al pătratului respectiv.
  4773.  
  4774. Pentru operaţiile de tăiere se foloseşte un strung cu laser. Fiecare operaţie de tăiere include:
  4775. fixarea unei plăci pe masa de tăiere;
  4776. stabilirea puterii laserului în funcţie de densitatea materialului de tăiat;
  4777. o singură deplasare a laserului de-a lungul oricărei drepte paralele cu una din axele de coordonate;
  4778. scoaterea celor două plăci de pe masa de tăiere.
  4779. Costul unei operaţii de tăiere se determină după formula c=dmax, unde dmax este densitatea maximă a bucăţilor 11 peste marginile cărora trece raza laserului. Evident, costul total T poate fi determinat adunând costurile individuale c ale tuturor operaţiilor de tăiere necesare pentru obţinerea bucăţilor 11.
  4780. Scrieţi un program care calculează costul minim T.
  4781. (Olimpiada Republicană de Informatică, Republica Moldova, 2001)
  4782. Date de intrare
  4783. Fişierul text LASER.IN conţ=ine pe prima linie numerele m şi n separate prin spaţiu. Următoarele m linii conţin câte n numere dxy separate prin spaţiu.
  4784. Date de ieşire
  4785. Fişierul text LASER.OUT conţine pe o singură linie numărul natural T.
  4786. Exemplu
  4787. LASER.IN
  4788. LASER.OUT
  4789. 3 5
  4790. 1 1 1 1 5
  4791. 1 7 1 1 1
  4792. 1 1 1 6 1
  4793. 52
  4794.  
  4795. Restricţii
  4796. m,nN, 2m,n20
  4797. dxyN, 1dxy100
  4798. Soluţie
  4799. Subproblemele problemei date constau în tăierea unui dreptunghi din placa dată, care are colţul stânga-sus în poziţia (i, j), are lungimea l şi înălţimea h.
  4800. Pentru a reţine soluţiile subproblemelor trebuie să utilizăm un tablou cu 4 dimensiuni Cnxmxnxm, cu semnificaţia C[i,j,h,l]=costul total de tăiere a unui unui dreptunghi din placa dată, care are colţul stânga-sus în poziţia (i, j), are lungimea l şi înălţimea h. Evident, soluţia problemei date va fi C[1,1,n,m].
  4801. Deoarece nu avem spaţiu suficient, vom aloca parţial tabloul c în mod dinamic, şi îl vom iniţializa cu 0:
  4802. int i, j, k, l, h;
  4803. for (i=0; i<=n; i++)
  4804. for (j=0; j<=m; j++)
  4805. for (h=0; h<=n; h++)
  4806. {c[i][j][h]=new int[MaxD];
  4807. for (l=0; l<=m; l++) c[i][j][h][l]=0;}
  4808. Pentru a tăia un dreptunghi din placa dată, care are colţul stânga-sus în poziţia (i, j), are lungimea l şi înălţimea h trebuie să executăm o primă tăietură completă. Aceasta poate fi trasată fie orizontal (între liniile k-1 şi k, unde k variază de la i+1 până la i+h-1), fie vertical, între coloanele k-1 şi k, unde k variază de la j+1 la j+l-1). Vom alege succesiv poziţia de tăiere k în toate modurile posibile şi vom reţine varianta care asigură optimul.
  4809. j j+1  j+l-1
  4810. i
  4811. i+1
  4812. ...
  4813. k-1
  4814. k
  4815. ...
  4816. i+h-1
  4817.  
  4818. Tăietură orizontală
  4819. j j+1  k-1 k  j+l-1
  4820. i
  4821. i+1
  4822. ...
  4823. i+h-1
  4824.  
  4825. Tăietură verticală
  4826.  
  4827. Prin urmare putem caracteriza substructura optimală a problemei prin următoarea relaţie de recurenţă:
  4828. C[i][j][1][1]=0; i{1,2,..,n}, j{1,2,..,m}
  4829. C[i][j][h][l]=min
  4830. {min{c[i][j][k-i][l]+c[k][j][h-k+i][l]+dmaxL(k,j,l)}//orizontal
  4831. k=i+1,i+h-1
  4832. min{c[i][j][h][k-j]+c[i][k][h][l-k+j]+dmaxC(k,i,h)}} //vertical
  4833. k=j+1,j+l-1
  4834. În relaţiile de recurenţă precedente am utilizat valorile:
  4835. dmaxL(k,j,l), reprezentând densitatea maximă a bucăţilor 11 peste marginile cărora trece raza laserului, la o tăietură între liniile k-1 şi k, de lungime l, începând de la coloana j;
  4836. dmaxC(k,i,h), reprezentând densitatea maximă a bucăţilor 11 peste marginile cărora trece raza laserului, la o tăietură între coloanele k-1 şi k, de lungime h, începând cu linia i.
  4837. Calculul soluţiei optime în mod bottom-up:
  4838. for (h=1; h<=n; h++)
  4839. for (l=1; l<=m; l++)
  4840. for (i=1; i<=n-h+1; i++)
  4841. for (j=1; j<=m-l+1; j++)
  4842. if (l>1 || h>1)
  4843. {//determin c[i][j][h][l]
  4844. c[i][j][h][l]=infinit;
  4845. //taieturi orizontale
  4846. for (k=i+1; k<i+h; k++)
  4847. {a=c[i][j][k-i][l]+c[k][j][h-k+i][l]+dmaxL(k,j,l);
  4848. if (c[i][j][h][l]>a) c[i][j][h][l]=a;}
  4849. //taieturi verticale
  4850. for (k=j+1; k<j+l; k++)
  4851. {a=c[i][j][h][k-j]+c[i][k][h][l-k+j]+dmaxC(k,i,h);
  4852. if (c[i][j][h][l]>a) c[i][j][h][l]=a;}
  4853. }
  4854. Observaţie
  4855. O optimizare posibilă a algoritmului constă în evitarea apelurilor funcţiilor dmaxL() şi dmaxC(), prin precalcularea valorilor respective o singură dată şi memorarea lor în câte un tablou tridimensional. Implementaţi această optimizare!
  4856. 8. Problema patronului
  4857. Un patron de gogoşerie a cumpărat un calculator şi doreşte să înveţe să lucreze pe el. Pentru aceasta va umple un raft de cărţi din colecţia „Informatica în lecţii de 9 minute şi 60 secunde”. Raftul are lungimea L cm. Seria dispune de n titluri, numerotate 1, 2,..., n având respectiv grosimile de g1, g2,..., gn cm.
  4858. Scrieţi un program care să selecteze titlurile pe care le va cumpăra patronul, astfel încât raftul să fie umplut complet (suma grosimilor cărţilor cumpărate să fie egală cu lungimea raftului) şi numărul cărţilor achiziţionate să fie maxim. Progra mul va afişa numărul cărţilor selectate, precum şi grosimile acestora. Dacă nu există soluţie, va fi afişat mesajul IMPOSIBIL. (ONI Suceava 1996, XI)
  4859. Restricţii
  4860. nN, 1n60
  4861. LN,1L200
  4862. giN*, gi30000, i{1,2,...,n}
  4863. Timp maxim de execuţie: 1 secundă/test.
  4864. Exemplu
  4865. Soluţie
  4866. Problema constă în selectarea unor elemente a căror sumă să fie egală cu L. În cazul în care există mai multe soluţii, este preferată soluţia cu număr maxim de elemente. O subproblemă a acestei probleme constă în selectarea unor elemente a căror sumă să fie egală cu S, SL.
  4867. Pentru a reţine soluţiile subproblemelor vom utiliza un vector Nr, cu L+1 componente, având semnificaţia: Nr[S]=numărul maxim de titluri ce pot fi cumpărate pentru a umple un raft de lungime S (0SL) sau -1 (dacă nu putem umple un raft de lungime S). Pentru a reţine şi cărţile cumpărate, vom utiliza o matrice Uz cu L+1 linii şi n coloane, având semnificaţia L[S][i] este 1, dacă am utilizat titlul i pentru a umple optimal raftul de lungime S şi 0, în caz contrar.
  4868. #define NMax 61
  4869. #define LMax 201
  4870. int n, L; //numarul de titluri si lungimea raftului
  4871. int g[NMax]; //grosimile
  4872. int Nr[LMax]; //numarul maxim de carti selectate
  4873. int Uz[LMax][NMax]; //indicii titlurilor utilizate
  4874. Să considerăm că ultimul titlu selectat pentru a umple un raft de lungime S este i. Prin urmare, în rest sunt selectate (obligatoriu în mod optim) cărţi a căror grosime totală trebuie să fie egală cu S-g[i]. Evident, pentru a putea alege titlul i, condiţia este ca acest titlu să nu fie deja utilizat pentru a umplerea restului raftului (de lungime S-g[i]). Alegerea titlului i trebuie să fie făcută de asemenea în mod optim (să maximizeze numărul total de cărţi selectate):
  4875. Nr[0]=0;
  4876. Nr[S]=max{-1, max{1+Nr[S-g[i]]|S-g[i]0 şi Nr[S-g[i]]-1 şi
  4877. i=1,n Uz[S-g[i]][i]=0}
  4878.  
  4879. Rezolvarea relaţiei de recurenţă:
  4880. int S, k, i;
  4881. for (S=1; S<=L; S++)
  4882. for (Nr[S]=-1, i=1; i<=n; i++)
  4883. if (g[i]<=S && Nr[S-g[i]]!=-1 && !Uz[S-g[i]][i] )
  4884. if (Nr[S]<1+Nr[S-g[i]])
  4885. {Nr[S]=1+Nr[S-g[i]];
  4886. for (k=1;k<=n;k++) Uz[S][k]=Uz[S-g[i]][k];
  4887. Uz[S][i]=1;}
  4888. Pentru a afişa soluţia, utilizăm informaţiile memorate în tabloul Uz:
  4889. if (Nr[L]==-1) cout<<"IMPOSIBIL";
  4890. else
  4891. {cout<<"Numarul maxim de carti este: "<<Nr[L]<<endl;
  4892. for (int k=1; k<=n; k++)
  4893. if (Uz[L][k]) cout <<g[k]<<" ";}
  4894. 9. Telecomanda
  4895. Cu ocazia olimpiadei naţionale de informatică, televiziunea locală organizează un nou joc în direct. Organizatorii utilizează un calculator, care generează şi afişează pe un monitor două numere de maxim 100 de cifre fiecare (X şi Y).
  4896.  
  4897. Fiecare concurent dispune de o telecomandă pre vă zută cu un afişaj de o cifră şi cu anumite taste, ca în figura alăturată. Telecomanda are şi o memorie, în care sunt reţinute în ordine cifrele obţinute de concurenţi.
  4898. Cifrele primului număr (X) sunt afişate succesiv pe afişajul telecomenzii fiecărui concurent, în ordine de la stânga la dreap ta. Concurenţii trebuie să transforme primul număr, obţinând în memoria telecomenzii proprii pe cel de al doilea, utilizând tastele pe care le au la dispoziţie pe telecomandă. După efectuarea unei operaţii asupra cifrei curente (cea de pe afişaj), pe afişaj apare automat urmă toarea cifră din X (dacă mai există). Efectele apăsării tastelor sunt următoarele:
  4899. Taste acţionate
  4900. Efect
  4901. + urmat de o cifră
  4902. Se generează suma dintre cifra de pe afişaj şi cifra tastată (operaţie posibilă doar dacă suma este tot o cifră). Cifra sumă este reţinută în memorie.
  4903. – urmat de o cifră
  4904. Se generează diferenţa dintre cifra de pe afişaj şi cifra tastată (operaţie posibilă doar dacă se obţine tot o cifră). Cifra obţinută este reţinută în memorie.
  4905. * urmat de o cifră
  4906. Se reţine în memorie valoarea tastei care se acţionează după tasta *. Deoarece asupra cifrei curente din X nu se efectuează nici o operaţie, aceasta nu dispare de pe afişaj.
  4907. /
  4908. Se şterge cifra curentă din X
  4909. #
  4910. Se şterg din X cifra curentă şi toate cifrele care urmează, până la sfârşit.
  4911. =
  4912. Se copiază în memorie cifra curentă.
  4913.  
  4914. Acţiunea se încheie atunci când toate cifrele lui X au fost prelucrate. Am obţinut o soluţie când în memoria telecomenzii se află cifrele numărului Y. O soluţie este optimă dacă numărul de taste acţionate este minim. Câştigătorii jocului sunt acei concurenţi care descoperă o soluţie optimă.
  4915. Date fiind X şi Y, scrieţi un program care să determine o soluţie optimă de transformare a numărului X în numărul Y. (ONI, Bacău 2001, XI-XII)
  4916. Date de intrare
  4917. Fişier de intrare TELE.IN conţine două linii:
  4918. X
  4919. Y
  4920. Date de ieşire
  4921. Fişier de ieşire TELE.OUT conţine două linii:
  4922. min
  4923. t1t2...tmin
  4924. unde:
  4925. min este un număr natural nenul, reprezentând numărul minim de taste acţionate pentru transformarea lui X în Y.
  4926. t1t2...tmin este o succesiune de min caractere, care reprezintă tastele acţionate; între caractere nu se vor pune separa tori.
  4927. Exemplu
  4928. TELE.IN TELE.OUT
  4929. 372 4
  4930. 78 /=+6
  4931. Timp maxim de execuţie/test: 1 secundă
  4932. Soluţie
  4933. Să notăm cu m numărul de cifre din X şi cu n numărul de cifre din Y. De asemenea vom nota Xi sufixul care începe cu cifra i din X (secvenţa de cifre XiXi+1...Xm) şi cu Yj sufixul care începe cu cifra j din Y (secvenţa de cifre YjYj+1...Yn). Subproblemele problemei date constau în determinarea transformării de cost minim a lui Xi în Yj, i{1,2,...,m} şi j{1,2,...,n}.
  4934. Pentru a reţine soluţiile subproblemelor vom utiliza două matrice cm şi o, fiecare cu m linii şi n coloane, având următoarea semnificaţie:
  4935. cm[i][j] = numărul minim de acţionări de taste necesar pentru a transforma Xi în Yj.
  4936. o[i][j] = prima operaţie ce va fi executată pentru a transforma optimal Xi în Yj.
  4937. typedef char Operatie[3];
  4938. char x[DimMax], y[DimMax];
  4939. int cm[DimMax][DimMax];
  4940. Operatie o[DimMax][DimMax];
  4941. int n, m;
  4942. Evident, cm[1][1] reprezintă numărul minim de acţionări de taste necesar pentru a transforma numărul X în numărul Y.
  4943. Relaţia de recurenţă carecaracterizează substructura optimală a problemei este:
  4944. cm[i][j]=min
  4945. {1+cm[i+1][j], //operatia /
  4946. 2+cm[i][j+1], //operatia *Y[j]
  4947. 2+cm[i+1][j+1], //operatia - X[i]-Y[j], daca X[i]>Y[j]
  4948. 2+cm[i+1][j+1], //operatia + Y[j]-X[i], daca X[i]<Y[j]
  4949. 1+cm[i+1][j+1], //operatia =
  4950. 1+cm[m+1,j]} //operatia #
  4951. Secvenţa de iniţializare:
  4952. void Init()
  4953. { m=strlen(x); n=strlen(y);
  4954. for (int i=1; i<=m; i++)
  4955. {cm[i][n+1]=1; strcpy(o[i][n+1],"#"); }
  4956. for (i=1; i<=n; i++)
  4957. {cm[m+1][i]= 2*(n-i+1);
  4958. for (int j=i; j<=n; j++)
  4959. {o[m+1][j][0]='*';
  4960. o[m+1][j][1]=y[j];o[m+1][j][2]=NULL;}
  4961. }
  4962. }
  4963. Rezolvăm relaţia de recurenţă în mod bottom-up:
  4964.  
  4965. Operatie omin;
  4966. int min;
  4967. for (int j=n; j>0; j--)
  4968. for (int i=m; i>0; i--)
  4969. {min=1+cm[i+1][j]; strcpy(omin,"/");
  4970. if (min>2+cm[i][j+1])
  4971. {min=2+cm[i][j+1];
  4972. omin[0]='*'; omin[1]=y[j]; omin[2]=NULL;}
  4973. if (x[i]>y[j])
  4974. {if (min>2+cm[i+1][j+1])
  4975. {min=2+cm[i+1][j+1];
  4976. omin[0]='-'; omin[1]=x[i]-y[j]+'0';
  4977. omin[2]=NULL;}
  4978. }
  4979. else
  4980. if (x[i]<y[j])
  4981. {if (min>2+cm[i+1][j+1])
  4982. {min=2+cm[i+1][j+1];
  4983. omin[0]='+'; omin[1]=y[j]-x[i]+'0';
  4984. omin[2]=NULL;}
  4985. }
  4986. else
  4987. {if (min>1+cm[i+1][j+1])
  4988. {min=1+cm[i+1][j+1]; strcpy(omin,"=");}
  4989. }
  4990. if (min>1+cm[m+1][j])
  4991. {min=1+cm[m+1][j]; strcpy(omin,"#");}
  4992. cm[i][j]=min;
  4993. strcpy(o[i][j],omin);
  4994. }
  4995.  
  4996. O soluţie optimă se obţine utilizând matricea o, a operaţiilor efectuate la fiecare pas.
  4997. ofstream ui("tele.out");
  4998. ui<<cm[1][1]<<endl;
  4999. for (int i=1,j=1; i<=m+1 && j<=n+1 && !(i==m+1 && j==n+1);)
  5000. {ui<<o[i][j];
  5001. if (o[i][j][0]=='+'||o[i][j][0]=='-'||o[i][j][0]=='=')
  5002. {i++; j++; }
  5003. else
  5004. if (o[i][j][0] =='*') j++;
  5005. else
  5006. if (o[i][j][0] =='/') i++;
  5007. else i=m+1;
  5008. }
  5009. ui.close();
  5010. 10. Codificare optimală
  5011. Fie un text de lungime maximă 100, ce conţine doar litere. Textul poate fi codificat, înlocuind apariţiile consecutive ale subşirurilor sale cu subşirul urmat de numărul său de apariţii.
  5012. Exemplu
  5013. Textul T="aaacaaacbbdefdef" poate fi codificat: "a3c1a3c1b2def2" dar şi "aaac2b2def2". Evident, cel de al doilea mod de codificare este mai scurt, deci mai convenabil.
  5014. Scrieţi un program care să codifice optimal un text dat (codul rezultat să fie de lungime minimă).
  5015. Soluţie
  5016. Spaţiul subproblemelor problemei iniţiale este format din determinarea unei codificări optimale pentru caracterele din text de la i până la j (T[i..j]), 0ij<n, unde n este lungimea textului. Evident, subproblemele se suprapun. De exemplu, determinarea codificării optime pentru T[i..j], necesită determinarea unor codificări optime pentru T[i..k] şi pentru T[k+1..j], k{0,1,..., j-1}.
  5017. Pentru a memora soluţiile subproblemelor, vom utiliza o matrice l, pătratică de ordin n, având semnificaţia l[i][j] = lungimea codificarii optime pentru T[i..j]; 0ij<n. Observaţi că este utilizată numai jumătatea de deasupra diagonalei principale.
  5018. Problema are substructură optimală, caracterizată de următoarea relaţie de recurenţă:
  5019. Orice caracter x se codifică pe două poziţii (x1), deci:
  5020. l[i][i]=2, i{0,1,..., n-1}
  5021. l[i][j]=min {j-i+2, minI, minII}
  5022. unde:
  5023. j-i+2 provine din codificarea întregului şir, urmat de 1
  5024. minI=min{l[i][k]+l[k+1][j]}
  5025. k=i,j-1
  5026. Codificăm optimal T[i..j] concatenând codificările optimale ale şirurilor T[i..k] şi T[k+1..j] (poziţia k{i, i+1,...,j-1} se alege în mod optimal)
  5027. minII=min{strlen(s)+NrCifre(k)}, unde s subşir al lui T[i..j] astfel încât T[i..j]=ss..s (de k ori). Deci T[i..j] se codifică sk.
  5028. Deoarece jumătatea de sub diagonala principală din matricea l este neutilizată, pentru a putea reconstitui soluţia optimă, o vom utiliza astfel:
  5029. l[j][i]=0, dacă l[i][j]=j-i+2
  5030. l[j][i]=k, unde k este poziţia de splitare a textului pentru l[i][j]=minI
  5031. l[j][i]=-k, unde k este lungimea subşirului s care se repetă, pentru T[i][j]=minII.
  5032. Rezolvarea relaţiei de recurenţă:
  5033. for (int i=0; i<n; i++) l[i][i]=2;
  5034. for (int d=2; d<=n; d++) //codific subsiruri de lungime d
  5035. for (i=0; i<=n-d; i++) //care incep la pozitia i
  5036. {int j=i+d-1; //si se termina la pozitia j
  5037. //cazul I- codificarea este intregul sir urmat de 1
  5038. l[i][j]=d+1; l[j][i]=0;
  5039. //cazul II
  5040. for (int k=i; k<j; k++)
  5041. if (l[i][j]>l[i][k]+l[k+1][j])
  5042. {l[i][j]=l[i][k]+l[k+1][j];
  5043. l[j][i]=k;}// pozitia optima de splitare
  5044. //cazul III
  5045. for (k=1; k<=d/2; k++)
  5046. if (d%k==0) //determin un subsir de lungime k
  5047. if (SeRepeta(i,j,k))
  5048. {l[i][j]=k+NrCifre(d/k);
  5049. l[j][i]=-k; //retin lungimea subsirului
  5050. break;}
  5051. }
  5052. Observaţi că am utilizat funcţia NrCifre() care determină numărul de cifre dintr-un număr natural, precum şi funcţia SeRepeta():
  5053. int SeRepeta (int i, int j, int k)
  5054. {/*verifica daca sirul T[i..j] este format prin concatenarea succesiva a lui T[i..i+k-1] */
  5055. char s[DimMax], s1[DimMax];
  5056. strncpy(s,T+i,k); s[k]=NULL; s1[k]=NULL;
  5057. for (int h=i+k; h<=j; h+=k)
  5058. {strncpy(s1,T+h, k);
  5059. if (strcmp(s,s1)) return 0;}
  5060. return 1;}
  5061. Afişarea soluţiei optime o vom realiza prin apelarea funcţiei recursive Afisare(0,n-1):
  5062. ofstream ui("cod.out");
  5063. void Afisare(int i, int j)
  5064. {
  5065. if (i==j) cout<<T[i]<<1; //un singur caracter
  5066. else
  5067. {int k=l[j][i];
  5068. char s[DimMax];
  5069. if (!k) // cazul I
  5070. {strncpy(s,T+i,j-i+1); s[j-i+1]=NULL;
  5071. cout<<s<<1; }
  5072. else
  5073. if (k>0) //cazul II
  5074. {Afisare (i, k);
  5075. Afisare (k+1,j);}
  5076. else //cazul III
  5077. {strncpy(s,T+i,-k); s[-k]=NULL;
  5078. cout<<s<<(j-i+1)/(-k);}
  5079. }
  5080. }
  5081. 12. Florărie
  5082. Presupunem că aveţi o florărie şi că doriţi să aranjaţi vitrina într-un mod cât mai plăcut. Aveţi F buchete de flori de feluri diferite şi cel puţin tot atâtea vase, aranjate pe un raft. Vazele sunt lipite de raft, şi sunt numerotate în ordine, de la stânga la dreapta, de la 1 la V, unde V este numărul de vaze. Mai exact vaza 1 este cea mai din stânga, iar vaza V cea mai din dreapta. Buchetele sunt şi ele numerotate distinct, cu numere între 1 şi F. Aceste numere de identificare a buchetelor au o semnificaţie: ele determină ordinea de apariţie cerută pentru buchete în vaze. Mai exact, buchetul i trebuie să fie într-o vază din stânga vazei care conţine buchetul j, dacă i<j.
  5083. Să presupunem, de exemplu, că aveţi un buchet de azalee (cu numărul de identificare 1) un buchet de begonii (cu numărul de identificare 2) şi un buchet de trandafiri (cu numărul de identificare 3). Acum, toate buchetele trebuie puse în vaze, astfel încât ordinea numerelor lor de identificare să se păstreze. Buchetul de azalee trebuie să fie într-o vază din stânga begoniilor, care trebuie să fie într-o vază din stânga trandafirilor. Dacă există mai multe vaze decât buchete, cele în plus vor rămâne goale. O vază poate conţine un singur buchet de flori.
  5084. Fiecare vază are o caracteristică proprie (asemănător florilor). Prin urmare, aşezănd un buchet de flori într-o anumită vază, obţineţi un anumit efect estetic, exprimat printr-o valoare întreagă. Valorile estetice sunt reprezentate sub forma unui tablou, ca în exemplul de mai jos. Dacă o vază rămâne goală, valoarea estetică este 0.
  5085. V A Z E
  5086. 1
  5087. 2
  5088. 3
  5089. 4
  5090. 5
  5091. Buchete
  5092. 1 (azalee)
  5093. 7
  5094. 23
  5095. -5
  5096. -24
  5097. 16
  5098. 2 (begonii)
  5099. 5
  5100. 21
  5101. -4
  5102. 10
  5103. 23
  5104. 3 (trandafiri)
  5105. -21
  5106. 5
  5107. -4
  5108. -20
  5109. 20
  5110.  
  5111. Conform acestui tabel, azaleele, de exemplu, vor arăta grozav în vaza 2 şi groaznic în vaza 4.
  5112. Pentru a obţine cel mai plăcut efect, trebuie să maximizaţi suma valorilor estetice ale vazelor, păstrând ordinea buchetelor. Dacă există mai multe soluţii, se cere numai una. (IOI Turcia 1999)
  5113. Restricţii
  5114. 1≤F≤100 unde F este numărul de buchete de flori.
  5115. F≤V≤100 unde V este numărul de vaze.
  5116. -50Aij50 unde Aij este valoarea estetică care se obţine punând buchetul i în vaza j.
  5117. Timp maxim de execuţie 2 secunde / test.
  5118. Date de intrare
  5119. Fişierul de intrare se numeşte flower.in. Prima linie conţine două numere: F V. Fiecare din următoarele F linii conţine câte V numere întregi, astfel încât Aij este al j-lea număr de pe linia (i+1) din fişierul de intrare.
  5120. Date de ieşire
  5121. Fişierul de ieşire flower.out conţine două linii. Prima linie conţine suma valorilor estetice a aranjamentului floral. A doua linie reprezintă aranjamentul floral, ca o listă de F numere, astfel încât cel de al k-lea număr de pe linie identifică vaza în care este pus buchetul k.
  5122. Exemplu
  5123. flower.in
  5124. flower.out
  5125. 3 5
  5126. 7 23 –5 –24 16
  5127. 5 21 -4 10 23
  5128. -21 5 -4 -20 20
  5129. 53
  5130. 2 4 5
  5131.  
  5132. Soluţie
  5133. Subproblemele problemei date constau în amplasarea optimă (cu maximizarea sumei valorilor estetice) a buchetelor 1..i în vazele 1..j, respectând ordinea buchetelor (i{1,2,...,F}, j{i,...,V-F+i}).
  5134. Pentru a reţine soluţiile subproblemelor vom utiliza o matrice c cu F linii şi V coloane (c[i][j]=valoarea estetică optimă care se poate obţine amplasând buchetele 1..i în vazele 1..j, respectând ordinea buchetelor. Evident, valoarea estetică optimă se obţine în c[F][V]. Pentru reconstituirea soluţiei optime, vom utiliza o matrice poz cu F linii şi V coloane (poz[i][j]= vaza în care plasăm buchetul i, într-o amplasare estetică optimă a buchetelor 1..i în vazele 1..j).
  5135. Pentru a amplasa optim buchetele 1..i în vazele 1..j, respectând ordinea buchetelor (i{1,2,...,F}, j{i,...,V-F+i}) avem două posibilităţi (dintre care o alegem pe cea mai convenabilă): fie amplasăm buchetul i în vaza j şi amplasăm optimal buchetele 1..i-1 în vazele 1..j-1, fie amplasăm buchetele 1..i în vazele 1..j-1. Prin urmare, caracterizăm substructura optimală a problemei prin următoarea relaţie de recurenţă:
  5136. c[i][i-1]=-;, i{1,2,...,F}
  5137. c[0][j]=0; j{0,...,V}
  5138. c[i][j]=max{A[i][j]+c[i-1][j-1], c[i][j-1]}, i{1,2,...,F}, j{i,...,V-F+i}
  5139. Pentru implementare observăm putem iniţializa c[i][j] cu valoarea Aij, astfel încât să nu mai fie necesar să utilizăm o matrice suplimentară A. Rezolvăm relaţia de recurenţă în mod bottom-up astfel:
  5140. int i, j;
  5141. for (i=1; i <= F; i++) c[i][i-1]=MINF;
  5142. for (i=1; i <= F; i++)
  5143. for (j=i; j <= (V - F + i); j++)
  5144. if (c[i-1][j-1]+c[i][j]>c[i][j-1])
  5145. {c[i][j] += c[i-1][j-1];
  5146. poz[i][j]=j;}
  5147. else
  5148. {c[i][j]=c[i][j-1];
  5149. poz[i][j]=poz[i][j-1];}
  5150. Afişarea soluţiei o vom face utilizând valorile memorate în matricea poz:
  5151. ofstream ui("flower.out");
  5152. ui<<c[F][V]<<endl;
  5153. int sol[MaxNr];
  5154. for (int i=F, j=V; i>0; j--)
  5155. if (poz[i][j]==j)
  5156. {sol[i]=j; i--;}
  5157. for (i=1; i<=F; i++) ui<<sol[i]<<' ';
  5158. ui.close();
  5159. 13. Vin bun
  5160. La un depozit specializat din Recaş sosesc, pe rând, n clienţi care solicită fiecare o cantitate dată de Cabernet. În butoiul din magazinul de deservire (considerat de capacitate nelimitată) nu se găseşte iniţial nici o picătură de vin. Dan Şeptică, administratorul depozitului, are un algoritm propriu de deservire a clienţilor: în funcţie de ceea ce are în butoi, dar şi de inspiraţia de moment, el poate să răspundă: „Vă ofer întreaga cantitate cu cea mai mare plăcere!” sau „Nu vă pot oferi acum ceea ce doriţi, reveniţi cu solicitarea altădată!”.
  5161. Pe clientul servit îl eliberează de grija banilor corespunzători costului licorii cumpărate, iar pe cel refuzat îl salută politicos şi are grijă ca , imediat ce a plecat clientul, să coboare şi să aducă în butoiul din magazin exact cantitatea solicitată de clientul respectiv (cel ce nu a fost servit) .
  5162. Clienţii sunt restaurante de lux şi nu cumpăra mai mult de 1 hectolitru.
  5163. Cunoscând cele n cantităţi cerute de clienţi, să se determine un mod de a răspunde solicitărilor astfel încât, în final, cantitatea de vin vânduta să fie maximă.
  5164. Date de intrare
  5165. Din fişierul de intrare CERERI.IN se citesc:
  5166. n – numărul de clienţi (n600);
  5167. c1 c2 ... cn – cantităţile (în litri) cerute de clienţi, în ordinea sosirii lor.
  5168. Date de ieşire
  5169. În fişierul VANZARI.OUT se va scrie cantitatea vândută (tot în litri).
  5170. Exemplu
  5171. CERERI.IN
  5172. VANZARI.OUT
  5173. 4
  5174. 5 3 4 2
  5175. 6
  5176.  
  5177. Interpretare
  5178. Acţiunile lui Septică sunt: refuză primul client şi pune 5 litri în butoi, îl refuză pe al doilea şi mai pune încă 3 litri în butoi, iar pe următorii doi clienţi îi serveşte , realizând o vânzare de 6 litri. (ONI Timişoara 1997, X)
  5179. Soluţie
  5180. Subproblemele problemei date constau în determinarea cantităţii maxime de vin ce poate fi vândută luând în considerare cererile clienţilor i..n, în ipoteza că iniţial avem în butoi o cantitate j. Soluţiile acestor subprobleme le vom reţine într-o matrice v.
  5181. Relaţia de recurenţă o obţinem astfel:
  5182. v[i][0]=0, i{1,2,...,n}
  5183. v[i][j]= max{v[i+1][j+c[i]] (cazul în care clientul i este refuzat)
  5184. c[i]+v[i+1][j-c[i]], dacă j≥c[i]
  5185. (cazul în care clientul i este servit)}
  5186. Soluţia problemei iniţiale o vom obţine în v[1][0].
  5187. O problemă de implementare o constituie dimensiunile matricei v: i variază de la 1 la n, deci numărul de linii este maxim 600). Numărul de coloane este determinat de cantitatea maximă care se poate acumula în butoi (în cazul cel mai defavorabil cei 600 de clienţi comandă fiecare câte 100 de litri), deci numărul maxim de coloane ar fi 60000. Nu putem aloca în memorie o matrice de 600x60000, dar observăm că pentru determinarea liniei i din matricea v este necesară numai linia i+1. Prin urmare este suficient să utilizăm doi vectori de 60000 de componente – v1 pentru a reţine linia precedentă (linia i+1) şi v2 pentru a calcula linia curentă (linia i). Aceşti doi vectori vor fi alocaţi dinamic, numărul de elemente alocate fiind max (suma tuturor cantităţilor cerute de clienţi):
  5188. unsigned *v1,*v2;
  5189. v1=new unsigned[max];
  5190. v2=new unsigned[max];
  5191. if(!v1 || !v2)
  5192. { cout<<"Nu s-a putut aloca memorie.";
  5193. exit(0); }
  5194. for(i=0; i<max; i++) v1[i]=0;
  5195. Rezolvarea relaţiei de recurenţă:
  5196. unsigned i, j, *aux;
  5197. for(i=n; i>=1; i--)
  5198. { for(j=0;j<c[i]; j++) v2[j]=v1[j+c[i]];
  5199. for (; j<max-c[i]; j++)
  5200. { v2[j]=v1[j+c[i]];
  5201. if (v2[j]<c[i]+v1[j-c[i]])
  5202. { v2[j]=c[i]+v1[j-c[i]]; } }
  5203. aux=v1; v1=v2; v2=aux;
  5204. }
  5205.  
  5206.  
  5207.  
  5208.  
  5209.  
  5210.  
  5211.  
  5212.  
  5213.  
  5214.  
  5215.  
  5216.  
  5217. //////////////////////////////////////////////////////////////
  5218. //////////////////////////////////////////////////////////////
  5219. //////////////////////////////////////////////////////////////
  5220. Componente tare conexe (SCC)
  5221. //////////////////////////////////////////////////////////////
  5222. //////////////////////////////////////////////////////////////
  5223. //////////////////////////////////////////////////////////////
  5224.  
  5225.  
  5226.  
  5227. #define foreach(V) for(vector<int>::iterator it=V.begin(),stop=V.end();it!=stop;++it)
  5228.  
  5229. int n;
  5230. int m;
  5231. vector<int> G[100000+10];
  5232. vector<int> sol[100000+10];
  5233.  
  5234. bool in_stack[100000+10];
  5235. stack<int> st;
  5236.  
  5237. bool viz[100000+10];
  5238.  
  5239. int min_lev[100000+10];
  5240.  
  5241. int nr=0;
  5242.  
  5243. void dfs_tarjan(int nod)
  5244. {
  5245. st.push(nod);
  5246. in_stack[nod]=true;
  5247. viz[nod]=true;
  5248.  
  5249. min_lev[nod]=idx;
  5250. int initial_min_lev=idx;
  5251. idx++;
  5252.  
  5253. foreach(G[nod]) {
  5254. if(!viz[*it]) {
  5255. dfs_tarjan(*it);
  5256. min_lev[nod]=min(min_lev[nod],min_lev[*it]);
  5257. } else if(in_stack[*it])
  5258. min_lev[nod]=min(min_lev[nod],min_lev[*it]);
  5259. }
  5260. if(min_lev[nod]==initial_min_lev) {
  5261. int x;
  5262. do {
  5263. x=st.top();
  5264. st.pop();
  5265. sol[nr].push_back(x);
  5266. in_stack[x]=false;
  5267. } while(x!=nod);
  5268. nr++;
  5269. }
  5270. }
  5271. //bool cmp(vector<int> a, vector<int> b)
  5272. //{
  5273. // return a[0]<b[0];
  5274. //}
  5275. int main()
  5276. {
  5277. fin>>n>>m;
  5278.  
  5279. for(; m; --m) {
  5280. int x,y;
  5281. fin>>x>>y;
  5282. G[x].push_back(y);
  5283. }
  5284.  
  5285. idx=0;
  5286.  
  5287. for(int i=1; i<=n; ++i)
  5288. if(!viz[i])
  5289. dfs_tarjan(i);
  5290.  
  5291. fout<<nr<<'\n';
  5292. // for(int i=0;i<nr;++i,cerr<<'\n')
  5293. // {
  5294. //// cerr<<sol[nr].size()<<' ';
  5295. // foreach(sol[i])
  5296. // cerr<<*it<<' ';
  5297. // }
  5298. // for(int i=0;i<nr;++i) {
  5299. // sort(sol[i].begin(),sol[i].end()); //sortare degeaba
  5300. // }
  5301. // sort(sol,sol+nr,cmp);//sortare degeaba
  5302. for(int i=0;i<nr;++i,fout<<'\n')
  5303. {
  5304. // fout<<sol[i].size()<<' ';
  5305. foreach(sol[i])
  5306. fout<<*it<<' ';
  5307. }
  5308.  
  5309. fout.close();
  5310. return 0;
  5311. }
  5312.  
  5313. //////////////////////////////////////////////////////////////
  5314. //////////////////////////////////////////////////////////////
  5315. //////////////////////////////////////////////////////////////
  5316. Componente biconexe
  5317. //////////////////////////////////////////////////////////////
  5318. //////////////////////////////////////////////////////////////
  5319. //////////////////////////////////////////////////////////////
  5320.  
  5321.  
  5322.  
  5323. #define foreach(V) for(vector<int>::iterator it=V.begin(),stop=V.end();it!=stop;++it)
  5324. #define foreach_set(V) for(set<int>::iterator it=V.begin(),stop=V.end();it!=stop;++it)
  5325.  
  5326. int n;
  5327. int m;
  5328. vector<int> G[100000+10];
  5329. set<int> sol[100000+10];
  5330.  
  5331. bool viz[100000+10];
  5332.  
  5333. int min_lev[100000+10];
  5334. int init_lev[100000+10];
  5335. int idx=0,nr=0;
  5336. stack<pair<int,int> > st;
  5337. inline void addsol(int x, int y)
  5338. {
  5339. int tmpx=0,tmpy=0;
  5340. while(tmpx!=x || tmpy!=y)
  5341. {
  5342. tmpx=st.top().first;
  5343. tmpy=st.top().second;
  5344. st.pop();
  5345. sol[nr].insert(tmpx);
  5346. sol[nr].insert(tmpy);
  5347. }
  5348. ++nr;
  5349. }
  5350. void df(int nod)
  5351. {
  5352. viz[nod]=true;
  5353. min_lev[nod]=idx;
  5354. init_lev[nod]=idx++;
  5355.  
  5356. foreach(G[nod]) {
  5357. if(!viz[*it]) {
  5358. st.push(make_pair(nod,*it));
  5359. df(*it);
  5360. if(min_lev[*it]>=init_lev[nod]) { //nodul fiu e critic
  5361. addsol(nod,*it);
  5362. }
  5363. min_lev[nod]=min(min_lev[nod],min_lev[*it]);
  5364. } else
  5365. min_lev[nod]=min(min_lev[nod],init_lev[*it]);
  5366. }
  5367. }
  5368. int main()
  5369. {
  5370. for(int i=0; i<m; ++i) {
  5371. int x,y;
  5372. fin>>x>>y;
  5373. G[x].push_back(y);
  5374. G[y].push_back(x);
  5375. }
  5376.  
  5377. for(int i=1; i<=n; ++i)
  5378. if(!viz[i])
  5379. df(i);
  5380. fout<<nr<<'\n';
  5381. for(int i=0;i<nr;++i,fout<<'\n')
  5382. foreach_set(sol[i])
  5383. fout<<*it<<' ';
  5384. }
  5385.  
  5386.  
  5387. //////////////////////////////////////////////////////////////
  5388. //////////////////////////////////////////////////////////////
  5389. //////////////////////////////////////////////////////////////
  5390. Flux maxim
  5391. //////////////////////////////////////////////////////////////
  5392. //////////////////////////////////////////////////////////////
  5393. //////////////////////////////////////////////////////////////
  5394.  
  5395.  
  5396.  
  5397. #include <stdio.h>
  5398. #include <vector>
  5399.  
  5400. using namespace std;
  5401.  
  5402. #define NMAX 1024
  5403. #define pb push_back
  5404. #define sz size()
  5405. #define mp make_pair
  5406. #define INF 0x3f3f3f3f
  5407.  
  5408. int C[NMAX][NMAX];
  5409. int F[NMAX][NMAX];
  5410. int TT[NMAX];
  5411. vector<int> G[NMAX];
  5412. int N, M;
  5413. int cd[NMAX];
  5414. int viz[NMAX];
  5415.  
  5416. int BF()
  5417. {
  5418. int i, j, nod, V;
  5419.  
  5420. cd[0] = 1;
  5421. cd[1] = 1;
  5422. memset(viz, 0, sizeof(viz));
  5423. viz[1] = 1;
  5424.  
  5425. for (i = 1; i <= cd[0]; i++)
  5426. {
  5427. nod = cd[i];
  5428. if (nod == N) continue;
  5429. for (j = 0; j < G[nod].sz; j++)
  5430. {
  5431. V = G[nod][j];
  5432. if (C[nod][V] == F[nod][V] || viz[V]) continue;
  5433. viz[V] = 1;
  5434. cd[ ++cd[0] ] = V;
  5435. TT[V] = nod;
  5436. }
  5437. }
  5438.  
  5439. return viz[N];
  5440. }
  5441.  
  5442. int main()
  5443. {
  5444. freopen("maxflow.in", "r", stdin);
  5445. freopen("maxflow.out", "w", stdout);
  5446.  
  5447. int i, flow, fmin, x, y, z, nod;
  5448.  
  5449. scanf("%d %d ", &N, &M);
  5450.  
  5451. for (i = 1; i <= M; i++)
  5452. {
  5453. scanf("%d %d %d ", &x, &y, &z);
  5454. C[x][y] += z;
  5455. G[x].pb(y);
  5456. G[y].pb(x);
  5457. }
  5458.  
  5459. for (flow = 0; BF();)
  5460. for (i = 0; i < G[N].sz; i++)
  5461. {
  5462. nod = G[N][i];
  5463. if (F[nod][N] == C[nod][N] || !viz[nod]) continue;
  5464. TT[N] = nod;
  5465.  
  5466. fmin = INF;
  5467. for (nod = N; nod != 1; nod = TT[nod])
  5468. fmin = min(fmin, C[ TT[nod] ][nod] - F[ TT[nod] ][nod]);
  5469. if (fmin == 0) continue;
  5470.  
  5471. for (nod = N; nod != 1; nod = TT[nod])
  5472. {
  5473. F[ TT[nod] ][nod] += fmin;
  5474. F[nod][ TT[nod] ] -= fmin;
  5475. }
  5476.  
  5477. flow += fmin;
  5478. }
  5479.  
  5480. printf("%d ", flow);
  5481. return 0;
  5482. }
  5483.  
  5484.  
  5485.  
  5486.  
  5487.  
  5488.  
  5489.  
  5490. //////////////////////////////////////////////////////////////
  5491. //////////////////////////////////////////////////////////////
  5492. //////////////////////////////////////////////////////////////
  5493. Cuplaj maxim in graf bipartit
  5494. //////////////////////////////////////////////////////////////
  5495. //////////////////////////////////////////////////////////////
  5496. //////////////////////////////////////////////////////////////
  5497.  
  5498.  
  5499. #include <cstdio>
  5500. #include <vector>
  5501. #include <algorithm>
  5502. using namespace std;
  5503.  
  5504. const char iname[] = "cuplaj.in";
  5505. const char oname[] = "cuplaj.out";
  5506.  
  5507. #define MAXN 10005
  5508. #define FOR(i, a, b) for (int i = (int)(a); i <= (int)(b); ++ i)
  5509. #define FORI(i, V) for (vector <int>::iterator i = (V).begin(); i != (V).end(); ++ i)
  5510.  
  5511. vector <int> G[MAXN];
  5512.  
  5513. int l[MAXN], r[MAXN], u[MAXN];
  5514.  
  5515.  
  5516. int pairup(const int n)
  5517. {
  5518. if (u[n]) return 0;
  5519. u[n] = 1;
  5520. FORI (i, G[n]) if (!r[*i]) {
  5521. l[n] = *i;
  5522. r[*i] = n;
  5523. return 1;
  5524. }
  5525. FORI (i, G[n]) if (pairup(r[*i])) {
  5526. l[n] = *i;
  5527. r[*i] = n;
  5528. return 1;
  5529. }
  5530. return 0;
  5531. }
  5532.  
  5533. int main(void)
  5534. {
  5535. freopen(iname, "r", stdin);
  5536. freopen(oname, "w", stdout);
  5537.  
  5538. int n, m, cnt_edges;
  5539. scanf("%d %d %d", &n, &m, &cnt_edges);
  5540.  
  5541. for (; cnt_edges --; )
  5542. {
  5543. int x, y;
  5544. scanf("%d %d", &x, &y);
  5545. G[x].push_back(y);
  5546. }
  5547. for (int change = 1; change; )
  5548. {
  5549. change = 0;
  5550. memset(u, 0, sizeof(u));
  5551. FOR (i, 1, n) if (!l[i])
  5552. change |= pairup(i);
  5553. }
  5554. int cuplaj = 0;
  5555. FOR (i, 1, n) cuplaj += (l[i] > 0);
  5556. printf("%d\n", cuplaj);
  5557. FOR (i, 1, n) if (l[i] > 0)
  5558. printf("%d %d\n", i, l[i]);
  5559.  
  5560. return 0;
  5561. }
  5562.  
  5563.  
  5564.  
  5565.  
  5566.  
  5567. //////////////////////////////////////////////////////////////
  5568. //////////////////////////////////////////////////////////////
  5569. //////////////////////////////////////////////////////////////
  5570. Flux maxim de cost minim
  5571. //////////////////////////////////////////////////////////////
  5572. //////////////////////////////////////////////////////////////
  5573. //////////////////////////////////////////////////////////////
  5574.  
  5575.  
  5576.  
  5577.  
  5578.  
  5579. #include <stdio.h>
  5580. #include <assert.h>
  5581. #include <vector>
  5582.  
  5583. using namespace std;
  5584.  
  5585. #define maxn 360
  5586. #define inf 2000000000
  5587. #define ll long long
  5588.  
  5589. int N, M, S, D;
  5590. int Drum, L, Sum;
  5591. vector <int> A[maxn];
  5592. int G[maxn];
  5593. int Dist[maxn], From[maxn], Pot[maxn];
  5594. int H[maxn], P[maxn];
  5595. int C[maxn][maxn], F[maxn][maxn], Cost[maxn][maxn];
  5596.  
  5597. void push(int x)
  5598. {
  5599. int aux;
  5600.  
  5601. while (x/2>1 && Dist[H[x]]<Dist[H[x/2]])
  5602. {
  5603. aux = H[x], H[x] = H[x/2], H[x/2] = aux;
  5604.  
  5605. P[H[x]] = x;
  5606. P[H[x/2]] = x/2;
  5607.  
  5608. x /= 2;
  5609. }
  5610. }
  5611.  
  5612. void pop(int x)
  5613. {
  5614. int y = 0, aux;
  5615.  
  5616. while (x != y)
  5617. {
  5618. y = x;
  5619. if (y*2<=L && Dist[H[x]]>Dist[H[y*2]]) x = y*2;
  5620. if (y*2+1 <= L && Dist[H[x]]>Dist[H[y*2+1]]) x = y*2+1;
  5621.  
  5622. aux = H[x], H[x] = H[y], H[y] = aux;
  5623. P[H[x]] = x;
  5624. P[H[y]] = y;
  5625. }
  5626. }
  5627.  
  5628. int BellmanFord()
  5629. {
  5630. int i, stop = 0, j, k;
  5631.  
  5632. for (i = 1; i <= N; i++) Dist[i] = inf;
  5633. Dist[S] = 0;
  5634.  
  5635. for (i = 1; i <= N && !stop; i++)
  5636. {
  5637. stop = 1;
  5638.  
  5639. for (j = 1; j <= N; j++)
  5640. for (k = 0; k < G[j]; k++)
  5641. if (C[j][A[j][k]]-F[j][A[j][k]]>0 && Dist[j]+Cost[j][A[j][k]]<Dist[A[j][k]])
  5642. {
  5643. stop = 0;
  5644. Dist[A[j][k]] = Dist[j] + Cost[j][A[j][k]];
  5645. }
  5646. }
  5647.  
  5648. Sum = Dist[D];
  5649.  
  5650. return stop;
  5651. }
  5652.  
  5653. int Dijkstra()
  5654. {
  5655. int i, j;
  5656.  
  5657. // Fac transformarea astfel incat sa am doar costuri pozitive pe arcele active (cele cu capacitate > flux)
  5658.  
  5659. for (i = 1; i <= N; i++)
  5660. for (j = 0; j < G[i]; j++)
  5661. if (Dist[i] != inf && Dist[A[i][j]] != inf) Cost[i][A[i][j]] += Dist[i] - Dist[A[i][j]];
  5662.  
  5663. // Initializari
  5664.  
  5665. for (i = 1; i <= N; i++)
  5666. {
  5667. Dist[i] = inf;
  5668. H[i] = i;
  5669. P[i] = i;
  5670. From[i] = -1;
  5671. }
  5672.  
  5673. // Fac Dijkstra
  5674.  
  5675. Dist[S] = 0;
  5676. H[1] = S, H[S] = 1;
  5677. P[1] = S, P[S] = 1;
  5678. L = N;
  5679.  
  5680. while (L>1 && Dist[H[1]] != inf)
  5681. {
  5682. for (i = 0; i < G[H[1]]; i++)
  5683. {
  5684. int v = A[H[1]][i];
  5685.  
  5686. if (C[H[1]][v]-F[H[1]][v]>0) assert(Cost[H[1]][v]>=0); // Verific daca am arce cu cost negativ active
  5687.  
  5688. if (C[H[1]][v]-F[H[1]][v]>0 && Dist[H[1]]+Cost[H[1]][v]<Dist[v])
  5689. {
  5690. Dist[v] = Dist[H[1]] + Cost[H[1]][v];
  5691. From[v] = H[1];
  5692. push(P[v]);
  5693. }
  5694. }
  5695.  
  5696. H[1] = H[L--];
  5697. P[H[1]] = 1;
  5698. if (L > 1) pop(1);
  5699. }
  5700.  
  5701. // Daca am gasit drum, cresc fluxul pe el
  5702.  
  5703. if (Dist[D] != inf)
  5704. {
  5705. int Vmin = inf;
  5706. Drum = 1;
  5707.  
  5708. for (i = D; i != S; i = From[i])
  5709. Vmin = min(Vmin, C[From[i]][i] - F[From[i]][i]);
  5710.  
  5711. for (i = D; i != S; i = From[i])
  5712. {
  5713. F[From[i]][i] += Vmin;
  5714. F[i][From[i]] -= Vmin;
  5715. }
  5716.  
  5717. Sum += Dist[D];
  5718. return Vmin * Sum;
  5719. }
  5720.  
  5721. return 0;
  5722. }
  5723.  
  5724. ll Flux()
  5725. {
  5726. ll Rez = 0;
  5727. Drum = 1;
  5728.  
  5729. // Cat timp mai exista un drum valabil, bag flux
  5730.  
  5731. while (Drum)
  5732. {
  5733. Drum = 0;
  5734. Rez += Dijkstra();
  5735. }
  5736.  
  5737. return Rez;
  5738. }
  5739.  
  5740. int main()
  5741. {
  5742. freopen("fmcm.in", "r", stdin);
  5743. freopen("fmcm.out", "w", stdout);
  5744.  
  5745. int i, x, y, z, cap;
  5746.  
  5747. // Citesc graful
  5748.  
  5749. scanf("%d %d %d %d ", &N, &M, &S, &D);
  5750.  
  5751. for (i = 1; i <= M; i++)
  5752. {
  5753. scanf("%d %d %d %d ", &x, &y, &cap, &z);
  5754.  
  5755. A[x].push_back(y);
  5756. A[y].push_back(x);
  5757.  
  5758. C[x][y] = cap;
  5759. Cost[x][y] = z;
  5760. Cost[y][x] = -z;
  5761. }
  5762.  
  5763. for (i = 1; i <= N; i++) G[i] = A[i].size();
  5764.  
  5765. // Fac primul Bellman-Ford, cand inca am costuri negative
  5766.  
  5767. assert(BellmanFord());
  5768.  
  5769. // Calculez fluxul maxim de cost minim
  5770.  
  5771. printf("%lld\n", Flux());
  5772.  
  5773. return 0;
  5774. }
  5775.  
  5776.  
  5777.  
  5778.  
  5779.  
  5780.  
  5781.  
  5782.  
  5783.  
  5784.  
  5785. //////////////////////////////////////////////////////////////
  5786. //////////////////////////////////////////////////////////////
  5787. //////////////////////////////////////////////////////////////
  5788. Cuplaj maxim de cost minim
  5789. //////////////////////////////////////////////////////////////
  5790. //////////////////////////////////////////////////////////////
  5791. //////////////////////////////////////////////////////////////
  5792.  
  5793.  
  5794.  
  5795.  
  5796.  
  5797.  
  5798. #include <stdio.h>
  5799. #include <vector>
  5800. #include <string.h>
  5801.  
  5802. using namespace std;
  5803.  
  5804. #define MAX_N 710
  5805. #define inf 2000000000
  5806. #define pb push_back
  5807.  
  5808. int n, m, e, dest, sol, nr, improve;
  5809. int Q[MAX_N * MAX_N], tata[MAX_N], dist[MAX_N], use[MAX_N];
  5810. int C[MAX_N][MAX_N], F[MAX_N][MAX_N], edge[MAX_N][MAX_N];
  5811.  
  5812. vector <int> v[MAX_N], cost[MAX_N];
  5813.  
  5814. void cit() {
  5815. scanf("%d %d %d", &n, &m, &e);
  5816. for (int i = 1; i <= e; i++) {
  5817. int p, q, val;
  5818. scanf("%d %d %d", &p, &q, &val);
  5819. p++; q += n + 1;
  5820.  
  5821. v[p].pb(q); cost[p].pb(val);
  5822. v[q].pb(p); cost[q].pb(-val);
  5823.  
  5824. edge[p][q] = i;
  5825. C[p][q] = 1;
  5826. }
  5827. }
  5828.  
  5829. void build_graph() {
  5830. //sursa este nodul 1, destinatia n + m + 2
  5831. dest = n + m + 2;
  5832. for (int i = 2; i <= n + 1; i++) {
  5833. v[1].pb(i); cost[1].pb(0);
  5834. v[i].pb(1); cost[i].pb(0);
  5835.  
  5836. C[1][i] = 1;
  5837. }
  5838. for (int i = n + 2; i <= n + m + 1; i++) {
  5839. v[i].pb(dest); cost[i].pb(0);
  5840. v[dest].pb(i); cost[dest].pb(0);
  5841.  
  5842. C[i][dest] = 1;
  5843. }
  5844. }
  5845.  
  5846. int bellman_ford() {
  5847. for (int i = 1; i <= dest; i++) {
  5848. dist[i] = inf;
  5849. tata[i] = -1;
  5850. use[i] = 0;
  5851. }
  5852. dist[1] = 0; use[1] = 1;
  5853.  
  5854. int st = 0, dr = 1; Q[1] = 1;
  5855. while (st < dr) {
  5856. st++;
  5857.  
  5858. int len = v[Q[st]].size();
  5859. for (int i = 0; i < len; i++) {
  5860. if (C[Q[st]][v[Q[st]][i]] > F[Q[st]][v[Q[st]][i]] && dist[v[Q[st]][i]] > dist[Q[st]] + cost[Q[st]][i]) {
  5861. dist[v[Q[st]][i]] = dist[Q[st]] + cost[Q[st]][i];
  5862. tata[v[Q[st]][i]] = Q[st];
  5863.  
  5864. if (!use[v[Q[st]][i]]) {
  5865. Q[++dr] = v[Q[st]][i];
  5866. use[v[Q[st]][i]] = 1;
  5867. }
  5868. }
  5869. }
  5870.  
  5871. use[Q[st]] = 0;
  5872. }
  5873.  
  5874. if (dist[dest] < inf) {
  5875. int flux = inf;
  5876. for (int i = dest; i != 1; i = tata[i])
  5877. flux = min(flux, C[tata[i]][i] - F[tata[i]][i]);
  5878.  
  5879. for (int i = dest; i != 1; i = tata[i]) {
  5880. F[tata[i]][i] += flux;
  5881. F[i][tata[i]] -= flux;
  5882. }
  5883.  
  5884. return flux * dist[dest];
  5885. }
  5886. return 0;
  5887. }
  5888.  
  5889. void solve() {
  5890. //construiesc graful de flux
  5891. build_graph();
  5892.  
  5893. improve = 1;
  5894. while (improve) {
  5895. improve = bellman_ford();
  5896. sol += improve;
  5897. }
  5898. }
  5899.  
  5900. void write() {
  5901. for (int i = 2; i <= n + 1; i++)
  5902. for (int j = n + 2; j < dest; j++)
  5903. if (C[i][j] && F[i][j]) {
  5904. nr++;
  5905. break;
  5906. }
  5907.  
  5908. printf("%d %d\n", nr, sol);
  5909. for (int i = 2; i <= n + 1; i++)
  5910. for (int j = n + 2; j < dest; j++)
  5911. if (C[i][j] && F[i][j]) {
  5912. printf("%d ", edge[i][j]);
  5913. break;
  5914. }
  5915. printf("\n");
  5916. }
  5917.  
  5918. int main() {
  5919. freopen("cmcm.in", "r", stdin);
  5920. freopen("cmcm.out", "w", stdout);
  5921.  
  5922. cit();
  5923. solve();
  5924. write();
  5925.  
  5926. return 0;
  5927. }
  5928.  
  5929.  
  5930.  
  5931.  
  5932.  
  5933.  
  5934.  
  5935.  
  5936. //////////////////////////////////////////////////////////////
  5937. //////////////////////////////////////////////////////////////
  5938. //////////////////////////////////////////////////////////////
  5939. Problema rucsacului
  5940. //////////////////////////////////////////////////////////////
  5941. //////////////////////////////////////////////////////////////
  5942. //////////////////////////////////////////////////////////////
  5943.  
  5944.  
  5945.  
  5946.  
  5947. // Problema rucsacului, dinamica O(N*G) timp, O(N) memorie
  5948.  
  5949. #include <cstdio>
  5950. #include <algorithm>
  5951.  
  5952. using namespace std;
  5953.  
  5954. #define MAXN 5010
  5955. #define MAXG 10010
  5956.  
  5957. int N, G, Pmax;
  5958. int W[MAXN], P[MAXN];
  5959. int D[2][MAXG];
  5960.  
  5961. int main()
  5962. {
  5963. freopen("rucsac.in", "r", stdin);
  5964. freopen("rucsac.out", "w", stdout);
  5965.  
  5966. // Citire
  5967. scanf("%d%d", &N, &G);
  5968. for(int i = 1; i <= N; ++i)
  5969. scanf("%d%d", &W[i], &P[i]);
  5970.  
  5971. // Dinamica D[i][cw] - profitul maxim pe care-l putem obtine adaugand o submultime a primelor i obiecte, insumand greutatea cw
  5972. // Din aceasta dinamica vom tine ultimele doua linii, astfel: linia l va fi cea pe care avem solutia pentru al (i-1)-lea element,
  5973. // in timp ce pe linia 1-l vom construi solutia pentru elementul i.
  5974. int l=0;
  5975. for(int i = 1; i <= N; ++i, l = 1 - l)
  5976. for(int cw = 0; cw <= G; ++cw)
  5977. {
  5978. // Mai intai nu punem obiectul i.
  5979. D[1-l][cw] = D[l][cw];
  5980.  
  5981. // Daca acest lucru duce la o solutie curenta mai buna, adaugam obiectul i la o solutie anterioara.
  5982. if(W[i] <= cw)
  5983. D[1-l][cw] = max(D[1-l][cw], D[l][cw - W[i]] + P[i]);
  5984. }
  5985.  
  5986. // Solutia se va afla in statea D[N][G], adica pe linia l, la coloana G
  5987. Pmax = D[l][G];
  5988.  
  5989. // Afisare
  5990. printf("%d\n", Pmax);
  5991.  
  5992. return 0;
  5993. }
  5994.  
  5995.  
  5996.  
  5997.  
  5998.  
  5999.  
  6000. //////////////////////////////////////////////////////////////
  6001. Problema rucsacului -- faster (descrescator)
  6002. //////////////////////////////////////////////////////////////
  6003.  
  6004.  
  6005. // Infoarena - Arhiva Educationala rucsac
  6006. // Februrie 2012 Marius Dumitran
  6007. // Programare dinamica clasica timp O(N*G) memorie O(G)
  6008.  
  6009. #include<string.h>
  6010. #include<stdio.h>
  6011. #include<vector>
  6012. #include<algorithm>
  6013. #define maxn 5001
  6014. #define maxg 10001
  6015.  
  6016. using namespace std;
  6017.  
  6018. int W[maxn], P[maxn];
  6019. int Optim[maxg];
  6020.  
  6021. int main() {
  6022.  
  6023. freopen("rucsac.in", "r", stdin);
  6024. freopen("rucsac.out", "w", stdout);
  6025. int N, G;
  6026. scanf("%d %d", &N, &G);
  6027.  
  6028. for (int i = 1; i <= N; ++i) {
  6029. scanf("%d %d", &W[i], &P[i]);
  6030. }
  6031.  
  6032. Optim[0] = 0;
  6033. int sol = 0;
  6034.  
  6035. for( int i = 1; i <= N; ++i)
  6036. for( int j = G - W[i]; j >= 0; --j) {
  6037. if( Optim[j+W[i]] < Optim[j] + P[i] )
  6038. {
  6039. Optim[j+W[i]] = Optim[j] + P[i];
  6040. if( Optim[j+W[i]] > sol)
  6041. sol = Optim[j+W[i]];
  6042. }
  6043. }
  6044. printf("%d", sol);
  6045. return 0;
  6046. }
  6047.  
  6048.  
  6049.  
  6050.  
  6051.  
  6052. //////////////////////////////////////////////////////////////
  6053. //////////////////////////////////////////////////////////////
  6054. //////////////////////////////////////////////////////////////
  6055. pscpld - palindrom in O(N)
  6056. //////////////////////////////////////////////////////////////
  6057. //////////////////////////////////////////////////////////////
  6058. //////////////////////////////////////////////////////////////
  6059.  
  6060.  
  6061.  
  6062.  
  6063. typedef long long int64;
  6064.  
  6065. const int MAX_N = 1000005;
  6066.  
  6067. int n;
  6068. char v[2 * MAX_N];
  6069. int d[2 * MAX_N];
  6070.  
  6071. void read() {
  6072. assert(freopen("pscpld.in", "r", stdin));
  6073. assert(freopen("pscpld.out", "w", stdout));
  6074.  
  6075. scanf("%s", v + 1);
  6076. n = strlen(v + 1);
  6077.  
  6078. for (int i = 2 * n + 1; i > 0; --i)
  6079. if ((i % 2) == 1)
  6080. v[i] = '#';
  6081. else
  6082. v[i] = v[i / 2];
  6083. n = 2 * n + 1;
  6084. }
  6085.  
  6086. void solve() {
  6087. int best = 0;
  6088. for (int i = 1; i <= n; ++i) {
  6089. if (best + d[best] >= i)
  6090. d[i] = min(best + d[best] - i, d[best - (i-best)]);
  6091. while (i - d[i] - 1 > 0 && i + d[i] + 1 <= n &&
  6092. v[i - d[i] - 1] == v[i + d[i] + 1])
  6093. ++d[i];
  6094. if (i + d[i] >= best + d[best])
  6095. best = i;
  6096. }
  6097.  
  6098. int64 sol = 0;
  6099. for (int i = 1; i <= n; ++i)
  6100. if ((i % 2) == 1)
  6101. sol += d[i] / 2;
  6102. else
  6103. sol += (d[i] + 1) / 2;
  6104. printf("%lld\n", sol);
  6105. }
  6106.  
  6107. int main() {
  6108. read();
  6109. solve();
  6110. }
  6111.  
  6112.  
  6113.  
  6114.  
  6115.  
  6116.  
  6117.  
  6118. //////////////////////////////////////////////////////////////
  6119. //////////////////////////////////////////////////////////////
  6120. //////////////////////////////////////////////////////////////
  6121. Eliminarea gaussiana
  6122. //////////////////////////////////////////////////////////////
  6123. //////////////////////////////////////////////////////////////
  6124. //////////////////////////////////////////////////////////////
  6125.  
  6126. /*
  6127. Eliminarea Gaussiana este cel mai folosit algoritm pentru rezolvarea sistemelor de ecuatii liniare. Metoda reduce succesiv ecuatiile, lasand matricea initiala sub o forma din care vom putea afla usor valorile necunoscutelor. Astfel, notand cu pi pozitia celui mai din stanga coeficient nenul de pe linia i, algoritmul garanteaza obtinerea urmatoarului sir de relatii: p1 < p2 < ... < pN (1). Aceste pozitii vor fi chiar indicii necunoscutelor fixe, cele care pot lua o singura valoare pentru ca sistemul sa aiba in continuare solutie. Celelalte necunoscute, ale caror indici nu se regasesc printre aceste pozitii, pot lua orice valoare si se numesc variabile libere. Pentru a usura calculele, vom considera in continuare ca acestea iau valoarea 0.
  6128.  
  6129. In continuare vom descrie algoritmul propriu-zis. Pornim cu un indice pentru linii, sa-l notam i, si un indice pentru coloane, j, initializate initial cu 1. Cautam pe coloana j, o linie x, i ≤ x astfel incat Ax,j ≠ 0. Daca aceasta linie nu exista, inseamna ca necunoscuta cu indicele j este variabila libera, iar noi incrementam indicele j. Altfel, interschimbam liniile i si x si impartim toata ecuatia de pe linia i la Ai,j, pentru a face coeficientul Ai,j egal cu 1, usurand calculele urmatoare. In continuare vom scadea, din toate ecuatiile u, i < u, ecuatia i inmultita cu o valoare zu, astfel incat toti coeficientii Au,j sa devina 0. Avem astfel Au,j - zu * Ai,j = 0 => zu = Au,j / Ai,j, dar cum Ai,j = 1, zu = Au,j. Aceasta reducere este necesara pentru respectarea conditiei (1), avand in vedere ca nu putem avea x ≠ i cu px = pi. Incrementam pe i si j si reluam procedeul de la inceput. Algoritmul se incheie cand i > N sau j > M. Complexitatea acestuia este O(N3) ca timp si O(N2) ca memorie.
  6130.  
  6131. Acum matricea respecta relatia (1) si putem incepe sa calculam valorile necunoscutelor. Luam ecuatiile in ordine de la N spre 1, gasim pozitia pi, iar xpi va fi dat de relatia xpi = Ai,M+1 - Ai,M * xM - Ai,M-1 * xM-1 - ... - Ai,pi+1 * xpi+1. Relatia (1) ne garanteaza ca xpi+1, xpi+2, ... , xM vor fi calculate anterior. Daca pe parcurs gasim o linie de forma (0, 0, 0, ... , 0, X) (doar rezultatul ecuatiei este nenul), sistemul nu are solutie.
  6132.  
  6133. O implementare de 100 de puncte gasiti aici. Acest algoritm poate fi aplicat cu succes pentru sisteme de ecuatii in care coeficientii, necunoscutele si rezultatele sunt doar 0 si 1, iar operatorul + din ecuatii este inlocuit de XOR.
  6134. */
  6135.  
  6136. #include <cstdio>
  6137.  
  6138. using namespace std;
  6139.  
  6140. #define MAXN 310
  6141. #define EPS 0.0000001
  6142.  
  6143. int N, M;
  6144. double A[MAXN][MAXN];
  6145. double X[MAXN];
  6146.  
  6147. int main()
  6148. {
  6149. freopen("gauss.in", "r", stdin);
  6150. freopen("gauss.out", "w", stdout);
  6151.  
  6152. //Citire
  6153. scanf("%d%d", &N, &M);
  6154. for(int i = 1; i <= N; ++i)
  6155. for(int j = 1; j <= M+1; ++j)
  6156. scanf("%lf", &A[i][j]);
  6157.  
  6158. int i = 1, j = 1, k;
  6159. double aux;
  6160.  
  6161. //Algoritmul lui Gauss propriu-zis
  6162. while(i <= N && j <= M)
  6163. {
  6164. //Cautam o linie k pentru care A[k][j] sa fie nenul. Folosim epsilonul pentru a nu lua in considerare micile erori de calcul.
  6165. for(k = i; k <= N; ++k)
  6166. if(A[k][j]<-EPS || A[k][j]>EPS)
  6167. break;
  6168.  
  6169. //Daca nu gasim linia, necunoscuta j este variabila libera, incrementam pe j si trecem la pasul urmator.
  6170. if(k == N+1)
  6171. {
  6172. ++j;
  6173. continue;
  6174. }
  6175.  
  6176. //Interschimbam pe k cu i, daca este cazul.
  6177. if(k != i)
  6178. for(int l = 1; l <= M+1; ++l)
  6179. {
  6180. aux = A[i][l];
  6181. A[i][l] = A[k][l];
  6182. A[k][l] = aux;
  6183. }
  6184.  
  6185. //Pentru a usura calculele, impartim toate valorile de pe linia i la A[i][j], A[i][j] devenind 1.
  6186. //Observam ca valorile de pe linia i si coloanele 1..j-1 sunt egale cu 0 de la pasii precedenti ai algoritmului,
  6187. //deci nu e necesar sa le parcurgem pentru a le imparti.
  6188. for(int l = j+1; l <= M+1; ++l)
  6189. A[i][l] = A[i][l] / A[i][j];
  6190. A[i][j] = 1;
  6191.  
  6192. //Scadem din ecuatiile i+1...N ecuatia i inmultita cu A[u][j], pentru a egala toti coeficientii de coloana j
  6193. //a acestor linii la 0.
  6194. for(int u = i+1; u <= N; ++u)
  6195. {
  6196. for(int l = j+1; l <= M+1; ++l)
  6197. A[u][l] -= A[u][j] * A[i][l];
  6198. A[u][j] = 0;
  6199. }
  6200.  
  6201. ++i; ++j;
  6202. }
  6203.  
  6204. //Calculul necunoscutelor
  6205. for(int i = N; i>0; --i)
  6206. for(int j = 1; j <= M+1; ++j)
  6207. if(A[i][j]>EPS || A[i][j]<-EPS)
  6208. {
  6209. //Singura valoare nenegativa de pe linia i este rezultatul => sistemul nu are solutie.
  6210. if(j == M+1)
  6211. {
  6212. printf("Imposibil\n");
  6213. return 0;
  6214. }
  6215.  
  6216. //Calculam pe necunoscuta j = rezultatul ecuatiei i - necunoscutele j+1...M inmultite cu coeficientii lor din aceasta ecuatie.
  6217. X[j] = A[i][M+1];
  6218. for(int k = j+1; k <= M; ++k)
  6219. X[j] -= X[k] * A[i][k];
  6220.  
  6221. break;
  6222. }
  6223.  
  6224. //Afisare
  6225. for(int i = 1; i <= M; ++i)
  6226. printf("%.8lf ", X[i]);
  6227. printf("\n");
  6228.  
  6229. return 0;
  6230. }
  6231.  
  6232.  
  6233.  
  6234.  
  6235.  
  6236.  
  6237.  
  6238.  
  6239.  
  6240. //////////////////////////////////////////////////////////////
  6241. //////////////////////////////////////////////////////////////
  6242. //////////////////////////////////////////////////////////////
  6243. // Trie
  6244. //////////////////////////////////////////////////////////////
  6245. //////////////////////////////////////////////////////////////
  6246. //////////////////////////////////////////////////////////////
  6247.  
  6248.  
  6249.  
  6250. #include <cstdio>
  6251. #include <cstring>
  6252.  
  6253. #define CH (*s - 'a')
  6254.  
  6255. using namespace std;
  6256.  
  6257. struct Trie {
  6258. int cnt, nrfii;
  6259. Trie *fiu[ 26 ];
  6260.  
  6261. Trie() {
  6262. cnt = nrfii = 0;
  6263. memset( fiu, 0, sizeof( fiu ) );
  6264. }
  6265. };
  6266.  
  6267. Trie *T = new Trie;
  6268.  
  6269. void ins( Trie *nod, char *s ) {
  6270. if( *s == '\n' ) {
  6271. nod->cnt ++; return;
  6272. }
  6273.  
  6274. if( nod->fiu[ CH ] == 0 ) {
  6275. nod->fiu[ CH ] = new Trie;
  6276. nod->nrfii ++;
  6277. }
  6278.  
  6279. ins( nod->fiu[ CH ], s+1 );
  6280. }
  6281.  
  6282. int del( Trie *nod, char *s ) {
  6283. if( *s == '\n' )
  6284. nod->cnt --;
  6285. else if( del( nod->fiu[ CH ], s+1 ) ) {
  6286. nod->fiu[ CH ] = 0;
  6287. nod->nrfii --;
  6288. }
  6289.  
  6290. if( nod->cnt == 0 && nod->nrfii == 0 && nod != T ) {
  6291. delete nod; return 1;
  6292. }
  6293. return 0;
  6294. }
  6295.  
  6296. int que( Trie *nod, char *s ) {
  6297. if( *s == '\n' )
  6298. return nod->cnt;
  6299.  
  6300. if( nod->fiu[ CH ] )
  6301. return que( nod->fiu[ CH ], s+1 );
  6302. return 0;
  6303. }
  6304.  
  6305. int pre( Trie *nod, char *s, int k ) {
  6306. if( *s == '\n' || nod->fiu[ CH ] == 0 )
  6307. return k;
  6308. return pre( nod->fiu[ CH ], s+1, k+1 );
  6309. }
  6310.  
  6311. int main() {
  6312. char line[ 32 ];
  6313.  
  6314. freopen( "trie.in", "r", stdin );
  6315. freopen( "trie.out", "w", stdout );
  6316.  
  6317. fgets( line, 32, stdin );
  6318.  
  6319. while( !feof( stdin ) ) {
  6320. switch( line[0] ) {
  6321. case '0': ins( T, line+2 ); break;
  6322. case '1': del( T, line+2 ); break;
  6323. case '2': printf( "%d\n", que( T, line+2 ) ); break;
  6324. case '3': printf( "%d\n", pre( T, line+2, 0 ) ); break;
  6325. }
  6326.  
  6327. fgets( line, 32, stdin );
  6328. }
  6329. return 0;
  6330. }
  6331.  
  6332.  
  6333.  
  6334.  
  6335.  
  6336.  
  6337.  
  6338.  
  6339.  
  6340.  
  6341. //////////////////////////////////////////////////////////////
  6342. //////////////////////////////////////////////////////////////
  6343. //////////////////////////////////////////////////////////////
  6344. // Heavy path decomposition
  6345. //////////////////////////////////////////////////////////////
  6346. //////////////////////////////////////////////////////////////
  6347. //////////////////////////////////////////////////////////////
  6348.  
  6349.  
  6350.  
  6351. //Heavy Path Decomposition, O(N * log N * log N)
  6352.  
  6353. #include <cstdio>
  6354. #include <algorithm>
  6355. #include <vector>
  6356. #include <utility>
  6357.  
  6358. using namespace std;
  6359.  
  6360. #define MAXN 100010
  6361.  
  6362. int N, M, nL;
  6363. int v[MAXN], fol[MAXN], niv[MAXN], w[MAXN], l[MAXN];
  6364. int aint[4*MAXN];
  6365. int lTata[MAXN], lNiv[MAXN], lDim[MAXN], lPoz[MAXN];
  6366. vector<int> G[MAXN], P[MAXN];
  6367. pair<int, pair<int, int> > op[MAXN];
  6368.  
  6369. void citire()
  6370. {
  6371. scanf("%d%d", &N, &M);
  6372. for(int i = 1; i <= N; ++i)
  6373. scanf("%d", &v[i]);
  6374.  
  6375. int a, b;
  6376. for(int i = 1; i < N; ++i)
  6377. {
  6378. scanf("%d%d", &a, &b);
  6379. G[a].push_back(b);
  6380. G[b].push_back(a);
  6381. }
  6382.  
  6383. int t, x, y;
  6384. for(int i = 1; i <= M; ++i)
  6385. {
  6386. scanf("%d%d%d", &t, &x, &y);
  6387. op[i] = make_pair(t, make_pair(x, y));
  6388. }
  6389. }
  6390.  
  6391. void df(int nod)
  6392. {
  6393. fol[nod] = 1;
  6394. w[nod] = 1;
  6395.  
  6396. int hN = -1, frunza = 1;
  6397.  
  6398. for(vector<int> :: iterator it = G[nod].begin(); it != G[nod].end(); ++it)
  6399. {
  6400. if(fol[*it])
  6401. continue;
  6402.  
  6403. frunza = 0;
  6404. niv[*it] = niv[nod] + 1;
  6405.  
  6406. df(*it);
  6407.  
  6408. w[nod] += w[*it];
  6409.  
  6410. if(hN == -1)
  6411. hN = *it;
  6412. else
  6413. if(w[hN] < w[*it])
  6414. hN = *it;
  6415. }
  6416.  
  6417. if(frunza)
  6418. {
  6419. l[nod] = ++nL;
  6420. lDim[nL]=1;
  6421. P[nL].push_back(nod);
  6422. return;
  6423. }
  6424.  
  6425. l[nod] = l[hN];
  6426. ++lDim[l[nod]];
  6427. P[l[nod]].push_back(nod);
  6428.  
  6429. for(vector<int> :: iterator it = G[nod].begin(); it != G[nod].end(); ++it)
  6430. {
  6431. if((*it) == hN || niv[*it] < niv[nod])
  6432. continue;
  6433.  
  6434. lTata[l[*it]] = nod;
  6435. lNiv[l[*it]] = niv[nod];
  6436. }
  6437. }
  6438.  
  6439. void build(int nod, int left, int right, int decalaj, int lant)
  6440. {
  6441. if(left == right)
  6442. {
  6443. aint[nod + decalaj] = v[ P[lant][left - 1] ];
  6444. return;
  6445. }
  6446.  
  6447. int med = (left + right) / 2;
  6448.  
  6449. build(nod * 2, left, med, decalaj, lant);
  6450. build(nod * 2 + 1, med+1, right, decalaj, lant);
  6451.  
  6452. aint[nod + decalaj] = max(aint[nod * 2 + decalaj], aint[nod * 2 + 1 + decalaj]);
  6453. }
  6454.  
  6455. void make_paths()
  6456. {
  6457. niv[1] = 1;
  6458. df(1);
  6459.  
  6460. for(int i = 1; i <= nL; ++i)
  6461. {
  6462. reverse(P[i].begin(), P[i].end());
  6463.  
  6464. if(i > 1)
  6465. lPoz[i] = lPoz[i-1] + lDim[i-1] * 4;
  6466.  
  6467. build(1, 1, lDim[i], lPoz[i], i);
  6468. }
  6469. }
  6470.  
  6471. void update(int nod, int left, int right, int poz, int val, int decalaj)
  6472. {
  6473. if(left == right)
  6474. {
  6475. aint[nod + decalaj] = val;
  6476. return;
  6477. }
  6478.  
  6479. int med = (left + right) / 2;
  6480.  
  6481. if(poz<=med)
  6482. update(nod * 2, left, med, poz, val, decalaj);
  6483. else
  6484. update(nod * 2 + 1, med+1, right, poz, val, decalaj);
  6485.  
  6486. aint[nod + decalaj] = max(aint[nod * 2 + decalaj], aint[nod * 2 + 1 + decalaj]);
  6487. }
  6488.  
  6489. int query(int nod, int left, int right, int qleft, int qright, int decalaj)
  6490. {
  6491. if(qleft <= left && right <= qright)
  6492. return aint[nod + decalaj];
  6493.  
  6494. int med = (left + right) / 2, rez = 0;
  6495.  
  6496. if(qleft <= med)
  6497. rez = max(rez, query(nod * 2, left, med, qleft, qright, decalaj) );
  6498. if(med < qright)
  6499. rez = max(rez, query(nod * 2 + 1, med + 1, right, qleft, qright, decalaj) );
  6500.  
  6501. return rez;
  6502. }
  6503.  
  6504. void solve()
  6505. {
  6506. int t, x, y, sol = 0;
  6507.  
  6508. for(int i = 1; i <= M; ++i)
  6509. {
  6510. t = op[i].first; x = op[i].second.first, y = op[i].second.second;
  6511. if(t==0)
  6512. update(1, 1, lDim[l[x]], niv[x] - lNiv[l[x]], y, lPoz[l[x]]);
  6513. else
  6514. {
  6515. sol = 0;
  6516. while(1)
  6517. {
  6518. if(l[x] == l[y])
  6519. {
  6520. if(niv[x] > niv[y])
  6521. swap(x, y);
  6522. sol = max(sol, query(1, 1, lDim[l[x]], niv[x] - lNiv[l[x]], niv[y] - lNiv[l[x]], lPoz[l[x]]) );
  6523. break;
  6524. }
  6525.  
  6526. if(lNiv[l[x]] < lNiv[l[y]])
  6527. swap(x, y);
  6528.  
  6529. sol = max(sol, query(1, 1, lDim[l[x]], 1, niv[x] - lNiv[l[x]], lPoz[l[x]]) );
  6530.  
  6531. x = lTata[l[x]];
  6532. }
  6533. printf("%d\n", sol);
  6534. }
  6535. }
  6536. }
  6537.  
  6538. int main()
  6539. {
  6540. freopen("heavypath.in", "r", stdin);
  6541. freopen("heavypath.out", "w", stdout);
  6542.  
  6543. citire();
  6544. make_paths();
  6545. solve();
  6546.  
  6547. return 0;
  6548. }
  6549.  
  6550.  
  6551.  
  6552.  
  6553.  
  6554.  
  6555.  
  6556.  
  6557.  
  6558. //////////////////////////////////////////////////////////////
  6559. //////////////////////////////////////////////////////////////
  6560. //////////////////////////////////////////////////////////////
  6561. kinetic parsare smechera / rapida
  6562. //////////////////////////////////////////////////////////////
  6563. //////////////////////////////////////////////////////////////
  6564. //////////////////////////////////////////////////////////////
  6565.  
  6566.  
  6567.  
  6568.  
  6569. #include <cstdio>
  6570. #include <cstdlib>
  6571. #include <cstring>
  6572. using namespace std;
  6573.  
  6574. char *buffer;
  6575. int AINT[1<<15];
  6576. void read(int &a)
  6577. {
  6578.     a&=0;
  6579.     char semn = 1;
  6580.     while((*buffer < '0' || *buffer > '9') && *buffer != '-')
  6581.         ++buffer;
  6582.     if(*buffer == '-')
  6583.         semn = -1,++buffer;
  6584.     while(*buffer >='0' && *buffer <= '9')
  6585.         a = a * 10 + *(buffer++) - 48;
  6586.     a*=semn;
  6587. }
  6588. int a[550],b[550];
  6589. int last_t;
  6590. int n,m;
  6591. inline int query(const int &x,const int &y,const int &t)
  6592. {
  6593.     int i;
  6594.     int ret=0;
  6595.     for(i=1;i<=n;++i)
  6596.     {
  6597.         if(a[i] + b[i]*t <= y && a[i]+b[i]*t >= x)
  6598.             ++ret;
  6599.     }
  6600.     return ret;
  6601. }
  6602. void swap(int &a,int &b)
  6603. {
  6604.     a ^=b;
  6605.     b ^=a;
  6606.     a ^=b;
  6607. }
  6608. int main()
  6609. {
  6610.  
  6611.     freopen("kinetic.in","r",stdin);
  6612.     freopen("kinetic.out","w",stdout);
  6613.     fseek(stdin,0,SEEK_END);
  6614.     int len = ftell(stdin);
  6615.     int i,j;
  6616.     int x,y,t;
  6617.     buffer = new char[len];
  6618.     rewind(stdin);
  6619.     fread(buffer,1,len,stdin);
  6620.     read(n);
  6621.     read(m);
  6622.     for(i=1;i<=n;++i)
  6623.     {
  6624.         read(a[i]);
  6625.         read(b[i]);
  6626.     }
  6627.     for(i=1;i<=m;++i)
  6628.     {
  6629.         read(x);
  6630.         read(y);
  6631.         read(t);
  6632.         if(x > y)
  6633.             swap(x,y);
  6634.         printf("%d\n",query(x,y,t));
  6635.     }
  6636.     return 0;
  6637. }
  6638.  
  6639.  
  6640.  
  6641.  
  6642.  
  6643.  
  6644. //////////////////////////////////////////////////////////////
  6645. //////////////////////////////////////////////////////////////
  6646. //////////////////////////////////////////////////////////////
  6647. scanare fisiere ok evaluator cheat
  6648. //////////////////////////////////////////////////////////////
  6649. //////////////////////////////////////////////////////////////
  6650. //////////////////////////////////////////////////////////////
  6651.  
  6652.  
  6653. #define nrlines 2
  6654. void uhyifbe(char *yhuiindu){for(char *yhujindu=yhuiindu+1;*yhujindu!=0;yhujindu+=2){*yhuiindu++=*yhujindu;}*yhuiindu='\0';}
  6655.  
  6656. int main()
  6657. {
  6658. int j;
  6659. ifstream ui;
  6660. ///retine date fin
  6661. string s2[nrlines];
  6662. for(j=0;j<nrlines;++j){
  6663. getline(fin,j[s2]);
  6664. // cerr<<s2[j]<<'\n';
  6665. }
  6666. fin.close();
  6667. for(int testnr=0;testnr<40;++testnr){
  6668. string s;
  6669. int oldtest=testnr;
  6670. if(testnr<=10) testnr=10-testnr;
  6671. ostringstream ss;
  6672. ss<<testnr;
  6673. string ys;
  6674. char ps[] = "\001C\002:\003/\004E\005v\001a\002l\003_\004O\005J\001I\002_\0032\0040\0051\0013\002_\003X\004I\005_\001X\002I\003I\004/\005p\001r\002o\003b\004l\005e\001m\002e\003/\000\000";uhyifbe(ps);
  6675. ys.append(ps);
  6676. ys.append(nume);
  6677. char dasjk[] = "\001/\002t\003e\004s\005t\001e\002/\000\000";uhyifbe(dasjk);
  6678. ys.append(dasjk);
  6679. ys.append(ss.str());
  6680. ys.append("-"nume".in");
  6681. ui.open(ys.c_str());
  6682.  
  6683. ///compara date din ui cu date din fin
  6684. for(j=0;j<nrlines;++j){
  6685. getline(ui,s);
  6686. if(s!=s2[j]) break;
  6687. }
  6688. ui.close();
  6689. if(j==nrlines)///ok, afiseaza/retine
  6690. {
  6691. ys="";
  6692. char kjhb[] = "\001C\002:\003/\004E\005v\001a\002l\003_\004O\005J\001I\002_\0032\0040\0051\0013\002_\003X\004I\005_\001X\002I\003I\004/\005p\001r\002o\003b\004l\005e\001m\002e\003/\000\000";uhyifbe(kjhb);
  6693. ys.append(kjhb);
  6694. ys.append(nume);
  6695. char dasjk[] = "\001/\002t\003e\004s\005t\001e\002/\000\000";uhyifbe(dasjk);
  6696. ys.append(dasjk);
  6697. ys.append(ss.str());
  6698. ys.append("-"nume);
  6699. char dasps[] = "\001.\002o\003k\000";uhyifbe(dasps);
  6700. ys.append(dasps);
  6701. ui.open(ys.c_str());
  6702. for(j=0;j<nrlines;++j){///afiseaza/retine
  6703. getline(ui,s);
  6704. fout<<s<<'\n';
  6705. }
  6706. ui.close();
  6707. break;
  6708. }
  6709. if(oldtest<=10)
  6710. testnr=oldtest;
  6711. }
  6712.  
  6713. return 0;
  6714. }
  6715.  
  6716.  
  6717.  
  6718.  
  6719.  
  6720.  
  6721.  
  6722. //////////////////////////////////////////////////////////////
  6723. //////////////////////////////////////////////////////////////
  6724. //////////////////////////////////////////////////////////////
  6725. generator teste
  6726. //////////////////////////////////////////////////////////////
  6727. //////////////////////////////////////////////////////////////
  6728. //////////////////////////////////////////////////////////////
  6729.  
  6730.  
  6731.  
  6732. ofstream fout(nume);
  6733. const int MAXN=5000;
  6734. const int MAXM=100000;
  6735.  
  6736. srand(time(0));
  6737.  
  6738. n=rand()%MAXN+1;
  6739. m=rand()%MAXM+1;
  6740.  
  6741. fout<<n<<' '<<m<<'\n';
  6742.  
  6743. vector<int> v(n);
  6744.  
  6745. for(int i=0;i<v.size();++i) v[i]=i+1;
  6746. random_shuffle(v.begin(),v.end());
  6747.  
  6748. foreach(it,v) fout<<*it<<' ';
  6749. fout<<'\n';
  6750.  
  6751. for(int i=0;i<m;++i){
  6752. int x=rand()%n;
  6753. int y=rand()%n;
  6754. while(v[x]>v[y]){
  6755. y=rand()%n;
  6756. }
  6757. fout<<v[x]<<' '<<v[y]<<'\n';
  6758. }
  6759.  
  6760.  
  6761.  
  6762.  
  6763.  
  6764.  
  6765.  
  6766.  
  6767.  
  6768.  
  6769.  
  6770. //////////////////////////////////////////////////////////////
  6771. //////////////////////////////////////////////////////////////
  6772. //////////////////////////////////////////////////////////////
  6773. evaluator budau
  6774. //////////////////////////////////////////////////////////////
  6775. //////////////////////////////////////////////////////////////
  6776. //////////////////////////////////////////////////////////////
  6777.  
  6778.  
  6779.  
  6780. #include <iostream>
  6781. #include <fstream>
  6782. #include <vector>
  6783. #include <cassert>
  6784. #include <cstdlib>
  6785. #include <ctime>
  6786. #include <algorithm>
  6787.  
  6788. using namespace std;
  6789.  
  6790. void gen(int N, int M) {
  6791. ofstream in("inversiuni.in");
  6792. in << N << " " << M << "\n";
  6793.  
  6794. vector<int> V(N);
  6795. for (int i = 0; i < N; ++i)
  6796. V[i] = i + 1;
  6797. random_shuffle(V.begin(), V.end());
  6798. for (int i = 0; i < N; ++i)
  6799. in << V[i] << " ";
  6800. in << "\n";
  6801. for (int i = 0; i < M; ++i) {
  6802. int x = rand() % N + 1;
  6803. int y = rand() % N + 1;
  6804. if (x > y)
  6805. swap(x, y);
  6806. in << x << " " << y << "\n";
  6807. }
  6808. }
  6809.  
  6810. vector<int> eval(const char *S) {
  6811. assert(system(S) == 0);
  6812. vector<int> result;
  6813. ifstream out("inversiuni.out");
  6814.  
  6815. int x;
  6816. while (out >> x)
  6817. result.push_back(x);
  6818. return result;
  6819. }
  6820.  
  6821. int main() {
  6822. srand(time(NULL));
  6823. int TESTS, MAXN, MAXM;
  6824. cout << "TESTS = "; cin >> TESTS;
  6825. cout << "MAXN = "; cin >> MAXN;
  6826. cout << "MAXM = "; cin >> MAXM;
  6827.  
  6828. for (int i = 1; i <= TESTS; ++i) {
  6829. if (i == TESTS)
  6830. gen(MAXN, MAXM);
  6831. else
  6832. gen(rand() % MAXN + 1, rand() % (MAXM + 1));
  6833.  
  6834. vector<int> main = eval("./main");
  6835. vector<int> brut = eval("./brut");
  6836.  
  6837. cout << "Case #" << i << ": ";
  6838. if (main != brut) {
  6839. cout << "Wrong! \n";
  6840. return 0;
  6841. }
  6842.  
  6843. cout << "OK!\n";
  6844. }
  6845. }
  6846.  
  6847.  
  6848.  
  6849.  
  6850.  
  6851.  
  6852.  
  6853.  
  6854.  
  6855.  
  6856.  
  6857.  
  6858.  
  6859.  
  6860.  
  6861.  
  6862.  
  6863.  
  6864.  
  6865.  
  6866.  
  6867.  
  6868.  
  6869.  
  6870.  
  6871.  
  6872.  
  6873.  
  6874.  
  6875.  
  6876. //////////////////////////////////////////////////////////////
  6877. //////////////////////////////////////////////////////////////
  6878. //////////////////////////////////////////////////////////////
  6879.  
  6880. //////////////////////////////////////////////////////////////
  6881. //////////////////////////////////////////////////////////////
  6882. //////////////////////////////////////////////////////////////
  6883.  
  6884.  
  6885.  
  6886.  
  6887.  
  6888.  
  6889.  
  6890.  
  6891.  
  6892.  
  6893.  
  6894.  
  6895.  
  6896.  
  6897.  
  6898.  
  6899.  
  6900.  
  6901.  
  6902.  
  6903.  
  6904.  
  6905.  
  6906.  
  6907.  
  6908.  
  6909.  
  6910.  
  6911.  
  6912.  
  6913.  
  6914.  
  6915. //////////////////////////////////////////////////////////////
  6916. //////////////////////////////////////////////////////////////
  6917. //////////////////////////////////////////////////////////////
  6918.  
  6919. //////////////////////////////////////////////////////////////
  6920. //////////////////////////////////////////////////////////////
  6921. //////////////////////////////////////////////////////////////
  6922.  
  6923.  
  6924.  
  6925.  
  6926.  
  6927.  
  6928.  
  6929.  
  6930.  
  6931.  
  6932.  
  6933.  
  6934.  
  6935.  
  6936.  
  6937.  
  6938.  
  6939.  
  6940.  
  6941.  
  6942.  
  6943.  
  6944.  
  6945.  
  6946.  
  6947.  
  6948.  
  6949.  
  6950.  
  6951.  
  6952.  
  6953.  
  6954. //////////////////////////////////////////////////////////////
  6955. //////////////////////////////////////////////////////////////
  6956. //////////////////////////////////////////////////////////////
  6957.  
  6958. //////////////////////////////////////////////////////////////
  6959. //////////////////////////////////////////////////////////////
  6960. //////////////////////////////////////////////////////////////
  6961.  
  6962.  
  6963.  
  6964.  
  6965.  
  6966.  
  6967.  
  6968.  
  6969.  
  6970.  
  6971.  
  6972.  
  6973.  
  6974.  
  6975.  
  6976.  
  6977.  
  6978.  
  6979.  
  6980.  
  6981.  
  6982.  
  6983.  
  6984.  
  6985.  
  6986.  
  6987.  
  6988.  
  6989.  
  6990.  
  6991.  
  6992.  
  6993.  
  6994.  
  6995.  
  6996.  
  6997.  
  6998.  
  6999.  
  7000.  
  7001. //////////////////////////////////////////////////////////////
  7002. //////////////////////////////////////////////////////////////
  7003. //////////////////////////////////////////////////////////////
  7004.  
  7005. //////////////////////////////////////////////////////////////
  7006. //////////////////////////////////////////////////////////////
  7007. //////////////////////////////////////////////////////////////
  7008.  
  7009.  
  7010.  
  7011.  
  7012.  
  7013.  
  7014.  
  7015.  
  7016.  
  7017.  
  7018.  
  7019.  
  7020.  
  7021.  
  7022.  
  7023.  
  7024.  
  7025.  
  7026.  
  7027.  
  7028.  
  7029.  
  7030.  
  7031.  
  7032.  
  7033.  
  7034.  
  7035.  
  7036.  
  7037.  
  7038.  
  7039.  
  7040.  
  7041.  
  7042. ´^/c/io/fscanf.htmÁoŽ/c/io/fseek.htmÏ~’P/c/io/fsetpos.htmâN‹C/c/io/ftell.htmî‰j/c/io/fwrite.htm÷{"/c/io/getc.htm‘…”t/c/io/getchar.htm‘šŠR/c/io/gets.htm‘¤c-/c/io/perror.htm‘²”|/c/io/printf.htm‘Ç Ãx/c/io/putc.htm’‹—
  7043. /io/flags.htm§Òs‰\
  7044. /io/flush.htm§ÜO‹d/io/gcount.htm§è3‰D /io/get.htm§ñwa/io/getline.htm¨XŸ
  7045. /io/good.htm¨®e/io/ignore.htm¨½}/io/io_flags.htm¨Íè /io/open.htm©µ6’M /io/peek.htm©È‰a/io/precision.htm©Ñd( /io/put.htm©á ‰?/io/putback.htm©êK‰U/io/rdstate.htm©ô Š /io/read.htm©þ(”K
  7046. /io/seekg.htmª’s‹n
  7047. /io/seekp.htmªža‹
  7048. /io/setf.htmª©k™A /io/sstream/ /io/sstream/constructors.htmªÃ, !/io/sstream/operators.htmªãMŒ?/io/sstream/rdbuf.htmªð ‰/io/sstream/start.htmªù“/io/sstream/str.htm«ž1
  7049. /io/start.htm««J¶G/io/sync_with_stdio.htm«â‰r
  7050. /io/tellg.htm«ì‰3
  7051. /io/tellp.htm«õ6•U/io/unsetf.htm¬‹ ‰
  7052. /io/width.htm¬”
  7053. /io/write.htm¬£.Š-
  7054. ¬W÷ ~@Œ•S;ía±{7Òß«ÖýƒM#k´ï¨dý™+Ò«©w=UÒŠM+Åø°X`3>¥Ã yhяvÐ9ñnVâ†Mçª"Ø%?z/:1ˆ<êÊkÓ
  7055. ^í ZÓ«rAÄcœGy_±à:Šø7
  7056. ª)ÖŒ€ëÀ Ï „&Àn
  7057. $ܶÖÀï*©h~iB/0ã5çü½Ë[
  7058. ±5ÇÅóÃÿdq2ÚR.8važ·øQkYa õ”}«Z>½5¥ä9—´ˆý2*ƒ†°Ê5Œ§w}3áÎÉÓKï¬ÑÄva† ­ù½®™]° 0`óØW,ß@÷èK…f™
  7059. ¾3U®ˆIô©Ò…#òÖ8Al/O¶q“íFŽ 3ßÊzw£öätÊ"¾pÍd—Å/Sk8SV÷Z\¾wvÚâ£^ðÕÄU´¬ÎÓiÃí» £ 3XÏ ãÿO,pEå˜ñ@üD„‘6xèÓ££bãÞò´Z}¿·í7!ÛdFöÈFxˆK
  7060. ‡î æ½€ðKï-1“Np¹å˜TåäÝø½Àø.¨IŸ$U©RÒ >ÓsùÛôñÐz‡/õSCv¡pÕ[Piªw žjaÄS,Î.L‹Þzã~*(®à˜`µ[³ä§?’cÉáØ÷+ÙGéS²óÓ„ÚÑúÙ O›•©Øq‡þ"ÉVn…ïGáö€æcg„…
  7061. uiìµ_öŒä×`HøõGk(VʁTKN©¿EXa„ẂîÒð+BÆšxI"^w PHÞQmè‘[ I²ôÁ½6¬¼t4v+á>h4ÏàRëKh葱JÏ#ÿZâ~
  7062. )¶×àÖÊ9㙯Z¿|-XŽKšù{§#_×ÄL<vŽIºE”WylèŸÔ"À]Ã_Ð!•KžšT
  7063. Z:ß
  7064. j*þsŽ
  7065. ë5×"zòsnˆ|g(‹sV :‚¹“+>PÒÉî+’æÁ~¼]•ù¥|ác¦õÖ
  7066. ¯•" q^ì´ž„ýÆœ2E<iÚüÄØÙ wuþÍ÷÷$Ävˍ{ÁÝèÐKÙ >åš=YN&ƒ]¶Ñp'"ÃØÑœð] Öɇë%ø:EϐcÅP¾¹EZ[nÖ(‹ï „\¤ `]—: Ó}}@¡÷ã/?/œ)r¶
  7067. «JË´ð_þD,pß^¬;áÞ1ÏpË¡iÎŽªâ~Õ.çf³¬ÔA«KçŽæ.ÙN'bfàž®Žõ%«é¢@kOp]-½#‘%Ƚ€\Æ…™4û˜Ô“NæOF®‹ÉùùÀ²,V¯ýù¥5Hú5ÃLõŒó}H~Ÿ©¶(¯É·w-¬¹úãÕ0@î×9[€Ú—…Ó*å§.ÌÐ Z/탯X]Ro\æ
  7068. ê^´-}íBÐÑi¼*ø\ áÀDZŸNO'¡š³TéóÚDz`ÖA‰I”
  7069. ¸îxø£Â{s—¨s ë'íGcjÆ'ÆK"€Ùãe5fƒ¹RÀ”-ÂóÏǸÙGã"zr¢‹R ¸ª“œ£³.[fz›?ˆõÆÂ#b
  7070. ÿÓ;×uÁØÍ©£šx}ŒJ÷¯ÎÇ9Íûø^Õ{ßÊí9Æ+õs•g>)ì~‡3ÈèM
  7071. k`Eå3r~u¸9þÉ3Ô4½ÏVÜ#ÓÿGÉØ£¼<WYsà’?yk‘ŠgÈΏcÌ
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!