рд╣реЗрдмрд░, рдпрд╣ рдореБрдЭреЗ рдлрд┐рд░ рд╕реЗ рд╣реИ, рдЕрд▓реЗрдХреНрд╕реА рдХреИрдВрд╕рд░ (рдлреЛрдЯреЛ рдореЗрд░рд╛ рдирд╣реАрдВ)ред рдкрд┐рдЫрд▓реЗ рд╕рд╛рд▓, рдореБрдЦреНрдп рдХрд╛рдо рдХреЗ рдЕрд▓рд╛рд╡рд╛, рдореИрдВ рдпреИрдВрдбреЗрдХреНрд╕ рдХреЗ рдЙрдореНрдореАрджрд╡рд╛рд░реЛрдВ рдХреЗ рд▓рд┐рдП рдХрд╛рд░реНрдпреЛрдВ рдХреЗ рд▓реЗрдЦрдХреЛрдВ рдореЗрдВ рд╕реЗ рдПрдХ рдмрди рдЧрдпрд╛ред рдЖрдЬ, рд╣рдорд╛рд░реА рдЯреАрдо рдкрд╣рд▓реА рдмрд╛рд░ рд▓рдВрдмреЗ рд╕рдордп рддрдХ рд╣реИрдмрд░ рдореЗрдВ рдбреЗрд╡рд▓рдкрд░реНрд╕ рдХреЗ рд▓рд┐рдП рд╡рд╛рд╕реНрддрд╡рд┐рдХ рдХрд╛рд░реНрдпреЛрдВ рдХреЛ рдкреНрд░рдХрд╛рд╢рд┐рдд рдХрд░рддреА рд╣реИ рдЬреЛ рдХрдВрдкрдиреА рдореЗрдВ рд╡реНрдпрд╡рд╕реНрдерд┐рдд рд╣реЛ рдЬрд╛рддреЗ рд╣реИрдВред рдЗрди рдХрд╛рд░реНрдпреЛрдВ рдХрд╛ рдЙрдкрдпреЛрдЧ рдлрд░рд╡рд░реА 2020 рддрдХ рдмреИрдХреЗрдВрдбрд░реНрд╕ рдХреЗ рд▓рд┐рдП рдПрдХ рдЗрдВрдЯрд░реНрдирд╢рд┐рдк рдХреЗ рд▓рд┐рдП рдХрд┐рдпрд╛ рдЧрдпрд╛ рдерд╛ред рдПрдХ рдХрдВрдкреНрдпреВрдЯрд░ рджреНрд╡рд╛рд░рд╛ рд╕рдорд╛рдзрд╛рдиреЛрдВ рдХреА рдЬрд╛рдБрдЪ рдХреА рдЧрдИред рдЕрдм рдЙрдореНрдореАрджрд╡рд╛рд░реЛрдВ рдХреЛ рд╕рдорд╛рди рдХрд╛рд░реНрдп рдорд┐рд▓рддреЗ рд╣реИрдВредрдбрд┐рдмреНрд░реАрдбрд┐рдВрдЧ рдФрд░ рдХреЛрдб рдХреЛ рдЬрд╛рдирдмреВрдЭрдХрд░ рд╕реНрдкреЙрдЗрд▓рд░ рдореЗрдВ рдЫрд┐рдкрд╛рдпрд╛ рдЧрдпрд╛ рд╣реИред рдпрджрд┐ рдЖрдк рдмрдбрд╝реА рдЖрдИрдЯреА рдХрдВрдкрдирд┐рдпреЛрдВ рдХреЗ рд╕рд╛рде рд╕рд╛рдХреНрд╖рд╛рддреНрдХрд╛рд░ рдХреА рддреИрдпрд╛рд░реА рдХрд░ рд░рд╣реЗ рд╣реИрдВ, рддреЛ рд╡рд┐рд╢реНрд▓реЗрд╖рдг рджреЗрдЦрдиреЗ рд╕реЗ рдкрд╣рд▓реЗ рдПрдХ рдпрд╛ рдЕрдзрд┐рдХ рд╕рдорд╕реНрдпрд╛рдУрдВ рдХреЛ рд╣рд▓ рдХрд░рдиреЗ рдХрд╛ рдкреНрд░рдпрд╛рд╕ рдХрд░реЗрдВред рдЖрдк рдХреЛрдб рд╕рддреНрдпрд╛рдкрди рдХреЗ рд▓рд┐рдП рд╕рдорд╛рдзрд╛рди рднреЗрдЬ рд╕рдХрддреЗ рд╣реИрдВ - рдЬрд╡рд╛рдм рддреБрд░рдВрдд рдЖрдПрдЧрд╛ ( рдХреЛрдбреЛрд░реЗрдВрд╕ рдФрд░ рдиреЛрдЯ рдХреЗ рд▓рд┐рдП рд▓рд┐рдВрдХ)) рдХреЛрдб рдкрд╛рдпрдерди, рд╕реА ++ рдФрд░ рдЬрд╛рд╡рд╛ рдореЗрдВ рдкреНрд░рд╕реНрддреБрдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред рдорд╣рддреНрд╡рдкреВрд░реНрдг: рд▓реЗрдЦрдХ рдХрд╛ "рдУрд▓рдВрдкрд┐рдпрд╛рдб" рдХреЛрдб рдЙрддреНрдкрд╛рджрди рдХреЗ рд▓рд┐рдП рдЕрднрд┐рдкреНрд░реЗрдд рдирд╣реАрдВ рд╣реИ, рдпрд╣ рдЗрд╕ рдЖрдзрд╛рд░ рдкрд░ рд▓рд┐рдЦрд╛ рдЧрдпрд╛ рд╣реИ рдХрд┐ рд╕рд┐рд╕реНрдЯрдо рдЗрд╕реЗ рд╕реНрд╡рдЪрд╛рд▓рд┐рдд рд░реВрдк рд╕реЗ рдЬрд╛рдВрдЪ рдХрд░реЗрдЧрд╛редрд▓реЗрдЦрдХ рдФрд░ рдореЗрд░реЗ рд╕рд╣рдХрд░реНрдореА: рдХрд╛рд░реНрдп рдП - рдкрд╛рд╡реЗрд▓ рджреЛрд░реЙрд╕реНрдХреЗрд╡рд┐рдЪ, рдмреА рдФрд░ рдПрдл - рдПрдЧреЛрд░ рдЪреБрдирд╛рд╡реЗрд╡, рдИ - рдПрдВрдбреНрд░реЗ рдЦреНрдпрд╛рд▓рд╛рд╡рд┐рди, рд╕реА рдФрд░ рдбреА - рдореБрдЭреЗредрдПред рд╡рд╛рд╕рд┐рдпрд╛ рдХрд╛ рдЬрдиреНрдорджрд┐рдиуАА
рд╕рдорд╛рдзрд╛рди рдФрд░ рдХреЛрдбрдмреАред рдирд┐рдЬреА рдХреБрдВрдЬреАуАА
рд╕рдорд╛рдзрд╛рди рдФрд░ рдХреЛрдбрд╕реАред рдкреНрд░реЛрдЧреНрд░рд╛рдорд░ рдСрди рджуАА
рд╕реЙрд▓реНрдпреВрд╢рди рдФрд░ рдХреЛрдбрдбреАред рдореВрд╡рд┐рдВрдЧ рдЪрдВрдХреНрд╕уАА
рд╕реЙрд▓реНрдпреВрд╢рди рдФрд░ рдХреЛрдбрдИред рдХреЙрд▓рдоуАА
рд╕реЙрд▓реНрдпреВрд╢рди рдФрд░ рдХреЛрдб рдХреЛ рдЕрд▓рдЧ рдХрд░рдирд╛ред рдЦреЛрдЬуАА
рд╕рдорд╛рдзрд╛рди рдФрд░ рдХреЛрдбрдПред рд╡рд╛рд╕рд┐рдпрд╛ рдХрд╛ рдЬрдиреНрдорджрд┐рди
рд╡рд╛рд╕реНрдпрд╛ рдФрд░ рдЙрд╕рдХреЗ рджреЛрд╕реНрдд рд╕реНрд╡рд╛рджрд┐рд╖реНрдЯ рдЦрд╛рдирд╛ рдкрд╕рдВрдж рдХрд░рддреЗ рд╣реИрдВред рдЙрдирдХреЗ рдЬрдиреНрдорджрд┐рди рдкрд░, рд╣рд░ рдХреЛрдИ рдирдП рд╕реНрд╡рд╛рджрд┐рд╖реНрдЯ рдФрд░ рд╕реНрд╡рд╕реНрде рд╡реНрдпрдВрдЬрди рддреИрдпрд╛рд░ рдХрд░рдХреЗ рджреВрд╕рд░реЛрдВ рдХреЛ рдЖрд╢реНрдЪрд░реНрдпрдЪрдХрд┐рдд рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдмрд╛рдзреНрдп рд╣реИредрдЖрдЬ рд╡рд╛рд╕рд┐рдпрд╛ рдХрд╛ рдЬрдиреНрдорджрд┐рди рд╣реИ, рдФрд░ рдЙрдиреНрд╣реЛрдВрдиреЗ рдЕрдкрдиреЗ рджреЛрд╕реНрддреЛрдВ рдХреЛ рдЕрдкрдиреЗ рдмреЗрд╣рддрд░реАрди рд╡реНрдпрдВрдЬрдиреЛрдВ рдХрд╛ рд╕реНрд╡рд╛рдж рдЪрдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдЖрдордВрддреНрд░рд┐рдд рдХрд┐рдпрд╛ред рдЙрдирдореЗрдВ рд╕реЗ рдкреНрд░рддреНрдпреЗрдХ рдХреЗ рдирд╛рдо рдореЗрдВ рдирд┐рдЪрд▓реЗ рдЕрдХреНрд╖рд░реЛрдВ рдореЗрдВ рдЕрдВрдЧреНрд░реЗрдЬреА рдХреЗ рдЕрдХреНрд╖рд░, рд╕рдВрдЦреНрдпрд╛рдПрдБ рдФрд░ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд╣реИрдВредрдирдВрдмрд░ I рдкрд░ рдЦрд╛рдирд╛ рдкрдХрд╛рдиреЗ рдХреЗ рд▓рд┐рдП z i рдЕрд╡рдпрд╡реЛрдВ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИ ред рдкреНрд░рддреНрдпреЗрдХ рдШрдЯрдХ рдХреЗ рд▓рд┐рдП, рдЗрд╕рдХрд╛ рдирд╛рдо рдЬреНрдЮрд╛рдд рд╣реИ, рдбрд┐рд╢ рдХреЗ рдПрдХ рд╣рд┐рд╕реНрд╕реЗ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рдорд╛рддреНрд░рд╛, рд╕рд╛рде рд╣реА рдорд╛рдк рдХреА рдЗрдХрд╛рдИ рдЬрд┐рд╕рдореЗрдВ рдпрд╣ рдорд╛рддреНрд░рд╛ рд╕реЗрдЯ рдХреА рдЧрдИ рд╣реИред рдЗрд╕рдХреЗ рдЕрд▓рд╛рд╡рд╛, рд╡рд╛рд╕рд┐рдпрд╛ рдХреЛ рдкрддрд╛ рд╣реИ рдХрд┐ рдЖрдИ-рд╡реЗрдВ рдкрд╛рдХ рдХреГрддрд┐ рдореИрдВ рджреЛрд╕реНрддреЛрдВ рдХреЗ рд╕рд╛рде рдкреНрд░рдпрд╛рд╕ рдХрд░рдирд╛ рдЪрд╛рд╣реЗрдЧреА редрдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдЗрдХрд╛рдЗрдпреЛрдВ рдХрд╛ рдЙрдкрдпреЛрдЧ рдХрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ:- рдЬреА, рдХрд┐рд▓реЛ - рдЧреНрд░рд╛рдо рдФрд░ рдХрд┐рд▓реЛрдЧреНрд░рд╛рдо рдХреНрд░рдорд╢рдГ;
- рдПрд▓, рдПрдордПрд▓ - рд▓реАрдЯрд░ рдФрд░ рдорд┐рд▓реАрд▓реАрдЯрд░ рдХреНрд░рдорд╢рдГ;
- cnt, рджрд╣рд╛рдИ - рдХреНрд░рдорд╢рдГ рдПрдХ рдЯреБрдХрдбрд╝рд╛ рдФрд░ рджрд╕ рдЯреБрдХрдбрд╝реЗред
рдПрдХ рдХрд┐рд▓реЛрдЧреНрд░рд╛рдо рдореЗрдВ 1000 рдЧреНрд░рд╛рдо рдФрд░ рдПрдХ рд▓реАрдЯрд░ рдореЗрдВ 1000 рдорд┐рд▓реАрд▓реАрдЯрд░ред рдЖрдк рдорд╛рдк рдХреА рдПрдХ рдЗрдХрд╛рдИ рд╕реЗ рджреВрд╕рд░реЗ рдореЗрдВ рд╕реНрдерд╛рдирд╛рдВрддрд░рдг рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдпрджрд┐ рдФрд░ рдХреЗрд╡рд▓ рдЕрдЧрд░ рд╡реЗ рдПрдХ рд╕рд╛рде рдпрд╛ рддреЛ рджреНрд░рд╡реНрдпрдорд╛рди, рдпрд╛ рдорд╛рддреНрд░рд╛, рдпрд╛ рдорд╛рддреНрд░рд╛ рдХреЛ рдЗрдВрдЧрд┐рдд рдХрд░рддреЗ рд╣реИрдВредрд╡рд╛рд╕рдпрд╛ рдХреЗ рдкрд╛рд╕ рджреЛ рд╕рдВрдШрдЯрдХ рдирд┐рд░реНрджреЗрд╢рд┐рдХрд╛рдПрдВ рд╣реИрдВред рдкреНрд░рддреНрдпреЗрдХ рдЕрд╡рдпрд╡ рдХреЗ рд▓рд┐рдП рдкрд╣рд▓рд╛ рдкреИрдХреЗрдЬ рдореЗрдВ рдЗрд╕рдХреА рдорд╛рддреНрд░рд╛ рдФрд░ рдкреНрд░рддрд┐ рдкреИрдХреЗрдЬ рдХреАрдордд рдЗрдВрдЧрд┐рдд рдХрд░рддрд╛ рд╣реИред рдкреНрд░рддреНрдпреЗрдХ рдШрдЯрдХ рдХреЗ рд▓рд┐рдП рджреВрд╕рд░реА рдирд┐рд░реНрджреЗрд╢рд┐рдХрд╛ рдкреНрд░реЛрдЯреАрди, рд╡рд╕рд╛, рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯ рдХреА рд╕рд╛рдордЧреНрд░реА рдФрд░ рдЗрд╕ рдШрдЯрдХ рдХреА рдПрдХ рдирд┐рд╢реНрдЪрд┐рдд рдорд╛рддреНрд░рд╛ рдХреЗ рдКрд░реНрдЬрд╛ рдореВрд▓реНрдп рдХреЛ рдЗрдВрдЧрд┐рдд рдХрд░рддреА рд╣реИредрд╡рд╛рд╕реНрдпрд╛ рдХреЛ рд╕рднреА рд╡реНрдпрдВрдЬрдиреЛрдВ рдХреЛ рдкрдХрд╛рдиреЗ рдХреА рдЬрд╝рд░реВрд░рдд рд╣реИ, рдЬрдмрдХрд┐ рдХреБрдЫ рднреА рдЕрддрд┐рд░рд┐рдХреНрдд рдирд╣реАрдВ рдЦрд░реАрджрдирд╛ред рдРрд╕рд╛ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП, рдЙрд╕реЗ рдпрд╣ рдирд┐рд░реНрдзрд╛рд░рд┐рдд рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ рдХрд┐ рд╕реНрдЯреЛрд░ рдореЗрдВ рдХреНрдпрд╛ рд╕рд╛рдордЧреНрд░реА рдФрд░ рдХрд┐рд╕ рдорд╛рддреНрд░рд╛ рдореЗрдВ рдЦрд░реАрджреА рдЬрд╛рдиреА рдЪрд╛рд╣рд┐рдПредрдЪреВрдВрдХрд┐ рдЬрдиреНрдорджрд┐рди рдХреЗ рд▓рдбрд╝рдХреЗ рдХреЗ рджреЛрд╕реНрдд рдкреЛрд╖рдг рдХреЗ рдмрд╛рд░реЗ рдореЗрдВ рдмрд╣реБрдд рд╕рд╛рд╡рдзрд╛рди рд╣реИрдВ, рдЗрд╕рд╕реЗ рдкрд╣рд▓реЗ рдХрд┐ рд╡реЗ рд╡рд╕реАрдирд╛ рдХреЗ рд╡реНрдпрдВрдЬрдиреЛрдВ рдХреА рдХреЛрд╢рд┐рд╢ рдХрд░реЗрдВ, рд╡реЗ рд╕рдм рдХреБрдЫ рдкрддрд╛ рд▓рдЧрд╛рдирд╛ рдЪрд╛рд╣реЗрдВрдЧреЗ: рд╡рд╛рд╕реНрдпрд╛ рдиреЗ рд╡реНрдпрдВрдЬрди, рдЙрдирдХреЗ рдКрд░реНрдЬрд╛ рдореВрд▓реНрдп рдФрд░ рдкреНрд░реЛрдЯреАрди, рд╡рд╕рд╛ рдФрд░ рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯ рдХреА рд╕рд╛рдордЧреНрд░реА рдХреИрд╕реЗ рддреИрдпрд╛рд░ рдХреАред рд╡рд╛рд╕рд┐рдпрд╛ рдХреЛ рдпрд╣ рдЬрд╛рдирдХрд╛рд░реА рддреИрдпрд╛рд░ рдХрд░рдиреЗ рдХреА рдЬрд░реВрд░рдд рд╣реИредрдЬрдиреНрдорджрд┐рди рдХреЗ рд╡реНрдпрдХреНрддрд┐ рдХреА рдЧрдгрдирд╛ рдХрд░рдиреЗ рдореЗрдВ рдорджрдж рдХрд░рдирд╛ рдЖрд╡рд╢реНрдпрдХ рд╣реИ рдХрд┐ рд╕реНрдЯреЛрд░ рдореЗрдВ рдЙрддреНрдкрд╛рджреЛрдВ рдХреЛ рдЦрд░реАрджрдиреЗ рдХреЗ рд▓рд┐рдП рдХрд┐рддрдиреЗ рдкреИрд╕реЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ, рдХреНрдпрд╛ рд╕рд╛рдордЧреНрд░реА рдФрд░ рдХрд┐рд╕ рдорд╛рддреНрд░рд╛ рдореЗрдВ рдЖрдкрдХреЛ рдЦрд░реАрджрдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ, рд╕рд╛рде рд╣реА рд╕рд╛рде рдкреНрд░рддреНрдпреЗрдХ рдкрдХрд╡рд╛рди рдХреЗ рд▓рд┐рдП, рдкреНрд░реЛрдЯреАрди, рд╡рд╕рд╛, рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯ рдФрд░ рдКрд░реНрдЬрд╛ рдореВрд▓реНрдп рдХреА рдЧрдгрдирд╛ рдХрд░реЗрдВ рдпрджрд┐ рдЖрдк рдкреВрд░реА рддрд░рд╣ рд╕реЗ рдЦрд╛рддреЗ рд╣реИрдВредрдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ n (1 тЙд n - 1000) рд╢рд╛рдорд┐рд▓ рд╣реИ - рд╡рд╛рд╕реНрдпрд╛ рджреНрд╡рд╛рд░рд╛ рдкрдХрд╛рдиреЗ рдХреЗ рд▓рд┐рдП рддрдп рдХрд┐рдП рдЧрдП рд╡реНрдпрдВрдЬрдиреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛редрдлрд┐рд░ n рд╡реНрдпрдВрдЬрдиреЛрдВ рдХрд╛ рд╡рд┐рд╡рд░рдг рдирд┐рдореНрдирд╛рдиреБрд╕рд╛рд░ рд╣реИред рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ i , z i (1 , c i , z i name 100) рдХреЗ рд╕рд╛рде рд╕реНрдЯреНрд░рд┐рдВрдЧ d i рдФрд░ рдкреВрд░реНрдгрд╛рдВрдХ рд╢рд╛рдорд┐рд▓ рд╣реИрдВ - рдкрдХрд╡рд╛рди рдХрд╛ рдирд╛рдо, рдЗрд╕ рд╡реНрдпрдВрдЬрди рдХреЛ рдЖрдЬрд╝рдорд╛рдирд╛ рдЪрд╛рд╣рддреЗ рджреЛрд╕реНрддреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рдФрд░ рдЦрд╛рдирд╛ рдкрдХрд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╕рд╛рдордЧреНрд░реА рдХреА рд╕рдВрдЦреНрдпрд╛ред рдбрд┐рд╢ рдХреЗ рдирд╛рдо рдореЗрдВ рд▓реЛрдЕрд░рдХреЗрд╕ рдЕрдВрдЧреНрд░реЗрдЬреА рдЕрдХреНрд╖рд░, рд╕рдВрдЦреНрдпрд╛ рдФрд░ рдПрдХ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд╣реЛрддрд╛ рд╣реИред рдЗрд╕рдХреА рд▓рдВрдмрд╛рдИ 20 рд╡рд░реНрдгреЛрдВ рд╕реЗ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИред рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд z i рд▓рд╛рдЗрдиреЛрдВ рдореЗрдВ рдЕрд╡рдпрд╡реЛрдВ рдХрд╛ рд╡рд░реНрдгрди рд╣реИред рд╕рдВрдЦреНрдпрд╛ j рд╡рд╛рд▓реА рд░реЗрдЦрд╛ рдореЗрдВ рд╕реНрдЯреНрд░рд┐рдВрдЧ s i, j рдШрдЯрдХ рдХрд╛ рдирд╛рдо рд╣реИ, рдкреВрд░реНрдгрд╛рдВрдХ i, j рд╣реИ(1 1 a i, j тЙд 1000) рдШрдЯрдХ рдХреА рдЖрд╡рд╢реНрдпрдХ рдорд╛рддреНрд░рд╛ рд╣реИ рдФрд░ рд╕реНрдЯреНрд░рд┐рдВрдЧ u i, j рдорд╛рддреНрд░рд╛ рдХреЗ рд▓рд┐рдП рдорд╛рдк рдХреА рдЗрдХрд╛рдИ рдХрд╛ рдирд╛рдо рд╣реИред рдШрдЯрдХ рдХрд╛ рдирд╛рдо рд▓реЛрдЕрд░рдХреЗрд╕ рдЕрдВрдЧреНрд░реЗрдЬреА рдЕрдХреНрд╖рд░, рд╕рдВрдЦреНрдпрд╛ рдФрд░ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд╣реЛрддрд╛ рд╣реИред рд▓рд╛рдЗрди рдХреА рд▓рдВрдмрд╛рдИ 20 рд╡рд░реНрдгреЛрдВ рд╕реЗ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИредрдЕрдЧрд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдкреВрд░реНрдгрд╛рдВрдХ k (1 тЙд k inte 1000) рд╣реИ - рдореВрд▓реНрдп рд╕реВрдЪреА рдореЗрдВ рд╕рд╛рдордЧреНрд░реА рдХреА рд╕рдВрдЦреНрдпрд╛редрдЕрдЧрд▓реЗ рдХрд╢реНрдореАрд░ рдкрдВрдХреНрддрд┐рдпреЛрдВ рдореЗрдВ рд╕реЗ рдкреНрд░рддреНрдпреЗрдХ рдЪрд╛рд░ рдЯреА рд╢рд╛рдорд┐рд▓ рдореИрдВ рдкреА рдореИрдВ рдПрдХ рдореИрдВ рдпреВ рдореИрдВ рд╕рдореНрдорд╛рди рдХрд░рддрд╛ рдШрдЯрдХ рдХрд╛ рд╡рд░реНрдгрдиред- рдЯреА i - рдШрдЯрдХ рдХрд╛ рдирд╛рдо, рдЕрдВрдЧреНрд░реЗрдЬреА рдХреЗ рдЕрдХреНрд╖рд░реЛрдВ, рд╕рдВрдЦреНрдпрд╛рдУрдВ рдФрд░ рдЕрдВрдбрд░рд╕реНрдХреЛрд░ рд╕реЗ рдорд┐рд▓рдХрд░ред рд▓рд╛рдЗрди рдХреА рд▓рдВрдмрд╛рдИ 20 рд╡рд░реНрдгреЛрдВ рд╕реЗ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИ;
- p i рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ (1 тй╜ p i ) 1000) рджрд┐рдП рдЧрдП рдШрдЯрдХ рдХреА рд▓рд╛рдЧрдд рд╣реИ ;
- рдПрдХ рдореИрдВ - рдЗрдХрд╛рдЗрдпреЛрдВ рдореЗрдВ рдкреИрдХреЗрдЬ рдореЗрдВ рдШрдЯрдХ рдХреА рд░рд╛рд╢рд┐, рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ рджреНрд╡рд╛рд░рд╛ рдирд┐рд░реНрджрд┐рд╖реНрдЯ (1 тй╜ рдПрдХ рдореИрдВ тй╜ 1000);
- u i - рдорд╛рддреНрд░рд╛ рдХреА рдорд╛рдк рдХреА рдЗрдХрд╛рдИ (l, ml, g, kg, cnt рдпрд╛ рджрд╕рд┐рдпреЛрдВ)ред
рдЕрдЧрд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдирдВрдмрд░ m (1 line m) 1000) рд╣реИ - рдЦрд╛рджреНрдп рдХреИрдЯрд▓реЙрдЧ рдореЗрдВ рд╕рд╛рдордЧреНрд░реА рдХреА рд╕рдВрдЦреНрдпрд╛редрдЕрдЧрд▓рд╛ рдореАрдЯрд░ рд▓рд╛рдЗрдиреЛрдВ, рдЬрд┐рдирдореЗрдВ рд╕реЗ рдкреНрд░рддреНрдпреЗрдХ рдЯреА рд╕рд╛рдд рдорд╛рди рд╢рд╛рдорд┐рд▓ рд╣реИрдВ рдореИрдВ рдПрдХ рдореИрдВ рдпреВ рдореИрдВ рдЬрдирд╕рдВрдкрд░реНрдХ рдореИрдВ рдЪ рдореИрдВ ch рдореИрдВ fv рдореИрдВ рдШрдЯрдХ рдХрд╛ рд╡рд░реНрдгрдиред- ti тАФ , , . 20 ;
- ai тАФ , , (1 тй╜ ai тй╜ 1000);
- ui тАФ (l, ml, g, kg, cnt tens);
- pri fi chi fvi тАФ , , , (0 тй╜ pri, fi, chi тй╜ 1000, 0 тй╜ fvi тй╜ 10 000).
рдпрд╣ рдЧрд╛рд░рдВрдЯреА рд╣реИ рдХрд┐:- рдХреИрдЯрд▓реЙрдЧ рдЦрд╛рдирд╛ рдкрдХрд╛рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрд╡рд╢реНрдпрдХ рд╕рднреА рд╕рд╛рдордЧреНрд░рд┐рдпреЛрдВ рдХреЛ рд╕реВрдЪреАрдмрджреНрдз рдХрд░рддрд╛ рд╣реИ;
- рдПрдХ рд╣реА рдирд╛рдо рдХреЗ рд╕рд╛рде рджреЛ рд╡реНрдпрдВрдЬрди рдирд╣реАрдВ рд╣реИрдВ;
- рдПрдХ рд╣реА рдирд╛рдо рдХреЗ рд╕рд╛рде рд╕рдорд╛рди рдХреИрдЯрд▓реЙрдЧ рдореЗрдВ рдХреЛрдИ рджреЛ рд╕рд╛рдордЧреНрд░рд┐рдпрд╛рдВ рдирд╣реАрдВ рд╣реИрдВ;
- рдПрдХ рд╣реА рдирд╛рдо рдХреЗ рд╕рд╛рде рдПрдХ рд╣реА рд╡реНрдпрдВрдЬрди рдореЗрдВ рджреЛ рд╕рд╛рдордЧреНрд░рд┐рдпрд╛рдВ рдирд╣реАрдВ рд╣реИрдВ;
- рдХрд┐рд╕реА рдШрдЯрдХ рдХреЗ рджреЛ рдЙрд▓реНрд▓реЗрдЦреЛрдВ рдХреЗ рд▓рд┐рдП, рдорд╛рдк рдХреА рдЗрдХрд╛рдЗрдпрд╛рдБ рдЬрд┐рдирдореЗрдВ рдЗрд╕рдХреА рдорд╛рддреНрд░рд╛рдПрдБ рджреА рдЧрдИ рд╣реИрдВ, рдПрдХ рджреВрд╕рд░реЗ рдореЗрдВ рдкрд░рд┐рд╡рд░реНрддрд┐рдд рд╣реЛ рд╕рдХрддреА рд╣реИрдВред
рдЙрддреНрдкрд╛рджрди
рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ рд╣реЛрдирд╛ рдЪрд╛рд╣рд┐рдП: рд╡рд╣ рд░рд╛рд╢рд┐ рдЬрд┐рд╕реЗ рдЕрд╡рдХрд╛рд╢ рдХреА рддреИрдпрд╛рд░реА рдХреЗ рд▓рд┐рдП рд╡рд╛рд╕рд┐рдпреЛрдВ рдХреЛ рдЦрд░реНрдЪ рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реЛрддреА рд╣реИредрдлрд┐рд░ k рд▓рд╛рдЗрдиреЛрдВ рдХрд╛ рдкрд╛рд▓рди рдХрд░рдирд╛ рдЪрд╛рд╣рд┐рдП, рдЬрд┐рдирдореЗрдВ рд╕реЗ рдкреНрд░рддреНрдпреЗрдХ рдореЗрдВ рдПрдХ рд╕реНрдерд╛рди рдШрдЯрдХ рдХреЗ рдирд╛рдо рдФрд░ рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ рдХреЛ рдЗрдВрдЧрд┐рдд рдХрд░рддрд╛ рд╣реИ - рдЙрди рдкреИрдХреЗрдЬреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рдЬреЛ рдЖрдкрдХреЛ рдЦрд░реАрджрдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИред рдЗрди k рд▓рд╛рдЗрдиреЛрдВ рдореЗрдВ рдкреНрд░рджрд░реНрд╢рд┐рдд рд╕рд╛рдордЧреНрд░реА рдХреЛ рдкрд╣рд▓реА рдирд┐рд░реНрджреЗрд╢рд┐рдХрд╛ рдореЗрдВ рд╡рд░реНрдгрд┐рдд рд╕рд╛рдордЧреНрд░рд┐рдпреЛрдВ рдХреЗ рдЕрдиреБрд░реВрдк рд╣реЛрдирд╛ рдЪрд╛рд╣рд┐рдПредрдЕрдЧрд▓реА рдПрди рд▓рд╛рдЗрдиреЛрдВ рдореЗрдВ рдкрдХрд╡рд╛рди рдХреЗ рдирд╛рдо рдФрд░ рдЙрд╕рдХреА рд╡рд┐рд╢реЗрд╖рддрд╛рдУрдВ рдХреЗ рдмреАрдЪ рдПрдХ рд╕реНрдерд╛рди рд╣реЛрдирд╛ рдЪрд╛рд╣рд┐рдП, рдЬрд┐рд╕реЗ рдЪрд╛рд░ рд╡рд╛рд╕реНрддрд╡рд┐рдХ рд╕рдВрдЦреНрдпрд╛рдУрдВ рджреНрд╡рд╛рд░рд╛ рд╡рд░реНрдгрд┐рдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ: рдкреНрд░реЛрдЯреАрди, рд╡рд╕рд╛, рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯ рдФрд░ рдКрд░реНрдЬрд╛ рдореВрд▓реНрдпредрд╕рд╛рдордЧреНрд░реА рдФрд░ рд╡реНрдпрдВрдЬрди рдХрд┐рд╕реА рднреА рдХреНрд░рдо рдореЗрдВ рдкреНрд░рджрд░реНрд╢рд┐рдд рдХрд░рдиреЗ рдХреА рдЕрдиреБрдорддрд┐ рд╣реИредрдпрджрд┐ рдЖрдкрдХрд╛ рдкреВрд░реНрдгрд╛рдВрдХ рдЬреВрд░реА рдХреЗ рдЙрддреНрддрд░ рдореЗрдВ рд╕рдВрдЧрдд рд╕рдВрдЦреНрдпрд╛рдУрдВ рд╕реЗ рдореЗрд▓ рдЦрд╛рддрд╛ рд╣реИ, рдФрд░ рдЙрддреНрддрд░ рдореЗрдВ рд╕рднреА рд╡рд╛рд╕реНрддрд╡рд┐рдХ рд╕рдВрдЦреНрдпрд╛рдУрдВ рдХреЗ рд▓рд┐рдП рдЙрдирдХреА рдкреВрд░реНрдг рдпрд╛ рд╕рд╛рдкреЗрдХреНрд╖ рддреНрд░реБрдЯрд┐ 10 -3 рд╕реЗ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИ, рддреЛ рдЖрдкрдХрд╛ рдЙрддреНрддрд░ рд╕рд╣реА рдорд╛рдирд╛ рдЬрд╛рдПрдЧрд╛ ред рдФрдкрдЪрд╛рд░рд┐рдХ рд░реВрдк рд╕реЗ, рдЖрдкрдХреЗ рдЙрддреНрддрд░ рдореЗрдВ рд╡рд╛рд╕реНрддрд╡рд┐рдХ рд╕рдВрдЦреНрдпрд╛ A рд╣реИ, рдФрд░ рдЬреВрд░реА рдХреЗ рдЙрддреНрддрд░ рдореЗрдВ рд╕рдВрдЧрдд рд╕рдВрдЦреНрдпрд╛ B рд╣реИред рддрдм рд╕рдВрдЦреНрдпрд╛ A рдХреЛ рд╕рд╣реА рдорд╛рдирд╛ рдЬрд╛рдПрдЧрд╛ рдпрджрд┐|рдП-рдмреА|рдордПрдПрдХреНрд╕(1,рдмреА)тй╜10-3редрдЙрджрд╛рд╣рд░рдг
рдзреНрдпрд╛рди рджреЗрдВ
рдкрд╣рд▓реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рд╡рд╛рд╕реНрдпрд╛ рдХреЛ 7 рд╕реИрдВрдбрд╡рд┐рдЪ рдФрд░ 9 рдЖрдорд▓реЗрдЯ рдкрдХрд╛рдиреЗ рдХреА рдЬрд░реВрд░рдд рд╣реИредрд╕рднреА рдкрд╣рд▓реЗ рд╡реНрдпрдВрдЬрди рддреИрдпрд╛рд░ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрдкрдХреЛ 10 all 7 рдЧреНрд░рд╛рдо рдордХреНрдЦрди, 2 1 7 рдмреНрд░реЗрдб рдФрд░ 30 grams 7 рдЧреНрд░рд╛рдо рд╕реЙрд╕реЗрдЬ рдЪрд╛рд╣рд┐рдПред рдкреНрд░рддреНрдпреЗрдХ рд╕реИрдВрдбрд╡рд┐рдЪ рд╢рд╛рдорд┐рд▓ рд╣реЛрдВрдЧреЗ0.8тЛЕ10100+7.3тЛЕ25+10тЛЕрддреАрд╕100=6 рдкреНрд░реЛрдЯреАрди рдХреЗ рдЧреНрд░рд╛рдо 72.5тЛЕ10100+1.6тЛЕ25+рдЕрдард╛рд░рд╣тЛЕрддреАрд╕100=13.29 рд╡рд╕рд╛ рдФрд░ рдЧреНрд░рд╛рдо 1.3тЛЕ10100+52.3тЛЕ25+1.5тЛЕрддреАрд╕100=21.5рдЧреНрд░рд╛рдо рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯред рдКрд░реНрдЬрд╛ рдореВрд▓реНрдп рд╣реЛрдЧрд╛661тЛЕ10100+248тЛЕ25+210тЛЕрддреАрд╕100=228.3рд╕реЗрд╡рд╛рд╕реЗрд╡рд╛рддрдерд╛рдПрд▓редрд╕рднреА рджреВрд╕рд░реЗ рдкрд╛рдареНрдпрдХреНрд░рдореЛрдВ рдХреЛ рддреИрдпрд╛рд░ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рдЖрдкрдХреЛ 4 all 9 = 36 рдЕрдВрдбреЗ, 120 1080 9 = 1080 рдорд┐рд▓реАрд▓реАрдЯрд░ рджреВрдз, 9 рдЧреНрд░рд╛рдо рдирдордХ, 50 = 9 = 450 рдЧреНрд░рд╛рдо рд╕реЙрд╕реЗрдЬ рдЪрд╛рд╣рд┐рдПред рдкреНрд░рддреНрдпреЗрдХ рдЖрдорд▓реЗрдЯ рдореЗрдВ рд╢рд╛рдорд┐рд▓ рд╣реЛрдЧрд╛рддреЗрд░рд╣тЛЕ4+3тЛЕ1201000+10тЛЕрдкрдЪрд╛рд╕100=57.36 рдкреНрд░реЛрдЯреАрди рдХреЗ рдЧреНрд░рд╛рдо 12тЛЕ4+4.5тЛЕ1201000+рдЕрдард╛рд░рд╣тЛЕрдкрдЪрд╛рд╕100=57,54рдХреБрдВрдЖрддрдерд╛рдЖрд░рдХреЗ рдмрд╛рд░реЗ рдореЗрдВрдкрд░ рддрдерд╛ 1тЛЕ4+4.7тЛЕ1201000+1.5тЛЕрдкрдЪрд╛рд╕100=5.314рдХрд╛рд░реНрдмреЛрд╣рд╛рдЗрдбреНрд░реЗрдЯред рдКрд░реНрдЬрд╛ рдореВрд▓реНрдп рд╣реЛрдЧрд╛рд╕реЛрд▓рд╣тЛЕ4+60тЛЕ1201000+210тЛЕрдкрдЪрд╛рд╕100=177.8рдХрд┐рд▓реЛ рдХреИрд▓реЛрд░реАредрдХреБрд▓ 70 рдЧреНрд░рд╛рдо рдордХреНрдЦрди, 36 рдЕрдВрдбреЗ, 1080 рд▓реАрдЯрд░ рджреВрдз, 9 рдЧреНрд░рд╛рдо рдирдордХ, 210 + 450 = 660 рдЧреНрд░рд╛рдо рд╕реЙрд╕реЗрдЬ рдФрд░ рдЯреЛрд╕реНрдЯ рдмреНрд░реЗрдб рдХреЗ 14 рд╕реНрд▓рд╛рдЗрд╕ рдХреА рдЬрд░реВрд░рдд рд╣реЛрддреА рд╣реИредрдЗрд╕ рдкреНрд░рдХрд╛рд░, рд╕реНрдЯреЛрд░ рдореЗрдВ рдЖрдкрдХреЛ рдордХреНрдЦрди рдХрд╛ рдПрдХ рдкреИрдХреЗрдЯ, 4 рджрд░реНрдЬрди рдЕрдВрдбреЗ, 2 рдкреИрдХ рд╕реЙрд╕реЗрдЬ рдФрд░ рджреВрдз, рдПрдХ рдкреИрдХреЗрдЯ рдирдордХ рдФрд░ рдЯреЛрд╕реНрдЯ рдмреНрд░реЗрдб рдЦрд░реАрджрдиреЗ рдХреА рдЬрд╝рд░реВрд░рдд рд╣реИ, рдЬрд┐рд╕рдХрд╛ рднреБрдЧрддрд╛рди 120 + 61 + 4 + 100 + 2 + 58 + 2 + 14 + 40 = 734 рд░реВрдмрд▓ рд╣реИред редрдлреЗрд╕рд▓рд╛, n dishes, prices k , catalog, , m .
:
1. , , .
2. , , .
.
. dishes prices.
1. - inredients, тАФ , тАФ ( ).
2. .
3. , ingredients .
4. , prices .
5. , . , 32- .
6. , k .
, - , 0.
. dishes catalog:
1. .
2. , , .
3. .
4. .
. 10 1000, Decimal . 1000, . , .
float , 6-7 . double . , .
- : O(тИСni=1zi), zi тАФ i- .
рдкрд╛рдпрдерди рдХреЛрдбimport collections
import math
import typing
from decimal import Decimal
class Amount(object):
def __init__(self, count: Decimal, unit: str):
self.count = count
self.unit = unit
def convert_to(self, unit: str):
multipliers_dict = {
'g': 1,
'kg': 1000,
'ml': 1,
'l': 1000,
'cnt': 1,
'tens': 10
}
assert self.is_compatible(self.unit, unit)
return Amount(self.count * multipliers_dict[self.unit] / multipliers_dict[unit], unit)
@staticmethod
def is_compatible(unit1, unit2):
unit_classes = [
('g', 'kg'),
('ml', 'l'),
('cnt', 'tens')
]
for unit_class in unit_classes:
if unit1 in unit_class:
return unit2 in unit_class
return False
class FoodInfo(object):
def __init__(self, proteins: Decimal = Decimal(0), fats: Decimal = Decimal(0), carbohydrates: Decimal = Decimal(0), food_value: Decimal = Decimal(0)):
self.proteins = proteins
self.fats = fats
self.carbohydrates = carbohydrates
self.food_value = food_value
def __mul__(self, other: Decimal):
assert isinstance(other, Decimal)
return FoodInfo(self.proteins * other, self.fats * other, self.carbohydrates * other, self.food_value * other)
def __add__(self, other):
assert isinstance(other, FoodInfo)
return FoodInfo(
self.proteins + other.proteins,
self.fats + other.fats,
self.carbohydrates + other.carbohydrates,
self.food_value + other.food_value
)
class AmountFoodInfo(object):
def __init__(self, amount, food_info):
self.amount = amount
self.food_info = food_info
class Ingredient(object):
def __init__(self, name: str, amount: Amount):
self.name = name
self.amount = amount
class CatalogIngredientInfo(object):
def __init__(self, name: str, price: int, amount: Amount):
self.name = name
self.price = price
self.amount = amount
class Dish(object):
def __init__(self, name: str, count: int, ingredients: typing.List[Ingredient]):
self.name = name
self.count = count
self.ingredients = ingredients
def read_dishes():
dish_count = int(input())
dishes = []
for _ in range(dish_count):
dish_name, dish_count, ingredient_count = input().split(' ')
ingredient_count = int(ingredient_count)
ingredients = []
for _ in range(ingredient_count):
ingredient_name, amount, unit = input().split(' ')
ingredients.append(Ingredient(name=ingredient_name, amount=Amount(Decimal(amount), unit)))
dishes.append(Dish(name=dish_name, ingredients=ingredients, count=int(dish_count)))
return dishes
def read_catalog():
ingredient_count = int(input())
catalog = {}
for _ in range(ingredient_count):
name, price, amount, unit = input().split(' ')
catalog[name] = CatalogIngredientInfo(
name=name,
price=int(price),
amount=Amount(Decimal(amount), unit)
)
return catalog
def read_food_info():
info_count = int(input())
food_info = {}
for _ in range(info_count):
name, amount, unit, proteins, fats, carbohydrates, food_value = input().split(' ')
food_info[name] = AmountFoodInfo(
amount=Amount(
count=Decimal(amount),
unit=unit
),
food_info=FoodInfo(
proteins=Decimal(proteins),
fats=Decimal(fats),
carbohydrates=Decimal(carbohydrates),
food_value=Decimal(food_value)
)
)
return food_info
def main():
dishes = read_dishes()
catalog = read_catalog()
food_info = read_food_info()
need_ingredients = collections.defaultdict(Decimal)
need_ingredients_count = collections.defaultdict(int)
dish_info = collections.defaultdict(FoodInfo)
for dish in dishes:
for ingredient in dish.ingredients:
converted_amount = ingredient.amount.convert_to(catalog[ingredient.name].amount.unit)
converted_food_info_amount = food_info[ingredient.name].amount.convert_to(catalog[ingredient.name].amount.unit)
need_ingredients[ingredient.name] += converted_amount.count * dish.count
dish_info[dish.name] += food_info[ingredient.name].food_info * (converted_amount.count / converted_food_info_amount.count)
total_price = Decimal(0)
for ingredient_name, need_ingredient in need_ingredients.items():
need_count = need_ingredient // catalog[ingredient_name].amount.count
if need_count * catalog[ingredient_name].amount.count < need_ingredient:
need_count += 1
need_ingredients_count[ingredient_name] = need_count
total_price += catalog[ingredient_name].price * need_count
print(total_price)
for name in catalog.keys():
print(name, need_ingredients_count[name])
for name, info in dish_info.items():
print(name, info.proteins, info.fats, info.carbohydrates, info.food_value)
if __name__ == '__main__':
main()
C ++ рдХреЛрдб#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <assert.h>
#include <algorithm>
#include <iomanip>
#include <time.h>
#include <math.h>
#include <bitset>
#include <unordered_map>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF = 1000 * 1000 * 1000 + 21;
const ll LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 10 * 1000 + 227;
const int MAX_LEN = 35;
struct ig_info {
ll cost = 0;
ll cnt = 0;
ll buy_cnt = 0;
ll eg_cnt = 0;
ld arr[4] = {0.0, 0.0, 0.0, 0.0};
};
struct rs {
string name;
ll mult = 0;
vector<pair<string, ll>> igs;
ld arr[4] = {0.0, 0.0, 0.0, 0.0};
};
int n, k, m;
char buf[MAX_LEN];
char buf_cnt[MAX_LEN];
rs arr[MAX_N];
unordered_map<string, ig_info> info;
ll get_cnt() {
ll cnt;
scanf("%lld %s", &cnt, buf_cnt);
if (!strcmp(buf_cnt, "kg") || !strcmp(buf_cnt, "l")) {
return 1000 * cnt;
}
if (!strcmp(buf_cnt, "tens")) {
return 10 * cnt;
}
return cnt;
}
int main() {
#ifdef CH_EGOR
freopen("input.txt", "r", stdin);
#else
#endif
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int sz;
scanf("%s%lld%d", buf, &arr[i].mult, &sz);
arr[i].name = buf;
arr[i].igs.resize(sz);
for (int j = 0; j < sz; ++j) {
scanf("%s", buf);
arr[i].igs[j].first = buf;
arr[i].igs[j].second = get_cnt();
}
}
scanf("%d", &k);
for (int i = 0; i < k; ++i) {
ll cost;
scanf("%s%lld", buf, &cost);
ig_info& cur_info = info[buf];
cur_info.cost = cost;
cur_info.cnt = get_cnt();
}
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%s", buf);
ig_info& cur_info = info[buf];
cur_info.eg_cnt = get_cnt();
for (int j = 0; j < 4; ++j) {
double x;
scanf("%lf", &x);
cur_info.arr[j] = x;
}
if (cur_info.cnt == 0) {
info.erase(buf);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < (int)arr[i].igs.size(); ++j) {
ig_info& cur_info = info[arr[i].igs[j].first];
cur_info.buy_cnt += arr[i].mult * arr[i].igs[j].second;
for (int k = 0; k < 4; ++k) {
arr[i].arr[k] += ((double)arr[i].igs[j].second / (double)cur_info.eg_cnt) * cur_info.arr[k];
}
}
}
ll ans = 0;
for (auto& cur_info : info) {
cur_info.second.buy_cnt = (cur_info.second.buy_cnt + cur_info.second.cnt - 1) / cur_info.second.cnt;
ans += cur_info.second.buy_cnt * cur_info.second.cost;
}
printf("%lld\n", ans);
for (const auto& cur_info : info) {
printf("%s %lld\n", cur_info.first.c_str(), cur_info.second.buy_cnt);
}
for (int i = 0; i < n; ++i) {
printf("%s ", arr[i].name.c_str());
for (int j = 0; j < 4; ++j) {
printf("%.20lf%c", (double)arr[i].arr[j], " \n"[j == 3]);
}
}
return 0;
}
рдЬрд╛рд╡рд╛ рдХреЛрдбimport java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.HashMap;
import java.io.IOException;
import java.util.Map.Entry;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
Recipes solver = new Recipes();
solver.solve(1, in, out);
out.close();
}
static class Recipes {
static final int CNT_ENERGY = 4;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
Recipes.Recipe[] recipes = new Recipes.Recipe[n];
for (int i = 0; i < n; ++i) {
recipes[i] = new Recipes.Recipe();
recipes[i].name = in.nextString();
recipes[i].mult = in.nextLong();
int ingredientsSize = in.nextInt();
recipes[i].ingredients = new Recipes.Ingredient[ingredientsSize];
for (int j = 0; j < recipes[i].ingredients.length; ++j) {
recipes[i].ingredients[j] = new Recipes.Ingredient();
recipes[i].ingredients[j].name = in.nextString();
recipes[i].ingredients[j].cnt = readCnt(in);
}
}
int k = in.nextInt();
HashMap<String, Recipes.IngredientBuyInfo> ingredientBuyInfo = new HashMap<>();
for (int i = 0; i < k; ++i) {
String name = in.nextString();
Recipes.IngredientBuyInfo curBuyInfo = new Recipes.IngredientBuyInfo();
curBuyInfo.cost = in.nextLong();
curBuyInfo.cnt = readCnt(in);
ingredientBuyInfo.put(name, curBuyInfo);
}
int m = in.nextInt();
HashMap<String, Recipes.IngredientEnergyInfo> ingredientEnergyInfo = new HashMap<>();
for (int i = 0; i < m; ++i) {
String name = in.nextString();
Recipes.IngredientEnergyInfo curEnergyInfo = new Recipes.IngredientEnergyInfo();
curEnergyInfo.cnt = readCnt(in);
for (int j = 0; j < CNT_ENERGY; ++j) {
curEnergyInfo.energyArr[j] = in.nextDouble();
}
ingredientEnergyInfo.put(name, curEnergyInfo);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < recipes[i].ingredients.length; ++j) {
Recipes.IngredientBuyInfo curBuyInfo = ingredientBuyInfo.get(recipes[i].ingredients[j].name);
curBuyInfo.buyCnt += recipes[i].mult * recipes[i].ingredients[j].cnt;
Recipes.IngredientEnergyInfo curEnergyInfo = ingredientEnergyInfo.get(recipes[i].ingredients[j].name);
for (int p = 0; p < CNT_ENERGY; ++p) {
recipes[i].energyArr[p] += ((double) recipes[i].ingredients[j].cnt / (double) curEnergyInfo.cnt) * curEnergyInfo.energyArr[p];
}
}
}
long totalCost = 0;
for (HashMap.Entry<String, Recipes.IngredientBuyInfo> entry : ingredientBuyInfo.entrySet()) {
totalCost += entry.getValue().cost * ((entry.getValue().buyCnt + entry.getValue().cnt - 1) / entry.getValue().cnt);
}
out.println(totalCost);
for (HashMap.Entry<String, Recipes.IngredientBuyInfo> entry : ingredientBuyInfo.entrySet()) {
out.println(entry.getKey() + " " + ((entry.getValue().buyCnt + entry.getValue().cnt - 1) / entry.getValue().cnt));
}
for (int i = 0; i < n; ++i) {
out.print(recipes[i].name + " ");
for (int j = 0; j < CNT_ENERGY; ++j) {
out.print(String.format("%.20f", recipes[i].energyArr[j]) + (j == CNT_ENERGY - 1 ? "\n" : " "));
}
}
}
private long readCnt(InputReader in) {
int cnt = in.nextInt();
String type = in.nextString();
if (type.compareTo("kg") == 0 || type.compareTo("l") == 0) {
return 1000 * cnt;
}
if (type.compareTo("tens") == 0) {
return 10 * cnt;
}
return cnt;
}
static class Ingredient {
String name;
long cnt;
}
static class IngredientBuyInfo {
long cost;
long cnt;
long buyCnt;
}
static class IngredientEnergyInfo {
long cnt;
double[] energyArr;
IngredientEnergyInfo() {
energyArr = new double[CNT_ENERGY];
for (int i = 0; i < CNT_ENERGY; ++i) {
energyArr[i] = 0.0;
}
}
}
static class Recipe {
String name;
long mult;
Recipes.Ingredient[] ingredients;
double[] energyArr;
Recipe() {
energyArr = new double[CNT_ENERGY];
for (int i = 0; i < CNT_ENERGY; ++i) {
energyArr[i] = 0.0;
}
}
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new UnknownError();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new UnknownError();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new UnknownError();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new UnknownError();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new UnknownError();
}
res *= 10;
res += c - '0';
c = read();
}
if (c == '.') {
c = read();
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new UnknownError();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}
public void println(Object... objects) {
print(objects);
writer.println();
}
public void close() {
writer.close();
}
public void println(long i) {
writer.println(i);
}
}
}
B. рдирд┐рдЬреА рдХреБрдВрдЬреА
IT- , тАФ .
YD (Yandex Dorogi) . YD YS (Yandex Shifrovatel).
YS : (p,q), p q тАФ . (p,q) ((p,q), (p,q)), . , YD . , , , , .
YD (x,y). , YD , , (p,q) , (x,y). , , YD, .
рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рджреЛ рдкреВрд░реНрдгрд╛рдВрдХ рд╣реЛрддреЗ рд╣реИрдВ рдПрдХреНрд╕ рддрдерд╛ y (1тЙдрдПрдХреНрд╕тЙдyтЙд1012) - рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рдХреБрдВрдЬреА рдХрд╛ рд╡рд┐рд╡рд░рдгред
рдЙрддреНрдкрд╛рджрди
рдПрдХрд▓ рдкреВрд░реНрдгрд╛рдВрдХ рдкреНрд░рд┐рдВрдЯ рдХрд░реЗрдВ - рдирд┐рдЬреА рдХреБрдВрдЬреА рдХреА рд╕рдВрдЦреНрдпрд╛ рдЬрд┐рд╕рдХреЗ рд▓рд┐рдП рдпрд╣ рдХреБрдВрдЬреА рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рд╣реИред
рдЙрджрд╛рд╣рд░рдг
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рел резреж
рдЙрддреНрдкрд╛рджрди2
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛резреж резрез
рдЙрддреНрдкрд╛рджрди0
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛527 9486
рдЙрддреНрдкрд╛рджрди4
рдзреНрдпрд╛рди рджреЗрдВ
рдкрд╣рд▓реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рджреЛ рдирд┐рдЬреА рдХреБрдВрдЬреА рд╣реИрдВ рдЬрд┐рдирдХреЗ рд▓рд┐рдП (5,10) рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рдХреБрдВрдЬреА рд╣реИ: (5,10) рддрдерд╛ (10,5)
рджреВрд╕рд░реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рджреАрдорд╛ рд╕реЗ рдЧрд▓рддреА рд╣реБрдИ, рдХреНрдпреЛрдВрдХрд┐ рдПрдХ рднреА рдирд┐рдЬреА рдХреБрдВрдЬреА рд╕рд╛рд░реНрд╡рдЬрдирд┐рдХ рдХреБрдВрдЬреА рдирд╣реАрдВ рдмрдирд╛рддреА рд╣реИ (10,рдЧреНрдпрд╛рд░рд╣)
рддреАрд╕рд░реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдЙрдкрдпреБрдХреНрдд рдирд┐рдЬреА рдХреБрдВрдЬреА рд╣реИрдВ:527,9486), (1054,4743), (4743,1054), (9486,527)
рджреЛ рдкреНрд░рд╛рдХреГрддрд┐рдХ рд╕рдВрдЦреНрдпрд╛рдУрдВ рдХрд╛ GCD (рд╕рдмрд╕реЗ рдмрдбрд╝рд╛ рд╕рд╛рдорд╛рдиреНрдп рдХрд╛рд░рдХ) рдкреА рддрдерд╛ рдХреНрд╖ рд╕рдмрд╕реЗ рдмрдбрд╝реА рд╕рдВрдЦреНрдпрд╛ рдХрд╣рд╛ рдЬрд╛рддрд╛ рд╣реИ рдХ рдРрд╕рд╛ рд╣реИ рдХрд┐ рдкреА рджреНрд╡рд╛рд░рд╛ рд╡рд┐рднрд╛рдЬрд┐рдд рдХ рддрдерд╛ рдХреНрд╖ рджреНрд╡рд╛рд░рд╛ рд╡рд┐рднрд╛рдЬрд┐рдд рдХред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдЬреАрд╕реАрдбреА (6,рдкрдВрджреНрд░рд╣) рдХреЗ рдмрд░рд╛рдмрд░ 3рдФрд░ рдЬреАрд╕реАрдбреА (рд╕реЛрд▓рд╣,8) рдХреЗ рдмрд░рд╛рдмрд░ 8ред
рджреЛ рдкреНрд░рд╛рдХреГрддрд┐рдХ рд╕рдВрдЦреНрдпрд╛рдУрдВ рдХрд╛ рдПрдирдУрд╕реА (рд╕рдмрд╕реЗ рдЫреЛрдЯрд╛ рдЖрдо рдХрдИ) рдкреА рддрдерд╛ рдХреНрд╖ рд╕рдмрд╕реЗ рдЫреЛрдЯреА рд╕рдВрдЦреНрдпрд╛ рдХрд╣рд╛ рдЬрд╛рддрд╛ рд╣реИ рдХ рдРрд╕рд╛ рд╣реИ рдХрд┐ рдХ рджреНрд╡рд╛рд░рд╛ рд╡рд┐рднрд╛рдЬрд┐рдд рдкреА рддрдерд╛ рдХ рджреНрд╡рд╛рд░рд╛ рд╡рд┐рднрд╛рдЬрд┐рдд рдХреНрд╖ред рдЙрджрд╛рд╣рд░рдг рдХреЗ рд▓рд┐рдП, рдПрдирдУрд╕реА (2,3) рдХреЗ рдмрд░рд╛рдмрд░ 6, рдФрд░ рдПрдирдУрд╕реА (10,рдмреАрд╕) 20 рдХреЗ рдмрд░рд╛рдмрд░ рд╣реИред
рд╕рдорд╛рдзрд╛рди рдФрд░ рдХреЛрдбy x, , , .
- p, q, gcd(p,q)=x, lcm(p,q)=y. pтА▓=px qтА▓=qx , gcd(pтА▓,qтА▓)=1, lcm(pтА▓,qтА▓)=yx.
, pтА▓, qтА▓ , lcm yx.
x=1, , xтА▓=1, yтА▓=yx.
O(factor(y)+number_of_divisors(y)тЛЕlog(y)).
pтА▓, qтА▓=yтА▓pтА▓, yтА▓=lcm(pтА▓,qтА▓)=pтА▓тЛЕqтА▓gcd(pтА▓,qтА▓)=pтА▓тЛЕqтА▓1=pтА▓тЛЕqтА▓. , , gcd(pтА▓,yтА▓pтА▓)=1, O(log(yтА▓)).
. 1 тИЪyтА▓, O(тИЪyтА▓). , 2тЛЕтИЪyтА▓, , gcd(pтА▓,yтА▓pтА▓)=1, 2тЛЕтИЪyтА▓ , O(тИЪyтА▓logyтА▓).
O(тИЪylog(y)).
++#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <assert.h>
#include <algorithm>
#include <iomanip>
#include <time.h>
#include <math.h>
#include <bitset>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF = 1000 * 1000 * 1000 + 21;
const ll LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
ll gcd(ll a, ll b) {
return b ? gcd(b, a % b) : a;
}
ll x, y;
int main() {
#ifdef CH_EGOR
freopen("input.txt", "r", stdin);
#else
#endif
scanf("%lld%lld", &x, &y);
if (y % x != 0) {
return 0 * printf("0\n");
}
y /= x;
ll ans = 0;
for (ll i = 1; i * i <= y; ++i) {
if (y % i == 0) {
if (gcd(i, y / i) == 1) {
ans += 1 + (i * i != y);
}
}
}
printf("%lld\n", ans);
return 0;
}
O(factor(y)).
z, yтА▓. lcm(pтА▓,qтА▓)=yтА▓, pтА▓, qтА▓ z╬▒, ╬▒ тАФ , z yтА▓. gcd(pтА▓,qтА▓)=1, z.
, , yтА▓, , pтА▓ qтА▓. 2number_of_distinct_prime_divisors(yтА▓).
Pythonx, y = map(int, input().split())
if y % x != 0:
print(0)
else:
y //= x
i = 2
ans = 0
while i * i <= y:
if y % i == 0:
ans += 1
while y % i == 0:
y //= i
i += 1
if y != 1:
ans += 1
print(2 ** ans)
C++#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <assert.h>
#include <algorithm>
#include <iomanip>
#include <time.h>
#include <math.h>
#include <bitset>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF = 1000 * 1000 * 1000 + 21;
const ll LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
ll x, y;
int main() {
#ifdef CH_EGOR
freopen("input.txt", "r", stdin);
#else
#endif
scanf("%lld%lld", &x, &y);
if (y % x != 0) {
return 0 * printf("0\n");
}
y /= x;
ll ans = 0;
for (ll i = 2; i * i <= y; ++i) {
if (y % i == 0) {
++ans;
while (y % i == 0) {
y /= i;
}
}
}
ans += (y != 1);
printf("%lld\n", (1ll << ans));
return 0;
}
Javaimport java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
GcdAndLcm solver = new GcdAndLcm();
solver.solve(1, in, out);
out.close();
}
static class GcdAndLcm {
public void solve(int testNumber, InputReader in, OutputWriter out) {
long x = in.nextLong();
long y = in.nextLong();
if (y % x != 0) {
out.println(0);
return;
}
y /= x;
long ans = 0;
for (long i = 2; i * i <= y; ++i) {
if (y % i == 0) {
++ans;
while (y % i == 0) {
y /= i;
}
}
}
if (y != 1) {
++ans;
}
out.println(1L << ans);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new UnknownError();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new UnknownError();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new UnknownError();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(long i) {
writer.println(i);
}
public void println(int i) {
writer.println(i);
}
}
}
рд╕реАред рдмреАрдЪ рдкреНрд░реЛрдЧреНрд░рд╛рдорд░
. , . , , , , , , . , .
, n (2тЙдnтЙд106) . 2: ( ), . , , . :
- - рдПрдореИрдВ (1тЙдрдореИрдВтЙдn, 0тЙдрдПрдореИрдВтЙд109)
- рдлрд┐рд░ рджреЛ рд╕рдирдмреЗрдбреНрд╕ рдХреА рдЕрд╕рдорд╛рдирддрд╛ рдХреА рдЧрдгрдирд╛ рдЗрди рд╕реВрд░реНрдпрд╛рд╕реНрддреЛрдВ рдХреЛ рд╕реМрдВрдкреА рдЧрдИ рд╕рдВрдЦреНрдпрд╛рдУрдВ рдХреЗ XOR (рдмрд┐рдЯрд╡рд╛рдЗрдб рдПрдХреНрд╕рдХреНрд▓реВрд╕рд┐рд╡ OR) рдХреЗ рд░реВрдк рдореЗрдВ рдХреА рдЬрд╛рддреА рд╣реИред рдЕрд╕рдорд╛рдирддрд╛ рдХрд╛ рдореВрд▓реНрдп рдЬрд┐рддрдирд╛ рдХрдо рд╣реЛрддрд╛ рд╣реИ, рд╕реВрд░реНрдп рдХреЗ рд╕рдорд╛рди рдЙрддрдиреЗ рд╣реА рдЕрдзрд┐рдХред
рдкреНрд░реЛрдЧреНрд░рд╛рдорд░ рдПрд▓реЗрдХреНрд╕реА рдХреЛ рдпрд╣ рд╕рдордЭрдиреЗ рдореЗрдВ рдорджрдж рдХрд░реЗрдВ рдХрд┐ рд╕реВрд░рдЬ рдмрд┐рд╕реНрддрд░реЛрдВ рдХреЗ рдмреАрдЪ рдХреЗ рдЕрдВрддрд░ рдХреЗ рд▓рд┐рдП рдиреНрдпреВрдирддрдо рдореВрд▓реНрдп рдХреНрдпрд╛ рд╣реИ рдЬреЛ рд╡рд╣ рдЬреЛрдбрд╝реЗ рдореЗрдВ рд╕рднреА рдирд┐рд╢реБрд▓реНрдХ рд╕рди рдмреЗрдб рдХреА рддреБрд▓рдирд╛ рдХрд░рдХреЗ рдкреНрд░рд╛рдкреНрдд рдХрд░ рд╕рдХрддрд╛ рд╣реИред
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдПрдХ рд╕рдВрдЦреНрдпрд╛ рд╣реЛрддреА рд╣реИ рдЯреА (1тЙдрдЯреАтЙд1000) - рдкрд░реАрдХреНрд╖рдгреЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ред рдкреНрд░рддреНрдпреЗрдХ рдкрд░реАрдХреНрд╖рдг рдореЗрдВ рджреЛ рд▓рд╛рдЗрдиреЗрдВ рд╣реЛрддреА рд╣реИрдВред
рдкреНрд░рддреНрдпреЗрдХ рдкрд░реАрдХреНрд╖рд╛ рдХреА рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдХреЛ рдПрдХ рдирдВрдмрд░ рджрд┐рдпрд╛ рдЬрд╛рддрд╛ рд╣реИ n (2тЙдnтЙд106) - рд╕рдирдмреЗрдб рдХреА рд╕рдВрдЦреНрдпрд╛ред
рдкреНрд░рддреНрдпреЗрдХ рдкрд░реАрдХреНрд╖рдг рдХреА рджреВрд╕рд░реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рд╢рд╛рдорд┐рд▓ рд╣реИ n рд╕рдВрдЦреНрдпрд╛ рдПрдореИрдВ (1тЙдрдореИрдВтЙдn, 0тЙдрдПрдореИрдВтЙд109) - рд╡реЗ рдорд╛рди рдЬреЛ рдмрд╛рд╣рд░реА рд╕рдВрдХреЗрддреЛрдВ рдХреЗ рдЕрдиреБрд╕рд╛рд░ рд╕рдирдмреЗрдбреНрд╕ рдореЗрдВ рдбрд╛рд▓реЗ рдЧрдП рдереЗред
рд░рдХрдо n рд╕рднреА рдкрд░реАрдХреНрд╖рдгреЛрдВ рдореЗрдВ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИ 106ред
рдЙрддреНрдкрд╛рджрди
рдкреНрд░рддреНрдпреЗрдХ рдкрд░реАрдХреНрд╖рдг рдорд╛рдорд▓реЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдкрдВрдХреНрддрд┐ рдкреНрд░рд┐рдВрдЯ рдХрд░реЗрдВ рдЬрд┐рд╕рдореЗрдВ рдПрдХ рд╣реА рд╕рдВрдЦреНрдпрд╛ рд╣реЛрдиреА рдЪрд╛рд╣рд┐рдП - рдЕрд╕рдорд╛рдирддрд╛ рдХрд╛ рдиреНрдпреВрдирддрдо рдореВрд▓реНрдпред
рдЙрджрд╛рд╣рд░рдг
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
1
5
рез реи рек 16 резрем
рдЙрддреНрдкрд╛рджрди3
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛2
2
реи рек
4
реи рек рем 6
рдЙрддреНрдкрд╛рджрди6
2
рдзреНрдпрд╛рди рджреЗрдВ
1 2.
2 4. 4 6.
, , . , : , .
, 2 . z, XOR , . тАУ z.
, . k тАУ , ( k=0, ). XOR , , x , [2xтИТ1,2xтИТ1] ( x=0 0, , x=1 1, , x=2 2, 3 . .). , , - , k. 2k. , XOR .
, , XOR . , , 2 , . , [a,b], a b тАУ .
Pythonimport sys
def read_int():
return int(sys.stdin.readline())
def read_ints():
return list(map(int, sys.stdin.readline().split()))
def main():
t = read_int()
for _ in range(t):
n = read_int()
a = sorted(read_ints())
r = a[0] ^ a[1]
for i in range(1, n):
r = min(r, a[i-1] ^ a[i])
print(r)
if __name__ == '__main__':
main()
C++#include <algorithm>
#include <cstdint>
#include <cstdio>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int* v = (int*) malloc(sizeof(int) * n);
for (int i = 0; i < n; ++i) {
scanf("%d", &v[i]);
}
sort(v, v + n);
int ans = INT32_MAX;
for (int i = 1; i < n; ++i) {
ans = min(ans, v[i] ^ v[i - 1]);
}
printf("%d\n", ans);
}
return 0;
}
Javaimport java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.util.Arrays;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.lang.Math;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
Scanner in = new Scanner(inputStream);
PrintWriter out = new PrintWriter(outputStream);
PairwiseXor solver = new PairwiseXor();
int n = in.nextInt();
for (int i = 1; i <= n; ++i) {
solver.solve(n, in, out);
}
out.close();
}
static class PairwiseXor {
public void solve(int testNumber, Scanner in, PrintWriter out) {
int n = in.nextInt();
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = in.nextInt();
}
Arrays.sort(a);
int answer = 2000000000;
for (int i = 1; i < n; ++i) {
answer = Math.min(answer, a[i - 1] ^ a[i]);
}
out.println(answer);
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
}
}
D.
, .
m , , n . . , . a,b,l,r l r a b. a . , .
. , , , . , , a,b,l,r, , l r a. , , . , l r a b.
, .
n,m q (1тЙдn,qтЙд100000,2тЙдmтЙд100000) тАФ , , , , .
n pi (1тЙдpiтЙдm), i- , i.
q рд▓рд╛рдЗрдиреЛрдВ рдореЗрдВ рдХрд╛рд▓рд╛рдиреБрдХреНрд░рдорд┐рдХ рдХреНрд░рдо рдореЗрдВ рдЪрдВрдХ рдЖрдВрджреЛрд▓рди рдХреЗ рдЕрдиреБрд░реЛрдзреЛрдВ рдХрд╛ рд╡рд░реНрдгрди рд╣реИред
рдкреНрд░рддреНрдпреЗрдХ рдЕрдиреБрд░реЛрдз рдЪрд╛рд░ рд╕рдВрдЦреНрдпрд╛рдУрдВ рджреНрд╡рд╛рд░рд╛ рд╡рд░реНрдгрд┐рдд рд╣реИ рдПрдореИрдВ,рдЦрдореИрдВ,рдПрд▓рдореИрдВ,рдЖрд░рдореИрдВ (1тЙдрдПрдореИрдВ,рдЦрдореИрдВтЙдрдо,рдПрдореИрдВтЙардЦрдореИрдВ,1тЙдрдПрд▓рдореИрдВтЙдрдЖрд░рдореИрдВтЙдn) рдФрд░ рд╕рдВрдЦреНрдпрд╛рдУрдВ рдХреЗ рд╕рд╛рде рдШреВрдордиреЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдЖрджреЗрд╢ рдХреЛ рджрд░реНрд╢рд╛рддрд╛ рд╣реИ рдПрд▓рдореИрдВ рджреНрд╡рд╛рд░рд╛ рдЖрд░рдореИрдВ (рд╕рдорд╛рд╡реЗрд╢реА) рд╕рд░реНрд╡рд░ рд╕реЗ рдПрдореИрдВ рд╕рд░реНрд╡рд░ рдХреЗ рд▓рд┐рдП рдЦрдореИрдВред
рдЙрддреНрдкрд╛рджрди
рдЫрд╛рдк рдХреНрд╖рд▓рд╛рдЗрдиреЛрдВред рд╕рдВрдЦреНрдпрд╛ рдХреЗ рдЕрдиреБрд░реВрдкрдореИрдВ рдкреНрд░рд┐рдВрдЯ 1рдЕрдЧрд░ рд╕рдВрдЦреНрдпрд╛ рдХреЗ рд╕рд╛рде рдЕрдиреБрд░реЛрдз рдореИрдВ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд┐рдпрд╛ рдЬрд╛рдПрдЧрд╛ рдФрд░ 0, рдЕрдЧрд░ рдирд╣реАрдВред
рдЙрджрд╛рд╣рд░рдг
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рез реи рез
1
рез реи рез рез рез
рдЙрддреНрдкрд╛рджрди1
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛рез реи рез
1
реи рез рез рез рез
рдЙрддреНрдкрд╛рджрди0
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛рел рел рем
1 2 3 4 5
рез реи рез рез рез
реи рей рез рей
4 2 4 4
реи рел рез рек
рей реи реи рей
рей реи рей рей
рдЙрддреНрдкрд╛рджрди1
0
1
0
0
1
рдзреНрдпрд╛рди рджреЗрдВ
рддреАрд╕рд░реЗ рдЙрджрд╛рд╣рд░рдг рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВред рдкреНрд░рд╛рд░рдВрдн рдореЗрдВ, рд╕рд░реНрд╡рд░ рдкрд░ рд╡рд┐рдЦрдВрдбреВ рдХрд╛ рд╕реНрдерд╛рди рдПрдХ рд╕рд░рдгреА рджреНрд╡рд╛рд░рд╛ рд╡рд░реНрдгрд┐рдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ[1,2,3,4,5]ред
рдкрд╣рд▓реЗ рдЕрдиреБрд░реЛрдз рдореЗрдВ, рдЖрдкрдХреЛ рдирдВрдмрд░ рдХреЗ рд╕рд╛рде рдЪрдВрдХ рдХреЛ рд╕реНрдерд╛рдирд╛рдВрддрд░рд┐рдд рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ 1 рд╕рд░реНрд╡рд░ рд╕реЗ 1 рд╕рд░реНрд╡рд░ рдХреЗ рд▓рд┐рдП 2ред рдПрдХ рдирдВрдмрд░ рдХреЗ рд╕рд╛рде рдЪрдВрдХ1 рд╕рд░реНрд╡рд░ рдкрд░ рд╣реИ 1, рдЗрд╕рд▓рд┐рдП рдХрджрдо рдмрдирд╛рдпрд╛ рдЬрд╛рдПрдЧрд╛ред рдЕрдиреБрд░реЛрдз рдХреЛ рдирд┐рд╖реНрдкрд╛рджрд┐рдд рдХрд░рдиреЗ рдХреЗ рдмрд╛рдж, рд╕рд░реНрд╡рд░ рдкрд░ рд╡рд┐рдЦрдВрдбреВ рдХрд╛ рд╕реНрдерд╛рди рдПрдХ рд╕рд░рдгреА рджреНрд╡рд╛рд░рд╛ рд╡рд░реНрдгрд┐рдд рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИ[2,2,3,4,5]ред
рджреВрд╕рд░реА рдХреНрд╡реЗрд░реА рдореЗрдВ, рдЖрдкрдХреЛ рдЪрдВрдХреНрд╕ рдХреЛ рд╕реНрдерд╛рдирд╛рдВрддрд░рд┐рдд рдХрд░рдиреЗ рдХреА рдЖрд╡рд╢реНрдпрдХрддрд╛ рд╣реИ 1,2 рддрдерд╛ 3 рд╕рд░реНрд╡рд░ рд╕реЗ 2 рд╕рд░реНрд╡рд░ рдХреЗ рд▓рд┐рдП 3ред рдЯреБрдХрдбрд╝рд╛3 рд╕рд░реНрд╡рд░ рдкрд░ рд╕реНрдерд┐рдд рдирд╣реАрдВ рд╣реИ 2, 3, . .
4 4 2. 4 4, . [2,2,3,2,5].
1,2,3 4 2 5. 3 3, 2, .
2 3 3 2, 2 2, .
3 3 2. 3 3, [2,2,2,2,5].
, . , a, l r. 2 Split Merge, O(logn). , . rтИТl+1, 1, , 0. O(1).
a, b. Split Merge, O(logn). O(qlogn). 0, .
Pythonimport sys
import random
INF = 10**9 + 21
random.seed(227)
class Node(object):
def __init__(self, x, value):
self.x = x
self.value = value
self.y = random.randint(1, 10**9)
self.l = None
self.r = None
def merge(t1, t2):
if t1 is None:
return t2
if t2 is None:
return t1
if t1.y < t2.y:
t1.r = merge(t1.r, t2)
return t1
else:
t2.l = merge(t1, t2.l)
return t2
def split(t, x):
if t is None:
return None, None
if t.x < x:
t1, t2 = split(t.r, x)
t.r = t1
return t, t2
else:
t1, t2 = split(t.l, x)
t.l = t2
return t1, t
def add(t, nd):
if t is None:
return nd
if nd.y < t.y:
nd.l, nd.r = split(t, nd.x)
return nd
root = t;
p = None
last_l = False
while t is not None and t.y < nd.y:
p = t
if t.x < nd.x:
last_l = False
t = t.r
else:
last_l = True
t = t.l
if last_l:
p.l = nd
else:
p.r = nd
nd.l, nd.r = split(t, nd.x)
return root
def remove(t, x):
if t.x == x:
return merge(t.l, t.r)
root = t
p = None
last_l = False
while t is not None and t.x != x:
p = t
if t.x < x:
last_l = False
t = t.r
else:
last_l = True
t = t.l
if last_l:
p.l = merge(t.l, t.r)
else:
p.r = merge(t.l, t.r)
return root
def get_up(t, x):
cur = None
while t is not None:
if t.x >= x and (cur is None or cur.x > t.x):
cur = t
if t.x >= x:
t = t.l
else:
t = t.r
return cur
def get_down(t, x):
cur = None
while t is not None:
if t.x <= x and (cur is None or cur.x < t.x):
cur = t
if t.x >= x:
t = t.l
else:
t = t.r
return cur
def main():
n, m, q = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
tree = None
tree = add(tree, Node(0, INF))
tree = add(tree, Node(n + 1, INF))
for i in range(n):
if i == n - 1 or arr[i] != arr[i + 1]:
tree = add(tree, Node(i + 1, arr[i]))
ans = ["0" for i in range(q)]
for i in range(q):
a, b, l, r = map(int, sys.stdin.readline().split())
ptr1 = get_up(tree, l)
ptr2 = get_up(tree, r)
if ptr1 is ptr2 and ptr1.value == a:
pr = get_down(tree, l - 1)
if pr.x + 1 != l:
tree = add(tree, Node(l - 1, a))
if pr.x + 1 == l and pr.value == b:
tree = remove(tree, pr.x)
need_add = True
if r == ptr1.x:
nx = get_up(tree, r + 1)
if nx.value == b:
need_add = False
tree = remove(tree, r)
if need_add:
tree = add(tree, Node(r, b))
ans[i] = "1"
sys.stdout.write("\n".join(ans) + "\n")
main()
c : . , . , ,
[l,r] a тАУ
1,
0.
1,
b. :
O(qlogn).
C++#include <iostream>
#include <vector>
using namespace std;
vector<int> min_t;
vector<int> max_t;
vector<int> u;
int p;
inline void update(int i) {
if (u[i]) {
int l = i << 1;
int r = l ^ 1;
min_t[l] = u[i];
min_t[r] = u[i];
max_t[l] = u[i];
max_t[r] = u[i];
u[l] = u[i];
u[r] = u[i];
u[i] = 0;
}
}
pair<int, int> get(int i, int l, int r, int ll, int rr) {
if (r <= ll || rr <= l) {
return make_pair(INT32_MAX, -1);
}
if (ll <= l && r <= rr) {
return make_pair(min_t[i], max_t[i]);
}
update(i);
int m = (l + r) >> 1;
auto a = get(i << 1, l, m, ll, rr);
auto b = get((i << 1) ^ 1, m, r, ll, rr);
return make_pair(min(a.first, b.first), max(a.second, b.second));
}
void set(int i, int l, int r, int ll, int rr, int v) {
if (r <= ll || rr <= l) {
return;
}
if (ll <= l && r <= rr) {
min_t[i] = v;
max_t[i] = v;
u[i] = v;
return;
}
update(i);
int m = (l + r) >> 1;
int a = i << 1;
int b = (i << 1) ^ 1;
set(a, l, m, ll, rr, v);
set(b, m, r, ll, rr, v);
min_t[i] = min(min_t[a], min_t[b]);
max_t[i] = max(max_t[a], max_t[b]);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
p = 1;
while (p < n) {
p <<= 1;
}
min_t.resize(p << 1);
max_t.resize(p << 1);
u.resize(p << 1);
for (int i = 0; i < n; ++i) {
cin >> min_t[i + p];
max_t[i + p] = min_t[i + p];
}
for (int i = p - 1; i > 0; --i) {
min_t[i] = min(min_t[i << 1], min_t[(i << 1) ^ 1]);
max_t[i] = max(max_t[i << 1], max_t[(i << 1) ^ 1]);
}
while (q--) {
int a, b, l, r;
cin >> a >> b >> l >> r;
auto t = get(1, 0, p, --l, r);
if (t.first == a && t.second == a) {
set(1, 0, p, l, r, b);
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
PythonMAX = 1000000000
n, m, q = map(int, input().split())
v = list(map(int, input().split()))
p = 1
while p < n:
p *= 2
min_t = [0] * (p * 2)
max_t = [0] * (p * 2)
u = [0] * (p * 2)
min_t[p:p+n] = v
max_t[p:p+n] = v
for i in range(p - 1, 0, -1):
min_t[i] = min(min_t[2 * i], min_t[2 * i + 1]);
max_t[i] = max(max_t[2 * i], max_t[2 * i + 1]);
def update(i):
if u[i] != 0 and i < p:
a = i * 2
b = a + 1
min_t[a] = u[i]
min_t[b] = u[i]
max_t[a] = u[i]
max_t[b] = u[i]
u[a] = u[i]
u[b] = u[i]
u[i] = 0
def get(i, l, r, ll, rr):
if rr <= l or r <= ll:
return MAX, -1
if ll <= l and r <= rr:
return min_t[i], max_t[i]
update(i)
m = (l + r) / 2
a, b = get(i * 2, l, m, ll, rr);
c, d = get(i * 2 + 1, m, r, ll, rr);
return min(a, c), max(b, d)
def set(i, l, r, ll, rr, v):
if rr <= l or r <= ll:
return
if ll <= l and r <= rr:
min_t[i] = max_t[i] = u[i] = v
return
update(i)
m = (l + r) / 2
set(i * 2, l, m, ll, rr, v)
set(i * 2 + 1, m, r, ll, rr, v)
min_t[i] = min(min_t[i * 2], min_t[i * 2 + 1])
max_t[i] = max(max_t[i * 2], max_t[i * 2 + 1])
while q > 0:
q -= 1
a, b, l, r = map(int, input().split())
l -= 1
c, d = get(1, 0, p, l, r)
if a == c == d:
print(1)
set(1, 0, p, l, r, b)
else:
print(0)
E.
G, n рдЪреЛрдЯрд┐рдпрд╛рдБ рдФрд░ рдо рдкрд╕рд▓рд┐рдпрд╛рдВред
рдЧреНрд░рд╛рдл рдХреЗ рдХреЛрдиреЗ рдХреЛ рджреЛ рдЧреИрд░-рдЦрд╛рд▓реА рд╕реЗрдЯреЛрдВ рдореЗрдВ рддреЛрдбрд╝реЗрдВ рддрд╛рдХрд┐ рдПрдХ рд╕реЗрдЯ рд╕реЗ рдХреЛрдиреЗ рдХреЛ рдЬреЛрдбрд╝рдиреЗ рд╡рд╛рд▓реЗ рдиреНрдпреВрдирддрдо рд╡рдЬрди рдХреЗ рдХрд┐рдирд╛рд░реЗ рдкрд░ рд╕рдмрд╕реЗ рдмрдбрд╝рд╛ рд╕рдВрднрд╡ рд╡рдЬрди рд╣реЛред
рдпрд╣ рдЧрд╛рд░рдВрдЯреА рд╣реИ рдХрд┐ рдЧреНрд░рд╛рдлрд╝ рдореЗрдВ рд▓реВрдк рдирд╣реАрдВ рд╣реИрдВ рдФрд░ рдЗрд╕реЗ рд╡рд┐рднрд╛рдЬрд┐рдд рдирд╣реАрдВ рдХрд┐рдпрд╛ рдЬрд╛ рд╕рдХрддрд╛ рд╣реИ рддрд╛рдХрд┐ рдЗрд╕ рддрд░рд╣ рдХреА рдмрдврд╝рдд рдореМрдЬреВрдж рди рд╣реЛред
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рдкрд╣рд▓реА рдкрдВрдХреНрддрд┐ рдореЗрдВ рдХреЛрдиреЗ рдХреА рд╕рдВрдЦреНрдпрд╛ рд╣реЛрддреА рд╣реИ n (3тЙдnтЙд105) рдФрд░ рдХрд┐рдирд╛рд░реЛрдВ рдХреА рд╕рдВрдЦреНрдпрд╛ рдо (3тЙдрдотЙд105) рдЧреНрд░рд╛рдлред
рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд рдореЗрдВ рдо рд▓рд╛рдЗрдиреЛрдВ рдХреЛ рдкреНрд░рд╛рд░реВрдк рдореЗрдВ рдХрд┐рдирд╛рд░реЗ рджрд┐рдП рдЧрдП рд╣реИрдВ рдпреВ, v, w (1тЙдрдпреВ,vтЙдn, рдпреВтЙаv, 1тЙдwтЙд105), рдХрд╣рд╛рдБ рдкреЗ рдпреВ рддрдерд╛ v рдХрд┐рдирд╛рд░реЗ рдХреЗ рд╢реБрд░реВ рдФрд░ рдЕрдВрдд рд╢реАрд░реНрд╖ рд╕реЗрдЯ, рдФрд░ w - рдЗрд╕рдХрд╛ рд╡рдЬрдиред
рдЙрддреНрдкрд╛рджрди
рдПрдХ рдкрдВрдХреНрддрд┐ рдореЗрдВ рдПрдХ рдХрд┐рдирд╛рд░реЗ рдХреЗ рдЕрдзрд┐рдХрддрдо рд╕рдВрднрд╛рд╡рд┐рдд рд╡рдЬрди рдХреЛ рдкреНрд░рд┐рдВрдЯ рдХрд░реЗрдВ, рдЬрд┐рд╕рдореЗрдВ рдиреНрдпреВрдирддрдо рд╡рдЬрди рд╣реИ рдЬреЛ рдПрдХ рд╣реА рд╕реЗрдЯ рд╕реЗ рд╕рдВрдмрдВрдзрд┐рдд рдХреЛрдиреЗ рдХреЛ рдЬреЛрдбрд╝рддрд╛ рд╣реИред
рдЙрджрд╛рд╣рд░рдг
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
рей рек
рез реи рез
рез реи реи
рез рей рей
рей реи рек
рдЙрддреНрдкрд╛рджрди4
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛рек рел
рез реи рез
реи рей рез
рей рек рез
рек рез рез
реи рек реи
рдЙрддреНрдкрд╛рджрди2
рдзреНрдпрд╛рди рджреЗрдВ
рд╣рд╛рд▓рдд рдХреЗ рдкрд╣рд▓реЗ рдЙрджрд╛рд╣рд░рдг рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░реЗрдВред рдЗрд╕рдореЗрдВ, рд╕рдВрднрд╡рддрдГ рдХреЗрд╡рд▓ 3 рдЕрд▓рдЧ-рдЕрд▓рдЧ рд╡рд┐рднрд╛рдЬрди рд╣реИрдВ рдЬреЛ рд╕реНрдерд┐рддрд┐ рдХреЛ рд╕рдВрддреБрд╖реНрдЯ рдХрд░рддреЗ рд╣реИрдВ, рд╣рдо рдЙрдирдореЗрдВ рд╕реЗ рдкреНрд░рддреНрдпреЗрдХ рдкрд░ рд╡рд┐рдЪрд╛рд░ рдХрд░рддреЗ рд╣реИрдВ:
- {{1,2},{3}}рдЗрд╕ рдорд╛рдорд▓реЗ рдореЗрдВ рдкрд╕рд▓рд┐рдпреЛрдВ 1 рддрдерд╛ 2 рдПрдХ рд╕реЗрдЯ рд╕реЗ рдХреЛрдиреЗ рдХрдиреЗрдХреНрдЯ рдХрд░реЗрдЧрд╛, рд╡рд╣ рд╣реИ, рдЙрддреНрддрд░ 1;
- {{1,3},{2}}, рдЗрд╕ рдорд╛рдорд▓реЗ рдореЗрдВ рдХреЗрд╡рд▓ рдПрдХ рдмрдврд╝рдд 3 рдПрдХ рд╕реЗрдЯ рд╕реЗ рд╡рд░реНрдЯрд┐рдХрд▓ рдХрдиреЗрдХреНрдЯ рдХрд░реЗрдЧрд╛, рдЕрд░реНрдерд╛рдд рдЙрддреНрддрд░ 3;
- {{2,3},{1}}, рдЗрд╕ рдорд╛рдорд▓реЗ рдореЗрдВ рдХреЗрд╡рд▓ рдПрдХ рдмрдврд╝рдд 4 рдПрдХ рд╕реЗрдЯ рд╕реЗ рд╡рд░реНрдЯрд┐рдХрд▓ рдХрдиреЗрдХреНрдЯ рдХрд░реЗрдЧрд╛, рдЕрд░реНрдерд╛рдд рдЙрддреНрддрд░ 4ред
рд╣рдо рдкрд╛рддреЗ рд╣реИрдВ рдХрд┐ рдкрд░реАрдХреНрд╖рдг рдХрд╛ рдЙрддреНрддрд░ рд╡рд┐рднрд╛рдЬрди рдХреЗ рддреАрд╕рд░реЗ рд╕рдВрд╕реНрдХрд░рдг рдХреЗ рд╕рд╛рде рд╣рд╛рд╕рд┐рд▓ рдХрд┐рдпрд╛ рдЧрдпрд╛ рд╣реИред
рджреВрд╕рд░реЗ рдкрд░реАрдХреНрд╖рдг рдореЗрдВ, рд╡рд┐рднрд╛рдЬрди рдкрд░ рдЙрддреНрддрд░ рдкреНрд░рд╛рдкреНрдд рд╣реЛрддрд╛ рд╣реИ {{1,3},{2,4}}. , , , .
.
, тАФ x. , x, , , , x. x. , x , , y<x. , y , x, , x>y. x , , z>x, , x, ( ), .
, , . (, ) . 0 1. :
- , 0.
- a b b , a (, val[a]=0, val[b]=1, ).
, , . , .
O(n+m), O((n+m)logmaxw).
Pythonimport sys
def bfs(g, cl, m, v):
qu = [v]
cl[v] = 1
l = 0
while l != len(qu):
v = qu[l]
l += 1
for u, w in g[v]:
if w > m:
continue
if cl[u] == 0:
cl[u] = 3 - cl[v]
qu.append(u)
elif cl[v] == cl[u]:
return False
return True
def check(g, m):
cl = [0 for i in range(len(g))]
for i in range(len(g)):
if cl[i] == 0 and not bfs(g, cl, m, i):
return False
return True
def main():
n, m = map(int, sys.stdin.readline().split())
ed = [tuple(map(int, sys.stdin.readline().split())) for i in range(m)]
g = [[] for i in range(n)]
mx = 0
for v, u, w in ed:
g[v - 1].append((u - 1, w))
g[u - 1].append((v - 1, w))
mx = max(mx, w)
if check(g, mx):
sys.stdout.write(str(mx) + "\n")
return
l = 0
r = mx + 1
while r - l > 1:
m = (l + r) // 2
if check(g, m):
l = m
else:
r = m
sys.stdout.write(str(r) + "\n")
main()
C++#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include <utility>
struct Solution {
int n, m;
std::vector<std::vector<std::pair<int, int>>> graph;
std::vector<int> colors;
bool dfs(int v, int color, int bound) {
colors[v] = color;
for (const auto &edge : graph[v]) {
if (edge.second >= bound) {
continue;
}
if (colors[edge.first] == color) {
return false;
}
if (colors[edge.first] == -1) {
if (!dfs(edge.first, 1 - color, bound)) {
return false;
}
}
}
return true;
}
bool check(int bound) {
for (int i = 0; i < n; i++) {
if (colors[i] == -1) {
if (!dfs(i, 0, bound)) {
return false;
}
}
}
return true;
}
void run(std::istream &in, std::ostream &out) {
in >> n >> m;
graph.assign(n, std::vector<std::pair<int, int>>());
for (int i = 0; i < m; i++) {
int u, v, w;
in >> u >> v >> w;
u--;
v--;
graph[u].emplace_back(v, w);
graph[v].emplace_back(u, w);
}
int l = 0;
int r = 1000000001;
while (r - l > 1) {
int m = (l + r) / 2;
colors.assign(n, -1);
if (!check(m)) {
r = m;
} else {
l = m;
}
}
out << l << "\n";
}
};
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
Solution().run(std::cin, std::cout);
return 0;
}
Javaimport java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;
public class Graph_AD_Correct {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
Graph solver = new Graph();
solver.solve(1, in, out);
out.close();
}
static class Graph {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.readInt();
int m = in.readInt();
List<Graph.Edge>[] g = new List[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
int left = Integer.MAX_VALUE;
int right = Integer.MIN_VALUE;
for (int i = 0; i < m; i++) {
int x = in.readInt() - 1;
int y = in.readInt() - 1;
int w = in.readInt();
g[x].add(new Graph.Edge(y, w));
g[y].add(new Graph.Edge(x, w));
left = Math.min(left, w);
right = Math.max(right, w);
}
int[] color = new int[n];
int ans = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (isBipartite(n, color, g, mid)) {
ans = mid;
left = mid + 1;
} else {
right = mid - 1;
}
}
if (ans == -1) {
throw new AssertionError();
}
out.printLine(ans);
}
private boolean isBipartite(int n, int[] color, List<Graph.Edge>[] g, int mid) {
Arrays.fill(color, -1);
for (int i = 0; i < n; i++) {
if (color[i] == -1) {
if (!dfs(i, -1, 0, color, g, mid)) {
return false;
}
}
}
return true;
}
private boolean dfs(int x, int p, int curColor, int[] color, List<Graph.Edge>[] g, int mid) {
color[x] = curColor;
for (Graph.Edge e : g[x]) {
if (e.w >= mid) {
continue;
}
int y = e.to;
if (y == p) {
continue;
}
if (color[y] == color[x]) {
return false;
}
if (color[y] == -1 && !dfs(y, x, 1 - curColor, color, g, mid)) {
return false;
}
}
return true;
}
static class Edge {
int to;
int w;
Edge(int to, int w) {
this.to = to;
this.w = w;
}
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void printLine(int i) {
writer.println(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int readInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
F.
. . , , .
: , . n - . тАФ , , . , . , , .
, , i (i<n) i+1, n 1. ( ) - , .
, , , k. , . .
. , , , .
t тАФ . .
.
n k (1тЙдnтЙд100000, 0тЙдkтЙдmin(nтИТ1,100)) тАФ , , , .
n рдкреВрд░реНрдгрд╛рдВрдХреЛрдВ рдПрдореИрдВ (-109тЙдрдПрдореИрдВтЙд109) - рджрд╕реНрддрд╛рд╡реЗрдЬреЛрдВ рдХреА рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ред
рдЧрд╛рд░рдВрдЯреА рд╣реИ рдХрд┐ рд░рд╛рд╢рд┐ n рд╕рднреА рдкрд░реАрдХреНрд╖рдг рдорд╛рдорд▓реЛрдВ рдореЗрдВ рдЕрдзрд┐рдХ рдирд╣реАрдВ рд╣реИ 100000ред
рдЙрддреНрдкрд╛рджрди
рдкреНрд░рддреНрдпреЗрдХ рдкрд░реАрдХреНрд╖рдг рдорд╛рдорд▓реЗ рдХреЗ рд▓рд┐рдП рдПрдХ рдкреВрд░реНрдгрд╛рдВрдХ рдкреНрд░рд┐рдВрдЯ рдХрд░реЗрдВ - рд╕рдорд╕реНрдпрд╛ рдХрд╛ рдЙрддреНрддрд░ред
рдЙрджрд╛рд╣рд░рдг
рдЗрдирдкреБрдЯ рдбреЗрдЯрд╛
6
рек реж
1 -2 9 10
рем рез
5 -5 5 -5 5 -5
рем реи
5 -5 5 -5 5 -5
рек рей
5 -5 5 -5
1 рез
-3 -1 5 6 -200 -200 5 -1
рей рез
-1 -2 -3
рдЙрддреНрдкрд╛рджрдирдмреАрд╕
10
рдкрдВрджреНрд░рд╣
10
14
-1
рдзреНрдпрд╛рди рджреЗрдВ
рдкрд╣рд▓реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рдХреЗ рд╕рд╛рде рдкреНрд░рд╛рд░рдВрднрд┐рдХ рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдХреЗ рд░реВрдк рдореЗрдВ рдЪрдпрди рдХрд░рдирд╛ рд▓рд╛рднрдкреНрд░рдж рд╣реИ 9рдФрд░ рдЗрд╕реЗ рдФрд░ рдирд┐рдореНрдирд▓рд┐рдЦрд┐рдд 2 рджрд╕реНрддрд╛рд╡реЗрдЬреЛрдВ рдХреЛ рдлрд╝рд┐рд▓реНрдЯрд░ рдХрд░рдиреЗ рдХреЗ рд▓рд┐рдП рднреЗрдЬреЗрдВред рдирд┐рд╕реНрдкрдВрджрди рдЪрд░рдг рдореЗрдВ, рд╕рднреА рджрд╕реНрддрд╛рд╡реЗрдЬреЛрдВ рдХреЛ рдЫреЛрдбрд╝рдирд╛ рд╣реЛрдЧрд╛ред
рджреВрд╕рд░реЗ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдХрд┐рд╕реА рднреА рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдХреЛ рдкреНрд░рд╛рд░рдВрднрд┐рдХ рдХреЗ рд░реВрдк рдореЗрдВ рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рдХреЗ рд╕рд╛рде рдЪреБрдирдирд╛ рд▓рд╛рднрдкреНрд░рдж рд╣реИ 5, рдЗрд╕реЗ рдлрд╝рд┐рд▓реНрдЯрд░рд┐рдВрдЧ рдЪрд░рдг рдФрд░ рдЗрд╕рдХреЗ рдмрд╛рдж 2 рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рднреЗрдЬреЗрдВред рдлрд╝рд┐рд▓реНрдЯрд░рд┐рдВрдЧ рдЪрд░рдг рдореЗрдВ, рдЖрдкрдХреЛ рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рдХреЗ рд╕рд╛рде рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдХреЛ рд╣рдЯрд╛рдирд╛ рд╣реЛрдЧрд╛-5рдЗрд╕ рдкреНрд░рдХрд╛рд░, рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рд╡рд╛рд▓реЗ рджреЛ рджрд╕реНрддрд╛рд╡реЗрдЬ рдЬрд╛рд░реА рдХрд┐рдП рдЬрд╛рдПрдВрдЧреЗ 5ред
рдкрд╛рдВрдЪрд╡реЗрдВ рдЙрджрд╛рд╣рд░рдг рдореЗрдВ, рдкреНрд░рд╛рд░рдВрднрд┐рдХ рдХреЗ рд░реВрдк рдореЗрдВ рд╕рдВрдЦреНрдпрд╛ рдХреЗ рд╕рд╛рде рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдЪреБрдирдирд╛ рдлрд╛рдпрджреЗрдордВрдж рд╣реИ 7 рдФрд░ рдЗрд╕реЗ рдлрд╝рд┐рд▓реНрдЯрд░рд┐рдВрдЧ рдЪрд░рдг рдФрд░ рдирд┐рдореНрди рдкрд░ рднреЗрдЬреЗрдВ 5рджрд╕реНрддрд╛рд╡реЗрдЬреЛрдВред рдЗрд╕ рдкреНрд░рдХрд╛рд░, рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рд╡рд╛рд▓реЗ рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдлрд╝рд┐рд▓реНрдЯрд░рд┐рдВрдЧ рдЪрд░рдг рдореЗрдВ рдкрд╣реБрдВрдЪ рдЬрд╛рдПрдВрдЧреЗ[5,-1,-3,-1,5,6]ред рдлрд╝рд┐рд▓реНрдЯрд░рд┐рдВрдЧ рдЪрд░рдг рдореЗрдВ, рдкреНрд░рд╛рд╕рдВрдЧрд┐рдХрддрд╛ рдХреЗ рд╕рд╛рде рджрд╕реНрддрд╛рд╡реЗрдЬрд╝ рдХреЛ рд╣рдЯрд╛рдирд╛ рд▓рд╛рднрдкреНрд░рдж рд╣реИ-3, [5,тИТ1,тИТ1,5,6] 14.
, .
, тАФ . , . 0, , - .
, .
dpi,j тАФ , - [l;i] (l , ), k .
: dpi,j=max(0,dpiтИТ1,j+ai,dpiтИТ1,jтИТ1), :
- 0 тАФ ┬л┬╗ .
- dpiтИТ1,j+ai тАФ - , i- .
- dpiтИТ1,jтИТ1 тАФ - , i- .
O(nk), max1тЙдiтЙдn0тЙдjтЙдkdpi,j.
, , n- .
.
dpli,j тАФ , [1;i], k .
: dpli,j=max(dpliтИТ1,j+ai,dpliтИТ1,jтИТ1), :
- dpliтИТ1,j+ai тАФ , i- .
- dpliтИТ1,jтИТ1 тАФ , i- .
, , .
, dpri,j тАФ , [i;n], k .
: dpri,j=max(dpri+1,j+ai,dpri+1,jтИТ1), :
- dpri+1,j+ai тАФ , i- .
- dpri+1,jтИТ1 тАФ , i- .
O(nk).
, n- ? p, , q, . тАФ dplp,q. тАФ , maxp<iтЙдn0тЙдjтЙдkтИТqdpri,j.
dpr_maxi,j=max(dpri,j,dpr_maxi+1,j,dpr_maxi,jтИТ1). тАФ O(nk), p q O(1).
O(nk) .
Pythonimport sys
def solve():
n, k = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
ans = max(arr)
if ans <= 0:
return ans
dp_l = [[0 for j in range(k + 2)] for i in range(n + 2)]
dp_r = [[0 for j in range(k + 2)] for i in range(n + 2)]
for i in range(1, n + 1):
for j in range(k + 1):
dp_l[i][j] = max(0, dp_l[i - 1][j] + arr[i - 1])
if j: dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j - 1])
ans = max(ans, dp_l[i][j])
for i in range(1, n + 1):
for j in range(k + 1):
dp_l[i][j] = dp_l[i - 1][j] + arr[i - 1]
if j: dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j - 1])
for i in range(n, 0, -1):
for j in range(k + 1):
dp_r[i][j] = dp_r[i + 1][j] + arr[i - 1]
if j: dp_r[i][j] = max(dp_r[i][j], dp_r[i + 1][j - 1])
for i in range(1, n + 1):
for j in range(k + 1):
if i != 1: dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j])
if j: dp_l[i][j] = max(dp_l[i][j], dp_l[i][j - 1])
for i in range(n, 0, -1):
for j in range(k + 1):
if i != n: dp_r[i][j] = max(dp_r[i][j], dp_r[i + 1][j])
if j: dp_r[i][j] = max(dp_r[i][j], dp_r[i][j - 1])
for i in range(1, n):
for j in range(k + 1):
ans = max(ans, dp_l[i][j] + dp_r[i + 1][k - j])
return ans
def main():
t = int(sys.stdin.readline())
ans = []
for i in range(t):
ans.append(str(solve()))
sys.stdout.write("\n".join(ans) + "\n")
main()
C++#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <assert.h>
#include <algorithm>
#include <iomanip>
#include <time.h>
#include <math.h>
#include <bitset>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long int ll;
typedef long double ld;
const int INF = 1000 * 1000 * 1000 + 21;
const ll LLINF = (1ll << 60) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 100 * 1000 + 227;
const int MAX_K = 105;
int n, k;
int arr[MAX_N];
ll dp_l[MAX_N][MAX_K];
ll dp_r[MAX_N][MAX_K];
void solve() {
scanf("%d%d", &n, &k);
ll ans = -LLINF;
for (int i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
ans = max(ans, (ll)arr[i]);
}
if (ans <= 0) {
printf("%lld\n", ans);
return;
}
for (int i = 0; i <= k; ++i) {
dp_l[n + 1][i] = 0;
dp_r[n + 1][i] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
dp_l[i][j] = max(0ll, dp_l[i - 1][j] + arr[i - 1]);
if (j) {
dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j - 1]);
}
ans = max(ans, dp_l[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
dp_l[i][j] = dp_l[i - 1][j] + arr[i - 1];
if (j) {
dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j - 1]);
}
}
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= k; ++j) {
dp_r[i][j] = dp_r[i + 1][j] + arr[i - 1];
if (j) {
dp_r[i][j] = max(dp_r[i][j], dp_r[i + 1][j - 1]);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
if (i != 1) {
dp_l[i][j] = max(dp_l[i][j], dp_l[i - 1][j]);
}
if (j) {
dp_l[i][j] = max(dp_l[i][j], dp_l[i][j - 1]);
}
}
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= k; ++j) {
if (i != n) {
dp_r[i][j] = max(dp_r[i][j], dp_r[i + 1][j]);
}
if (j) {
dp_r[i][j] = max(dp_r[i][j], dp_r[i][j - 1]);
}
}
}
for (int i = 1; i < n; ++i) {
for (int j = 0; j <= k; ++j) {
ans = max(ans, dp_l[i][j] + dp_r[i + 1][k - j]);
}
}
printf("%lld\n", ans);
}
int main() {
#ifdef CH_EGOR
freopen("input.txt", "r", stdin);
#else
#endif
int t;
scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
Javaimport java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
MaxSum solver = new MaxSum();
int testCount = Integer.parseInt(in.next());
for (int i = 1; i <= testCount; i++)
solver.solve(i, in, out);
out.close();
}
static class MaxSum {
static final long LLINF = (1L << 60) + 5;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt();
int k = in.nextInt();
int[] arr = new int[n];
long[][] dp_l = new long[n + 2][k + 2];
long[][] dp_r = new long[n + 2][k + 2];
long ans = -LLINF;
for (int i = 0; i < n; ++i) {
arr[i] = in.nextInt();
ans = Math.max(ans, arr[i]);
}
if (ans <= 0) {
out.println(ans);
return;
}
for (int i = 0; i <= k; ++i) {
dp_l[n + 1][i] = 0;
dp_r[n + 1][i] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
dp_l[i][j] = Math.max(0L, dp_l[i - 1][j] + arr[i - 1]);
if (j != 0) {
dp_l[i][j] = Math.max(dp_l[i][j], dp_l[i - 1][j - 1]);
}
ans = Math.max(ans, dp_l[i][j]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
dp_l[i][j] = dp_l[i - 1][j] + arr[i - 1];
if (j != 0) {
dp_l[i][j] = Math.max(dp_l[i][j], dp_l[i - 1][j - 1]);
}
}
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= k; ++j) {
dp_r[i][j] = dp_r[i + 1][j] + arr[i - 1];
if (j != 0) {
dp_r[i][j] = Math.max(dp_r[i][j], dp_r[i + 1][j - 1]);
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
if (i != 1) {
dp_l[i][j] = Math.max(dp_l[i][j], dp_l[i - 1][j]);
}
if (j != 0) {
dp_l[i][j] = Math.max(dp_l[i][j], dp_l[i][j - 1]);
}
}
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= k; ++j) {
if (i != n) {
dp_r[i][j] = Math.max(dp_r[i][j], dp_r[i + 1][j]);
}
if (j != 0) {
dp_r[i][j] = Math.max(dp_r[i][j], dp_r[i][j - 1]);
}
}
}
for (int i = 1; i < n; ++i) {
for (int j = 0; j <= k; ++j) {
ans = Math.max(ans, dp_l[i][j] + dp_r[i + 1][k - j]);
}
}
out.println(ans);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(long i) {
writer.println(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new UnknownError();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new UnknownError();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new UnknownError();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String nextString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next() {
return nextString();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}