| 10740 |
Fetching from uHunt |
non-starred |
standard K-Best Shortest Paths problem |
|
0.0 |
| 10989 |
Fetching from uHunt |
non-starred |
this is the basic problem solvable with Stoer Wagner's algorithm |
|
0.0 |
| 11594 |
Fetching from uHunt |
non-starred |
use Gomory-Hu tree |
|
0.0 |
| 11603 |
Fetching from uHunt |
non-starred |
get the maximum spanning tree of the input table; then check if its all pairs maximum flow equals to the input table |
|
0.0 |
| 10071 |
Fetching from uHunt |
1.4a, I/O + Sequences Only |
super simple: output 2*v*t |
|
0.0 |
| 11614 |
Fetching from uHunt |
1.4a, I/O + Sequences Only |
root of a quadratic equation |
|
0.0 |
| 11805 |
Fetching from uHunt |
1.4a, I/O + Sequences Only |
very simple O(1) formula exists |
|
0.0 |
| 12478 |
Fetching from uHunt |
1.4a, I/O + Sequences Only |
try one of the eight names |
|
0.0 |
| 13025 |
Fetching from uHunt |
1.4a, I/O + Sequences Only |
giveaway, just print the one-line answer |
|
0.0 |
| 01124 |
Fetching from uHunt |
1.4b, Repetition Only |
LA 2681 - SouthEasternEurope06; just echo/re-print the input again |
|
0.0 |
| 10055 |
Fetching from uHunt |
1.4b, Repetition Only |
absolute function; the only trap is to use long long |
|
0.0 |
| 11044 |
Fetching from uHunt |
1.4b, Repetition Only |
one liner code/formula exists |
|
0.0 |
| 11547 |
Fetching from uHunt |
1.4b, Repetition Only |
a one liner O(1) solution exists |
|
0.0 |
| 00621 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
case analysis for only 4 possible outputs |
|
0.0 |
| 11172 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
very easy; one liner |
|
0.0 |
| 11723 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
simple math |
|
0.0 |
| 11727 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
sort the 3 numbers and get the median |
|
0.0 |
| 12250 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
LA 4995 - KualaLumpur10; if-else |
|
0.0 |
| 12289 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
just use if-else statements |
|
0.0 |
| 12372 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
just check if all L, W, H ≤ 20 |
|
0.0 |
| 12468 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
easy; there are only 4 possibilities |
|
0.0 |
| 12577 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
straightforward |
|
0.0 |
| 12646 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
simply enumerate all cases |
|
0.0 |
| 12917 |
Fetching from uHunt |
1.4d, Multiple TC + Selection |
simple O(1) check |
|
0.0 |
| 00272 |
Fetching from uHunt |
1.4e, Control Flow |
replace all double quotes to TeX style quotes |
|
0.0 |
| 10300 |
Fetching from uHunt |
1.4e, Control Flow |
ignore the number of animals |
|
0.0 |
| 11364 |
Fetching from uHunt |
1.4e, Control Flow |
linear scan to get l and r; answer = 2*(r-l) |
|
0.0 |
| 11498 |
Fetching from uHunt |
1.4e, Control Flow |
just use if-else statements |
|
0.0 |
| 11764 |
Fetching from uHunt |
1.4e, Control Flow |
one linear scan to count high low jumps |
|
0.0 |
| 11799 |
Fetching from uHunt |
1.4e, Control Flow |
one linear scan; find max value |
|
0.0 |
| 12279 |
Fetching from uHunt |
1.4e, Control Flow |
simple linear scan |
|
0.0 |
| 12403 |
Fetching from uHunt |
1.4e, Control Flow |
straightforward |
|
0.0 |
| 13012 |
Fetching from uHunt |
1.4e, Control Flow |
giveaway |
|
0.0 |
| 13034 |
Fetching from uHunt |
1.4e, Control Flow |
giveaway, simple loop 13 times |
|
0.0 |
| 13130 |
Fetching from uHunt |
1.4e, Control Flow |
simple |
|
0.0 |
| 01709 |
Fetching from uHunt |
1.4f, Function |
LA 7150 - WorldFinals Marrakech15; linear scan; probably one of the easiest WorldFinals problem; also available at Kattis - artichoke |
|
0.0 |
| 10424 |
Fetching from uHunt |
1.4f, Function |
just do as asked |
|
0.0 |
| 10550 |
Fetching from uHunt |
1.4f, Function |
simple; do as asked; also available at Kattis - combinationlock |
|
0.0 |
| 11078 |
Fetching from uHunt |
1.4f, Function |
one linear scan; max function |
|
0.0 |
| 11332 |
Fetching from uHunt |
1.4f, Function |
simple recursion |
|
0.0 |
| 11687 |
Fetching from uHunt |
1.4f, Function |
direct simulation; also available at Kattis - digits |
|
0.0 |
| 01585 |
Fetching from uHunt |
1.4g, 1D Array, Easier |
LA 3354 - Seoul05; very easy one pass algorithm |
|
0.0 |
| 11679 |
Fetching from uHunt |
1.4g, 1D Array, Easier |
simulate; see if all banks have ≥ 0 reserve |
|
0.0 |
| 11942 |
Fetching from uHunt |
1.4g, 1D Array, Easier |
check if input is sorted |
|
0.0 |
| 12015 |
Fetching from uHunt |
1.4g, 1D Array, Easier |
traverse the list twice |
|
0.0 |
| 01641 |
Fetching from uHunt |
1.4h, Easy |
scan row by row; flip the status of inside/outside polygon due to the presence of character slash or backslash |
|
0.0 |
| 10963 |
Fetching from uHunt |
1.4h, Easy |
for two blocks to be merge-able, the gaps between their columns must be the same |
|
0.0 |
| 12503 |
Fetching from uHunt |
1.4h, Easy |
easy simulation |
|
0.0 |
| 12554 |
Fetching from uHunt |
1.4h, Easy |
easy simulation |
|
0.0 |
| 12658 |
Fetching from uHunt |
1.4h, Easy |
character recognition check |
|
0.0 |
| 12696 |
Fetching from uHunt |
1.4h, Easy |
LA 6608 - Phuket 2013; easy problem |
|
0.0 |
| 12750 |
Fetching from uHunt |
1.4h, Easy |
simply loop through the given dataset in O(n) and output the answer |
|
0.0 |
| 12798 |
Fetching from uHunt |
1.4h, Easy |
simply loop through the given dataset in O(N*M) and output the answer |
|
0.0 |
| 10114 |
Fetching from uHunt |
1.4i, Still Easy |
just simulate the process |
|
0.0 |
| 10141 |
Fetching from uHunt |
1.4i, Still Easy |
solvable with one linear scan |
|
0.0 |
| 10324 |
Fetching from uHunt |
1.4i, Still Easy |
simplify using 1D array: change counter |
|
0.0 |
| 10919 |
Fetching from uHunt |
1.4i, Still Easy |
process the requirements as the input is read; also available at Kattis - prerequisites |
|
0.0 |
| 11559 |
Fetching from uHunt |
1.4i, Still Easy |
one linear pass |
|
0.0 |
| 11586 |
Fetching from uHunt |
1.4i, Still Easy |
TLE if brute force; find the pattern |
|
0.0 |
| 11661 |
Fetching from uHunt |
1.4i, Still Easy |
linear scan |
|
0.0 |
| 11683 |
Fetching from uHunt |
1.4i, Still Easy |
one linear pass is enough |
|
0.0 |
| 11786 |
Fetching from uHunt |
1.4i, Still Easy |
need to observe the pattern |
|
0.0 |
| 12614 |
Fetching from uHunt |
1.4i, Still Easy |
this problem has nice bitmask story camouflage; the final solution--after some thought--is very easy |
|
0.0 |
| 13007 |
Fetching from uHunt |
1.4i, Still Easy |
simple simulation |
|
0.0 |
| 00119 |
Fetching from uHunt |
1.4j, Medium |
simulate the give and receive process |
|
0.0 |
| 00573 |
Fetching from uHunt |
1.4j, Medium |
simulation; several corner cases |
|
0.0 |
| 00661 |
Fetching from uHunt |
1.4j, Medium |
simulation |
|
0.0 |
| 01237 |
Fetching from uHunt |
1.4j, Medium |
LA 4142 - Jakarta08; input is small |
|
0.0 |
| 11507 |
Fetching from uHunt |
1.4j, Medium |
simulation; if-else |
|
0.0 |
| 11956 |
Fetching from uHunt |
1.4j, Medium |
simulation; ignore '.' |
|
0.0 |
| 12157 |
Fetching from uHunt |
1.4j, Medium |
LA 4405 - KualaLumpur08; compute and compare the two plans |
|
0.0 |
| 12545 |
Fetching from uHunt |
1.4j, Medium |
analyzing patterns; not that hard; also available at Kattis - bitsequalizer |
|
0.0 |
| 12643 |
Fetching from uHunt |
1.4j, Medium |
it has tricky test cases |
|
0.0 |
| 00162 |
Fetching from uHunt |
1.6a, Game (Card) |
card game simulation; straightforward |
|
0.0 |
| 00462 |
Fetching from uHunt |
1.6a, Game (Card) |
simulation; card |
|
0.0 |
| 00555 |
Fetching from uHunt |
1.6a, Game (Card) |
card game |
|
0.0 |
| 10205 |
Fetching from uHunt |
1.6a, Game (Card) |
card game |
|
0.0 |
| 10315 |
Fetching from uHunt |
1.6a, Game (Card) |
tedious problem |
|
0.0 |
| 10388 |
Fetching from uHunt |
1.6a, Game (Card) |
card simulation; uses random number to determine moves; need data structure to maintain the face-up and face-down cards |
|
0.0 |
| 10646 |
Fetching from uHunt |
1.6a, Game (Card) |
shuffle cards with some rules and then get a certain card |
|
0.0 |
| 11225 |
Fetching from uHunt |
1.6a, Game (Card) |
card game |
|
0.0 |
| 11678 |
Fetching from uHunt |
1.6a, Game (Card) |
just an array manipulation problem |
|
0.0 |
| 12247 |
Fetching from uHunt |
1.6a, Game (Card) |
This is a starred problem; refer to CP3/4 book |
|
0.0 |
| 12366 |
Fetching from uHunt |
1.6a, Game (Card) |
set and pair checks; various corner cases; but the given sample I/O is quite thorough |
|
0.0 |
| 12952 |
Fetching from uHunt |
1.6a, Game (Card) |
returning the max of (A, B) is always the best strategy for this problem |
|
0.0 |
| 00255 |
Fetching from uHunt |
1.6b, Game (Chess) |
check the validity of chess moves |
|
0.0 |
| 00278 |
Fetching from uHunt |
1.6b, Game (Chess) |
basic chess knowledge is needed; derive the closed form formulas |
|
0.0 |
| 00696 |
Fetching from uHunt |
1.6b, Game (Chess) |
ad hoc; chess |
|
0.0 |
| 10196 |
Fetching from uHunt |
1.6b, Game (Chess) |
ad hoc; chess; tedious |
|
0.0 |
| 10284 |
Fetching from uHunt |
1.6b, Game (Chess) |
FEN = Forsyth-Edwards Notation is a standard notation for describing board positions in a chess game |
|
0.0 |
| 10849 |
Fetching from uHunt |
1.6b, Game (Chess) |
chess |
|
0.0 |
| 11494 |
Fetching from uHunt |
1.6b, Game (Chess) |
ad hoc;chess |
|
0.0 |
| 00340 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
determine strong and weak matches |
|
0.0 |
| 00489 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
just do as asked |
|
0.0 |
| 00947 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
similar to UVa 340 |
|
0.0 |
| 10189 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
simulate the classic Minesweeper game; similar to UVa 10279 |
|
0.0 |
| 10279 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
a 2D array helps; similar to UVa 10189 |
|
0.0 |
| 10409 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
just simulate the die movement |
|
0.0 |
| 10530 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
use a 1D flag array; also available at Kattis - guessinggame |
|
0.0 |
| 11459 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
simulate it; similar to UVa 647 |
|
0.0 |
| 12239 |
Fetching from uHunt |
1.6c, Game (Others), Easier |
try all 90^2 pairs; see if all numbers in [0..N] are there |
|
0.0 |
| 00114 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
simulation of pinball machine |
|
0.0 |
| 00141 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
solvable with one linear scan |
|
0.0 |
| 00220 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
follow the game rules; a bit tedious |
|
0.0 |
| 00227 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
parse the input; array manipulation |
|
0.0 |
| 00232 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
complex array manipulation problem |
|
0.0 |
| 00339 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
follow problem description |
|
0.0 |
| 00379 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
follow problem description |
|
0.0 |
| 00584 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
simulation; games; reading comprehension |
|
0.0 |
| 00647 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
childhood board game; also see UVa 11459 |
|
0.0 |
| 10363 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
check validity of Tic Tac Toe game; tricky; also available at Kattis - tictactoe2 |
|
0.0 |
| 10443 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
2D arrays manipulation; also available at Kattis - rockscissorspaper |
|
0.0 |
| 10813 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
follow the problem description |
|
0.0 |
| 10903 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
count wins and losses; output win average; also available at Kattis - rockpaperscissors |
|
0.0 |
| 11013 |
Fetching from uHunt |
1.6d, Game (Others), Harder |
check permutations of 5 cards to determine the best run; brute force the 6th card and replace one of your card with it |
|
0.0 |
| 00362 |
Fetching from uHunt |
1.6e, Real Life, Easier |
typical file download situation |
|
0.0 |
| 00637 |
Fetching from uHunt |
1.6e, Real Life, Easier |
application in printer driver software |
|
0.0 |
| 01586 |
Fetching from uHunt |
1.6e, Real Life, Easier |
LA 3900 - Seoul07; basic Chemistry |
|
0.0 |
| 10082 |
Fetching from uHunt |
1.6e, Real Life, Easier |
use 2D mapper array to simplify the problem; also available at Kattis - wertyu |
|
0.0 |
| 10554 |
Fetching from uHunt |
1.6e, Real Life, Easier |
are you concerned with your weights? |
|
0.0 |
| 11530 |
Fetching from uHunt |
1.6e, Real Life, Easier |
handphone users encounter this issue in the past |
|
0.0 |
| 11744 |
Fetching from uHunt |
1.6e, Real Life, Easier |
this is another topic on Computer Organization; this time on Digital Logic design |
|
0.0 |
| 11945 |
Fetching from uHunt |
1.6e, Real Life, Easier |
a bit of output formatting |
|
0.0 |
| 11984 |
Fetching from uHunt |
1.6e, Real Life, Easier |
F to C conversion and vice versa |
|
0.0 |
| 12195 |
Fetching from uHunt |
1.6e, Real Life, Easier |
count the number of correct measures |
|
0.0 |
| 12808 |
Fetching from uHunt |
1.6e, Real Life, Easier |
basic Physics formula for freefall is H = 1/2*g*t*t or t = sqrt(2*H/g) and the formula for displacement is X = V*t; they are not given in the problem description |
|
0.0 |
| 13151 |
Fetching from uHunt |
1.6e, Real Life, Easier |
marking programming exam; ad hoc; straightforward |
|
0.0 |
| 00161 |
Fetching from uHunt |
1.6f, Real Life, Medium |
this is a typical situation on the road |
|
0.0 |
| 00187 |
Fetching from uHunt |
1.6f, Real Life, Medium |
an accounting problem |
|
0.0 |
| 00447 |
Fetching from uHunt |
1.6f, Real Life, Medium |
life simulation model |
|
0.0 |
| 00457 |
Fetching from uHunt |
1.6f, Real Life, Medium |
simplified game of life simulation; similar idea with UVa 00447; explore the Internet for that term |
|
0.0 |
| 00857 |
Fetching from uHunt |
1.6f, Real Life, Medium |
MIDI; application in computer music |
|
0.0 |
| 10191 |
Fetching from uHunt |
1.6f, Real Life, Medium |
you may want to apply this to your own schedule |
|
0.0 |
| 10528 |
Fetching from uHunt |
1.6f, Real Life, Medium |
music knowledge in problem description |
|
0.0 |
| 10812 |
Fetching from uHunt |
1.6f, Real Life, Medium |
be careful with boundary cases! |
|
0.0 |
| 11736 |
Fetching from uHunt |
1.6f, Real Life, Medium |
this is a (simplified) introduction to Computer Organization on how computer stores data in memory |
|
0.0 |
| 11743 |
Fetching from uHunt |
1.6f, Real Life, Medium |
Luhn's algorithm to check credit card numbers; search the Internet to learn more |
|
0.0 |
| 12555 |
Fetching from uHunt |
1.6f, Real Life, Medium |
one of the first question asked when a new baby is born; requires a bit of input processing |
|
0.0 |
| 00139 |
Fetching from uHunt |
1.6g, Real Life, Harder |
calculate phone bill; string manipulation |
|
0.0 |
| 00145 |
Fetching from uHunt |
1.6g, Real Life, Harder |
similar to UVa 00139 |
|
0.0 |
| 00333 |
Fetching from uHunt |
1.6g, Real Life, Harder |
this problem has buggy test data with blank lines that potentially cause lots of Presentation Errors |
|
0.0 |
| 00346 |
Fetching from uHunt |
1.6g, Real Life, Harder |
musical chord; major/minor |
|
0.0 |
| 00403 |
Fetching from uHunt |
1.6g, Real Life, Harder |
emulation of printer driver; tedious |
|
0.0 |
| 00448 |
Fetching from uHunt |
1.6g, Real Life, Harder |
tedious hexadecimal to assembly language conversion |
|
0.0 |
| 00449 |
Fetching from uHunt |
1.6g, Real Life, Harder |
easier if you have a musical background |
|
0.0 |
| 00538 |
Fetching from uHunt |
1.6g, Real Life, Harder |
the problem's premise is quite true |
|
0.0 |
| 00706 |
Fetching from uHunt |
1.6g, Real Life, Harder |
like in old digital display |
|
0.0 |
| 01061 |
Fetching from uHunt |
1.6g, Real Life, Harder |
LA 3736 - WorldFinals Tokyo07; try all eight possible blood + Rh types with the information given |
|
0.0 |
| 01091 |
Fetching from uHunt |
1.6g, Real Life, Harder |
LA 4786 - WorldFinals Harbin10; tedious simulation and reading comprehension |
|
0.0 |
| 10415 |
Fetching from uHunt |
1.6g, Real Life, Harder |
about musical instruments; also available at Kattis - saxophone |
|
0.0 |
| 10659 |
Fetching from uHunt |
1.6g, Real Life, Harder |
typical presentation programs do this |
|
0.0 |
| 11223 |
Fetching from uHunt |
1.6g, Real Life, Harder |
tedious morse code conversion |
|
0.0 |
| 11279 |
Fetching from uHunt |
1.6g, Real Life, Harder |
an extension of UVa 11278 problem; it is interesting to compare QWERTY and DVORAK keyboard layout |
|
0.0 |
| 12342 |
Fetching from uHunt |
1.6g, Real Life, Harder |
tax computation can be tricky indeed |
|
0.0 |
| 12394 |
Fetching from uHunt |
1.6g, Real Life, Harder |
interesting problem with real life back story; be careful of various corner cases |
|
0.0 |
| 00579 |
Fetching from uHunt |
1.6h, Time, Easier |
be careful with corner cases |
|
0.0 |
| 00893 |
Fetching from uHunt |
1.6h, Time, Easier |
use Java GregorianCalendar; similar to UVa 11356 |
|
0.0 |
| 10683 |
Fetching from uHunt |
1.6h, Time, Easier |
simple clock system conversion |
|
0.0 |
| 11219 |
Fetching from uHunt |
1.6h, Time, Easier |
be careful with boundary cases! |
|
0.0 |
| 11356 |
Fetching from uHunt |
1.6h, Time, Easier |
very easy if you use Java GregorianCalendar |
|
0.0 |
| 11650 |
Fetching from uHunt |
1.6h, Time, Easier |
some mathematics required; similar to UVa 11677 |
|
0.0 |
| 11677 |
Fetching from uHunt |
1.6h, Time, Easier |
similar idea with UVa 11650 |
|
0.0 |
| 11958 |
Fetching from uHunt |
1.6h, Time, Easier |
be careful with 'past midnight' |
|
0.0 |
| 12019 |
Fetching from uHunt |
1.6h, Time, Easier |
Gregorian Calendar; get DAY_OF_WEEK |
|
0.0 |
| 12136 |
Fetching from uHunt |
1.6h, Time, Easier |
LA 4202 - Dhaka08; check time |
|
0.0 |
| 12148 |
Fetching from uHunt |
1.6h, Time, Easier |
easy with Gregorian Calendar; use method 'add' to add one day to previous date and see if it is the same as the current date |
|
0.0 |
| 12531 |
Fetching from uHunt |
1.6h, Time, Easier |
angles between two clock hands |
|
0.0 |
| 13275 |
Fetching from uHunt |
1.6h, Time, Easier |
QY-Y (if not 29 Feb) or NumOfLeapYears(QY)-NumOfLeapYears(Y) otherwise |
|
0.0 |
| 00150 |
Fetching from uHunt |
1.6i, Time, Harder |
convert between Julian and Gregorian dates |
|
0.0 |
| 00158 |
Fetching from uHunt |
1.6i, Time, Harder |
a simulation of calendar manager; it requires sorting and a bit of string processing |
|
0.0 |
| 00170 |
Fetching from uHunt |
1.6i, Time, Harder |
simulation; time |
|
0.0 |
| 00300 |
Fetching from uHunt |
1.6i, Time, Harder |
ad hoc; time |
|
0.0 |
| 00602 |
Fetching from uHunt |
1.6i, Time, Harder |
Gregorian versus Julian calendar |
|
0.0 |
| 10070 |
Fetching from uHunt |
1.6i, Time, Harder |
more than ordinary leap years |
|
0.0 |
| 10339 |
Fetching from uHunt |
1.6i, Time, Harder |
find the formula |
|
0.0 |
| 10371 |
Fetching from uHunt |
1.6i, Time, Harder |
follow the description, tedious; also available at Kattis - timezones |
|
0.0 |
| 10942 |
Fetching from uHunt |
1.6i, Time, Harder |
try all 3! = 6 permutations of 3 integers to form YY MM DD; check validity of the date; pick the earliest valid date |
|
0.0 |
| 11947 |
Fetching from uHunt |
1.6i, Time, Harder |
easier with Java GregorianCalendar |
|
0.0 |
| 12439 |
Fetching from uHunt |
1.6i, Time, Harder |
inclusion-exclusion; lots of corner cases; be careful |
|
0.0 |
| 12822 |
Fetching from uHunt |
1.6i, Time, Harder |
convert hh:mm:ss to second to simplify the problem; then this is just a tedious simulation problem |
|
0.0 |
| 00185 |
Fetching from uHunt |
1.6j, Roman Numerals |
also involving backtracking |
|
0.0 |
| 00344 |
Fetching from uHunt |
1.6j, Roman Numerals |
count Roman chars used in [1..N] |
|
0.0 |
| 00759 |
Fetching from uHunt |
1.6j, Roman Numerals |
validation problem |
|
0.0 |
| 11616 |
Fetching from uHunt |
1.6j, Roman Numerals |
Roman numeral conversion problem |
|
0.0 |
| 12397 |
Fetching from uHunt |
1.6j, Roman Numerals |
each Roman digit has a value |
|
0.0 |
| 00444 |
Fetching from uHunt |
1.6k, Cipher, Easier |
each char is mapped to 2 or 3 digits |
|
0.0 |
| 00458 |
Fetching from uHunt |
1.6k, Cipher, Easier |
shift ASCII values by -7 |
|
0.0 |
| 00641 |
Fetching from uHunt |
1.6k, Cipher, Easier |
reverse the given formula and simulate |
|
0.0 |
| 00795 |
Fetching from uHunt |
1.6k, Cipher, Easier |
prepare an 'inverse mapper' |
|
0.0 |
| 00865 |
Fetching from uHunt |
1.6k, Cipher, Easier |
simple character substitution mapping |
|
0.0 |
| 01339 |
Fetching from uHunt |
1.6k, Cipher, Easier |
count character frequencies of both strings; sort and compare |
|
0.0 |
| 10019 |
Fetching from uHunt |
1.6k, Cipher, Easier |
find the pattern |
|
0.0 |
| 10222 |
Fetching from uHunt |
1.6k, Cipher, Easier |
simple decoding mechanism |
|
0.0 |
| 10851 |
Fetching from uHunt |
1.6k, Cipher, Easier |
ignore border; treat '\/' as 1/0 |
|
0.0 |
| 10878 |
Fetching from uHunt |
1.6k, Cipher, Easier |
treat space/'o' as 0/1; then it is binary to decimal conversion |
|
0.0 |
| 10896 |
Fetching from uHunt |
1.6k, Cipher, Easier |
try all possible keys; use tokenizer |
|
0.0 |
| 10921 |
Fetching from uHunt |
1.6k, Cipher, Easier |
simple conversion problem |
|
0.0 |
| 11220 |
Fetching from uHunt |
1.6k, Cipher, Easier |
follow instruction in the problem |
|
0.0 |
| 11278 |
Fetching from uHunt |
1.6k, Cipher, Easier |
map QWERTY keys to DVORAK |
|
0.0 |
| 11541 |
Fetching from uHunt |
1.6k, Cipher, Easier |
read char by char and simulate |
|
0.0 |
| 11946 |
Fetching from uHunt |
1.6k, Cipher, Easier |
ad hoc |
|
0.0 |
| 12896 |
Fetching from uHunt |
1.6k, Cipher, Easier |
simple cipher; use mapper |
|
0.0 |
| 13107 |
Fetching from uHunt |
1.6k, Cipher, Easier |
simple encode; be careful with 20-26 |
|
0.0 |
| 13145 |
Fetching from uHunt |
1.6k, Cipher, Easier |
shift alphabet values by +6 characters to read the problem statement; simple Caesar Cipher problem |
|
0.0 |
| 00245 |
Fetching from uHunt |
1.6l, Cipher, Medium |
LA 5184 - WorldFinals Nashville95 |
|
0.0 |
| 00483 |
Fetching from uHunt |
1.6l, Cipher, Medium |
read char by char from left to right |
|
0.0 |
| 00492 |
Fetching from uHunt |
1.6l, Cipher, Medium |
ad hoc; similar to UVa 483 |
|
0.0 |
| 00632 |
Fetching from uHunt |
1.6l, Cipher, Medium |
simulate the process; use sorting |
|
0.0 |
| 00739 |
Fetching from uHunt |
1.6l, Cipher, Medium |
straightforward conversion problem |
|
0.0 |
| 00740 |
Fetching from uHunt |
1.6l, Cipher, Medium |
just simulate the process |
|
0.0 |
| 11716 |
Fetching from uHunt |
1.6l, Cipher, Medium |
simple cipher |
|
0.0 |
| 11787 |
Fetching from uHunt |
1.6l, Cipher, Medium |
follow the description |
|
0.0 |
| 00271 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
grammar check; linear scan |
|
0.0 |
| 00327 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
implementation can be tricky |
|
0.0 |
| 00391 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
use flags; tedious parsing |
|
0.0 |
| 00397 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
iteratively perform the next operation |
|
0.0 |
| 00442 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
properties of matrix chain multiplication |
|
0.0 |
| 00486 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
parsing |
|
0.0 |
| 00537 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
simple formula; parsing is difficult |
|
0.0 |
| 01200 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
LA 2972 - Tehran03; tokenize input |
|
0.0 |
| 10252 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
A-Z keys |
|
0.0 |
| 10906 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
BNF parsing; iterative solution |
|
0.0 |
| 11148 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
extract integers; simple/mixed fractions from a line; a bit of gcd |
|
0.0 |
| 11878 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
expression parsing |
|
0.0 |
| 12543 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
LA 6150 - HatYai12; iterative parser |
|
0.0 |
| 12820 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
count letter frequencies; let n be the number of different letter frequencies; n has to be greater or equal to 2; then we sort the frequencies and check if we have [1..n-1] |
|
0.0 |
| 13047 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
simple parsing; left-to-right or right-to-left checks |
|
0.0 |
| 13093 |
Fetching from uHunt |
1.6m, Input Parsing (Iterative) |
simple string tokenize; take first characters of each word |
|
0.0 |
| 00110 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
actually an ad hoc sorting problem |
|
0.0 |
| 00320 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
requires flood fill technique |
|
0.0 |
| 00445 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
simulation; output formatting |
|
0.0 |
| 00488 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
use several loops |
|
0.0 |
| 00490 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
2d array manipulation; output formatting |
|
0.0 |
| 01605 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
LA 4044 - NortheasternEurope07; we can answer this problem with just h=2 levels |
|
0.0 |
| 10146 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
the problem description tries to hide the meaning of 'dictionary'; it is not a hard problem actually |
|
0.0 |
| 10500 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
simulate; output formatting |
|
0.0 |
| 10894 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
how fast can you can solve this problem? |
|
0.0 |
| 11074 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
output formatting |
|
0.0 |
| 11482 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
tedious |
|
0.0 |
| 11965 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
replace consecutive spaces with only one space |
|
0.0 |
| 12364 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
2D array check; check all possible digits [0..9] |
|
0.0 |
| 13091 |
Fetching from uHunt |
1.6n, Output Formatting, Easier |
just output formatting |
|
0.0 |
| 00144 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation |
|
0.0 |
| 00214 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
just simulate the process; be careful with subtract (-); divide (/); and negate (@); tedious |
|
0.0 |
| 00335 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation |
|
0.0 |
| 00349 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation |
|
0.0 |
| 00556 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation |
|
0.0 |
| 01721 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
LA 7162 - WorldFinals Marrakech15; tedious simulation problem; also available at Kattis - windows |
|
0.0 |
| 10028 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
tedious simulation with several corner cases |
|
0.0 |
| 10033 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
adhoc; simulation |
|
0.0 |
| 10134 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
must be very careful with details |
|
0.0 |
| 10281 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
distance = speed*time elapsed; also available at Kattis - averagespeed |
|
0.0 |
| 10850 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
gossip spread simulation |
|
0.0 |
| 11638 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation; needs to use bitmask for parameter C |
|
0.0 |
| 12060 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
LA 3012 - Dhaka04; output format |
|
0.0 |
| 12085 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
LA 2189 - Dhaka06; watch out for PE |
|
0.0 |
| 12608 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
simulation with several corner cases |
|
0.0 |
| 12700 |
Fetching from uHunt |
1.6o, Time Waster, Easier |
just do as instructed |
|
0.0 |
| 00337 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation; output related |
|
0.0 |
| 00381 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 00405 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 00603 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 00618 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
tedious |
|
0.0 |
| 00830 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
very hard to get AC; one minor error = WA; not recommended |
|
0.0 |
| 00945 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulate the given cargo loading process |
|
0.0 |
| 10142 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 10188 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 10267 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
simulation |
|
0.0 |
| 10961 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
tedious simulation |
|
0.0 |
| 11140 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
ad hoc |
|
0.0 |
| 11717 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
tricky simulation |
|
0.0 |
| 12280 |
Fetching from uHunt |
1.6p, Time Waster, Harder |
a tedious problem |
|
0.0 |
| 00414 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
get the longest stretch of Bs |
|
0.0 |
| 00482 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
you may need to use a string tokenizer as the size of the array is not specified |
|
0.0 |
| 00591 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
sum all items; get the average; sum the total absolute differences of each item from the average divided by two |
|
0.0 |
| 10038 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
1D Boolean flags to check [1..n-1]; also available at Kattis - jollyjumpers |
|
0.0 |
| 10050 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
1D boolean flag |
|
0.0 |
| 11192 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
character array |
|
0.0 |
| 11496 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
store data in 1D array; count the peaks |
|
0.0 |
| 11608 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
use three arrays: created; required; available |
|
0.0 |
| 11875 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
get median of a sorted input |
|
0.0 |
| 12150 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
simple manipulation |
|
0.0 |
| 12356 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
similar to deletion in doubly linked lists but we can still use a 1D array for the underlying data structure |
|
0.0 |
| 12854 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
1D array of size 5; trivial |
|
0.0 |
| 12959 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
just go through the 1D array |
|
0.0 |
| 12996 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
we need 1D array to store the number of N mango types first |
|
0.0 |
| 13026 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
you have to store the N strings in an array first |
|
0.0 |
| 13181 |
Fetching from uHunt |
2.2a, 1D Array, Medium |
find the largest gap between two Xs; special corner cases at the two end points |
|
0.0 |
| 00230 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
string parsing; maintain sorted books by author names then by title; the input size is small; we do not need balanced BST |
|
0.0 |
| 00394 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
any n-dimensional array is stored in computer memory as a single dimensional array; follow the problem description |
|
0.0 |
| 00467 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
linear scan; 1D boolean flag |
|
0.0 |
| 00665 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
use 1D boolean flags; each =; <; or > tells us an information; check if there is only one candidate false coin left at the end |
|
0.0 |
| 00946 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
just 1D array manipulation; be careful with the special restriction |
|
0.0 |
| 10978 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
1D string array |
|
0.0 |
| 11093 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
linear scan; circular array; a bit challenging |
|
0.0 |
| 11222 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
use several 1D arrays |
|
0.0 |
| 11850 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
for each integer location from 0 to 1322; can Brenda reach (anywhere within 200 miles of) any charging stations? |
|
0.0 |
| 12662 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
1D array manipulation; brute force |
|
0.0 |
| 13048 |
Fetching from uHunt |
2.2b, 1D Array, Harder |
use 1D Boolean array; simulate |
|
0.0 |
| 00541 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
count the number of 1s for each row/col; which must be even; if there is an error; see if the odd number of 1s appear on the same row and col |
|
0.0 |
| 00585 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
recursive grammar check and output formatting |
|
0.0 |
| 10703 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
use 2D boolean array of size 500*500 |
|
0.0 |
| 10920 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
simulate the process |
|
0.0 |
| 11040 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
non trivial 2D array manipulation |
|
0.0 |
| 11349 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
use long long to avoid issues |
|
0.0 |
| 11581 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
simulate the process |
|
0.0 |
| 11835 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
do as asked |
|
0.0 |
| 12187 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
simulate the process |
|
0.0 |
| 12667 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
use both 1D and 2D arrays to store submission status |
|
0.0 |
| 12981 |
Fetching from uHunt |
2.2c, 2D Array, Easier |
small 2x2 matrix rotation |
|
0.0 |
| 00101 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
stack-like simulation; but we need to access the content of each stack too; so it is better to use 2D array |
|
0.0 |
| 00434 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
a kind of visibility problem in geometry; solvable with using 2D array manipulation |
|
0.0 |
| 00466 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
core functions: rotate and reflect |
|
0.0 |
| 00512 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
apply all rows/columns modifications in descending order; for each query; report the new position of the cell or report GONE |
|
0.0 |
| 00707 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
this requires 3D array; but as there is no such category; it is classified here |
|
0.0 |
| 10016 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
tedious |
|
0.0 |
| 10855 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
string array; 90 degrees clockwise rotation |
|
0.0 |
| 11360 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
do as asked |
|
0.0 |
| 12291 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
do as asked; a bit tedious |
|
0.0 |
| 12398 |
Fetching from uHunt |
2.2d, 2D Array, Harder |
simulate backwards; do not forget to mod 10 |
|
0.0 |
| 00400 |
Fetching from uHunt |
2.2e, Sorting, Easier |
this command is very frequently used in UNIX |
|
0.0 |
| 00855 |
Fetching from uHunt |
2.2e, Sorting, Easier |
sort; median |
|
0.0 |
| 10107 |
Fetching from uHunt |
2.2e, Sorting, Easier |
find median of a growing/dynamic list of integers; we can use multiple calls of nth_element in algorithm |
|
0.0 |
| 10880 |
Fetching from uHunt |
2.2e, Sorting, Easier |
use sort |
|
0.0 |
| 10905 |
Fetching from uHunt |
2.2e, Sorting, Easier |
modified comparison function; use sort |
|
0.0 |
| 11039 |
Fetching from uHunt |
2.2e, Sorting, Easier |
use sort then count different signs |
|
0.0 |
| 11588 |
Fetching from uHunt |
2.2e, Sorting, Easier |
sort simplifies the problem |
|
0.0 |
| 11777 |
Fetching from uHunt |
2.2e, Sorting, Easier |
sort simplifies the problem |
|
0.0 |
| 11824 |
Fetching from uHunt |
2.2e, Sorting, Easier |
sort simplifies the problem |
|
0.0 |
| 12071 |
Fetching from uHunt |
2.2e, Sorting, Easier |
reading comprehension; sort the input; compute something |
|
0.0 |
| 12541 |
Fetching from uHunt |
2.2e, Sorting, Easier |
LA 6148 - HatYai12; sort; youngest + oldest |
|
0.0 |
| 12709 |
Fetching from uHunt |
2.2e, Sorting, Easier |
LA 6650 - Dhaka13; although the problem has a complicated story; it has a very easy solution with sort routine |
|
0.0 |
| 12861 |
Fetching from uHunt |
2.2e, Sorting, Easier |
sort the timezones first and try adjacent pairings (two possibilities) |
|
0.0 |
| 13113 |
Fetching from uHunt |
2.2e, Sorting, Easier |
count the votes; sort; pick the top 2 |
|
0.0 |
| 00123 |
Fetching from uHunt |
2.2f, Sorting, Harder |
modified comparison function; use sort |
|
0.0 |
| 00450 |
Fetching from uHunt |
2.2f, Sorting, Harder |
tedious sorting problem |
|
0.0 |
| 00790 |
Fetching from uHunt |
2.2f, Sorting, Harder |
multi-fields sorting; use sort; similar to UVa 10258 |
|
0.0 |
| 01610 |
Fetching from uHunt |
2.2f, Sorting, Harder |
LA 6196 - MidAtlanticUSA12; median |
|
0.0 |
| 10194 |
Fetching from uHunt |
2.2f, Sorting, Harder |
multi-fields sorting; use sort |
|
0.0 |
| 10258 |
Fetching from uHunt |
2.2f, Sorting, Harder |
multi-fields sorting; use sort; similar to UVa 00790 |
|
0.0 |
| 10698 |
Fetching from uHunt |
2.2f, Sorting, Harder |
multi-fields sorting; use sort |
|
0.0 |
| 11300 |
Fetching from uHunt |
2.2f, Sorting, Harder |
use sort; involving the median |
|
0.0 |
| 11321 |
Fetching from uHunt |
2.2f, Sorting, Harder |
be careful with negative mod! |
|
0.0 |
| 12269 |
Fetching from uHunt |
2.2f, Sorting, Harder |
sort and check if Guido covers all land (end-to-end and side-to-side); also available at Kattis - lawnmower |
|
0.0 |
| 00299 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
can use O(n^2) bubble sort |
|
0.0 |
| 00612 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
needs O(n^2) stable_sort |
|
0.0 |
| 10327 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
solvable with O(n^2) bubble sort |
|
0.0 |
| 10810 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
requires O(n log n) merge sort; also available at Kattis - ultraquicksort |
|
0.0 |
| 11462 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
standard Counting Sort problem |
|
0.0 |
| 11495 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
requires O(n log n) merge sort |
|
0.0 |
| 11858 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
requires O(n log n) merge sort; 64-bit integer; also available at Kattis - froshweek |
|
0.0 |
| 13212 |
Fetching from uHunt |
2.2g, Special Sorting Problems |
requires O(n log n) merge sort |
|
0.0 |
| 00594 |
Fetching from uHunt |
2.2h, Bit Manipulation |
manipulate bit string with bitset |
|
0.0 |
| 00700 |
Fetching from uHunt |
2.2h, Bit Manipulation |
can be solved with bitset |
|
0.0 |
| 01241 |
Fetching from uHunt |
2.2h, Bit Manipulation |
LA 4147 - Jakarta08; easy |
|
0.0 |
| 10264 |
Fetching from uHunt |
2.2h, Bit Manipulation |
heavy bitmask manipulation |
|
0.0 |
| 10469 |
Fetching from uHunt |
2.2h, Bit Manipulation |
super simple if you use xor |
|
0.0 |
| 11173 |
Fetching from uHunt |
2.2h, Bit Manipulation |
Divide and Conquer pattern or one liner bit manipulation |
|
0.0 |
| 11760 |
Fetching from uHunt |
2.2h, Bit Manipulation |
separate row col checks; use two bitsets |
|
0.0 |
| 11926 |
Fetching from uHunt |
2.2h, Bit Manipulation |
use 1M bitset to check if a slot is free |
|
0.0 |
| 11933 |
Fetching from uHunt |
2.2h, Bit Manipulation |
simple bit exercise |
|
0.0 |
| 12571 |
Fetching from uHunt |
2.2h, Bit Manipulation |
precalculate AND operations |
|
0.0 |
| 12720 |
Fetching from uHunt |
2.2h, Bit Manipulation |
observe the pattern in this binary to decimal conversion variant; involves modulo arithmetic |
|
0.0 |
| 00424 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger addition |
|
0.0 |
| 00465 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger add/multiply; compare with 2^31-1$ |
|
0.0 |
| 00619 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger |
|
0.0 |
| 00713 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger StringBuffer reverse() |
|
0.0 |
| 00748 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger exponentiation |
|
0.0 |
| 01226 |
Fetching from uHunt |
2.2i, Big Integer |
LA 3997 - Danang07; mod operation |
|
0.0 |
| 01647 |
Fetching from uHunt |
2.2i, Big Integer |
find the simple pattern first using brute force; then precompute the answers using BigInteger |
|
0.0 |
| 10013 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger addition |
|
0.0 |
| 10083 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger number theory |
|
0.0 |
| 10106 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger multiplication |
|
0.0 |
| 10198 |
Fetching from uHunt |
2.2i, Big Integer |
recurrences; BigInteger |
|
0.0 |
| 10430 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger; derive formula first |
|
0.0 |
| 10433 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger: pow; substract; mod |
|
0.0 |
| 10464 |
Fetching from uHunt |
2.2i, Big Integer |
Java BigDecimal class |
|
0.0 |
| 10494 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger division |
|
0.0 |
| 10519 |
Fetching from uHunt |
2.2i, Big Integer |
recurrences; BigInteger |
|
0.0 |
| 10523 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger addition; multiplication; and power |
|
0.0 |
| 10669 |
Fetching from uHunt |
2.2i, Big Integer |
Big Integer is for 3^n; binary rep of set; also available at Kattis - threepowers |
|
0.0 |
| 10925 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger addition and division |
|
0.0 |
| 10992 |
Fetching from uHunt |
2.2i, Big Integer |
input size is up to 50 digits |
|
0.0 |
| 11448 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger subtraction |
|
0.0 |
| 11664 |
Fetching from uHunt |
2.2i, Big Integer |
simple simulation involving BigInteger |
|
0.0 |
| 11821 |
Fetching from uHunt |
2.2i, Big Integer |
Java BigDecimal class |
|
0.0 |
| 11830 |
Fetching from uHunt |
2.2i, Big Integer |
use BigInteger string representation |
|
0.0 |
| 11879 |
Fetching from uHunt |
2.2i, Big Integer |
BigInteger: mod; divide; subtract; equals |
|
0.0 |
| 12143 |
Fetching from uHunt |
2.2i, Big Integer |
LA 4209 - Dhaka08; formula simplification---the hard part; use BigInteger---the easy part |
|
0.0 |
| 12459 |
Fetching from uHunt |
2.2i, Big Integer |
draw the ancestor tree to see the pattern |
|
0.0 |
| 12930 |
Fetching from uHunt |
2.2i, Big Integer |
Java BigDecimal class; compareTo |
|
0.0 |
| 00127 |
Fetching from uHunt |
2.2j, Stack |
shuffling stack |
|
0.0 |
| 00514 |
Fetching from uHunt |
2.2j, Stack |
use stack to simulate the process |
|
0.0 |
| 00732 |
Fetching from uHunt |
2.2j, Stack |
use stack to simulate the process |
|
0.0 |
| 01062 |
Fetching from uHunt |
2.2j, Stack |
LA 3752 - WorldFinals Tokyo07; simulation with stack; maximum answer is 26 stacks; O(n) solution exists |
|
0.0 |
| 10858 |
Fetching from uHunt |
2.2j, Stack |
use stack |
|
0.0 |
| 13055 |
Fetching from uHunt |
2.2j, Stack |
nice problem about stack |
|
0.0 |
| 00551 |
Fetching from uHunt |
2.2k, Special Stack-based Problems |
bracket matching; use stack |
|
0.0 |
| 00673 |
Fetching from uHunt |
2.2k, Special Stack-based Problems |
similar to UVa 551; classic |
|
0.0 |
| 00727 |
Fetching from uHunt |
2.2k, Special Stack-based Problems |
Infix to Postfix conversion problem |
|
0.0 |
| 11111 |
Fetching from uHunt |
2.2k, Special Stack-based Problems |
bracket matching with twists |
|
0.0 |
| 00246 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
card simulation with queue and deque |
|
0.0 |
| 00540 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
modified queue |
|
0.0 |
| 10172 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
use both queue and stack |
|
0.0 |
| 10901 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with queue; also available at Kattis - ferryloading3 |
|
0.0 |
| 10935 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with queue |
|
0.0 |
| 11034 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with queue; also available at Kattis - ferryloading4 |
|
0.0 |
| 11797 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with 5 queues |
|
0.0 |
| 11988 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
rare linked list problem |
|
0.0 |
| 12100 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with queue |
|
0.0 |
| 12108 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
simulation with N queues |
|
0.0 |
| 12207 |
Fetching from uHunt |
2.2l, List/Queue/Deque |
use both queue and deque |
|
0.0 |
| 01203 |
Fetching from uHunt |
2.3a, Priority Queue |
LA 3135 - Beijing04; use priority_queue |
|
0.0 |
| 11995 |
Fetching from uHunt |
2.3a, Priority Queue |
stack; queue; and priority_queue |
|
0.0 |
| 11997 |
Fetching from uHunt |
2.3a, Priority Queue |
sort the lists; merge two sorted lists using priority_queue to keep the K-th smallest sum every time |
|
0.0 |
| 13190 |
Fetching from uHunt |
2.3a, Priority Queue |
similar to UVa 01203; use PQ; use drug numbering id as tie-breaker |
|
0.0 |
| 00499 |
Fetching from uHunt |
2.3b, DAT, ASCII |
ASCII keys |
|
0.0 |
| 00895 |
Fetching from uHunt |
2.3b, DAT, ASCII |
get the letter frequency of each word; compare with puzzle line |
|
0.0 |
| 10008 |
Fetching from uHunt |
2.3b, DAT, ASCII |
A-Z keys |
|
0.0 |
| 10062 |
Fetching from uHunt |
2.3b, DAT, ASCII |
ASCII character frequency count |
|
0.0 |
| 10260 |
Fetching from uHunt |
2.3b, DAT, ASCII |
DAT for soundex A-Z code mapping; also available at Kattis - soundex |
|
0.0 |
| 10293 |
Fetching from uHunt |
2.3b, DAT, ASCII |
A-Z keys |
|
0.0 |
| 10625 |
Fetching from uHunt |
2.3b, DAT, ASCII |
ASCII character; frequency addition n times |
|
0.0 |
| 11340 |
Fetching from uHunt |
2.3b, DAT, ASCII |
ASCII keys |
|
0.0 |
| 11577 |
Fetching from uHunt |
2.3b, DAT, ASCII |
A-Z keys |
|
0.0 |
| 12626 |
Fetching from uHunt |
2.3b, DAT, ASCII |
A-Z keys |
|
0.0 |
| 00755 |
Fetching from uHunt |
2.3c, DAT, Others |
Direct Addressing Table; convert the letters except Q and Z to 2-9; keep 0-9 as 0-9; sort the integers; find duplicates if any |
|
0.0 |
| 01368 |
Fetching from uHunt |
2.3c, DAT, Others |
for each column j, find the highest frequency character among all j-th column of all m DNA strings |
|
0.0 |
| 11203 |
Fetching from uHunt |
2.3c, DAT, Others |
count frequency of x/y/z |
|
0.0 |
| 12650 |
Fetching from uHunt |
2.3c, DAT, Others |
use 1D Boolean array for each person |
|
0.0 |
| 10887 |
Fetching from uHunt |
2.3d, Hash Table (set) |
Use O(M*N*log(MN)*10) algorithm; concatenate all pairs of strings; put them in a set; report set size |
|
0.0 |
| 11849 |
Fetching from uHunt |
2.3d, Hash Table (set) |
unordered_set is faster than set here; or use modified merge as the input is sorted; also available at Kattis - cd |
|
0.0 |
| 12049 |
Fetching from uHunt |
2.3d, Hash Table (set) |
unordered_multiset manipulation |
|
0.0 |
| 13148 |
Fetching from uHunt |
2.3d, Hash Table (set) |
we can store all precomputed answers - which are given - into unordered_set |
|
0.0 |
| 00484 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
maintain frequency with map |
|
0.0 |
| 00860 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
frequency counting |
|
0.0 |
| 00902 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
read char by char; count word freq |
|
0.0 |
| 10282 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
a pure dictionary problem; use unordered_map; also available at Kattis - babelfish |
|
0.0 |
| 10295 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use unordered_map to deal with Hay Points dictionary; also available at Kattis - haypoints |
|
0.0 |
| 10374 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use unordered_map for frequency counting |
|
0.0 |
| 10686 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use map to manage the data |
|
0.0 |
| 11286 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use unordered_map to count frequencies of the sorted permutations of 5 ids; also available at Kattis - conformity |
|
0.0 |
| 11348 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use map and set to check uniqueness |
|
0.0 |
| 11629 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use map |
|
0.0 |
| 12592 |
Fetching from uHunt |
2.3e, Hash Table (map), Easier |
use map; string to string |
|
0.0 |
| 00417 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
generate all words; add to map for auto sorting |
|
0.0 |
| 10132 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
use map; brute force |
|
0.0 |
| 10145 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
use map and set |
|
0.0 |
| 11572 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
use unordered_map to record the occurrence index of a certain snowflake size; use this to determine the answer in linear time; also available at Kattis - snowflakes |
|
0.0 |
| 11860 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
use set and map; linear scan |
|
0.0 |
| 11917 |
Fetching from uHunt |
2.3f, Hash Table (map), Harder |
use map |
|
0.0 |
| 00501 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
use multiset with efficient iterator manipulation |
|
0.0 |
| 00978 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
simulation; use multiset |
|
0.0 |
| 10815 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
use set and string |
|
0.0 |
| 11062 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
similar to UVa 10815 with twists |
|
0.0 |
| 11136 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
use multiset |
|
0.0 |
| 13037 |
Fetching from uHunt |
2.3g, Balanced BST (set) |
we can use set or a sorted array |
|
0.0 |
| 00939 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
map child name to his/her gene and parents' names |
|
0.0 |
| 10138 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
map plates to bills; entrance time; and position |
|
0.0 |
| 10226 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
use map; sorted output; also available at Kattis - hardwoodspecies |
|
0.0 |
| 10420 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
word frequency counting; use map |
|
0.0 |
| 11239 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
use map and set to check previous strings; order needed; also available at Kattis - opensource |
|
0.0 |
| 11308 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
use map and set |
|
0.0 |
| 12504 |
Fetching from uHunt |
2.3h, Balanced BST (map) |
use map; string to string |
|
0.0 |
| 10909 |
Fetching from uHunt |
2.3i, Order Statistics Tree |
involves dynamic selection; use pb\_ds, Fenwick Tree, or augment balanced BST |
|
0.0 |
| 00599 |
Fetching from uHunt |
2.4a, Graph Data Structures |
V-E = number of CCs; use a bitset of size 26 to count the number of vertices that have some edge |
|
0.0 |
| 10895 |
Fetching from uHunt |
2.4a, Graph Data Structures |
transpose adjacency list |
|
0.0 |
| 10928 |
Fetching from uHunt |
2.4a, Graph Data Structures |
counting out-degrees |
|
0.0 |
| 11550 |
Fetching from uHunt |
2.4a, Graph Data Structures |
graph representation; incidence matrix |
|
0.0 |
| 11991 |
Fetching from uHunt |
2.4a, Graph Data Structures |
Adjacency List |
|
0.0 |
| 00793 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
trivial; application of disjoint sets |
|
0.0 |
| 01197 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
LA 2817 - Kaohsiung03; Connected Components |
|
0.0 |
| 01329 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
LA 3027 - SouthEasternEurope04; interesting UFDS variant; modify the union and find routine |
|
0.0 |
| 10158 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
advanced usage of disjoint sets with a nice twist; memorize list of enemies |
|
0.0 |
| 10227 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
merge two disjoint sets if they are consistent; also available at Kattis - forests |
|
0.0 |
| 10507 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
disjoint sets simplifies this problem |
|
0.0 |
| 10583 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
count disjoint sets after all unions |
|
0.0 |
| 10608 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
find the set with the largest element |
|
0.0 |
| 10685 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
find the set with the largest element |
|
0.0 |
| 11503 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
maintain set attribute (size) in rep item; also available at Kattis - virtualfriends |
|
0.0 |
| 11690 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
check if total money from each member is 0 |
|
0.0 |
| 11987 |
Fetching from uHunt |
2.4b, Union-Find Disjoint Sets |
maintain set attribute (size and sum) in rep item; new operation: move; key idea: do not destroy the parent array structure; also available at Kattis - almostunionfind |
|
0.0 |
| 00297 |
Fetching from uHunt |
2.4c, Tree-related DS |
simple quadtree problem |
|
0.0 |
| 01232 |
Fetching from uHunt |
2.4c, Tree-related DS |
LA 4108 - Singapore07; we have to use a Segment Tree; note that this problem is not about RSQ/RMQ |
|
0.0 |
| 01513 |
Fetching from uHunt |
2.4c, Tree-related DS |
LA 5902 - NorthWesternEurope11; not stack but dynamic RSQ problem; use DAT (for mapping) and Fenwick Tree (for RSQ); also available at Kattis - moviecollection |
|
0.0 |
| 11235 |
Fetching from uHunt |
2.4c, Tree-related DS |
range maximum query |
|
0.0 |
| 11297 |
Fetching from uHunt |
2.4c, Tree-related DS |
Quad Tree with updates or use 2D segment tree |
|
0.0 |
| 11350 |
Fetching from uHunt |
2.4c, Tree-related DS |
simple tree data structure question |
|
0.0 |
| 11402 |
Fetching from uHunt |
2.4c, Tree-related DS |
Segment Tree with lazy updates |
|
0.0 |
| 11423 |
Fetching from uHunt |
2.4c, Tree-related DS |
clever usage of Fenwick Tree and large array; important hint: look at the constraints carefully |
|
0.0 |
| 12086 |
Fetching from uHunt |
2.4c, Tree-related DS |
LA 2191 - Dhaka06; pure dynamic RSQ problem; solvable with Fenwick Tree or Segment Tree |
|
0.0 |
| 12299 |
Fetching from uHunt |
2.4c, Tree-related DS |
Segment Tree with a few point (not range) updates; RMQs |
|
0.0 |
| 12532 |
Fetching from uHunt |
2.4c, Tree-related DS |
clever usage of Fenwick/Segment Tree |
|
0.0 |
| 00165 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
requires some DP too; can be pre-calculated |
|
0.0 |
| 00167 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
8-queens chess problem |
|
0.0 |
| 00256 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
brute force; math; pre-calculate-able |
|
0.0 |
| 00347 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
simulate the process; pre-calculate-able |
|
0.0 |
| 00750 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
classic backtracking problem; only 92 possible 8-queens positions |
|
0.0 |
| 00861 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
backtracking with pruning as in 8-queens recursive backtracking solution; then pre-calculate the results |
|
0.0 |
| 10128 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
backtracking with pruning; try all $N!$ permutations that satisfy the requirement; 13! will TLE; pre-calculate the results |
|
0.0 |
| 10177 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
2/3/4 nested loops; precalculate |
|
0.0 |
| 10276 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
insert a number one by one |
|
0.0 |
| 11085 |
Fetching from uHunt |
3.2a, Pre-calculate-able |
see UVa 750; pre-calculation |
|
0.0 |
| 00105 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
height map; sweep left-right |
|
0.0 |
| 00592 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
key idea: there are only 3^5*2 possible states: the status of each person and whether it is day or night |
|
0.0 |
| 00617 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
try all integer speeds from 30 to 60 mph |
|
0.0 |
| 01260 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
LA 4843 - Daejeon10; check all |
|
0.0 |
| 01588 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
LA 3712 - NorthEasternEurope06; good iterative brute force problem; beware of corner cases |
|
0.0 |
| 10041 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
try all possible locations |
|
0.0 |
| 10487 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
sort and then do O(n^2) pairings; also available at Kattis - closestsums |
|
0.0 |
| 10570 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
brute force all possible final configurations (ascending/descending) and see which one requires the smallest number of exchanges |
|
0.0 |
| 10670 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
2 nested loops; with sorting; also available at Kattis - reduction |
|
0.0 |
| 10730 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
2 nested loops with pruning can still pass the time limit; compare this with UVa 11129; also available at Kattis - antiarithmetic |
|
0.0 |
| 11242 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
brute force plus sorting; also available at Kattis - tourdefrance |
|
0.0 |
| 12205 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
brute force; check intervals; also available at Kattis - telephones |
|
0.0 |
| 12488 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
2 nested loops; simulate overtaking process |
|
0.0 |
| 12583 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
2 nested loops; be careful of overcounting |
|
0.0 |
| 13018 |
Fetching from uHunt |
3.2b, Iterative (Two Nested Loops) |
2 dices, small range; 2 nested loops |
|
0.0 |
| 00154 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 00441 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
6 nested loops; easy |
|
0.0 |
| 00626 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 00703 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 00735 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops; then count |
|
0.0 |
| 10102 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
4 nested loops will do; we do not need BFS; get max of minimum Manhattan distance from a 1 to a 3 |
|
0.0 |
| 10662 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 11059 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops; input is small |
|
0.0 |
| 12498 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 12515 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops |
|
0.0 |
| 12801 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
3 nested loops; still possible to be optimized further |
|
0.0 |
| 12844 |
Fetching from uHunt |
3.2c, Three+ Nested Loops, Easier |
5 nested loops; scaled down version of UVa 10202; do observations first |
|
0.0 |
| 00253 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
try all; similar problem in UVa 11959 |
|
0.0 |
| 00296 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
try all 10000 possible codes; 4 nested loops; use similar solution as Master-Mind game |
|
0.0 |
| 00386 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
4 nested loops with pruning |
|
0.0 |
| 10360 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
also solvable using 1024^2 DP max sum |
|
0.0 |
| 10365 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
use 3 nested loops with pruning |
|
0.0 |
| 10483 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
2 nested loops for a; b; derive c from a; b; there are 354 answers for range [0.01 .. 255.99]; similar to UVa 11236 |
|
0.0 |
| 10502 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
6 nested loops; rectangle |
|
0.0 |
| 10660 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
7 nested loops; Manhattan distance |
|
0.0 |
| 10973 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
3 nested loops with pruning |
|
0.0 |
| 11108 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
try all 2^5 = 32 values with pruning; also available at Kattis - tautology |
|
0.0 |
| 11236 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
3 nested loops for a; b; c; derive d from a; b; c; check if you have 949 lines of output |
|
0.0 |
| 11342 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
pre-calculate squared values from 0^2 to 224^2; use 3 nested loops to generate the answers; use map to avoid duplicates |
|
0.0 |
| 11548 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
4 nested loops; string; pruning |
|
0.0 |
| 11565 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
3 nested loops with pruning |
|
0.0 |
| 11804 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
5 nested loops |
|
0.0 |
| 11959 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
try all possible dice positions; compare with the 2nd one |
|
0.0 |
| 11975 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
3 nested loops; simulate the game as asked |
|
0.0 |
| 12337 |
Fetching from uHunt |
3.2d, Three+ Nested Loops, Harder |
try all possible row x col size and test if it is beautiful |
|
0.0 |
| 00140 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
max n is just 8; use next_permutation; the algorithm inside next_permutation is iterative |
|
0.0 |
| 00146 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
use next_permutation |
|
0.0 |
| 00234 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
LA 5173 - WorldFinals Phoenix94; use next_permutation; simulation |
|
0.0 |
| 00418 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
use next_permutation to permute the 4 molecule locations and then use 12^6 six-nested-loops to check the area of the super molecule; if any |
|
0.0 |
| 01064 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
LA 3808 - WorldFinals Tokyo07; permutation of up to 5 messages; simulation; mind the word 'consecutive' |
|
0.0 |
| 01209 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
LA 3173 - Manila06; STL next and prev_permutation |
|
0.0 |
| 10997 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
not an easy problem; require analysis to realize that the search space is small; also available at Kattis - medals |
|
0.0 |
| 11412 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
next_permutation; find one possibility from 6! |
|
0.0 |
| 11742 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
try all permutations |
|
0.0 |
| 12249 |
Fetching from uHunt |
3.2e, Iterative (Permutation) |
LA 4994 - KualaLumpur10; try all permutations; a bit of string matching |
|
0.0 |
| 00435 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
only 2^20 possible coalition combinations |
|
0.0 |
| 00517 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
convert (a; b) to (0; 1) first so that we only work with integers; there can only be 2^16 possibilities although s can be gigantic; stop upon encountering a cycle |
|
0.0 |
| 00639 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
generate 2^(4x4) = 2^16 combinations and prune |
|
0.0 |
| 01047 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
LA 3278 - WorldFinals Shanghai05; try all 2^n subsets of towers to be taken; use inclusion-exclusion principle |
|
0.0 |
| 11205 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
try all 2^15 bitmask |
|
0.0 |
| 11659 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
try all 2^20 bitmask and check |
|
0.0 |
| 12346 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
LA 5723 - Phuket11; try all 2^n combinations; pick the best one |
|
0.0 |
| 12348 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
LA 5725 - Phuket11; try all 2^n combinations |
|
0.0 |
| 12406 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
try all 2^p possible bitmasks; change '0's to '2's |
|
0.0 |
| 12694 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
LA 6606 - Phuket13; it is safest to just brute force all 2^20 possibilities; greedy solution should be possible too |
|
0.0 |
| 13103 |
Fetching from uHunt |
3.2f, Iterative (Combination) |
try all 2^k combinations; swapping a 0-bit with another 0-bit or 1-bit with another 1-bit has no effect |
|
0.0 |
| 00102 |
Fetching from uHunt |
3.2g, Try All Possible Answers |
try all 6 combinations of possible answers |
|
0.0 |
| 00188 |
Fetching from uHunt |
3.2g, Try All Possible Answers |
3 nested loops; keep trying until an answer is found |
|
0.0 |
| 00471 |
Fetching from uHunt |
3.2g, Try All Possible Answers |
somewhat similar to UVa 00725 |
|
0.0 |
| 00725 |
Fetching from uHunt |
3.2g, Try All Possible Answers |
try all possible answers |
|
0.0 |
| 10908 |
Fetching from uHunt |
3.2g, Try All Possible Answers |
4 nested loops; try all possible odd square lengths |
|
0.0 |
| 00100 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
simply do as asked; the only trap is that j can be < i |
|
0.0 |
| 00371 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
similar to UVa 100 |
|
0.0 |
| 00382 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
do trial division |
|
0.0 |
| 00654 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
just use brute force |
|
0.0 |
| 00906 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
compute c from d = 1 until a/b < c/d |
|
0.0 |
| 01225 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
LA 3996 - Danang07; N is small |
|
0.0 |
| 01583 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
N is small; prepare an array of size 100044; that is the largest possible digit sum for this problem |
|
0.0 |
| 10346 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
interesting simulation problem |
|
0.0 |
| 10370 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
compute average; see how many are above it; also available at Kattis - aboveaverage |
|
0.0 |
| 10783 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
input range is very small; just brute force it |
|
0.0 |
| 10879 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
just use brute force |
|
0.0 |
| 11001 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
brute force math; maximize function |
|
0.0 |
| 11150 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
similar to UVa 10346; be careful with boundary cases! |
|
0.0 |
| 11247 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
brute force around the answer to be safe |
|
0.0 |
| 11313 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
similar to UVa 10346 |
|
0.0 |
| 11689 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
similar to UVa 10346; also available at Kattis - sodasurpler |
|
0.0 |
| 11877 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
similar to UVa 10346 |
|
0.0 |
| 11934 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
just do plain brute-force |
|
0.0 |
| 12527 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
try all; check repeated digits |
|
0.0 |
| 12938 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
complete search; 4 digits; square numbers |
|
0.0 |
| 13059 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
just simulate the counting; it will only runs in logarithmic steps; use long long |
|
0.0 |
| 13131 |
Fetching from uHunt |
3.2h, Math Simulation, Easier |
brute force version of modified sumDiv(N) function |
|
0.0 |
| 00493 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
simulate the spiral process |
|
0.0 |
| 00550 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
rotamult property; try one by one starting from 1 digit |
|
0.0 |
| 00616 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
brute force up to sqrt(n); get pattern |
|
0.0 |
| 00697 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
output formatting and basic Physics |
|
0.0 |
| 00846 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
uses the sum of arithmetic progression formula |
|
0.0 |
| 10025 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
simplify the formula first; iterative |
|
0.0 |
| 10035 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
count the number of carry operations |
|
0.0 |
| 11130 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
mirror the billiard table to the right (and/or top) so that we will only deal with one straight line instead of bouncing lines |
|
0.0 |
| 11254 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
use sum of AP; brute force all values of r from sqrt(2n) down to 1; stop at the first valid a |
|
0.0 |
| 11490 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
let missing_people = 2*a^2; thickness_of_soldiers = b; derive a formula involving a; b; and the given S |
|
0.0 |
| 11968 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
average; fabs; if ties; choose the smaller one! |
|
0.0 |
| 12169 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
brute force constants a and b between [0..10 000] and do O(n) checks; break early as soon as a solution is found; also available at Kattis - disgruntledjudge |
|
0.0 |
| 12290 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
no -1 in the answer |
|
0.0 |
| 12665 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
be careful with boundary conditions |
|
0.0 |
| 12792 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
simulate the process to get the answer |
|
0.0 |
| 12895 |
Fetching from uHunt |
3.2i, Math Simulation, Harder |
verbatim brute force check |
|
0.0 |
| 00130 |
Fetching from uHunt |
3.2j, Josephus Problem |
the original Josephus problem |
|
0.0 |
| 00133 |
Fetching from uHunt |
3.2j, Josephus Problem |
brute force; similar to UVa 130 |
|
0.0 |
| 00151 |
Fetching from uHunt |
3.2j, Josephus Problem |
the original Josephus problem |
|
0.0 |
| 00305 |
Fetching from uHunt |
3.2j, Josephus Problem |
the answer can be precalculated |
|
0.0 |
| 00402 |
Fetching from uHunt |
3.2j, Josephus Problem |
modified Josephus; simulation |
|
0.0 |
| 00440 |
Fetching from uHunt |
3.2j, Josephus Problem |
brute force; similar to UVa 151 |
|
0.0 |
| 01176 |
Fetching from uHunt |
3.2j, Josephus Problem |
LA 2346 - Dhaka01; special case when k = 2; use Josephus recurrence; simulation |
|
0.0 |
| 10015 |
Fetching from uHunt |
3.2j, Josephus Problem |
modified Josephus; dynamic k; variant of UVa 305 |
|
0.0 |
| 10771 |
Fetching from uHunt |
3.2j, Josephus Problem |
brute force; input size is small |
|
0.0 |
| 10774 |
Fetching from uHunt |
3.2j, Josephus Problem |
repeated special case of Josephus when k = 2 |
|
0.0 |
| 11351 |
Fetching from uHunt |
3.2j, Josephus Problem |
use general case Josephus recurrence |
|
0.0 |
| 00380 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
simple backtracking; but we have to work with strings |
|
0.0 |
| 00487 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
use map to store the generated words |
|
0.0 |
| 00524 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
involving prime number |
|
0.0 |
| 00529 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
use backtracking to get the solution |
|
0.0 |
| 00571 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
solution can be suboptimal; add flag to avoid cycling |
|
0.0 |
| 00598 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
print all solutions with backtracking |
|
0.0 |
| 00628 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
backtracking; follow the rules in description |
|
0.0 |
| 00677 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
print all solutions with backtracking |
|
0.0 |
| 00729 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
generate all possible bit strings |
|
0.0 |
| 00868 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
backtracking from row 1 to N; 4 choices per step; some constraints |
|
0.0 |
| 10344 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
5 operands + 3 operators |
|
0.0 |
| 10452 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
at each pos; Indy can go forth/left/right; try all |
|
0.0 |
| 10503 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
max 13 spaces only |
|
0.0 |
| 10576 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
generate all; prune; take max |
|
0.0 |
| 10624 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
backtracking with divisibility check |
|
0.0 |
| 10776 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
recursive backtracking |
|
0.0 |
| 10950 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
sort the input; run backtracking; the output should be sorted; only display the first 100 sorted output |
|
0.0 |
| 11201 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
backtracking involving strings |
|
0.0 |
| 11961 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
up to 4^10 possible DNA strings; mutation power is at most K ≤ 5 so the search space is much smaller; sort the output; remove duplicates |
|
0.0 |
| 12840 |
Fetching from uHunt |
3.2k, Backtracking (Easier) |
simple backtracking |
|
0.0 |
| 00129 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
backtracking; string processing check; a bit of output formatting |
|
0.0 |
| 00208 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
LA 5147 - WorldFinals SanAntonio91; backtracking with some pruning |
|
0.0 |
| 00222 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
LA 5161 - WorldFinals Indianapolis93; cannot use DP 'tank' is floating-point; use backtracking |
|
0.0 |
| 00301 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
2^22 with pruning is possible |
|
0.0 |
| 00307 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
sort the sticks in descending length; group similar lengths; brute force the number of sticks; backtracking to check feasibility |
|
0.0 |
| 00331 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
n <= 5... |
|
0.0 |
| 00416 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
backtrack; try all |
|
0.0 |
| 00433 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
similar to UVa 416 |
|
0.0 |
| 00565 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
backtracking with lots of pruning |
|
0.0 |
| 01262 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
LA 4845 - Daejeon10; sort grid columns; process common passwords in lexicographic order; skip two similar passwords |
|
0.0 |
| 10001 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
the upperbound of 2^32 is scary but with efficient pruning; we can pass the time limit as the test case is not extreme |
|
0.0 |
| 10063 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
do as asked |
|
0.0 |
| 10094 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
this problem is like the n-queens chess problem; but must find/use the pattern! |
|
0.0 |
| 10460 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
similar nature with UVa 10063 |
|
0.0 |
| 10475 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
generate and prune; try all |
|
0.0 |
| 10582 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
simplify complex input first; then backtrack |
|
0.0 |
| 11052 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
the worst case time complexity of 2^1000 looks scary but the search space is apparently not that big |
|
0.0 |
| 11753 |
Fetching from uHunt |
3.2l, Backtracking (Harder) |
the state is probably too big if we use DP; but we can pass the time limit with just backtracking |
|
0.0 |
| 00679 |
Fetching from uHunt |
3.3a, Binary Search |
binary search; bit manipulation solutions exist |
|
0.0 |
| 00957 |
Fetching from uHunt |
3.3a, Binary Search |
complete search binary search: upper_bound |
|
0.0 |
| 10057 |
Fetching from uHunt |
3.3a, Binary Search |
involves the median; use STL sort; upper_bound; lower_bound and some checks |
|
0.0 |
| 10077 |
Fetching from uHunt |
3.3a, Binary Search |
binary search |
|
0.0 |
| 10474 |
Fetching from uHunt |
3.3a, Binary Search |
simple: use sort and then lower_bound |
|
0.0 |
| 10567 |
Fetching from uHunt |
3.3a, Binary Search |
store inc indices of each char of S in 52 vectors; binary search for the position of the char in the correct vector |
|
0.0 |
| 10611 |
Fetching from uHunt |
3.3a, Binary Search |
binary search |
|
0.0 |
| 10706 |
Fetching from uHunt |
3.3a, Binary Search |
binary search some mathematical insights |
|
0.0 |
| 10742 |
Fetching from uHunt |
3.3a, Binary Search |
use sieve; binary search |
|
0.0 |
| 11057 |
Fetching from uHunt |
3.3a, Binary Search |
sort; target pair problem |
|
0.0 |
| 11621 |
Fetching from uHunt |
3.3a, Binary Search |
generate numbers with factor 2 and/or 3; sort; upper_bound |
|
0.0 |
| 11876 |
Fetching from uHunt |
3.3a, Binary Search |
[lower|upper]_bound on sorted sequence N |
|
0.0 |
| 12192 |
Fetching from uHunt |
3.3a, Binary Search |
input array is specially sorted; lower_bound |
|
0.0 |
| 12965 |
Fetching from uHunt |
3.3a, Binary Search |
sort producer/consumer prices; the answer is one of the prices mentioned; use binary searches to count the answer |
|
0.0 |
| 01753 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
LA 8043 - WorldFinals RapidCity17; BSTA + Physics; also available at Kattis - speed |
|
0.0 |
| 10341 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
bisection method; for alternative solutions; see http://www.algorithmist.com/index.php/UVa_10341 |
|
0.0 |
| 11413 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + simulation |
|
0.0 |
| 11627 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
binary search the answer + Physics simulation; also available at Kattis - slalom2 |
|
0.0 |
| 11881 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
bisection method |
|
0.0 |
| 11935 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + simulation |
|
0.0 |
| 12032 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + simulation |
|
0.0 |
| 12190 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + algebra |
|
0.0 |
| 12791 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + math formula to check if the leader pilot can overtake the backmarker pilot at that lap |
|
0.0 |
| 13142 |
Fetching from uHunt |
3.3b, Bisection and BSTA (Easier) |
BSTA + Physics simulation |
|
0.0 |
| 00183 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
simple exercise of DnC |
|
0.0 |
| 00608 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
classical problem; after each weighing; we can halve the search space |
|
0.0 |
| 01738 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
LA 7578 - WorldFinals Phuket16; BST insertion then tree equality check; also available at Kattis - ceiling |
|
0.0 |
| 10385 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
the function is unimodal; ternary search |
|
0.0 |
| 11147 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
implement the given recursive DnC |
|
0.0 |
| 11701 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
a kind of ternary search |
|
0.0 |
| 12893 |
Fetching from uHunt |
3.3c, Ternary Search and Others |
convert the given code into recursive DnC |
|
0.0 |
| 00410 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
load balancing |
|
0.0 |
| 01193 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
LA 2519 - Beijing02; interval covering |
|
0.0 |
| 10020 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
interval covering |
|
0.0 |
| 10249 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
greedy; sorting |
|
0.0 |
| 10382 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
interval covering; also available at Kattis - grass |
|
0.0 |
| 11264 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
coin change variant |
|
0.0 |
| 11292 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
sort; greedy matching; also available at Kattis - loowater |
|
0.0 |
| 11389 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
load balancing |
|
0.0 |
| 12210 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
greedy; sorting |
|
0.0 |
| 12321 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
interval covering |
|
0.0 |
| 12405 |
Fetching from uHunt |
3.4a, Greedy (Classical) |
simpler interval covering problem |
|
0.0 |
| 10763 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 10785 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 11269 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 11369 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 11729 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 11900 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 12485 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 13031 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 13109 |
Fetching from uHunt |
3.4b, Involving Sorting, Easier |
greedy; sorting |
|
0.0 |
| 10026 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting |
|
0.0 |
| 10037 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting |
|
0.0 |
| 11100 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting; also available at Kattis - trip2007 |
|
0.0 |
| 11103 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting; also available at Kattis - wffnproof |
|
0.0 |
| 12673 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
LA 6530 - LatinAmerica13; greedy; sorting |
|
0.0 |
| 12834 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting |
|
0.0 |
| 13054 |
Fetching from uHunt |
3.4c, Involving Sorting, Harder |
greedy; sorting |
|
0.0 |
| 01153 |
Fetching from uHunt |
3.4d, Involving Priority Queue |
greedy; priority queue |
|
0.0 |
| 10954 |
Fetching from uHunt |
3.4d, Involving Priority Queue |
greedy; priority queue |
|
0.0 |
| 12390 |
Fetching from uHunt |
3.4d, Involving Priority Queue |
greedy; priority queue |
|
0.0 |
| 13177 |
Fetching from uHunt |
3.4d, Involving Priority Queue |
greedy; priority queue |
|
0.0 |
| 10152 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10340 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10440 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10602 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10656 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10672 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy; also available at Kattis - marblestree |
|
0.0 |
| 10700 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 10714 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy; also available at Kattis - ants |
|
0.0 |
| 11054 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 11520 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 11532 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 12482 |
Fetching from uHunt |
3.4e, Non Classical, Easier |
greedy |
|
0.0 |
| 00311 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 00668 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 10718 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 10821 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 10982 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11157 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11230 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11240 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11330 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11335 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11491 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11567 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11583 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 11890 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 12124 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 12516 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 13082 |
Fetching from uHunt |
3.4f, Non Classical, Harder |
greedy |
|
0.0 |
| 00108 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
max 2D range sum |
|
0.0 |
| 00507 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
standard problem |
|
0.0 |
| 00787 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
max 1D range product; be careful with 0; use Java BigInteger |
|
0.0 |
| 00836 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
convert '0' to -INF |
|
0.0 |
| 00983 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
max 2D range sum; get submatrix |
|
0.0 |
| 01105 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
LA 5132 - WorldFinals Orlando11; more advanced 2D Range Sum Queries |
|
0.0 |
| 10074 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
standard problem |
|
0.0 |
| 10667 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
standard problem |
|
0.0 |
| 10684 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
standard; Kadane's algorithm |
|
0.0 |
| 10755 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
max 2D range sum in 2 of the 3 dimensions; max 1D range sum with Kadane's algorithm on the 3rd dimension |
|
0.0 |
| 10827 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
copy n*n matrix into n*2n matrix; then this problem becomes a standard max 2D range sum problem again |
|
0.0 |
| 11951 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
use long long; max 2D range sum; prune the search space whenever possible |
|
0.0 |
| 12640 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
standard; Kadane's algorithm |
|
0.0 |
| 13095 |
Fetching from uHunt |
3.5a, Max 1D/2D Range Sum |
create 10 range sum queries; you don't need Fenwick Tree actually |
|
0.0 |
| 00111 |
Fetching from uHunt |
3.5b, LIS |
be careful of the ranking system |
|
0.0 |
| 00231 |
Fetching from uHunt |
3.5b, LIS |
straightforward |
|
0.0 |
| 00437 |
Fetching from uHunt |
3.5b, LIS |
can be modeled as LIS |
|
0.0 |
| 00481 |
Fetching from uHunt |
3.5b, LIS |
O(n log k) LIS+solution |
|
0.0 |
| 00497 |
Fetching from uHunt |
3.5b, LIS |
solution must be printed |
|
0.0 |
| 01196 |
Fetching from uHunt |
3.5b, LIS |
LA 2815 - Kaohsiung03; sort all the blocks in increasing L[i]; then we get the classical LIS problem |
|
0.0 |
| 10131 |
Fetching from uHunt |
3.5b, LIS |
sort elephants based on decreasing IQ; LIS on increasing weight |
|
0.0 |
| 10154 |
Fetching from uHunt |
3.5b, LIS |
LIS variant |
|
0.0 |
| 10534 |
Fetching from uHunt |
3.5b, LIS |
must use O(n log k) LIS twice |
|
0.0 |
| 11456 |
Fetching from uHunt |
3.5b, LIS |
max(LIS(i)+LDS(i)-1), ∀i ∈ [0...n-1]; also available at Kattis - trainsorting |
|
0.0 |
| 11790 |
Fetching from uHunt |
3.5b, LIS |
combination of LIS LDS; weighted |
|
0.0 |
| 00431 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
classic 0-1 Knapsack Problem; output any optimal solution as there is a special checker for this problem |
|
0.0 |
| 00562 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
use a one dimensional table |
|
0.0 |
| 00990 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
print the solution |
|
0.0 |
| 01213 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
LA 3619 - Yokohama06; extension of 0-1 KNAPSACK; s: (id, remN, remK) instead of s: (id, remN) |
|
0.0 |
| 10130 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
very basic 0-1 KNAPSACK problem |
|
0.0 |
| 10261 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
s: (current_car; left; right) |
|
0.0 |
| 10616 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
input can be -ve; use long long |
|
0.0 |
| 10664 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
Subset Sum |
|
0.0 |
| 10690 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
DP Subset Sum with negative offset technique; with addition of simple math |
|
0.0 |
| 10819 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
0-1 knapsack with 'credit card' twist |
|
0.0 |
| 11003 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
try all max weight from 0 to max(weight[i] capacity[i]); forall i in [0..n-1]; if a max weight is known; how many boxes can be stacked? |
|
0.0 |
| 11341 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
s: (id; h_learned; h_left); t: learn module 'id' by 1 hour or skip it |
|
0.0 |
| 11566 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
KNAPSACK variant: double each dim sum; add one parameter to see if we have bought too many dishes |
|
0.0 |
| 11658 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
s: (id; share); t: form/ignore coalition with id |
|
0.0 |
| 11832 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
interesting DP; s: (id; val); use offset to handle negative numbers; t: plus or minus; print solution |
|
0.0 |
| 12621 |
Fetching from uHunt |
3.5c, 0-1 KNAPSACK |
DP Subset Sum; simplify the multiple of 10 |
|
0.0 |
| 00147 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
similar to UVa 357 and 674 |
|
0.0 |
| 00166 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
two coin change variants in one problem |
|
0.0 |
| 00242 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
LA 5181 - WorldFinals Nashville95; Complete Search + DP Coin-Change |
|
0.0 |
| 00357 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
similar to UVa 147 and 674 |
|
0.0 |
| 00674 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
basic coin change problem |
|
0.0 |
| 10313 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
modified coin change and DP 1D range sum |
|
0.0 |
| 10448 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
after dealing with traversal on tree; you can reduce the original problem into coin change; not trivial |
|
0.0 |
| 11137 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
use long long |
|
0.0 |
| 11259 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
part of the problem is DP COIN-CHANGE with restricted number of coins per type; inclusion-exclusion |
|
0.0 |
| 11517 |
Fetching from uHunt |
3.5d, COIN-CHANGE |
a variation to the coin change problem; also available at Kattis - exactchange2 |
|
0.0 |
| 00216 |
Fetching from uHunt |
3.5e, TSP |
LA 5155 - WorldFinals KansasCity92; DP TSP problem; but still solvable with backtracking |
|
0.0 |
| 01281 |
Fetching from uHunt |
3.5e, TSP |
LA 6028 - WorldFinals Warsaw12; DP TSP variant; also available at Kattis - bustour |
|
0.0 |
| 10496 |
Fetching from uHunt |
3.5e, TSP |
DP or recursive backtracking with sufficient pruning; also available at Kattis - beepers |
|
0.0 |
| 11795 |
Fetching from uHunt |
3.5e, TSP |
DP TSP variant; counting paths on DAG; DP+bitmask; let Mega Buster owned by a dummy 'Robot 0' |
|
0.0 |
| 12841 |
Fetching from uHunt |
3.5e, TSP |
simply find and print the lexicographically smallest Hamiltonian path; use DP-TSP technique |
|
0.0 |
| 00116 |
Fetching from uHunt |
3.5f, DP level 1 |
similar to UVa 10337 |
|
0.0 |
| 00196 |
Fetching from uHunt |
3.5f, DP level 1 |
3.5g |
|
0.0 |
| 00215 |
Fetching from uHunt |
3.5f, DP level 1 |
3.5g |
|
0.0 |
| 01261 |
Fetching from uHunt |
3.5f, DP level 1 |
LA 4844 - Daejeon10; a simple backtracking problem; but we use a setÿto prevent the same state (a substring) from being checked twice |
|
0.0 |
| 10003 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (l; r) |
|
0.0 |
| 10036 |
Fetching from uHunt |
3.5f, DP level 1 |
must use offset technique as value can be negative |
|
0.0 |
| 10086 |
Fetching from uHunt |
3.5f, DP level 1 |
3.5g |
|
0.0 |
| 10337 |
Fetching from uHunt |
3.5f, DP level 1 |
DP; shortest paths on DAG |
|
0.0 |
| 10446 |
Fetching from uHunt |
3.5f, DP level 1 |
edit the given recursive function a bit; add memoization |
|
0.0 |
| 10520 |
Fetching from uHunt |
3.5f, DP level 1 |
just write the given formula as a top-down DP with memoization |
|
0.0 |
| 10721 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (n; k); t: try all from 1 to m |
|
0.0 |
| 10910 |
Fetching from uHunt |
3.5f, DP level 1 |
two dimensional DP table |
|
0.0 |
| 10912 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (len; last; sum); t: try next char |
|
0.0 |
| 10943 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (n; k); t: try all the possible splitting points; alternative solution is to use the closed form mathematical formula: C(n k-1; k-1) which also needs DP |
|
0.0 |
| 10980 |
Fetching from uHunt |
3.5f, DP level 1 |
simple DP |
|
0.0 |
| 11026 |
Fetching from uHunt |
3.5f, DP level 1 |
DP; similar idea with binomial theorem |
|
0.0 |
| 11407 |
Fetching from uHunt |
3.5f, DP level 1 |
can be memoized |
|
0.0 |
| 11420 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (prev; id; numlck); lock/unlock this chest |
|
0.0 |
| 11450 |
Fetching from uHunt |
3.5f, DP level 1 |
standard DP |
|
0.0 |
| 11703 |
Fetching from uHunt |
3.5f, DP level 1 |
can be memoized |
|
0.0 |
| 12654 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (hole); t: use patch T1 or patch T2 |
|
0.0 |
| 12951 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (day, has_stock); t: ignore, buy (if does not have stock), or sell (if has stock) |
|
0.0 |
| 13141 |
Fetching from uHunt |
3.5f, DP level 1 |
s: (level, branch_previously); t: not branching if branch_previously or branching (one side) otherwise |
|
0.0 |
| 00662 |
Fetching from uHunt |
3.5g, DP level 2 |
s: (L; R; k); that denotes the minimum distance sum to cover restaurants at index [L..R] with k depots left |
|
0.0 |
| 10039 |
Fetching from uHunt |
3.5g, DP level 2 |
create the graph first; then apply DP; s: (city; curtime); t: try all feasible trains |
|
0.0 |
| 10069 |
Fetching from uHunt |
3.5g, DP level 2 |
use Java BigInteger |
|
0.0 |
| 10081 |
Fetching from uHunt |
3.5g, DP level 2 |
s: (i, j); #tight words of length i that end in digit j divided by #words: (k+1)^n; also available at Kattis - tight |
|
0.0 |
| 10120 |
Fetching from uHunt |
3.5g, DP level 2 |
DP; special case for N >= 49 |
|
0.0 |
| 10164 |
Fetching from uHunt |
3.5g, DP level 2 |
a bit number theory (modulo); backtracking; do memoization on DP s: (sum; taken) |
|
0.0 |
| 10239 |
Fetching from uHunt |
3.5g, DP level 2 |
convert double to long long first; medium DP; either put this book in the current shelf (if possible) or put it in a new shelf |
|
0.0 |
| 10400 |
Fetching from uHunt |
3.5g, DP level 2 |
backtracking with clever pruning is sufficient |
|
0.0 |
| 10465 |
Fetching from uHunt |
3.5g, DP level 2 |
one dimensional DP table |
|
0.0 |
| 10651 |
Fetching from uHunt |
3.5g, DP level 2 |
small problem size; doable with backtracking |
|
0.0 |
| 11485 |
Fetching from uHunt |
3.5g, DP level 2 |
the problem description looks scary but the solution is not that complex |
|
0.0 |
| 11514 |
Fetching from uHunt |
3.5g, DP level 2 |
modified 0-1 Knapsack; Batman can use or skip a certain super power; check if the best configuration uses ≤ E calories; print 'yes' or 'no' accordingly |
|
0.0 |
| 11908 |
Fetching from uHunt |
3.5g, DP level 2 |
sort the advertisements based on starting level; ending level; and cost; DP 1 dimension |
|
0.0 |
| 12324 |
Fetching from uHunt |
3.5g, DP level 2 |
spheres > n are useless |
|
0.0 |
| 12862 |
Fetching from uHunt |
3.5g, DP level 2 |
1D DP to compute the path cost from every vertex that goes up to the mountain top; compute answer |
|
0.0 |
| 12955 |
Fetching from uHunt |
3.5g, DP level 2 |
there are only 8 eligible factorials under 100000; we can use DP; s: (i, sum); t: take/stay, take/move, don't take/move |
|
0.0 |
| 00260 |
Fetching from uHunt |
4.2a, Finding CCs |
6 neighbors per cell |
|
0.0 |
| 00280 |
Fetching from uHunt |
4.2a, Finding CCs |
reachability check; traverse the graph |
|
0.0 |
| 00459 |
Fetching from uHunt |
4.2a, Finding CCs |
also solvable with UFDS |
|
0.0 |
| 10687 |
Fetching from uHunt |
4.2a, Finding CCs |
build graph; geometry; reachability |
|
0.0 |
| 11518 |
Fetching from uHunt |
4.2a, Finding CCs |
unlike UVa 11504, we treat SCCs as CCs; also available at Kattis - dominoes2 |
|
0.0 |
| 11749 |
Fetching from uHunt |
4.2a, Finding CCs |
find the largest CC with highest average PPA; also solvable with UFDS |
|
0.0 |
| 11841 |
Fetching from uHunt |
4.2a, Finding CCs |
implicit graph; check if there is a CC from x = y = z = 0 to say 'Benny wins' |
|
0.0 |
| 11902 |
Fetching from uHunt |
4.2a, Finding CCs |
disable vertex one by one; check if the reachability from vertex 0 changes |
|
0.0 |
| 11906 |
Fetching from uHunt |
4.2a, Finding CCs |
DFS/BFS for reachability; several tricky cases; be careful when M = 0; N = 0; or M = N |
|
0.0 |
| 00352 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count number of CCs; see UVa 00572 |
|
0.0 |
| 00469 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count size of a CC |
|
0.0 |
| 00572 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count number of CCs |
|
0.0 |
| 00657 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
there are three colors here; non-standard but still relatively easy floodfill problem |
|
0.0 |
| 00722 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count the size of CCs |
|
0.0 |
| 00871 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
find the largest CC size |
|
0.0 |
| 10336 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count and rank CCs with similar color |
|
0.0 |
| 11244 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
count number of CCs |
|
0.0 |
| 11470 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
you can do flood fill layer by layer; however; there is other way to solve this problem; e.g. by finding the patterns |
|
0.0 |
| 11561 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
flood fill with extra blocking constraint; also available at Kattis - gold |
|
0.0 |
| 11953 |
Fetching from uHunt |
4.2b, Flood Fill, Easier |
interesting twist of flood fill problem |
|
0.0 |
| 00601 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
floodfill is one of the component |
|
0.0 |
| 00705 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
build the implicit graph first |
|
0.0 |
| 00758 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
floodfill |
|
0.0 |
| 00776 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
label CCs with indices; format output |
|
0.0 |
| 00782 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
replace spaces with hexes in the grid; similar to UVa 784 and 785 |
|
0.0 |
| 00784 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
similar to UVa 782 and 785 |
|
0.0 |
| 00785 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
similar to UVa 782 and 784 |
|
0.0 |
| 00852 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
interesting board game 'Go' |
|
0.0 |
| 01103 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
LA 5130 - WorldFinals Orlando11; major hint: each hieroglyph has unique number of white CCs |
|
0.0 |
| 10592 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
floodfill ; two layers |
|
0.0 |
| 10707 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
check graph isomorphism; a tedious problem; involving connected components |
|
0.0 |
| 10946 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
find CCs and rank them by their size |
|
0.0 |
| 11094 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
tricky flood fill; scrolling |
|
0.0 |
| 11110 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
flood fill satisfy the constraints given |
|
0.0 |
| 11585 |
Fetching from uHunt |
4.2c, Flood Fill, Harder |
polynomial-time verifier for an NP-complete puzzle Nurikabe; this verifier requires clever usage of flood fill algorithm |
|
0.0 |
| 00124 |
Fetching from uHunt |
4.2d, Topological Sort |
use backtracking to generate valid toposorts |
|
0.0 |
| 00200 |
Fetching from uHunt |
4.2d, Topological Sort |
toposort |
|
0.0 |
| 00872 |
Fetching from uHunt |
4.2d, Topological Sort |
similar to UVa 00124; use backtracking |
|
0.0 |
| 10305 |
Fetching from uHunt |
4.2d, Topological Sort |
simply run toposort algorithm |
|
0.0 |
| 11060 |
Fetching from uHunt |
4.2d, Topological Sort |
Kahn's algorithm---modified BFS toposort |
|
0.0 |
| 11686 |
Fetching from uHunt |
4.2d, Topological Sort |
cycle check + toposort if DAG; also available at Kattis - pickupsticks |
|
0.0 |
| 00840 |
Fetching from uHunt |
4.2e, Graph Properties Check |
a simple problem to detect cycle in a graph; however the output format is not clearly specified |
|
0.0 |
| 10004 |
Fetching from uHunt |
4.2e, Graph Properties Check |
bipartite graph check |
|
0.0 |
| 10116 |
Fetching from uHunt |
4.2e, Graph Properties Check |
traversal on implicit graph; cycle check |
|
0.0 |
| 10505 |
Fetching from uHunt |
4.2e, Graph Properties Check |
bipartite; take max(left; right) |
|
0.0 |
| 10510 |
Fetching from uHunt |
4.2e, Graph Properties Check |
use DFS to identify forward/cross edges; involving Strongly Connected graph |
|
0.0 |
| 11080 |
Fetching from uHunt |
4.2e, Graph Properties Check |
bipartite graph check; tricky cases |
|
0.0 |
| 11396 |
Fetching from uHunt |
4.2e, Graph Properties Check |
it is just a bipartite graph check |
|
0.0 |
| 00315 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding articulation points |
|
0.0 |
| 00610 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding bridges |
|
0.0 |
| 00796 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding bridges |
|
0.0 |
| 10199 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding articulation points |
|
0.0 |
| 10765 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding articulation points |
|
0.0 |
| 12363 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
LA 5796 - Latin America; transform input to graph of its bridges; see if b is reachable from a with only the bridges |
|
0.0 |
| 12783 |
Fetching from uHunt |
4.2f, Cut Vertices/Bridges |
finding bridges |
|
0.0 |
| 00247 |
Fetching from uHunt |
4.2g, Finding SCCs |
SCC + printing solution |
|
0.0 |
| 01229 |
Fetching from uHunt |
4.2g, Finding SCCs |
LA 4099 - Iran07; identify the SCC of the graph; these vertices and the vertices that have path towards them are the answers of the question |
|
0.0 |
| 10731 |
Fetching from uHunt |
4.2g, Finding SCCs |
SCC + printing solution; also available at Kattis - test2 |
|
0.0 |
| 11504 |
Fetching from uHunt |
4.2g, Finding SCCs |
count the number of SCCs without incoming edge from a vertex outside that SCC; also available at Kattis - dominos |
|
0.0 |
| 11709 |
Fetching from uHunt |
4.2g, Finding SCCs |
find the number of SCCs |
|
0.0 |
| 11770 |
Fetching from uHunt |
4.2g, Finding SCCs |
similar to UVa 11504 |
|
0.0 |
| 11838 |
Fetching from uHunt |
4.2g, Finding SCCs |
see if input graph is an SCC |
|
0.0 |
| 00118 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
traversal on implicit graph |
|
0.0 |
| 00168 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
Adjacency Matrix; parsing; traversal |
|
0.0 |
| 00173 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
non classic graph traversal variant; use bitmask to record vertices visited by Paskill and Lisper as they move through the graph |
|
0.0 |
| 00318 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
graph traversal; be careful of corner cases |
|
0.0 |
| 00614 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
traversal on implicit graph |
|
0.0 |
| 00824 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
traversal on implicit graph |
|
0.0 |
| 10113 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
just graph traversal; but uses fraction and GCD |
|
0.0 |
| 10377 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
traversal on implicit graph |
|
0.0 |
| 11831 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
traversal on implicit graph |
|
0.0 |
| 12376 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
simulated greedy traversal on DAG |
|
0.0 |
| 12442 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
modified DFS; special graph |
|
0.0 |
| 12582 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
given graph DFS traversal; count the degree of each vertex |
|
0.0 |
| 12648 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
simple graph (DAG) traversal; DFS |
|
0.0 |
| 13015 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
modified DFS; special graph; DAG; also available at Kattis - promotions |
|
0.0 |
| 13038 |
Fetching from uHunt |
4.2h, Really Ad Hoc |
simple, use DFS to find the length of the deepest branch |
|
0.0 |
| 00908 |
Fetching from uHunt |
4.3a, MST, Standard |
basic MST problem |
|
0.0 |
| 01174 |
Fetching from uHunt |
4.3a, MST, Standard |
LA 3988 - SouthWesternEurope07; classic MST; just need a mapper to map city names to indices |
|
0.0 |
| 01208 |
Fetching from uHunt |
4.3a, MST, Standard |
LA 3171 - Manila06; MST |
|
0.0 |
| 01235 |
Fetching from uHunt |
4.3a, MST, Standard |
LA 4138 - Jakarta08; the underlying problem is MST |
|
0.0 |
| 10034 |
Fetching from uHunt |
4.3a, MST, Standard |
straightforward MST problem; also available at Kattis - freckles |
|
0.0 |
| 11228 |
Fetching from uHunt |
4.3a, MST, Standard |
split output for short vs long edges |
|
0.0 |
| 11631 |
Fetching from uHunt |
4.3a, MST, Standard |
weight of (all graph edges - all MST edges) |
|
0.0 |
| 11710 |
Fetching from uHunt |
4.3a, MST, Standard |
output 'Impossible' if the graph is still disconnected after running MST |
|
0.0 |
| 11733 |
Fetching from uHunt |
4.3a, MST, Standard |
maintain cost at every update |
|
0.0 |
| 11747 |
Fetching from uHunt |
4.3a, MST, Standard |
sum the edge weights of the chords |
|
0.0 |
| 11857 |
Fetching from uHunt |
4.3a, MST, Standard |
find weight of the last edge added to MST by Kruskal's; also available at Kattis - drivingrange |
|
0.0 |
| 00534 |
Fetching from uHunt |
4.3b, MST, Variants |
minimax; also solvable with Floyd Warshall's |
|
0.0 |
| 00544 |
Fetching from uHunt |
4.3b, MST, Variants |
maximin; also solvable with Floyd Warshall's |
|
0.0 |
| 01013 |
Fetching from uHunt |
4.3b, MST, Variants |
LA 2478 - WorldFinals Honolulu02; very interesting MST variant |
|
0.0 |
| 01160 |
Fetching from uHunt |
4.3b, MST, Variants |
LA 3644 - SouthWesternEurope06; count the number of edges not taken by Kruskal's |
|
0.0 |
| 01216 |
Fetching from uHunt |
4.3b, MST, Variants |
LA 3678 - Kaohsiung06; minimum 'spanning forest' |
|
0.0 |
| 01234 |
Fetching from uHunt |
4.3b, MST, Variants |
LA 4110 - Singapore07; 'maximum' spanning tree |
|
0.0 |
| 01265 |
Fetching from uHunt |
4.3b, MST, Variants |
LA 4848 - Daejeon10; very interesting non-standard variant of 'maximum' spanning tree |
|
0.0 |
| 10048 |
Fetching from uHunt |
4.3b, MST, Variants |
classic MiniMax path problem |
|
0.0 |
| 10099 |
Fetching from uHunt |
4.3b, MST, Variants |
maximin; also solvable with Floyd Warshall's |
|
0.0 |
| 10147 |
Fetching from uHunt |
4.3b, MST, Variants |
'minimum' spanning subgraph |
|
0.0 |
| 10369 |
Fetching from uHunt |
4.3b, MST, Variants |
minimum spanning 'forest'; also available at Kattis - arcticnetwork |
|
0.0 |
| 10397 |
Fetching from uHunt |
4.3b, MST, Variants |
'minimum' spanning subgraph |
|
0.0 |
| 10457 |
Fetching from uHunt |
4.3b, MST, Variants |
interesting MST modeling |
|
0.0 |
| 10462 |
Fetching from uHunt |
4.3b, MST, Variants |
second best spanning tree |
|
0.0 |
| 10600 |
Fetching from uHunt |
4.3b, MST, Variants |
second best spanning tree |
|
0.0 |
| 10842 |
Fetching from uHunt |
4.3b, MST, Variants |
find min weighted edge in 'max' spanning tree |
|
0.0 |
| 00336 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
simple SSSP; BFS |
|
0.0 |
| 00388 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
key idea: we want to minimize planet movements because every edge used decreases value by 5% |
|
0.0 |
| 00429 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
each word is a vertex; connect 2 words with an edge if differ by 1 letter |
|
0.0 |
| 00627 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
also print the path |
|
0.0 |
| 00762 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
simple SSSP solvable with BFS; use mapper |
|
0.0 |
| 00924 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
the spread is like BFS traversal |
|
0.0 |
| 01148 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
LA 3502 - SouthWesternEurope05; single source single target shortest path problem but exclude endpoints |
|
0.0 |
| 10009 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
simple SSSP solvable with BFS |
|
0.0 |
| 10610 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
simple SSSP solvable with BFS |
|
0.0 |
| 10653 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
need efficient BFS implementation |
|
0.0 |
| 10959 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
SSSP from source 0 to the rest |
|
0.0 |
| 12160 |
Fetching from uHunt |
4.4a, SSSP, BFS, Easier |
LA 4408 - KualaLumpur08; s: (4-digits number); edges: button pushes; BFS |
|
0.0 |
| 00314 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
pre-process the input graph first; s: (r, c, dir); 5 edges: turn left/right or move 1/2/3 steps; BFS |
|
0.0 |
| 00383 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
simple SSSP solvable with BFS; use mapper |
|
0.0 |
| 00532 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
3D BFS; also available at Kattis - dungeon |
|
0.0 |
| 00859 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
BFS |
|
0.0 |
| 00949 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
interesting graph data structure twist |
|
0.0 |
| 10044 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
the input parsing part is troublesome |
|
0.0 |
| 10067 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
implicit graph in problem statement |
|
0.0 |
| 10977 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
BFS with blocked states |
|
0.0 |
| 10993 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
s: (the current number modulo N); BFS |
|
0.0 |
| 11049 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
some restricted moves; print the path |
|
0.0 |
| 11101 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
multi-sources BFS from m1; get minimum at border of m2; also available at Kattis - mallmania |
|
0.0 |
| 11352 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
filter the graph first; then it becomes SSSP |
|
0.0 |
| 11377 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
a city to another city without/with airport has edge weight 1/0, respectively; BFS+deque; if the start and end city are the same and has no airport, the answer should be 0 |
|
0.0 |
| 11573 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
0/1-weighted SSSP; BFS+deque; also available at Kattis - oceancurrents |
|
0.0 |
| 11624 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
multi-sources BFS; also available at Kattis - fire3 |
|
0.0 |
| 11792 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
be careful with 'important station' |
|
0.0 |
| 12826 |
Fetching from uHunt |
4.4b, SSSP, BFS, Harder |
SSSP from (r1; c1) to (r2; c2) avoiding (r3; c3); BFS |
|
0.0 |
| 00439 |
Fetching from uHunt |
4.4c, Knight Moves |
one BFS per query is enough |
|
0.0 |
| 00633 |
Fetching from uHunt |
4.4c, Knight Moves |
alternating Knight Moves and Bishop Moves (limited to distance 2)); solvable with just one BFS per query |
|
0.0 |
| 10426 |
Fetching from uHunt |
4.4c, Knight Moves |
for each knight, do BFS when the monster is sleep/awake; try: one awake the monster, the rest go around |
|
0.0 |
| 10477 |
Fetching from uHunt |
4.4c, Knight Moves |
s: (row; col; knight_state); implicit unweighted graph; different edges per different knight_state |
|
0.0 |
| 00929 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
on a 2D maze/implicit graph |
|
0.0 |
| 01112 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
LA 2425 - SouthwesternEurope01; SDSP |
|
0.0 |
| 10389 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
use basic geometry skill to build the weighted graph; then run Dijkstra's; also available at Kattis - subway2 |
|
0.0 |
| 10986 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
direct Dijkstra's application |
|
0.0 |
| 12878 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
Dijkstra's; record predecessor graph as there can be multiple shortest paths; also available at Kattis - flowerytrails |
|
0.0 |
| 13127 |
Fetching from uHunt |
4.4d, SSSP, Dijkstra, Easier |
Dijkstra's from multiple sources |
|
0.0 |
| 00157 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
tedious input parsing; SSSP on graph with 2-valued weighted graph (1 or 3 units of time); print the shortest path |
|
0.0 |
| 00523 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
this is actually an SSSP problem on weighted graph solvable with Dijkstra's; use the vertex splitting technique to handle vertex weight |
|
0.0 |
| 00589 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
weighted SSSP: move box from s to t + unweighted SSSP: move player to correct position to push the box |
|
0.0 |
| 00721 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
essentially this problem is just about SSSP from vertex 1 to all vertices and SDestinationSP from all vertices to vertex 1 by reversing the edges |
|
0.0 |
| 01202 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
LA 3133 - Beijing04; SSSP; Dijkstra's on a grid: treat each cell as a vertex; the idea is simple but one should be careful with the implementation |
|
0.0 |
| 10166 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
this can be modeled as an SSSP problem |
|
0.0 |
| 10187 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
special cases: start = destination: 0 litre; starting or destination city not found or destination city not reachable from starting city: no route; the rest: Dijkstra's |
|
0.0 |
| 10278 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
Dijkstra's from fire stations to all intersections; need pruning to pass the time limit; also available at Kattis - firestation |
|
0.0 |
| 10280 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
Dijkstra's; also available at Kattis - wine |
|
0.0 |
| 10356 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
attach one extra info to each vertex: do we come to that vertex using cycle or not; Dijkstra's |
|
0.0 |
| 10603 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
state: (a; b; c); source: (0; 0; c); 6 possible transitions |
|
0.0 |
| 10801 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
model the graph carefully |
|
0.0 |
| 10967 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
model the graph; SSSP |
|
0.0 |
| 11338 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
the test data is weaker than what the problem description says (n ≤ 10 000); we use O(n^2) loop to build the weighted graph and runs Dijkstra's without getting TLE |
|
0.0 |
| 11367 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
model the graph carefully; state: (location, fuel), source s = (s, 0), sink t = (e, any), only enqueue fuel+1; also available at Kattis - fulltank |
|
0.0 |
| 11492 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
vertex = word; edges as per problem description; connect source/sink to all words in start/finish language, respectively; vertex split; Dijkstra's |
|
0.0 |
| 11833 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
stop Dijkstra's at service route path plus some modification |
|
0.0 |
| 12047 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
clever usage of Dijkstra's; run Dijkstra's from source and from d from destination |
|
0.0 |
| 12144 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
Dijkstra's; store multiple predecessors |
|
0.0 |
| 12950 |
Fetching from uHunt |
4.4e, SSSP, Dijkstra, Harder |
clever usage of Dijstra's; instead of extending by one edge, we can extend by two edges at a time |
|
0.0 |
| 00423 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
the graph is small; Bellman-Ford or Floyd-Warshall |
|
0.0 |
| 00558 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
check if negative cycle exists |
|
0.0 |
| 10449 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
find the minimum weight path; which may be negative; be careful: INF negative weight is lower than INF |
|
0.0 |
| 10557 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
check 'positive' cycle; check connectedness; also available at Kattis - xyzzy |
|
0.0 |
| 11280 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
modified Bellman-Ford |
|
0.0 |
| 12768 |
Fetching from uHunt |
4.4f, SSSP, -ve weight |
insert -F as edge weight; see if negative cycle exists; or find min SSSP value from s = 1 |
|
0.0 |
| 00341 |
Fetching from uHunt |
4.5a, APSP, Standard |
the graph is small |
|
0.0 |
| 00567 |
Fetching from uHunt |
4.5a, APSP, Standard |
simple SSSP solvable with BFS; but the graph is small, so can be solved easier with Floyd-Warshall |
|
0.0 |
| 00821 |
Fetching from uHunt |
4.5a, APSP, Standard |
LA 5221 - WorldFinals Orlando00; one of the easiest ICPC WorldFinals problem |
|
0.0 |
| 01233 |
Fetching from uHunt |
4.5a, APSP, Standard |
LA 4109 - Singapore07; Floyd-Warshall can be used to find the minimum cost cycle in the graph |
|
0.0 |
| 01247 |
Fetching from uHunt |
4.5a, APSP, Standard |
LA 4524 - Hsinchu09; Floyd-Warshall with modification: prefer shortest path with less intermediate vertices |
|
0.0 |
| 10171 |
Fetching from uHunt |
4.5a, APSP, Standard |
easy with APSP information |
|
0.0 |
| 10354 |
Fetching from uHunt |
4.5a, APSP, Standard |
find and remove edges involved in boss's shortest paths; re-run shortest paths from home to market |
|
0.0 |
| 10525 |
Fetching from uHunt |
4.5a, APSP, Standard |
use two adjacency matrices: time and length; use modified Floyd-Warshall |
|
0.0 |
| 10724 |
Fetching from uHunt |
4.5a, APSP, Standard |
adding one edge only changes a few things |
|
0.0 |
| 10793 |
Fetching from uHunt |
4.5a, APSP, Standard |
Floyd-Warshall simplifies this problem |
|
0.0 |
| 10803 |
Fetching from uHunt |
4.5a, APSP, Standard |
graph is small |
|
0.0 |
| 10947 |
Fetching from uHunt |
4.5a, APSP, Standard |
graph is small |
|
0.0 |
| 11015 |
Fetching from uHunt |
4.5a, APSP, Standard |
graph is small |
|
0.0 |
| 11463 |
Fetching from uHunt |
4.5a, APSP, Standard |
solution is easy with APSP information |
|
0.0 |
| 12319 |
Fetching from uHunt |
4.5a, APSP, Standard |
Floyd-Warshall 2x and compare |
|
0.0 |
| 13249 |
Fetching from uHunt |
4.5a, APSP, Standard |
Floyd-Warshall; use O(N^2) check, not O(N^4) check to avoid TLE |
|
0.0 |
| 00104 |
Fetching from uHunt |
4.5b, APSP, Variants |
small arbitrage problem solvable with Floyd-Warshall |
|
0.0 |
| 00125 |
Fetching from uHunt |
4.5b, APSP, Variants |
modified Floyd-Warshall |
|
0.0 |
| 00186 |
Fetching from uHunt |
4.5b, APSP, Variants |
graph is small; print path |
|
0.0 |
| 00274 |
Fetching from uHunt |
4.5b, APSP, Variants |
variant of transitive closure problem |
|
0.0 |
| 00334 |
Fetching from uHunt |
4.5b, APSP, Variants |
transitive closure |
|
0.0 |
| 00436 |
Fetching from uHunt |
4.5b, APSP, Variants |
another arbitrage problem |
|
0.0 |
| 00869 |
Fetching from uHunt |
4.5b, APSP, Variants |
run Warshall's 2x on different graph; compare the two Adjacency Matrices |
|
0.0 |
| 00925 |
Fetching from uHunt |
4.5b, APSP, Variants |
transitive closure |
|
0.0 |
| 01056 |
Fetching from uHunt |
4.5b, APSP, Variants |
LA 3569 - WorldFinals SanAntonio06; finding diameter of a small graph with Floyd-Warshall |
|
0.0 |
| 01198 |
Fetching from uHunt |
4.5b, APSP, Variants |
LA 2818 - Kaohsiung03; transitive closure |
|
0.0 |
| 01757 |
Fetching from uHunt |
4.5b, APSP, Variants |
LA 8047 - WorldFinals RapidCity17; Warshall's transitive closure; also available at Kattis - secretchamber |
|
0.0 |
| 10246 |
Fetching from uHunt |
4.5b, APSP, Variants |
modify the Floyd-Warshall recurrence a bit to handle the maximum cost to hold feast for Obelix |
|
0.0 |
| 10331 |
Fetching from uHunt |
4.5b, APSP, Variants |
use Floyd-Warshall to obtain the APSP information; then use brute force to count the time an edge is used; report accordingly |
|
0.0 |
| 10342 |
Fetching from uHunt |
4.5b, APSP, Variants |
Floyd-Warshall to get APSP values; to get the second best shortest path, try to make a single mistake |
|
0.0 |
| 10436 |
Fetching from uHunt |
4.5b, APSP, Variants |
as there is vertex weight, use vertex splitting technique; run Floyd-Warshall on the still-small graph; print path |
|
0.0 |
| 10987 |
Fetching from uHunt |
4.5b, APSP, Variants |
creative usage of Floyd-Warshall algorithm; if we can detour without increasing cost, then delete the direct edge |
|
0.0 |
| 11047 |
Fetching from uHunt |
4.5b, APSP, Variants |
print path; special case: if origin = destination; print twice |
|
0.0 |
| 00103 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on DAG; backtracking OK |
|
0.0 |
| 00452 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on DAG |
|
0.0 |
| 10000 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on DAG; backtracking OK |
|
0.0 |
| 10051 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on DAG; DP |
|
0.0 |
| 10259 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on implicit DAG; DP |
|
0.0 |
| 10285 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
longest paths on implicit DAG; however; the graph is small enough for recursive backtracking solution |
|
0.0 |
| 10350 |
Fetching from uHunt |
4.6a, S/Longest Paths on DAG |
shortest paths; implicit DAG; DP |
|
0.0 |
| 00825 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in grid (implicit DAG); DP; similar to UVa 00926 and 11067 |
|
0.0 |
| 00926 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in grid (implicit DAG); DP; similar to UVa 825 and 11067 |
|
0.0 |
| 00986 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in DAG; DP; s: (x; y; lastmove; peaksfound); t: try NE/SE |
|
0.0 |
| 00988 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in DAG; DP |
|
0.0 |
| 10401 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in implicit DAG; DP; s: (col; row); t: next col; avoid 2 or 3 adjacent rows |
|
0.0 |
| 10544 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in implicit DAG |
|
0.0 |
| 10564 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in implicit DAG (top-down); print one solution |
|
0.0 |
| 10926 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in DAG; DP |
|
0.0 |
| 11067 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in grid (implicit DAG); DP; similar to UVa 825 and 926 |
|
0.0 |
| 11569 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
determine the length of one of the longest paths and then count the number of such longest paths in DAG |
|
0.0 |
| 11655 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in DAG and one more similar task: counting the number of vertices involved in the paths |
|
0.0 |
| 11957 |
Fetching from uHunt |
4.6b, Counting Paths, Easier |
counting paths in implicit DAG; DP |
|
0.0 |
| 00590 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; day_left) |
|
0.0 |
| 00607 |
Fetching from uHunt |
4.6c, Conversion to DAG |
returns pair of information |
|
0.0 |
| 00757 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (lake_id, time_left); this time_left is best left as multiple of 5 minutes; output the optimal solution too |
|
0.0 |
| 00907 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; night_left) |
|
0.0 |
| 00910 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; move_left) |
|
0.0 |
| 01025 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (station, cur_t); t: stay until meeting time (if at station N), or either go to right or go to left using any of the available next train, pick the minimum |
|
0.0 |
| 10201 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos, fuel_left); also available at Kattis - adventuremoving4 |
|
0.0 |
| 10271 |
Fetching from uHunt |
4.6c, Conversion to DAG |
Observation: The 3rd chopstick can be any chopstick; s: (pos, K_left); t: ignore this chopstick, or take this chopstick and the chopstick immediately next to it |
|
0.0 |
| 10543 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; speech_given) |
|
0.0 |
| 10681 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; day_left) |
|
0.0 |
| 10702 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos; T_left); similar to UVa 12875 |
|
0.0 |
| 10874 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (row; left/right); t: go left/right |
|
0.0 |
| 10913 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (r; c; neg_left; stat); t: down/(left/right) |
|
0.0 |
| 11307 |
Fetching from uHunt |
4.6c, Conversion to DAG |
Min Chromatic Sum; max 6 colors |
|
0.0 |
| 11487 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (r; c; cur_food; len); t: 4 dirs |
|
0.0 |
| 11545 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (cPos; cTime; cWTime); t: move forward/rest |
|
0.0 |
| 11782 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (id; rem_K); t: take root/try left-right subtree |
|
0.0 |
| 12875 |
Fetching from uHunt |
4.6c, Conversion to DAG |
LA 6853 - Bangkok14; similar to UVa 10702; s: (cur_store; cur_concert); t: pick any next store for next concert |
|
0.0 |
| 13122 |
Fetching from uHunt |
4.6c, Conversion to DAG |
s: (pos, K_left); knapsack style DP; jump 1, 2, ..., K_left points; connect with the two points with a line with cost equals to their Euclidean distance; keep the minimum |
|
0.0 |
| 00112 |
Fetching from uHunt |
4.6d, Tree |
backtracking |
|
0.0 |
| 00115 |
Fetching from uHunt |
4.6d, Tree |
tree traversal to determine relationships between vertices |
|
0.0 |
| 00122 |
Fetching from uHunt |
4.6d, Tree |
tree traversal |
|
0.0 |
| 00536 |
Fetching from uHunt |
4.6d, Tree |
reconstructing binary tree from preorder and inorder binary tree traversal |
|
0.0 |
| 00548 |
Fetching from uHunt |
4.6d, Tree |
reconstructing tree from in postorder |
|
0.0 |
| 00615 |
Fetching from uHunt |
4.6d, Tree |
graph property check |
|
0.0 |
| 00699 |
Fetching from uHunt |
4.6d, Tree |
preorder traversal |
|
0.0 |
| 00712 |
Fetching from uHunt |
4.6d, Tree |
simple binary tree traversal variant |
|
0.0 |
| 00839 |
Fetching from uHunt |
4.6d, Tree |
can be viewed as a recursive problem on tree |
|
0.0 |
| 10308 |
Fetching from uHunt |
4.6d, Tree |
diameter of tree |
|
0.0 |
| 10459 |
Fetching from uHunt |
4.6d, Tree |
diameter of tree |
|
0.0 |
| 10701 |
Fetching from uHunt |
4.6d, Tree |
reconstructing tree from pre inorder |
|
0.0 |
| 10805 |
Fetching from uHunt |
4.6d, Tree |
involving diameter of tree |
|
0.0 |
| 11131 |
Fetching from uHunt |
4.6d, Tree |
read tree; produce two postorder traversals |
|
0.0 |
| 11234 |
Fetching from uHunt |
4.6d, Tree |
converting post-order to level-order; binary tree |
|
0.0 |
| 11615 |
Fetching from uHunt |
4.6d, Tree |
counting size of subtrees |
|
0.0 |
| 11695 |
Fetching from uHunt |
4.6d, Tree |
cut the worst edge along the tree diameter; link two centers; also available at Kattis - flight |
|
0.0 |
| 12186 |
Fetching from uHunt |
4.6d, Tree |
the input graph is a tree |
|
0.0 |
| 12347 |
Fetching from uHunt |
4.6d, Tree |
given pre-order traversal of a BST; use BST property to get the BST; output the post-order traversal that BST |
|
0.0 |
| 12379 |
Fetching from uHunt |
4.6d, Tree |
find the diameter of tree first; we only traverse the diameter once and we traverse the other edges twice |
|
0.0 |
| 00663 |
Fetching from uHunt |
4.6e, Bipartite Graph |
try disallowing an edge to see if MCBM changes; which implies that the edge has to be used |
|
0.0 |
| 00670 |
Fetching from uHunt |
4.6e, Bipartite Graph |
MCBM |
|
0.0 |
| 00753 |
Fetching from uHunt |
4.6e, Bipartite Graph |
initially a non standard matching problem but this problem can be reduced to a simple MCBM problem |
|
0.0 |
| 10080 |
Fetching from uHunt |
4.6e, Bipartite Graph |
MCBM; also available at Kattis - gopher2 |
|
0.0 |
| 11138 |
Fetching from uHunt |
4.6e, Bipartite Graph |
a pure MCBM problem |
|
0.0 |
| 12644 |
Fetching from uHunt |
4.6e, Bipartite Graph |
classic MCBM problem wrapped inside a creative problem statement |
|
0.0 |
| 12668 |
Fetching from uHunt |
4.6e, Bipartite Graph |
LA 6525 - LatinAmerica13; split rows/columns due to the presence of pawns; then run MCBM |
|
0.0 |
| 00117 |
Fetching from uHunt |
4.6f, Eulerian Graph |
Euler tour; get cost of tour |
|
0.0 |
| 00291 |
Fetching from uHunt |
4.6f, Eulerian Graph |
Euler tour on a small graph; backtracking is sufficient |
|
0.0 |
| 00302 |
Fetching from uHunt |
4.6f, Eulerian Graph |
Euler tour; print the tour |
|
0.0 |
| 10054 |
Fetching from uHunt |
4.6f, Eulerian Graph |
printing the Euler tour |
|
0.0 |
| 10129 |
Fetching from uHunt |
4.6f, Eulerian Graph |
Euler Graph property check |
|
0.0 |
| 10203 |
Fetching from uHunt |
4.6f, Eulerian Graph |
the underlying graph is Euler graph |
|
0.0 |
| 10596 |
Fetching from uHunt |
4.6f, Eulerian Graph |
Euler Graph property check |
|
0.0 |
| 01315 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
find the pattern; hint: odd indices |
|
0.0 |
| 10014 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
derive the required formula |
|
0.0 |
| 10110 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
check if n is a square number |
|
0.0 |
| 10170 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
one liner formula exists |
|
0.0 |
| 10499 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
simple formula exists |
|
0.0 |
| 10696 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
very simple formula simplification |
|
0.0 |
| 10751 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
trivial for N = 1 and N = 2; derive the formula first for N > 2; hint: use diagonal as much as possible |
|
0.0 |
| 10773 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
several tricky cases |
|
0.0 |
| 10940 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
find the pattern with brute force solution; then submit the optimized solution |
|
0.0 |
| 11202 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
consider symmetry and flip |
|
0.0 |
| 11393 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
draw several small Kn; derive the pattern |
|
0.0 |
| 12004 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
try small n; get the pattern; use long long |
|
0.0 |
| 12027 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
sqrt trick |
|
0.0 |
| 12502 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
must understand the wording trick first |
|
0.0 |
| 12725 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
simple O(1) adhoc math formula manipulation |
|
0.0 |
| 12918 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
sum of arithmetic progression; long long |
|
0.0 |
| 12992 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
simple formula, just 2*N-1 |
|
0.0 |
| 13049 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
simple; for each digit, you should not do more than 5 steps |
|
0.0 |
| 13071 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
simple formula involving sum of arithmetic progression |
|
0.0 |
| 13216 |
Fetching from uHunt |
5.2a, Finding Formula, Easier |
print the first few answer to see the clear pattern; use Big Integer |
|
0.0 |
| 00651 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
use the given sample I/O to derive the simple formula |
|
0.0 |
| 00913 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
derive the short formulas |
|
0.0 |
| 10161 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
sqrt and ceil |
|
0.0 |
| 10257 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
need some mathematical insights; also available at Kattis - dickandjane |
|
0.0 |
| 10493 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
tree; derive the formula |
|
0.0 |
| 10509 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
there are only three different cases |
|
0.0 |
| 10666 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
analyze the binary representation of X |
|
0.0 |
| 10693 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
derive the short Physics formula |
|
0.0 |
| 10710 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
a bit hard to derive the formula; modPow |
|
0.0 |
| 10882 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
inclusion-exclusion principle |
|
0.0 |
| 10970 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
direct formula exists; or use DP |
|
0.0 |
| 10994 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
formula simplification |
|
0.0 |
| 11038 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
define a function f that counts the number of 0s from 1 to n; also available at Kattis - howmanyzeros |
|
0.0 |
| 11170 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
key derivation: cos(NA) = 2cos((N-1)A)*cos(A) - cos((N-2)A); cos(NA) is a polynomial of degree N in cos(A) |
|
0.0 |
| 11231 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
there is an O(1) formula |
|
0.0 |
| 11246 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
derive the formula |
|
0.0 |
| 11296 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
simple formula exists |
|
0.0 |
| 11298 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
simple maths; derive the pattern first |
|
0.0 |
| 11387 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
impossible for odd n or when n = 2; derive the formula |
|
0.0 |
| 11718 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
convert loops to a closed form formula; use modPow to compute the results |
|
0.0 |
| 12909 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
find the pattern; OEIS A001108 |
|
0.0 |
| 13096 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
there are patterns; but the formula is quite hard to find |
|
0.0 |
| 13140 |
Fetching from uHunt |
5.2b, Finding Formula, Harder |
write a brute force program; answer is when i ∈ [9 999..10 005] |
|
0.0 |
| 00290 |
Fetching from uHunt |
5.2c, Base Number Conversion |
also involving palindrome |
|
0.0 |
| 00343 |
Fetching from uHunt |
5.2c, Base Number Conversion |
try all possible pair of bases |
|
0.0 |
| 00355 |
Fetching from uHunt |
5.2c, Base Number Conversion |
basic base number conversion |
|
0.0 |
| 00389 |
Fetching from uHunt |
5.2c, Base Number Conversion |
use Java Integer class |
|
0.0 |
| 00446 |
Fetching from uHunt |
5.2c, Base Number Conversion |
base number conversion |
|
0.0 |
| 10473 |
Fetching from uHunt |
5.2c, Base Number Conversion |
Decimal to Hexadecimal and vice versa; if you use C/C ; you can use strtol |
|
0.0 |
| 10551 |
Fetching from uHunt |
5.2c, Base Number Conversion |
also involving BigInteger mod; also available at Kattis - basicremains |
|
0.0 |
| 11185 |
Fetching from uHunt |
5.2c, Base Number Conversion |
Decimal to base 3 |
|
0.0 |
| 11952 |
Fetching from uHunt |
5.2c, Base Number Conversion |
check base 2 to 18; special case for base 1 |
|
0.0 |
| 00377 |
Fetching from uHunt |
5.2d, Base Number Variants |
base 4 operations |
|
0.0 |
| 00575 |
Fetching from uHunt |
5.2d, Base Number Variants |
base modification |
|
0.0 |
| 00636 |
Fetching from uHunt |
5.2d, Base Number Variants |
base number conversion up to base 99; Java BigInteger cannot be used as it is MAX_RADIX is limited to 36 |
|
0.0 |
| 10093 |
Fetching from uHunt |
5.2d, Base Number Variants |
try all |
|
0.0 |
| 10677 |
Fetching from uHunt |
5.2d, Base Number Variants |
try all from r2 to r1 |
|
0.0 |
| 10931 |
Fetching from uHunt |
5.2d, Base Number Variants |
convert decimal to binary; count number of 1s |
|
0.0 |
| 11005 |
Fetching from uHunt |
5.2d, Base Number Variants |
try all possible bases from 2 to 36 |
|
0.0 |
| 11121 |
Fetching from uHunt |
5.2d, Base Number Variants |
search for the term 'negabinary' |
|
0.0 |
| 11398 |
Fetching from uHunt |
5.2d, Base Number Variants |
just follow the new rules |
|
0.0 |
| 12602 |
Fetching from uHunt |
5.2d, Base Number Variants |
simple base conversion |
|
0.0 |
| 00136 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
use similar technique as UVa 443 |
|
0.0 |
| 00138 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
arithmetic progression formula; precalculation |
|
0.0 |
| 00413 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
simulate; array manipulation |
|
0.0 |
| 00443 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
try all 2^i * 3^j * 5^k * 7^l; sort |
|
0.0 |
| 00640 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
DP bottom up; generate the numbers; flag once |
|
0.0 |
| 00694 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
similar to UVa 100 |
|
0.0 |
| 00927 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
use sum of arithmetic series |
|
0.0 |
| 00962 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
pre-calculate the answer |
|
0.0 |
| 00974 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
there are not that many Kaprekar numbers |
|
0.0 |
| 10006 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
non prime which has >= 3 prime factors |
|
0.0 |
| 10042 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
prime factorization; sum the digits |
|
0.0 |
| 10049 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
enough to get past > 2G by storing only the first 700K numbers of the Self-describing sequence |
|
0.0 |
| 10101 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
follow the problem description carefully |
|
0.0 |
| 10408 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
first; generate (i; j) pairs such that gcd(i; j) = 1; then sort |
|
0.0 |
| 10930 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
ad-hoc; follow the rules given in description |
|
0.0 |
| 11028 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
this is a 'dartboard sequence' |
|
0.0 |
| 11063 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
see if a number is repeated; be careful with -ve |
|
0.0 |
| 11461 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
answer is sqrt(b) - sqrt(a-1) |
|
0.0 |
| 11660 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
simulate; break after $j$-th character |
|
0.0 |
| 11970 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
square numbers; divisibility; brute force |
|
0.0 |
| 12149 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
finding the pattern; square numbers |
|
0.0 |
| 12751 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
sum of arithmetic series [1..N]; inclusion-exclusion |
|
0.0 |
| 13161 |
Fetching from uHunt |
5.2e, Number Systems/Sequences |
sum of arithmetic series [1..N]; -6 for Rita or -3 for Theo; brute force Rita's age; also available at Kattis - candlebox |
|
0.0 |
| 00107 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use logarithm; power |
|
0.0 |
| 00113 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use exp(ln(x)*y) |
|
0.0 |
| 00474 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
this is just a log and pow exercise |
|
0.0 |
| 00545 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use logarithm; power; similar to UVa 474 |
|
0.0 |
| 00701 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use log to count number of digits |
|
0.0 |
| 10916 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use logarithm; power; also available at Kattis - factstone |
|
0.0 |
| 11384 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
find the smallest power of two greater than n; can be solved easily using ceil(eps log2(n)) |
|
0.0 |
| 11556 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
related to power of two; use long long; also available at Kattis - bestcompression |
|
0.0 |
| 11636 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
uses logarithm |
|
0.0 |
| 11666 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
find the formula! |
|
0.0 |
| 11714 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
use decision tree model to find min and second min; eventually the solution only involves logarithm |
|
0.0 |
| 11847 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
O(1) math formula exists: floor(log2(n)) |
|
0.0 |
| 11986 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
log2 (N 1); manual check for precision |
|
0.0 |
| 12416 |
Fetching from uHunt |
5.2f, Log, Exp, Pow |
the answer is log2 of the max consecutive spaces in a line |
|
0.0 |
| 00121 |
Fetching from uHunt |
5.2g, Grid |
use Pythagorean theorem; grid |
|
0.0 |
| 00264 |
Fetching from uHunt |
5.2g, Grid |
grid; pattern |
|
0.0 |
| 00808 |
Fetching from uHunt |
5.2g, Grid |
grid; similar to UVa 10182 |
|
0.0 |
| 00880 |
Fetching from uHunt |
5.2g, Grid |
grid; similar to UVa 264 |
|
0.0 |
| 10022 |
Fetching from uHunt |
5.2g, Grid |
this is not an SSSP problem; find the pattern in this grid (triangle)-like system |
|
0.0 |
| 10182 |
Fetching from uHunt |
5.2g, Grid |
grid |
|
0.0 |
| 10233 |
Fetching from uHunt |
5.2g, Grid |
the number of items in row forms arithmetic progression series; use hypot |
|
0.0 |
| 10620 |
Fetching from uHunt |
5.2g, Grid |
just simulate the jumps; also available at Kattis - fleaonachessboard |
|
0.0 |
| 10642 |
Fetching from uHunt |
5.2g, Grid |
the reverse of UVa 264 |
|
0.0 |
| 10964 |
Fetching from uHunt |
5.2g, Grid |
convert the coordinates to (x; y); then this problem is just about finding Euclidean distance between two coordinates |
|
0.0 |
| 12705 |
Fetching from uHunt |
5.2g, Grid |
we need to match grid cells to characters; there is a greedy solution; find the required pattern |
|
0.0 |
| 00126 |
Fetching from uHunt |
5.2h, Polynomial |
polynomial multiplication and tedious output formatting |
|
0.0 |
| 00392 |
Fetching from uHunt |
5.2h, Polynomial |
follow the orders; output formatting |
|
0.0 |
| 00498 |
Fetching from uHunt |
5.2h, Polynomial |
polynomial evaluation |
|
0.0 |
| 00930 |
Fetching from uHunt |
5.2h, Polynomial |
Ruffini's rule; roots of quadratic eq |
|
0.0 |
| 10215 |
Fetching from uHunt |
5.2h, Polynomial |
two trivial cases for smallest; derive the formula for largest which involves quadratic equation |
|
0.0 |
| 10268 |
Fetching from uHunt |
5.2h, Polynomial |
polynomial derivation; Horner's rule |
|
0.0 |
| 10302 |
Fetching from uHunt |
5.2h, Polynomial |
use long double |
|
0.0 |
| 10326 |
Fetching from uHunt |
5.2h, Polynomial |
given roots of the polynomial; reconstruct the polynomial; formatting |
|
0.0 |
| 10586 |
Fetching from uHunt |
5.2h, Polynomial |
compute number of prime factors of each integer in the desired range; use 1D RSQ DP; binary search |
|
0.0 |
| 10719 |
Fetching from uHunt |
5.2h, Polynomial |
polynomial division and remainder |
|
0.0 |
| 00332 |
Fetching from uHunt |
5.2i, Fractions |
use GCD |
|
0.0 |
| 00834 |
Fetching from uHunt |
5.2i, Fractions |
do as asked |
|
0.0 |
| 10555 |
Fetching from uHunt |
5.2i, Fractions |
try every single possible repeating decimals |
|
0.0 |
| 10814 |
Fetching from uHunt |
5.2i, Fractions |
BigInteger gcd |
|
0.0 |
| 10976 |
Fetching from uHunt |
5.2i, Fractions |
total solutions is asked upfront; therefore do brute force twice |
|
0.0 |
| 12068 |
Fetching from uHunt |
5.2i, Fractions |
involving fraction; use LCM and GCD |
|
0.0 |
| 12848 |
Fetching from uHunt |
5.2i, Fractions |
find formula involving fraction and use GCD to simplify it |
|
0.0 |
| 12970 |
Fetching from uHunt |
5.2i, Fractions |
simple Physics time comparison; GCD to simplify fraction |
|
0.0 |
| 00276 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
multiplication of Egyptian hieroglyphs |
|
0.0 |
| 00496 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
set manipulation |
|
0.0 |
| 00613 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
analyze the number; determine the type; similar spirit with the cycle finding problem |
|
0.0 |
| 10023 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
code Newton's method with BigInteger |
|
0.0 |
| 10137 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
be careful with precision error; also available at Kattis - trip |
|
0.0 |
| 10190 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
simulate the process |
|
0.0 |
| 11042 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
case analysis; only 4 possible outputs |
|
0.0 |
| 11055 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
not classic; observation needed to avoid brute-force solution |
|
0.0 |
| 11241 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
the hardest case is computing Dew point given temperature and Humidex; derive it with Algebra |
|
0.0 |
| 11526 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
brute force up to sqrt(n); find the pattern; avoid TLE |
|
0.0 |
| 11715 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
physics simulation |
|
0.0 |
| 11816 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
simple math; precision required |
|
0.0 |
| 12036 |
Fetching from uHunt |
5.2j, Really Ad Hoc |
use pigeon hole principle |
|
0.0 |
| 00406 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; take the middle ones |
|
0.0 |
| 00543 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; complete search; Goldbach's conjecture; similar to UVa 00686, 10311, and 10948 |
|
0.0 |
| 00686 |
Fetching from uHunt |
5.3a, Prime Numbers |
similar to UVa 543; 10311; and 10948 |
|
0.0 |
| 00897 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; just need to check digit rotations |
|
0.0 |
| 00914 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; be careful with L and U < 2 |
|
0.0 |
| 01644 |
Fetching from uHunt |
5.3a, Prime Numbers |
LA 3883 - Tokyo07; sieve; prime check; upper bound - lower bound |
|
0.0 |
| 10140 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; linear scan |
|
0.0 |
| 10168 |
Fetching from uHunt |
5.3a, Prime Numbers |
backtracking with pruning |
|
0.0 |
| 10311 |
Fetching from uHunt |
5.3a, Prime Numbers |
case analysis; brute force; similar to UVa 543; 686; and 10948 |
|
0.0 |
| 10394 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; check if p and p plus 2 are both primes; if yes; they are twin primes; precalculate the result |
|
0.0 |
| 10490 |
Fetching from uHunt |
5.3a, Prime Numbers |
ad Hoc; precalculate the answers |
|
0.0 |
| 10650 |
Fetching from uHunt |
5.3a, Prime Numbers |
3 uni-distance consecutive primes |
|
0.0 |
| 10852 |
Fetching from uHunt |
5.3a, Prime Numbers |
sieve; p = 1; find the first prime number >= n/2 plus 1 |
|
0.0 |
| 10948 |
Fetching from uHunt |
5.3a, Prime Numbers |
Goldbach's conjecture; similar to UVa 543; 686; and 10311 |
|
0.0 |
| 11752 |
Fetching from uHunt |
5.3a, Prime Numbers |
try base: 2 to 2^16; composite power; sort |
|
0.0 |
| 00960 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
there is a number theory behind this |
|
0.0 |
| 01180 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
LA 2350 - Dhaka01; small prime check |
|
0.0 |
| 01210 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
LA 3399 - Tokyo05; simple |
|
0.0 |
| 10235 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
case analysis: prime/emirp/not prime; emirp is prime number that if reversed is still a prime number |
|
0.0 |
| 10924 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
check if the sum of letter values is a prime |
|
0.0 |
| 11287 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
yes if !isPrime(p) && a.modPow(p, p) = a; Big Integer; also available at Kattis - pseudoprime |
|
0.0 |
| 12542 |
Fetching from uHunt |
5.3b, (Prob) Prime Testing |
LA 6149 - HatYai12; brute force; use isProbablePrime to test primality |
|
0.0 |
| 00516 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
problem involving prime-power factorization |
|
0.0 |
| 00583 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
basic factorization problem |
|
0.0 |
| 10392 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
enumerate the prime factors of input |
|
0.0 |
| 11466 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
use efficient sieve implementation to get the largest prime factors |
|
0.0 |
| 12703 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
uses small Fibonacci numbers up to 40 and simple prime factorization as a and b can be non-primes |
|
0.0 |
| 12805 |
Fetching from uHunt |
5.3c, Finding Prime Factors |
prime check; primes of format 4m-1 and 4m plus 1; simple prime factorization |
|
0.0 |
| 00294 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
numDiv(N) |
|
0.0 |
| 00884 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
numPF(N); precalculate |
|
0.0 |
| 01246 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
LA 4340 - Amrita08; numDiv(N) |
|
0.0 |
| 10179 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
EulerPhi(N) |
|
0.0 |
| 10290 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
find number of odd divisors |
|
0.0 |
| 10299 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
EulerPhi(N); also available at Kattis - relatives |
|
0.0 |
| 10820 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
a[i] = a[i-1] plus 2*EulerPhi(i) |
|
0.0 |
| 10958 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
2 * numDiv(n*m*p*p) - 1 |
|
0.0 |
| 11064 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
N - EulerPhi(N) - numDiv(N) |
|
0.0 |
| 11086 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
find numbers N with numPF(N) == 2 |
|
0.0 |
| 11226 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
sumPF(N); get length; DP |
|
0.0 |
| 11353 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
numPF(N); sort variant |
|
0.0 |
| 11728 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
sumDiv(N) |
|
0.0 |
| 12005 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
numDiv(4N-3) |
|
0.0 |
| 13185 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
just see UVa 13194 |
|
0.0 |
| 13194 |
Fetching from uHunt |
5.3d, Prime Factors Functions |
similar to Kattis - almostperfect; sumDiv(N)-N; long long |
|
0.0 |
| 10699 |
Fetching from uHunt |
5.3e, Modified Sieve |
numDiffPF(N) for a range |
|
0.0 |
| 10738 |
Fetching from uHunt |
5.3e, Modified Sieve |
numDiffPF(N) for a range of N |
|
0.0 |
| 10990 |
Fetching from uHunt |
5.3e, Modified Sieve |
modified sieve to compute a range of Euler Phi values; use DP to compute depth Phi values; then finally use Max 1D Range Sum DP to output the answer |
|
0.0 |
| 11327 |
Fetching from uHunt |
5.3e, Modified Sieve |
pre-calculate EulerPhi(N) |
|
0.0 |
| 11426 |
Fetching from uHunt |
5.3e, Modified Sieve |
pre-calculate EulerPhi(N) |
|
0.0 |
| 12043 |
Fetching from uHunt |
5.3e, Modified Sieve |
sumDiv(N) and numDiv(N); brute force |
|
0.0 |
| 00106 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
brute force; use GCD to get relatively prime triples |
|
0.0 |
| 00412 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
brute force; GCD to find elements with no common factor |
|
0.0 |
| 10193 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
convert two binary strings S1 and S2 to decimal and check see if gcd(s1; s2) > 1 |
|
0.0 |
| 10407 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
subtract the set s with s[0]; find gcd |
|
0.0 |
| 10892 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
number of divisor pairs of N: (m; n) such that gcd(m; n) = 1 |
|
0.0 |
| 11388 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
understand the relationship of GCD with LCM |
|
0.0 |
| 11417 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
just use brute force as input is small |
|
0.0 |
| 11774 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
find pattern involving gcd with small test cases |
|
0.0 |
| 11827 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
GCD of many numbers; small input |
|
0.0 |
| 12708 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
actually we do not need to compute the GCD; simply find an easy pattern to solve this problem |
|
0.0 |
| 12852 |
Fetching from uHunt |
5.3f, GCD and/or LCM |
LCM of the N given numbers times 35 |
|
0.0 |
| 00324 |
Fetching from uHunt |
5.3g, Factorial |
count digits of n! up to 366! |
|
0.0 |
| 00568 |
Fetching from uHunt |
5.3g, Factorial |
can use Java BigInteger; slow but AC |
|
0.0 |
| 00623 |
Fetching from uHunt |
5.3g, Factorial |
easy with Java BigInteger |
|
0.0 |
| 10220 |
Fetching from uHunt |
5.3g, Factorial |
use Java BigInteger; precalculate |
|
0.0 |
| 10323 |
Fetching from uHunt |
5.3g, Factorial |
overflow: n>13/-odd n; underflow: n$<$8/-even n; PS: actually; factorial of negative number is not defined |
|
0.0 |
| 10338 |
Fetching from uHunt |
5.3g, Factorial |
use long long to store up to 20! |
|
0.0 |
| 11076 |
Fetching from uHunt |
5.3g, Factorial |
do not use next_permutation for 12!; TLE; observe the digits in all permutations; hint: the solution involves factorial |
|
0.0 |
| 12335 |
Fetching from uHunt |
5.3g, Factorial |
given the k-th permutation, recover the 1st permutation; use factorial; use Java BigInteger |
|
0.0 |
| 12869 |
Fetching from uHunt |
5.3g, Factorial |
LA 6847 - Bangkok 2014; every zero in factorial(n) is due to multiplication of factor 2 and 5; factor 2 grows faster than factor 5; this is a major hint |
|
0.0 |
| 12934 |
Fetching from uHunt |
5.3g, Factorial |
can use brute force; stop at n not more than sqrt(k); m smaller than n |
|
0.0 |
| 00160 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
precalculate small primes as prime factors of 100! is < 100$ |
|
0.0 |
| 00993 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
find divisors from 9 down to 1; similar to UVa 10527 |
|
0.0 |
| 10061 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
in Decimal; '10' with 1 zero is due to factor 2*5 |
|
0.0 |
| 10139 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
factorize m; see if it has support in n!; Legendre's formula; also available at Kattis - factovisors |
|
0.0 |
| 10484 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
prime factors of factorial; D can be negative |
|
0.0 |
| 10527 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
similar to UVa 00993; also available at Kattis - persistent |
|
0.0 |
| 10622 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
GCD of all prime powers; note if x is negative; also available at Kattis - perfectpowers |
|
0.0 |
| 10680 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
use primefactors([1..N]) to get LCM(1; 2; ...; N) |
|
0.0 |
| 10780 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
similar to UVa 10139 |
|
0.0 |
| 10791 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
analyze the prime factors of N |
|
0.0 |
| 11347 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
prime-power factorization; numDiv(N) |
|
0.0 |
| 11395 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
key hint: a square number multiplied by powers of two; i.e. 2^k * i^2 for k >= 0; i >= 1 has odd sum of divisors |
|
0.0 |
| 11889 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
LCM; involving prime factorization |
|
0.0 |
| 13067 |
Fetching from uHunt |
5.3h, Working with Prime Factors |
cryptic problem description, it turns out that the restaurant uses prime power system; output sum of prime powers |
|
0.0 |
| 00128 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
(a * b) % s = ((a % s) * (b % s)) % s |
|
0.0 |
| 10127 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
no factor of 2 and 5 implies that there is no trailing zero |
|
0.0 |
| 10174 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
no Spinster number |
|
0.0 |
| 10176 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
convert binary to decimal digit by digit; do modulo 131071 to the intermediate result |
|
0.0 |
| 10212 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
multiply numbers from N down to N-M+1; use / 10 to discard the trailing zero(es); use % 1 Billion |
|
0.0 |
| 10489 |
Fetching from uHunt |
5.3i, Modular Arithmetic |
keep values small with modulo |
|
0.0 |
| 10090 |
Fetching from uHunt |
5.3j, Extended Euclid |
use solution for Linear Diophantine Equation |
|
0.0 |
| 10104 |
Fetching from uHunt |
5.3j, Extended Euclid |
pure Ext Euclid problem |
|
0.0 |
| 10633 |
Fetching from uHunt |
5.3j, Extended Euclid |
let C = N-M, N = 10a+b, and M = a; Linear Diophantine Equation: 9a+b = C |
|
0.0 |
| 10673 |
Fetching from uHunt |
5.3j, Extended Euclid |
uses Extended Euclidean |
|
0.0 |
| 10922 |
Fetching from uHunt |
5.3k, Divisibility Test |
test divisibility by 9 |
|
0.0 |
| 10929 |
Fetching from uHunt |
5.3k, Divisibility Test |
test divisibility by 11 |
|
0.0 |
| 11344 |
Fetching from uHunt |
5.3k, Divisibility Test |
use divisibility theory of [1..12] |
|
0.0 |
| 11371 |
Fetching from uHunt |
5.3k, Divisibility Test |
the solving strategy is given |
|
0.0 |
| 00495 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
O(n) DP; Big Integer |
|
0.0 |
| 00580 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
related to Tribonacci series |
|
0.0 |
| 00763 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
Zeckendorf representation; greedy; Big Integer |
|
0.0 |
| 00900 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
combinatorics; the pattern ~ Fibonacci |
|
0.0 |
| 00948 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
Zeckendorf representation; greedy |
|
0.0 |
| 01258 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
LA 4721 - Phuket09; Fibonacci variant; Zeckendorf representation; greedy |
|
0.0 |
| 10183 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
get the number of Fibonaccis when generating them; BigInteger |
|
0.0 |
| 10334 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
combinatorics; Big Integer |
|
0.0 |
| 10450 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
combinatorics; the pattern ~ Fibonacci |
|
0.0 |
| 10497 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
the pattern ~ Fibonacci |
|
0.0 |
| 10579 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
very easy with Java BigInteger |
|
0.0 |
| 10689 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
easy; Pisano period |
|
0.0 |
| 10862 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
the pattern ends up ~ Fibonacci |
|
0.0 |
| 11000 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
combinatorics; the pattern is similar to Fibonacci |
|
0.0 |
| 11089 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
the list of Fi-binary Numbers follow the Zeckendorf's theorem |
|
0.0 |
| 11161 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
Fibonacci median |
|
0.0 |
| 11780 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
the background problem is Fibonacci numbers |
|
0.0 |
| 12281 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
Zeckendorf theorem a bit of combinatorics |
|
0.0 |
| 12620 |
Fetching from uHunt |
5.4a, Fibonacci Numbers |
Pisano period of 10^2 = 300 |
|
0.0 |
| 00326 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
difference table |
|
0.0 |
| 00369 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
be careful with overflow issue |
|
0.0 |
| 00485 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
binomial coefficients BigInteger |
|
0.0 |
| 00530 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
work with doubles; optimize computation |
|
0.0 |
| 00911 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
there is a formula for this: result = n! / (z_1! * z_2! * z_3! * ... * z_k!$) |
|
0.0 |
| 10105 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
similar to UVa 911 |
|
0.0 |
| 10375 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
the main task is to avoid overflow |
|
0.0 |
| 10532 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
modified binomial coefficient |
|
0.0 |
| 10541 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
a good combinatorics problem |
|
0.0 |
| 11955 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
pure application; DP |
|
0.0 |
| 12712 |
Fetching from uHunt |
5.4b, Binomial Coefficients |
the answer is sum i=M to N of C(L*L;i)*i!; but simplify the computation of this formula instead of running it directly |
|
0.0 |
| 00991 |
Fetching from uHunt |
5.4c, Catalan Numbers |
Catalan Numbers |
|
0.0 |
| 10007 |
Fetching from uHunt |
5.4c, Catalan Numbers |
answer is Cat(n) * n!; BigInteger |
|
0.0 |
| 10223 |
Fetching from uHunt |
5.4c, Catalan Numbers |
you can precalculate the answers as there are only 19 Catalan Numbers < 2^{32}-1 |
|
0.0 |
| 10303 |
Fetching from uHunt |
5.4c, Catalan Numbers |
generate Cat(n) as shown in this section; use Java BigInteger |
|
0.0 |
| 10312 |
Fetching from uHunt |
5.4c, Catalan Numbers |
number of binary bracketing = Cat(n); number of bracketing = Super-Catalan numbers |
|
0.0 |
| 10643 |
Fetching from uHunt |
5.4c, Catalan Numbers |
Cat(n) is part of a bigger problem |
|
0.0 |
| 10079 |
Fetching from uHunt |
5.4d, Others, Easier |
derive the one liner formula |
|
0.0 |
| 11115 |
Fetching from uHunt |
5.4d, Others, Easier |
N^D; use Java BigInteger |
|
0.0 |
| 11310 |
Fetching from uHunt |
5.4d, Others, Easier |
requires DP: let dp[i] be the number of ways the cakes can be packed for a box 2*i |
|
0.0 |
| 11401 |
Fetching from uHunt |
5.4d, Others, Easier |
spot the pattern |
|
0.0 |
| 11480 |
Fetching from uHunt |
5.4d, Others, Easier |
try all r; but simpler formula exists |
|
0.0 |
| 11597 |
Fetching from uHunt |
5.4d, Others, Easier |
uses knowledge of graph theory; the answer is very trivial |
|
0.0 |
| 11609 |
Fetching from uHunt |
5.4d, Others, Easier |
N * 2^(N-1); use Java BigInteger for the modPow part |
|
0.0 |
| 12463 |
Fetching from uHunt |
5.4d, Others, Easier |
double the socks and the shoes to simplify the problem |
|
0.0 |
| 00153 |
Fetching from uHunt |
5.4e, Others, Harder |
find formula for this; similar with UVa 941 |
|
0.0 |
| 00941 |
Fetching from uHunt |
5.4e, Others, Harder |
formula to get the n-th permutation |
|
0.0 |
| 01224 |
Fetching from uHunt |
5.4e, Others, Harder |
LA 3904 - Seoul07; derive formula from observing the small instances first |
|
0.0 |
| 10359 |
Fetching from uHunt |
5.4e, Others, Harder |
derive the formula; use Java BigInteger |
|
0.0 |
| 10733 |
Fetching from uHunt |
5.4e, Others, Harder |
Burnside's lemma |
|
0.0 |
| 10784 |
Fetching from uHunt |
5.4e, Others, Harder |
the number of diagonals in n-gon = n*(n-3)/2; use it to derive the solution |
|
0.0 |
| 10790 |
Fetching from uHunt |
5.4e, Others, Harder |
uses arithmetic progression formula |
|
0.0 |
| 10918 |
Fetching from uHunt |
5.4e, Others, Harder |
there are two related recurrences here |
|
0.0 |
| 11069 |
Fetching from uHunt |
5.4e, Others, Harder |
use Dynamic Programming |
|
0.0 |
| 11204 |
Fetching from uHunt |
5.4e, Others, Harder |
only first choice matters |
|
0.0 |
| 11270 |
Fetching from uHunt |
5.4e, Others, Harder |
sequence A004003 in OEIS |
|
0.0 |
| 11538 |
Fetching from uHunt |
5.4e, Others, Harder |
count along rows; columns; and diagonals |
|
0.0 |
| 11554 |
Fetching from uHunt |
5.4e, Others, Harder |
similar to UVa 11401 |
|
0.0 |
| 12001 |
Fetching from uHunt |
5.4e, Others, Harder |
counting; combinatorics |
|
0.0 |
| 12022 |
Fetching from uHunt |
5.4e, Others, Harder |
number of ways n competitors can rank in a competition allowing for the possibility of ties; sequence A000670 in OEIS |
|
0.0 |
| 01636 |
Fetching from uHunt |
5.5a, Probability, Easier |
LA 4596 - NorthEasternEurope09; ad hoc probability question, one tricky special case involving all zeroes |
|
0.0 |
| 10238 |
Fetching from uHunt |
5.5a, Probability, Easier |
DP; s: (dice_left, score); try F values; Big Integer; no need to simplify the fraction; see UVa 10759 |
|
0.0 |
| 10328 |
Fetching from uHunt |
5.5a, Probability, Easier |
DP; 1-D state; Big Integer |
|
0.0 |
| 10491 |
Fetching from uHunt |
5.5a, Probability, Easier |
two ways to get a car: either pick a cow first; then switch to a car; or pick a car first; and then switch to another car |
|
0.0 |
| 10759 |
Fetching from uHunt |
5.5a, Probability, Easier |
DP; s: (dice_left; score); try 6 values; gcd; similar to UVa 10238 |
|
0.0 |
| 11181 |
Fetching from uHunt |
5.5a, Probability, Easier |
iterative brute force; try all possibilities |
|
0.0 |
| 12024 |
Fetching from uHunt |
5.5a, Probability, Easier |
derangement |
|
0.0 |
| 12114 |
Fetching from uHunt |
5.5a, Probability, Easier |
simple probability |
|
0.0 |
| 12230 |
Fetching from uHunt |
5.5a, Probability, Easier |
simple expected value problem |
|
0.0 |
| 12457 |
Fetching from uHunt |
5.5a, Probability, Easier |
simple expected value problem; use DP |
|
0.0 |
| 12461 |
Fetching from uHunt |
5.5a, Probability, Easier |
brute force small n to see that the answer is very easy |
|
0.0 |
| 00542 |
Fetching from uHunt |
5.5b, Probability, Harder |
divide and conquer |
|
0.0 |
| 00557 |
Fetching from uHunt |
5.5b, Probability, Harder |
one possible solution involves combinatorics which can be computed with DP |
|
0.0 |
| 10056 |
Fetching from uHunt |
5.5b, Probability, Harder |
get the closed form formula |
|
0.0 |
| 10218 |
Fetching from uHunt |
5.5b, Probability, Harder |
probability and a bit of binomial coefficients |
|
0.0 |
| 10648 |
Fetching from uHunt |
5.5b, Probability, Harder |
DP; s: (rem_boxes; num_empty) |
|
0.0 |
| 10777 |
Fetching from uHunt |
5.5b, Probability, Harder |
expected value |
|
0.0 |
| 11021 |
Fetching from uHunt |
5.5b, Probability, Harder |
probability |
|
0.0 |
| 11176 |
Fetching from uHunt |
5.5b, Probability, Harder |
DP, s: (rem_games, streak); t: lose this game, or win the next W = [1..n] games and lose the (W+1)-th game |
|
0.0 |
| 11346 |
Fetching from uHunt |
5.5b, Probability, Harder |
a bit of geometry |
|
0.0 |
| 11500 |
Fetching from uHunt |
5.5b, Probability, Harder |
Gambler's Ruin Problem |
|
0.0 |
| 11628 |
Fetching from uHunt |
5.5b, Probability, Harder |
p[i] = ticket bought by i at the last round/total tickets bought at the last round by all n; gcd |
|
0.0 |
| 11762 |
Fetching from uHunt |
5.5b, Probability, Harder |
use Sieve of Eratosthenes to know the rank of each prime number; DP; expected value |
|
0.0 |
| 00202 |
Fetching from uHunt |
5.6a, Cycle Finding |
do expansion digit by digit until it cycles |
|
0.0 |
| 00275 |
Fetching from uHunt |
5.6a, Cycle Finding |
similar to UVa 202 except the output format |
|
0.0 |
| 00350 |
Fetching from uHunt |
5.6a, Cycle Finding |
very basic cycle-finding problem; simply run Floyd's cycle-finding algorithm |
|
0.0 |
| 00408 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle-finding problem with easier solution: it is a good choice if step < mod and GCD(step, mod) == 1 |
|
0.0 |
| 00547 |
Fetching from uHunt |
5.6a, Cycle Finding |
a problem about 'eventually constant' sequence; similar flavor as cycle-finding |
|
0.0 |
| 00942 |
Fetching from uHunt |
5.6a, Cycle Finding |
similar to UVa 202 |
|
0.0 |
| 00944 |
Fetching from uHunt |
5.6a, Cycle Finding |
similar to UVa 10591 |
|
0.0 |
| 10162 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle after 100 steps; use Java BigInteger to read the input; precalculate |
|
0.0 |
| 10515 |
Fetching from uHunt |
5.6a, Cycle Finding |
concentrate on the last digit |
|
0.0 |
| 10591 |
Fetching from uHunt |
5.6a, Cycle Finding |
this sequence is 'eventually periodic'; similar to UVa 944 |
|
0.0 |
| 11036 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle-finding; evaluate Reverse Polish f with a stack |
|
0.0 |
| 11053 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle-finding; the answer is N-lambda |
|
0.0 |
| 11511 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle-finding on vectors; the pattern will cycle fast |
|
0.0 |
| 11549 |
Fetching from uHunt |
5.6a, Cycle Finding |
repeat squaring with limited digits until it cycles; Floyd's cycle-finding algorithm is only used to detect the cycle; we do not use the value of mu or lambda |
|
0.0 |
| 11634 |
Fetching from uHunt |
5.6a, Cycle Finding |
cycle-finding; f(a) = (a*a/100) % 10000; or use DAT |
|
0.0 |
| 12464 |
Fetching from uHunt |
5.6a, Cycle Finding |
although n can be very huge; the pattern is actually cyclic; find the length of the cycle l and modulo n with l |
|
0.0 |
| 13217 |
Fetching from uHunt |
5.6a, Cycle Finding |
the given function cycles very early so we can pre-calculate the answers although $n$ is very big |
|
0.0 |
| 00847 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
simulate the perfect play; also available at Kattis - amultiplicationgame |
|
0.0 |
| 10111 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
Tic-Tac-Toe; minimax; backtracking |
|
0.0 |
| 10368 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
minimax; backtracking; also available at Kattis - euclidsgame |
|
0.0 |
| 10404 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
2 players game; Dynamic Programming; also available at Kattis - bachetsgame |
|
0.0 |
| 10536 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
model the 4*4 board and 48 possible pins as bitmask; then this is a simple two player game |
|
0.0 |
| 10578 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
backtracking; try all; see who wins the game |
|
0.0 |
| 11489 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
game theory; reducible to simple math |
|
0.0 |
| 12293 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
analyze the game tree of smaller instances to get the mathematical insight to solve this problem |
|
0.0 |
| 12469 |
Fetching from uHunt |
5.7a, Game Theory (Basic) |
game playing; Dynamic Programming; pruning |
|
0.0 |
| 00374 |
Fetching from uHunt |
5.8a, Matrix Power |
solvable with Java BigInteger modPow; or write your own code |
|
0.0 |
| 01230 |
Fetching from uHunt |
5.8a, Matrix Power |
LA 4104 - Singapore07; modPow |
|
0.0 |
| 10229 |
Fetching from uHunt |
5.8a, Matrix Power |
Fibonacci; modPow |
|
0.0 |
| 10518 |
Fetching from uHunt |
5.8a, Matrix Power |
derive the pattern of the answers for small $n$; the answer is 2*fib(n)-1; then use UVa 10229 solution |
|
0.0 |
| 10655 |
Fetching from uHunt |
5.8a, Matrix Power |
derive the square matrix |
|
0.0 |
| 10870 |
Fetching from uHunt |
5.8a, Matrix Power |
form the required matrix first; power of matrix |
|
0.0 |
| 11029 |
Fetching from uHunt |
5.8a, Matrix Power |
combination of logarithmic trick to get the first three digits and 'big mod' trick to get the last three digits |
|
0.0 |
| 11486 |
Fetching from uHunt |
5.8a, Matrix Power |
model as adjacency matrix; raise the adjacency matrix to the power of N in O(log N) to get the number of paths |
|
0.0 |
| 11582 |
Fetching from uHunt |
5.8a, Matrix Power |
Pisano period: The sequence f(i)%n is periodic; use modPow |
|
0.0 |
| 12470 |
Fetching from uHunt |
5.8a, Matrix Power |
similar to UVa 10229; the 3*3 matrix is = [0 1 0; 0 0 1; 1 1 1]; the answer is at matrix[1][1] after it is raised to the power of n and with modulo 1000000009 |
|
0.0 |
| 12796 |
Fetching from uHunt |
5.8a, Matrix Power |
count the number of paths of length L in an undirected graph where L can be up to 2^30 |
|
0.0 |
| 00179 |
Fetching from uHunt |
6.2a, Cipher, Harder |
use brute force |
|
0.0 |
| 00213 |
Fetching from uHunt |
6.2a, Cipher, Harder |
LA 5152 - WorldFinals SanAntonio91 |
|
0.0 |
| 00306 |
Fetching from uHunt |
6.2a, Cipher, Harder |
can be made faster by avoiding cycle |
|
0.0 |
| 00385 |
Fetching from uHunt |
6.2a, Cipher, Harder |
a kind of decryption problem; tedious |
|
0.0 |
| 00468 |
Fetching from uHunt |
6.2a, Cipher, Harder |
letter frequency mapping |
|
0.0 |
| 00554 |
Fetching from uHunt |
6.2a, Cipher, Harder |
try all shifts; output formatting |
|
0.0 |
| 00726 |
Fetching from uHunt |
6.2a, Cipher, Harder |
frequency cypher |
|
0.0 |
| 00741 |
Fetching from uHunt |
6.2a, Cipher, Harder |
simulate the process |
|
0.0 |
| 00850 |
Fetching from uHunt |
6.2a, Cipher, Harder |
plaintext attack; tricky test cases |
|
0.0 |
| 00856 |
Fetching from uHunt |
6.2a, Cipher, Harder |
3 nested loops; one for each digit |
|
0.0 |
| 11385 |
Fetching from uHunt |
6.2a, Cipher, Harder |
string manipulation and Fibonacci |
|
0.0 |
| 11697 |
Fetching from uHunt |
6.2a, Cipher, Harder |
follow the description; a bit tedious; also available at Kattis - playfair |
|
0.0 |
| 00134 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check; tedious |
|
0.0 |
| 00171 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check; tedious |
|
0.0 |
| 00172 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
another recursive parser; tedious |
|
0.0 |
| 00384 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check |
|
0.0 |
| 00464 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
generate output based on the given BNF grammar |
|
0.0 |
| 00533 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check |
|
0.0 |
| 00586 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check and output formatting |
|
0.0 |
| 00620 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check |
|
0.0 |
| 00622 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check/evaluation |
|
0.0 |
| 00743 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check |
|
0.0 |
| 10854 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive parsing plus counting |
|
0.0 |
| 11070 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar evaluation |
|
0.0 |
| 11291 |
Fetching from uHunt |
6.2b, Input Parsing (Recursive) |
recursive grammar check |
|
0.0 |
| 00325 |
Fetching from uHunt |
6.2c, Regular Expression |
trivial with regex |
|
0.0 |
| 00494 |
Fetching from uHunt |
6.2c, Regular Expression |
trivial with regex |
|
0.0 |
| 00576 |
Fetching from uHunt |
6.2c, Regular Expression |
solvable with regex |
|
0.0 |
| 10058 |
Fetching from uHunt |
6.2c, Regular Expression |
solvable with regex |
|
0.0 |
| 00159 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tedious output formatting problem |
|
0.0 |
| 00330 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
use map to help |
|
0.0 |
| 00338 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tedious |
|
0.0 |
| 00373 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
check 'g' versus 'p'; ad hoc |
|
0.0 |
| 00426 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tokenize; sort; reformat output |
|
0.0 |
| 00570 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
use map to help |
|
0.0 |
| 00645 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
use recursion to simulate directory structure as it helps the output formatting |
|
0.0 |
| 00848 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tedious string processing |
|
0.0 |
| 00890 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
simulation; follow the steps; tedious |
|
0.0 |
| 00918 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tedious; follow the steps |
|
0.0 |
| 01219 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
LA 3791 - Tehran06 |
|
0.0 |
| 10333 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
a real time waster problem |
|
0.0 |
| 10562 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
output formatting with clever recursion |
|
0.0 |
| 10761 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tricky with output formatting; note that 'END' is part of input |
|
0.0 |
| 10800 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
tedious problem |
|
0.0 |
| 10875 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
simple but tedious problem |
|
0.0 |
| 11403 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
similar with UVa 00338; tedious |
|
0.0 |
| 12155 |
Fetching from uHunt |
6.2d, Output Formatting, Harder |
LA 4403 - KualaLumpur08; use proper index manipulation |
|
0.0 |
| 00409 |
Fetching from uHunt |
6.2e, String Comparison |
tokenize and compare with list of excuses |
|
0.0 |
| 00644 |
Fetching from uHunt |
6.2e, String Comparison |
use brute force |
|
0.0 |
| 00671 |
Fetching from uHunt |
6.2e, String Comparison |
string comparison |
|
0.0 |
| 00912 |
Fetching from uHunt |
6.2e, String Comparison |
simulation; find and replace |
|
0.0 |
| 11048 |
Fetching from uHunt |
6.2e, String Comparison |
flexible string comparison with respect to a dictionary |
|
0.0 |
| 11056 |
Fetching from uHunt |
6.2e, String Comparison |
sorting; case-insensitive string comparison |
|
0.0 |
| 11233 |
Fetching from uHunt |
6.2e, String Comparison |
string comparison |
|
0.0 |
| 11713 |
Fetching from uHunt |
6.2e, String Comparison |
modified string comparison |
|
0.0 |
| 11734 |
Fetching from uHunt |
6.2e, String Comparison |
custom comparison |
|
0.0 |
| 00263 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
sort digits; convert to integers; check cycle |
|
0.0 |
| 00892 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
basic string processing problem |
|
0.0 |
| 00943 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
the Portuguese rule is not given; use translation service in the Internet to help you solve this problem |
|
0.0 |
| 01215 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
LA 3669 - Hanoi06 |
|
0.0 |
| 10045 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
brute force string processing |
|
0.0 |
| 10115 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
simply do as asked in the problem description; uses string |
|
0.0 |
| 10126 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
sort the words to simplify this problem; also available at Kattis - zipfslaw |
|
0.0 |
| 10197 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
must follow the description very closely |
|
0.0 |
| 10361 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
read; tokenize; process as requested |
|
0.0 |
| 10391 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
more like a data structure problem |
|
0.0 |
| 10393 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
follow problem description |
|
0.0 |
| 10508 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
number of words = number of letters plus 1 |
|
0.0 |
| 10679 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
the test data weak; just checking if T is a prefix of S is AC when it should not |
|
0.0 |
| 11452 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
string period; small input; brute force |
|
0.0 |
| 11483 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
straightforward; use 'escape character' |
|
0.0 |
| 11839 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
illegal if mark 0 or >1 alternatives |
|
0.0 |
| 11962 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
find formula; similar to UVa 941; base 4 |
|
0.0 |
| 12243 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
simple string tokenizer problem |
|
0.0 |
| 12414 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
brute force problem involving string |
|
0.0 |
| 12916 |
Fetching from uHunt |
6.2f, Really Ad Hoc |
factorize n; string period; also see UVa 11452 |
|
0.0 |
| 00164 |
Fetching from uHunt |
6.3a, DP String, Classic |
String Alignment/Edit Distance |
|
0.0 |
| 00526 |
Fetching from uHunt |
6.3a, DP String, Classic |
String Alignment/Edit Distance |
|
0.0 |
| 00531 |
Fetching from uHunt |
6.3a, DP String, Classic |
Longest Common Subsequence; print the solution |
|
0.0 |
| 01192 |
Fetching from uHunt |
6.3a, DP String, Classic |
LA2460 - Singapore01; classic String Alignment DP problem with a bit of (unclear) output formatting |
|
0.0 |
| 01207 |
Fetching from uHunt |
6.3a, DP String, Classic |
LA 3170 - Manila06; classical String Edit problem |
|
0.0 |
| 01244 |
Fetching from uHunt |
6.3a, DP String, Classic |
LA 4336 - Amritapuri08; store the best path between i; j; the DP table contains strings |
|
0.0 |
| 10066 |
Fetching from uHunt |
6.3a, DP String, Classic |
Longest Common Subsequence problem; but not on 'string' |
|
0.0 |
| 10100 |
Fetching from uHunt |
6.3a, DP String, Classic |
Longest Common Subsequence |
|
0.0 |
| 10192 |
Fetching from uHunt |
6.3a, DP String, Classic |
Longest Common Subsequence |
|
0.0 |
| 10405 |
Fetching from uHunt |
6.3a, DP String, Classic |
very classic Longest Common Subsequence problem |
|
0.0 |
| 10635 |
Fetching from uHunt |
6.3a, DP String, Classic |
find LCS of two permutations; also available at Kattis - princeandprincess |
|
0.0 |
| 12747 |
Fetching from uHunt |
6.3a, DP String, Classic |
similar to UVa 10635 |
|
0.0 |
| 13146 |
Fetching from uHunt |
6.3a, DP String, Classic |
classic Edit Distance problem |
|
0.0 |
| 11022 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
s: the min weight of substring [i..j]; also available at Kattis - stringfactoring |
|
0.0 |
| 11081 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
DP on string; s: (t; i; j; k) |
|
0.0 |
| 11084 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
using next_permutation/brute force is probably not the best approach; there is a DP formulation for this |
|
0.0 |
| 11258 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
dp(i) = int from substring [i..k] dp(k) |
|
0.0 |
| 11361 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
counting paths in DAG; need insights for efficient implementation; K > 90 is useless; double DP; use prefix-sum idea |
|
0.0 |
| 11552 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
dp(i; c) = minimum number of chunks after considering the first i segments ending with character c |
|
0.0 |
| 12855 |
Fetching from uHunt |
6.3b, DP String, Non Classic |
s: (pos, len) that describes the cost to transform the string so that S[0..pos-1] are all already 'B's and S[pos..pos+len] will be transformed to Bs |
|
0.0 |
| 00455 |
Fetching from uHunt |
6.4a, String Matching, Standard |
find s in s+s; similar with UVa 10298 |
|
0.0 |
| 00886 |
Fetching from uHunt |
6.4a, String Matching, Standard |
convert first letter of given name and all the letters of the surname into digits; special string matching where we want the matching to start at the prefix of a string |
|
0.0 |
| 01449 |
Fetching from uHunt |
6.4a, String Matching, Standard |
LA 4670 - Hefei09; just use strstr; Suffix Array will get TLE as there are too many long strings to be processed |
|
0.0 |
| 10298 |
Fetching from uHunt |
6.4a, String Matching, Standard |
find s in s+s; similar with UVa 00455; also available at Kattis - powerstrings |
|
0.0 |
| 11362 |
Fetching from uHunt |
6.4a, String Matching, Standard |
string sort; matching |
|
0.0 |
| 11576 |
Fetching from uHunt |
6.4a, String Matching, Standard |
modified string matching; complete search; also available at Kattis - scrollingsign |
|
0.0 |
| 11837 |
Fetching from uHunt |
6.4a, String Matching, Standard |
transform the input of X notes into X-1 distances; then apply KMP |
|
0.0 |
| 00422 |
Fetching from uHunt |
6.4b, String Matching, 2D Grid |
2D grid; backtracking |
|
0.0 |
| 00604 |
Fetching from uHunt |
6.4b, String Matching, 2D Grid |
2D grid; backtracking; sort and compare |
|
0.0 |
| 00736 |
Fetching from uHunt |
6.4b, String Matching, 2D Grid |
2D grid; a bit modified |
|
0.0 |
| 10010 |
Fetching from uHunt |
6.4b, String Matching, 2D Grid |
2D grid; backtracking |
|
0.0 |
| 11283 |
Fetching from uHunt |
6.4b, String Matching, 2D Grid |
2D grid; backtracking; do not count twice |
|
0.0 |
| 00719 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
min lexicographic rotation; O(n log n) build SA |
|
0.0 |
| 00760 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
Longest Common Substring of two strings |
|
0.0 |
| 01223 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
LA 3901 - Seoul07; Longest Repeated Substring (or KMP) |
|
0.0 |
| 01254 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
LA 4657 - Jakarta09; Suffix Array with Segment Tree or Sparse Table; LCP range |
|
0.0 |
| 01584 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
LA 3225 - Seoul04; min lexicographic rotation; similar with UVa 00719; other solutions exist |
|
0.0 |
| 11107 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
Longest Common Substring of > 1/2 of the strings; also available at Kattis - lifeforms |
|
0.0 |
| 11512 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
Longest Repeated Substring |
|
0.0 |
| 11855 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
Longest Repeated Substring that appears X times (2 ≤ X < N); also available at Kattis - buzzwords |
|
0.0 |
| 12506 |
Fetching from uHunt |
6.5a, Suffix Trie/Tree/Array |
we can use Trie to solve this problem |
|
0.0 |
| 11475 |
Fetching from uHunt |
6.6a, String Hashing |
similar with UVa 12467 |
|
0.0 |
| 12467 |
Fetching from uHunt |
6.6a, String Hashing |
hashing/'border' of KMP; see UVa 11475 |
|
0.0 |
| 12604 |
Fetching from uHunt |
6.6a, String Hashing |
try Rabin-Karp/KMP up to 62 times |
|
0.0 |
| 00148 |
Fetching from uHunt |
6.7a, Anagram |
uses backtracking |
|
0.0 |
| 00156 |
Fetching from uHunt |
6.7a, Anagram |
easier with algorithm::sort |
|
0.0 |
| 00195 |
Fetching from uHunt |
6.7a, Anagram |
use algorithm::next_permutation |
|
0.0 |
| 00454 |
Fetching from uHunt |
6.7a, Anagram |
anagram |
|
0.0 |
| 00630 |
Fetching from uHunt |
6.7a, Anagram |
ad hoc; string |
|
0.0 |
| 00642 |
Fetching from uHunt |
6.7a, Anagram |
go through the given small dictionary for the list of possible anagrams |
|
0.0 |
| 10098 |
Fetching from uHunt |
6.7a, Anagram |
very similar to UVa 195 |
|
0.0 |
| 12641 |
Fetching from uHunt |
6.7a, Anagram |
anagram problem variation |
|
0.0 |
| 12770 |
Fetching from uHunt |
6.7a, Anagram |
count frequencies; print odd frequency characters with except the last one -- put it in the middle of a palindrome |
|
0.0 |
| 00257 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
palindrome check (DP-able) plus brute force checks for non embedding criteria |
|
0.0 |
| 00353 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
brute force all substrings; count how many substrings are palindrome |
|
0.0 |
| 00401 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
simple palindrome check |
|
0.0 |
| 10848 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
related to UVa 10453; palindrome check, character frequency check, and a few others |
|
0.0 |
| 10945 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
palindrome check; ignore case and punctuation |
|
0.0 |
| 11221 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
palindrome check; we deal with a matrix (magic square) this time |
|
0.0 |
| 11309 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
palindrome check; on HH:MM format |
|
0.0 |
| 11584 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
use two O(n^2) DP string; one for palindrome check and the other for partitioning |
|
0.0 |
| 11888 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
let ss = s+s; find reverse(s) in ss, but it cannot match the first n chars or the last n chars of ss |
|
0.0 |
| 12960 |
Fetching from uHunt |
6.7b, Palindrome (Checking) |
additional twist; special positioning; DP pair |
|
0.0 |
| 01239 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
LA 4144 - Jakarta08; as S <= 1000; brute-force is enough; consider odd and even length palindromes |
|
0.0 |
| 10018 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
generating palindrome with specific math simulation; very easy |
|
0.0 |
| 10453 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
s: (l; r); t: (l 1; r-1) if S[l] == S[r]; or one plus min of(l 1; r) or (l; r-1); also print the required solution; similar with UVa 10739; 11151; and 11404 |
|
0.0 |
| 10617 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
s: (l; r); counting substrings that are palindrome |
|
0.0 |
| 10739 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
similar to UVa 10453; 11151; and 11404 |
|
0.0 |
| 11151 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
s: (l; r); similar to UVa 10453; 10739; and 11404 |
|
0.0 |
| 11404 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
similar to UVa 10453; 10739; and 11151; print the solution in lexicographically smallest manner |
|
0.0 |
| 12718 |
Fetching from uHunt |
6.7c, Palindrome (Generating) |
LA 6659 - Dhaka13; try all substrings; count character frequencies in them and analyze |
|
0.0 |
| 00152 |
Fetching from uHunt |
7.2a, Points |
sort the 3D points first |
|
0.0 |
| 00587 |
Fetching from uHunt |
7.2a, Points |
Euclidean dist |
|
0.0 |
| 00920 |
Fetching from uHunt |
7.2a, Points |
Euclidean dist |
|
0.0 |
| 01595 |
Fetching from uHunt |
7.2a, Points |
use set to record the positions of all sorted points; check half of the points if the symmetries are in the set too? |
|
0.0 |
| 10357 |
Fetching from uHunt |
7.2a, Points |
Euclidean dist; simple Physics simulation |
|
0.0 |
| 10466 |
Fetching from uHunt |
7.2a, Points |
Euclidean dist |
|
0.0 |
| 10585 |
Fetching from uHunt |
7.2a, Points |
sort the points |
|
0.0 |
| 10832 |
Fetching from uHunt |
7.2a, Points |
3D Euclidean distance; simulation |
|
0.0 |
| 10865 |
Fetching from uHunt |
7.2a, Points |
points and quadrants; simple; also available at Kattis - browniepoints |
|
0.0 |
| 10927 |
Fetching from uHunt |
7.2a, Points |
sort points by gradient; Euclidean dist |
|
0.0 |
| 11012 |
Fetching from uHunt |
7.2a, Points |
find i and j for which this function is maximal: |x_i-x_j| |y_i-y_j| |z_i-z_j|; the solution must be faster than O(n^2) |
|
0.0 |
| 11505 |
Fetching from uHunt |
7.2a, Points |
Euclidean dist; also available at Kattis - logo |
|
0.0 |
| 11894 |
Fetching from uHunt |
7.2a, Points |
about rotating and translating points |
|
0.0 |
| 12704 |
Fetching from uHunt |
7.2a, Points |
circle; radius; but eventually just about computing Euclidean distance |
|
0.0 |
| 00191 |
Fetching from uHunt |
7.2b, Lines |
line segment intersection |
|
0.0 |
| 00378 |
Fetching from uHunt |
7.2b, Lines |
library routines: areParallel; areSame; areIntersect |
|
0.0 |
| 00833 |
Fetching from uHunt |
7.2b, Lines |
recursive check; use the ccw tests |
|
0.0 |
| 00837 |
Fetching from uHunt |
7.2b, Lines |
line segments; sort x-coords first |
|
0.0 |
| 00866 |
Fetching from uHunt |
7.2b, Lines |
use line segment intersection library; O(n^2) solution can pass |
|
0.0 |
| 01249 |
Fetching from uHunt |
7.2b, Lines |
LA 4601 - SoutheastUSA09; vector |
|
0.0 |
| 10242 |
Fetching from uHunt |
7.2b, Lines |
toVec; translate points w.r.t. that vector |
|
0.0 |
| 10250 |
Fetching from uHunt |
7.2b, Lines |
vector; rotation |
|
0.0 |
| 10263 |
Fetching from uHunt |
7.2b, Lines |
use distToLineSegment |
|
0.0 |
| 10902 |
Fetching from uHunt |
7.2b, Lines |
line segment intersection |
|
0.0 |
| 11068 |
Fetching from uHunt |
7.2b, Lines |
simple 2 linear equations with 2 unknowns |
|
0.0 |
| 11343 |
Fetching from uHunt |
7.2b, Lines |
line segment intersection |
|
0.0 |
| 11519 |
Fetching from uHunt |
7.2b, Lines |
n vectors that sum to 0; given n-1 vectors, find the unknown vector; also available at Kattis - logo2 |
|
0.0 |
| 11783 |
Fetching from uHunt |
7.2b, Lines |
O(N^2) brute force line segment intersection tests |
|
0.0 |
| 13117 |
Fetching from uHunt |
7.2b, Lines |
dist + distToLineSegment |
|
0.0 |
| 01388 |
Fetching from uHunt |
7.2c, Circles |
LA 3708 - NortheasternEurope06; divide the circle into n sectors first and then into (n m) sectors |
|
0.0 |
| 10005 |
Fetching from uHunt |
7.2c, Circles |
complete search; use circle2PtsRad |
|
0.0 |
| 10136 |
Fetching from uHunt |
7.2c, Circles |
complete search; use circle2PtsRad; similar with UVa 10005 |
|
0.0 |
| 10180 |
Fetching from uHunt |
7.2c, Circles |
closest point from AB to origin; arc |
|
0.0 |
| 10209 |
Fetching from uHunt |
7.2c, Circles |
square; arcs; similar with UVa 10589 |
|
0.0 |
| 10221 |
Fetching from uHunt |
7.2c, Circles |
finding arc and chord length of a circle |
|
0.0 |
| 10283 |
Fetching from uHunt |
7.2c, Circles |
derive the formula |
|
0.0 |
| 10287 |
Fetching from uHunt |
7.2c, Circles |
derive the formula |
|
0.0 |
| 10432 |
Fetching from uHunt |
7.2c, Circles |
simple problem: area of n-sided reg-polygon in a circle |
|
0.0 |
| 10451 |
Fetching from uHunt |
7.2c, Circles |
inner/outer circle of n-sided reg polygon |
|
0.0 |
| 10573 |
Fetching from uHunt |
7.2c, Circles |
there is no 'impossible' case |
|
0.0 |
| 10589 |
Fetching from uHunt |
7.2c, Circles |
check if point is inside intersection of 4 circles |
|
0.0 |
| 10678 |
Fetching from uHunt |
7.2c, Circles |
area of an ellipse; generalization of the formula for area of a circle |
|
0.0 |
| 12578 |
Fetching from uHunt |
7.2c, Circles |
area of rectangle and circle |
|
0.0 |
| 12748 |
Fetching from uHunt |
7.2c, Circles |
brute force and simple in-circle test |
|
0.0 |
| 00313 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
use trigonometry to project the light to the ground through the pipes; sort the intervals; merge overlapping intervals; if any |
|
0.0 |
| 00427 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
for each 2 consecutive corridors, try rotating the piano by a angle α ∈ [0.1..89.9] degrees; trigonometry |
|
0.0 |
| 10210 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
basic trigonometry |
|
0.0 |
| 10286 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
Law of Sines |
|
0.0 |
| 10387 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
expanding surface; trigonometry |
|
0.0 |
| 10792 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
derive the trigonometry formulas |
|
0.0 |
| 11326 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
trigonometry; tangent; reflection trick |
|
0.0 |
| 11854 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
Pythagorean theorem/triple; also available at Kattis - egypt |
|
0.0 |
| 11909 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
Law of Sines (or tangent); two possible cases |
|
0.0 |
| 12901 |
Fetching from uHunt |
7.2d, Triangles (Trigonometry) |
tangent, sine, arcsin, etc |
|
0.0 |
| 00143 |
Fetching from uHunt |
7.2e, Triangles + Circles |
count integer points in triangle; beware of precision issue |
|
0.0 |
| 00190 |
Fetching from uHunt |
7.2e, Triangles + Circles |
triangle's circumcircle |
|
0.0 |
| 00375 |
Fetching from uHunt |
7.2e, Triangles + Circles |
triangle'sincircles |
|
0.0 |
| 00438 |
Fetching from uHunt |
7.2e, Triangles + Circles |
compute triangle's circumcircle |
|
0.0 |
| 10195 |
Fetching from uHunt |
7.2e, Triangles + Circles |
triangle'sincircle; Heron's formula |
|
0.0 |
| 10347 |
Fetching from uHunt |
7.2e, Triangles + Circles |
given 3 medians of a triangle; find its area |
|
0.0 |
| 10522 |
Fetching from uHunt |
7.2e, Triangles + Circles |
derive the formula; uses Heron's formula |
|
0.0 |
| 10577 |
Fetching from uHunt |
7.2e, Triangles + Circles |
get center radius of outer circle from 3 points; get all vertices; get the min-x/max-x/min-y/max-y of the polygon; also available at Kattis - boundingbox |
|
0.0 |
| 10991 |
Fetching from uHunt |
7.2e, Triangles + Circles |
Heron's formula; Law of Cosines; area of sector |
|
0.0 |
| 11152 |
Fetching from uHunt |
7.2e, Triangles + Circles |
triangle's (in/circum)circle; Heron's formula |
|
0.0 |
| 11164 |
Fetching from uHunt |
7.2e, Triangles + Circles |
use Triangle properties |
|
0.0 |
| 11281 |
Fetching from uHunt |
7.2e, Triangles + Circles |
circumcircle for a non obtuse triangle; largest side of the triangle for an obtuse triangle |
|
0.0 |
| 11437 |
Fetching from uHunt |
7.2e, Triangles + Circles |
hint: 1/7 |
|
0.0 |
| 11479 |
Fetching from uHunt |
7.2e, Triangles + Circles |
property check |
|
0.0 |
| 11579 |
Fetching from uHunt |
7.2e, Triangles + Circles |
sort; greedily check if three successive sides satisfy triangle inequality and if it is the largest triangle found so far |
|
0.0 |
| 11936 |
Fetching from uHunt |
7.2e, Triangles + Circles |
see if 3 sides form a valid triangle |
|
0.0 |
| 13215 |
Fetching from uHunt |
7.2e, Triangles + Circles |
area of rectangle minus area of squares and equilateral triangles |
|
0.0 |
| 00155 |
Fetching from uHunt |
7.2f, Quadrilaterals |
recursive counting |
|
0.0 |
| 00209 |
Fetching from uHunt |
7.2f, Quadrilaterals |
LA 5148 - WorldFinals SanAntonio91; brute force check; answer is either triangle, parallelogram, or hexagon |
|
0.0 |
| 00460 |
Fetching from uHunt |
7.2f, Quadrilaterals |
rectangle-rectangle intersection |
|
0.0 |
| 00476 |
Fetching from uHunt |
7.2f, Quadrilaterals |
basic problem; also see related problems: UVa 00477 and 00478 |
|
0.0 |
| 00477 |
Fetching from uHunt |
7.2f, Quadrilaterals |
similar with UVa 00476 and 00478 |
|
0.0 |
| 11207 |
Fetching from uHunt |
7.2f, Quadrilaterals |
cutting rectangle into 4-equal-sized squares |
|
0.0 |
| 11314 |
Fetching from uHunt |
7.2f, Quadrilaterals |
a thin line cake that is formed by stretching line segment AB until it hits the y and x-axis is the quadrilateral with smallest perimeter |
|
0.0 |
| 11345 |
Fetching from uHunt |
7.2f, Quadrilaterals |
rectangle-rectangle intersection |
|
0.0 |
| 11455 |
Fetching from uHunt |
7.2f, Quadrilaterals |
property check |
|
0.0 |
| 11639 |
Fetching from uHunt |
7.2f, Quadrilaterals |
rectangle-rectangle intersection; use flag array |
|
0.0 |
| 11648 |
Fetching from uHunt |
7.2f, Quadrilaterals |
derive the closed form formula |
|
0.0 |
| 11800 |
Fetching from uHunt |
7.2f, Quadrilaterals |
use next_permutation to try all possible 4! = 24 permutations of 4 points; check the requirements |
|
0.0 |
| 11834 |
Fetching from uHunt |
7.2f, Quadrilaterals |
packing two circles in a rectangle |
|
0.0 |
| 12256 |
Fetching from uHunt |
7.2f, Quadrilaterals |
LA 5001 - KualaLumpur10; first 3 sides are 1, 1, 1; the 4th side onwards are sum of previous threes |
|
0.0 |
| 12611 |
Fetching from uHunt |
7.2f, Quadrilaterals |
a problem involving a rectangle and a circle |
|
0.0 |
| 12894 |
Fetching from uHunt |
7.2f, Quadrilaterals |
continuation of UVa 12611; another problem involving a rectangle and a circle |
|
0.0 |
| 00478 |
Fetching from uHunt |
7.3a, Polygon, Easier |
inPolygon/Triangle/Circle/Rectangle |
|
0.0 |
| 00634 |
Fetching from uHunt |
7.3a, Polygon, Easier |
basic inPolygon routine; notice that the input polygon can be convex or concave |
|
0.0 |
| 00681 |
Fetching from uHunt |
7.3a, Polygon, Easier |
CH; with output formatting |
|
0.0 |
| 01206 |
Fetching from uHunt |
7.3a, Polygon, Easier |
LA 3169 - Manila06; CH; input is formatted in complex manner |
|
0.0 |
| 10060 |
Fetching from uHunt |
7.3a, Polygon, Easier |
area of polygon; area of circle |
|
0.0 |
| 10112 |
Fetching from uHunt |
7.3a, Polygon, Easier |
test if point inPolygon/inTriangle; similar with UVa 478 |
|
0.0 |
| 11072 |
Fetching from uHunt |
7.3a, Polygon, Easier |
find CH and then check if the query point inside is inside the convex hull |
|
0.0 |
| 11096 |
Fetching from uHunt |
7.3a, Polygon, Easier |
very classic CH problem; perimeter of polygon |
|
0.0 |
| 11447 |
Fetching from uHunt |
7.3a, Polygon, Easier |
area of polygon |
|
0.0 |
| 11473 |
Fetching from uHunt |
7.3a, Polygon, Easier |
modified perimeter of polygon |
|
0.0 |
| 11626 |
Fetching from uHunt |
7.3a, Polygon, Easier |
find CH; be careful with collinear points |
|
0.0 |
| 00109 |
Fetching from uHunt |
7.3b, Polygon, Harder |
find CH; test if point inPolygon; compute area of polygon |
|
0.0 |
| 00132 |
Fetching from uHunt |
7.3b, Polygon, Harder |
brute force as instructed in problem description; use polygon routines |
|
0.0 |
| 00137 |
Fetching from uHunt |
7.3b, Polygon, Harder |
convex polygon intersection; line segment intersection; inPolygon; CH; area; inclusion-exclusion principle |
|
0.0 |
| 00218 |
Fetching from uHunt |
7.3b, Polygon, Harder |
LA 5157 - WorldFinals KansasCity92; find CH; perimeter of polygon |
|
0.0 |
| 00361 |
Fetching from uHunt |
7.3b, Polygon, Harder |
check if a point is inside CH of Cop/Robber; if $pt$ is inside CH, pt satisfies the requirement |
|
0.0 |
| 00596 |
Fetching from uHunt |
7.3b, Polygon, Harder |
basic CH problem; but output formatting is a bit tedious |
|
0.0 |
| 00858 |
Fetching from uHunt |
7.3b, Polygon, Harder |
vertical line and polygon intersection; sort; alternating segments |
|
0.0 |
| 01111 |
Fetching from uHunt |
7.3b, Polygon, Harder |
LA 5138 - WorldFinals Orlando11; CH; output minimax distance of each CH side to the other vertices |
|
0.0 |
| 10002 |
Fetching from uHunt |
7.3b, Polygon, Harder |
centroid; center of CH; area of polygon |
|
0.0 |
| 10065 |
Fetching from uHunt |
7.3b, Polygon, Harder |
find area of polygon; the CH; then area of CH |
|
0.0 |
| 10256 |
Fetching from uHunt |
7.3b, Polygon, Harder |
given 2 CHs, output 'No' if there is a point in 1st CH inside the 2nd one; 'Yes' otherwise |
|
0.0 |
| 10406 |
Fetching from uHunt |
7.3b, Polygon, Harder |
vector; rotate; translate; then cutPolygon |
|
0.0 |
| 10445 |
Fetching from uHunt |
7.3b, Polygon, Harder |
angle checks; use library code; some corner cases exist |
|
0.0 |
| 10652 |
Fetching from uHunt |
7.3b, Polygon, Harder |
rotate; translate; CH; area; also available at Kattis - wrapping |
|
0.0 |
| 11265 |
Fetching from uHunt |
7.3b, Polygon, Harder |
seems to be a complex problem; but essentially just cutPolygon; inPolygon; area |
|
0.0 |
| 00535 |
Fetching from uHunt |
7.4a, 3D Geometry |
gcDistance |
|
0.0 |
| 00737 |
Fetching from uHunt |
7.4a, 3D Geometry |
cube and cube intersection |
|
0.0 |
| 00815 |
Fetching from uHunt |
7.4a, 3D Geometry |
LA 5215 - WorldFinals Eindhoven99; volume; greedy |
|
0.0 |
| 01280 |
Fetching from uHunt |
7.4a, 3D Geometry |
LA 6027 - WorldFinals Warsaw12; BSTA+geometric formula; also available at Kattis - bottles |
|
0.0 |
| 10297 |
Fetching from uHunt |
7.4a, 3D Geometry |
volumes of cylinders and cones; inclusion-exclusion; also available at Kattis - beavergnaw |
|
0.0 |
| 10316 |
Fetching from uHunt |
7.4a, 3D Geometry |
gcDistance; also available at Kattis - airlinehub |
|
0.0 |
| 10897 |
Fetching from uHunt |
7.4a, 3D Geometry |
gcDistance |
|
0.0 |
| 11817 |
Fetching from uHunt |
7.4a, 3D Geometry |
gcDistance; 3D Euclidean distance; also available at Kattis - tunnelingtheearth |
|
0.0 |
| 00131 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
backtracking with 2^5 bitmask to help deciding which card is retained in hand/exchanged with the top of deck; use 5! permutation to shuffle the 5 cards in hand |
|
0.0 |
| 00211 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
map the complex bone IDs to pips using 2D array; use backtracking to try the placement of various domino bones |
|
0.0 |
| 00387 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
use backtracking to try placement of various puzzle pieces |
|
0.0 |
| 00710 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
backtracking with memoization/pruning |
|
0.0 |
| 00711 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
backtracking with pruning |
|
0.0 |
| 01052 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
LA 3565 - WorldFinals SanAntonio06; backtracking with some form of bitmask |
|
0.0 |
| 10202 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
backtracking; pruning |
|
0.0 |
| 10309 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
brute force the first row in 2^10; the rest follows |
|
0.0 |
| 10318 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
the order is not important, so we can try pressing the buttons in increasing order, row by row, column by column |
|
0.0 |
| 10422 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
Depth Limited Search (up to 11 moves); also available at Kattis - knightsfen |
|
0.0 |
| 10890 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
looks like a DP problem but the state---involving bitmask---cannot be memoized; fortunately the grid size is small |
|
0.0 |
| 11090 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
this is the simplest form of Min Mean Cycle problem; however it has small constraints and thus this problem is still solvable with just backtracking |
|
0.0 |
| 11127 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
backtracking with bitmask |
|
0.0 |
| 11195 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
use backtracking with bitmask |
|
0.0 |
| 11451 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
the input constraints are small; backtracking with bitmask without memoization; or use DP |
|
0.0 |
| 11464 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
brute force the first row in 2^15; the rest follows |
|
0.0 |
| 11471 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
reduce search space by grouping tiles of the same type; recursive backtracking |
|
0.0 |
| 11699 |
Fetching from uHunt |
8.2a, Challenging Backtracking |
try all the possible row combinations on which we put rooks and keep the best |
|
0.0 |
| 00298 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (row; col; 49 possible speeds) |
|
0.0 |
| 00928 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (row; col; direction; step) |
|
0.0 |
| 01600 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
LA 3670 - Hanoi06; s: (row; col; k_left); reset k_left to the original k as soon as the robot enters a non obstacle cell |
|
0.0 |
| 10047 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (row, col, dir, color) |
|
0.0 |
| 10097 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (N1; N2); implicit unweighted graph |
|
0.0 |
| 10306 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (conventional-value, infotechnological-value); BFS; also available at Kattis - ecoins |
|
0.0 |
| 10682 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (current_city; current_speed); output path |
|
0.0 |
| 11513 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (vector of 9 integers); SDSP; BFS |
|
0.0 |
| 11974 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
s: (bitmask); BFS; similar with UVa 12135 |
|
0.0 |
| 12135 |
Fetching from uHunt |
8.2b, State-Space, BFS, Easier |
LA 4201 - Dhaka08; s: (bitmask); BFS; similar with UVa 11974 |
|
0.0 |
| 00321 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (position; bitmask 2^10); print the path |
|
0.0 |
| 00704 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
state-space search; use meet-in-the-middle to bring down 4^16 to 2*4^8 |
|
0.0 |
| 00816 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
LA 5216 - WorldFinals Orlando00; build the graph; then run BFS with state s: (row; col; dir) |
|
0.0 |
| 00985 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
4 rotations is the same as 0 rotations; s: (row; col; rotation = [0..3]); find the shortest path from state [1][1][0] to state [R][C][x] where 0 <= x <= 3 |
|
0.0 |
| 01251 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
LA 4637 - Tokyo09 |
|
0.0 |
| 01253 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
LA 4645 - Tokyo09; tedious state modeling |
|
0.0 |
| 01714 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
LA 7155 - WorldFinals Marrakech15; s: (row, col, char_typed); also available at Kattis - keyboard |
|
0.0 |
| 10021 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (row; col; cube position which is a permutation of 6 sides) or up to 10*10*720 = 72000 distinct states |
|
0.0 |
| 10085 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
each vertex is the 9 puzzle configuration; BFS from starting configuration to all vertices; print longest shortest path |
|
0.0 |
| 11160 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (rA; cA; rB; cB; rC; cC); move A; B; C together |
|
0.0 |
| 11198 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (permutation); tricky to code |
|
0.0 |
| 11212 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
meet in the middle |
|
0.0 |
| 11329 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (bitmask); 4 bits for die position; 16 bits for cells with fleas; 6 bits for side with a flea; use map; tedious |
|
0.0 |
| 12445 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
meet in the middle; similar with UVa 11212; uses heavy bitmasking for the 6 operations |
|
0.0 |
| 12569 |
Fetching from uHunt |
8.2c, State-Space, BFS, Harder |
s: (robot_pos, obstacle_mask); BFS |
|
0.0 |
| 00658 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
s: (bitmask---whether a bug is present or not); the state-space graph is weighted |
|
0.0 |
| 01048 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
LA 3561 - WorldFinals SanAntonio06; tedious state-space search problem; use Dijkstra's |
|
0.0 |
| 01057 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
LA 3570 - WorldFinals SanAntonio06; Floyd-Warshall; APSP; reduce to weighted SSSP problem; Dijkstra's |
|
0.0 |
| 10269 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
use Floyd-Warshall to pre-compute APSP using only Villages; use Dijkstra's on s: (u, super_run_left) |
|
0.0 |
| 10923 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
s: (ship_position; location_of_enemies; location_of_obstacles; steps_so_far); implicit weighted graph |
|
0.0 |
| 11374 |
Fetching from uHunt |
8.2d, State-Space, Dijkstra |
each vertex has one more parameter: has the Commercial-Xpress ticket been used? |
|
0.0 |
| 00672 |
Fetching from uHunt |
8.3a, DP level 3 |
s: (gangster_id, openness_level); do not use cur_time as part of the state |
|
0.0 |
| 00882 |
Fetching from uHunt |
8.3a, DP level 3 |
s: (lo, hi, mailbox_left); try all; also available at Kattis - mailbox |
|
0.0 |
| 01172 |
Fetching from uHunt |
8.3a, DP level 3 |
LA 3986 - SouthWesternEurope07; weighted bipartite matching with additional constraints |
|
0.0 |
| 01211 |
Fetching from uHunt |
8.3a, DP level 3 |
LA 3404 - Tokyo05; precompute T[L], the time to run a path of length L; s: (i) - checkpoint i is we change tire |
|
0.0 |
| 10163 |
Fetching from uHunt |
8.3a, DP level 3 |
try all possible safe line L and run DP; s: (id; N_left); t: hire/skip person id for looking at K storage; the DP part is similar to DP 0-1 Knapsack |
|
0.0 |
| 10604 |
Fetching from uHunt |
8.3a, DP level 3 |
the mixing can be done with any pair of chemicals until there are only two chemicals left; memoize the remaining chemicals with help of map; sorting the remaining chemicals help increasing the number of hits to the memo table |
|
0.0 |
| 10645 |
Fetching from uHunt |
8.3a, DP level 3 |
s: (days_left, budget_left, prev_dish, prev_dish_cnt); the first 2 params are knapsack-style; the last 2 params to determine price |
|
0.0 |
| 10898 |
Fetching from uHunt |
8.3a, DP level 3 |
similar to DP bitmask; store state as integer |
|
0.0 |
| 11002 |
Fetching from uHunt |
8.3a, DP level 3 |
a simple DP; use negative offset technique |
|
0.0 |
| 11285 |
Fetching from uHunt |
8.3a, DP level 3 |
maintain the best CAD and USD each day; also available at Kattis - exchangerates |
|
0.0 |
| 11523 |
Fetching from uHunt |
8.3a, DP level 3 |
each part between non-recyclable items must be solved separately; for each part; use O(n^3) DP |
|
0.0 |
| 11555 |
Fetching from uHunt |
8.3a, DP level 3 |
sort; compute tree positions; s: (l_left, r_left), t: put next tree on the left/right; also available at Kattis - aspenavenue |
|
0.0 |
| 12208 |
Fetching from uHunt |
8.3a, DP level 3 |
actually just a simple combinatorics; it is classified here due to the usage of map data structure as the DP table as the range is big |
|
0.0 |
| 12563 |
Fetching from uHunt |
8.3a, DP level 3 |
knapsack style DP; sing or skip a song; special base case; memo of pairs |
|
0.0 |
| 00473 |
Fetching from uHunt |
8.3b, DP level 4 |
the input constraint is not clear; therefore use resizeable vector and compact states |
|
0.0 |
| 00812 |
Fetching from uHunt |
8.3b, DP level 4 |
LA 5212 - WorldFinals Eindhoven99; mix between greedy and DP |
|
0.0 |
| 01222 |
Fetching from uHunt |
8.3b, DP level 4 |
LA 3797 - Tehran06; DP on Tree |
|
0.0 |
| 01231 |
Fetching from uHunt |
8.3b, DP level 4 |
LA 4106 - Singapore07; dimension reduction |
|
0.0 |
| 01238 |
Fetching from uHunt |
8.3b, DP level 4 |
LA 4143 - Jakarta08; offset technique |
|
0.0 |
| 10029 |
Fetching from uHunt |
8.3b, DP level 4 |
use map as memo table |
|
0.0 |
| 10118 |
Fetching from uHunt |
8.3b, DP level 4 |
DP bitmask; not trivial |
|
0.0 |
| 10304 |
Fetching from uHunt |
8.3b, DP level 4 |
classical DP; requires 1D range sum and Knuth-Yao speed up to get O(n^2) solution |
|
0.0 |
| 10482 |
Fetching from uHunt |
8.3b, DP level 4 |
drop one parameter to save memory |
|
0.0 |
| 10559 |
Fetching from uHunt |
8.3b, DP level 4 |
DP with clever state and transitions |
|
0.0 |
| 10626 |
Fetching from uHunt |
8.3b, DP level 4 |
drop parameter n1; recover it from b (number of coke bought), n5, and n10; also available at Kattis - coke |
|
0.0 |
| 12870 |
Fetching from uHunt |
8.3b, DP level 4 |
LA 6848 - Bangkok14; split DP for fishing and nourishing; try all combination of K fishing + 2K nourishing events |
|
0.0 |
| 00702 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
s: (n_above, n_below, go_up) |
|
0.0 |
| 10722 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in implicit DAG; s: (N_digits_left; B; first; previous_digit_is_one) and use a bit of simple combinatorics to get the answer; need to use Java BigInteger |
|
0.0 |
| 11125 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in implicit DAG; the implicit DAG is not trivial; 8 parameters |
|
0.0 |
| 11133 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in DAG; the implicit DAG is not trivial; 2 parameters |
|
0.0 |
| 11375 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in DAG; 2 parameters; be careful that we can create a 0 with 6 sticks; need to use Java BigInteger |
|
0.0 |
| 11432 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in DAG; the implicit DAG is not trivial; 6 parameters |
|
0.0 |
| 12063 |
Fetching from uHunt |
8.3c, Counting Paths, Harder |
counting paths in DAG; s: (zeros; ones; mod); we do not need a parameter to denote the current bit as it can be recovered from zeros ones |
|
0.0 |
| 01076 |
Fetching from uHunt |
8.3d, DP with Bitmask |
LA 4126 - WorldFinals Banff08; preprocess the strings; challenging DP bitmask; output up to 42 possible solutions |
|
0.0 |
| 01099 |
Fetching from uHunt |
8.3d, DP with Bitmask |
LA 4794 - WorldFinals Harbin10; s: (w; bitmask); recover parameter value h |
|
0.0 |
| 01240 |
Fetching from uHunt |
8.3d, DP with Bitmask |
LA 4146 - Jakarta08; a medium-level DP problem |
|
0.0 |
| 01252 |
Fetching from uHunt |
8.3d, DP with Bitmask |
LA 4643 - Tokyo09; DP, s: (mask1, mask2) where mask1/mask2 describes the features/answers, respectively |
|
0.0 |
| 10123 |
Fetching from uHunt |
8.3d, DP with Bitmask |
DP; s: (bitmask) that describes objects that have been taken; use Physics to determine whether those taken objects will cause the tipping or not |
|
0.0 |
| 10149 |
Fetching from uHunt |
8.3d, DP with Bitmask |
DP with bitmask; uses card rules; tedious |
|
0.0 |
| 10364 |
Fetching from uHunt |
8.3d, DP with Bitmask |
bitmask technique can be used |
|
0.0 |
| 10817 |
Fetching from uHunt |
8.3d, DP with Bitmask |
s: (id; bitmask) |
|
0.0 |
| 10911 |
Fetching from uHunt |
8.3d, DP with Bitmask |
the intro problem of this book; DP with bitmask; weighted MCM; small complete weighted graph |
|
0.0 |
| 11218 |
Fetching from uHunt |
8.3d, DP with Bitmask |
still solvable with complete search |
|
0.0 |
| 11391 |
Fetching from uHunt |
8.3d, DP with Bitmask |
counting paths in DAG; the implicit DAG is not trivial; 3 parameters with 1 bitmask parameter that describes the 2D grid |
|
0.0 |
| 11472 |
Fetching from uHunt |
8.3d, DP with Bitmask |
counting paths in DAG; the implicit DAG is not trivial; 4 parameters with 1 bitmask parameter |
|
0.0 |
| 11806 |
Fetching from uHunt |
8.3d, DP with Bitmask |
counting paths in DAG; s: (r; c; rem_cheerleader; bitmask); bitmask is a 4 bit integer to check if all 4 corners have at least one cheerleader |
|
0.0 |
| 11825 |
Fetching from uHunt |
8.3d, DP with Bitmask |
first; use iterative brute force: try which subset of vertices can cover all vertices; then use DP to figure out the best possible attacks |
|
0.0 |
| 12030 |
Fetching from uHunt |
8.3d, DP with Bitmask |
counting paths in DAG; the implicit DAG is not trivial; s: (idx; bitmask; all1; has2); t: try all shoes that has not been matched to the girl that choose dress 'idx' |
|
0.0 |
| 00259 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
assignment problem; matching with capacity; similar to UVa 10092; 11045; and 12873; but actually the input constraint is actually small enough for recursive backtracking |
|
0.0 |
| 00820 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
LA 5220 - WorldFinals Orlando00; very basic max flow problem |
|
0.0 |
| 10092 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
assignment problem; matching with capacity; similar to UVa 259; 11045; and 12873 |
|
0.0 |
| 10511 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
matching; max flow; print the assignment; also available at Kattis - councilling |
|
0.0 |
| 10779 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
build a flow graph s.t. each augmenting path corresponds to a series of exchange of duplicate stickers; repeat until this is no longer possible |
|
0.0 |
| 11045 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
assignment problem; matching with capacity; similar to UVa 259; 10092; and 12873; but actually the input constraint is actually small enough for recursive backtracking |
|
0.0 |
| 11082 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
very similar to Kattis - tomography |
|
0.0 |
| 11167 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
many edges in the flow graph; compress the capacity-1 edges when possible; use Dinic's |
|
0.0 |
| 11418 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
two layers of graph matching (not really bipartite matching); use max flow solution |
|
0.0 |
| 12873 |
Fetching from uHunt |
8.4a, Network Flow, Standard |
LA 6851 - Bangkok14; assignment problem; similar to UVa 00259, 11045, and 10092; use Dinic's |
|
0.0 |
| 00563 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
check whether the maximum number of independent paths on the flow graph equals to b banks |
|
0.0 |
| 01242 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
LA 4271 - Hefei08; to have a necklace; we need to be able to two edge-disjoint s-t flows |
|
0.0 |
| 10330 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
max flow; vertex capacities |
|
0.0 |
| 10480 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
straightforward min cut problem |
|
0.0 |
| 11380 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
max flow modeling with vertex capacities; similar to UVa 12125 |
|
0.0 |
| 11506 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
min cut with vertex capacities |
|
0.0 |
| 11757 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
creative problem about min cut; build the flow graph with a bit of simple geometry involving circle; then find the min cut from source (left side) to sink (right side) |
|
0.0 |
| 11765 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
interesting min cut variant |
|
0.0 |
| 12125 |
Fetching from uHunt |
8.4b, Network Flow, Variants |
max flow modeling with vertex capacities; similar to UVa 11380; also available at Kattis - marchofpenguins |
|
0.0 |
| 00193 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
optimization version of Max Independent Set problem on general graph which is NP-Hard with small input |
|
0.0 |
| 00539 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
LONGEST-PATH problem; small input/general graph |
|
0.0 |
| 00574 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
print all solutions with backtracking |
|
0.0 |
| 00624 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
input size is small; backtracking is enough |
|
0.0 |
| 00775 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
backtracking suffices as the search space is small; it is more likely to have a HAMILTONIAN-TOUR in a dense graph, so we can prune early |
|
0.0 |
| 00989 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
classic SUDOKU puzzle; the small 9x9 instance is solvable with backtracking with pruning; use bitmask to speed up |
|
0.0 |
| 10957 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
very similar with UVa 989; if you can solve that one; you can modify your code a bit to solve this one |
|
0.0 |
| 11088 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
similar to UVa 10911 but partitioning of three persons to one team; PARTITION-INTO-TRIANGLES |
|
0.0 |
| 12455 |
Fetching from uHunt |
8.6a, NP-hard/C, small, Easier |
SUBSET-SUM; try all; see the harder UVa 12911 that requires meet in the middle |
|
0.0 |
| 01098 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
LA 4793 - WorldFinals Harbin10; HAMILTONIAN-TOUR; backtracking+pruning; meet in the middle |
|
0.0 |
| 01217 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
LA 3681 - Kaohsiung06; TSP-like optimization problem; which is NP-Hard; solvable with A*/IDA* |
|
0.0 |
| 10032 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
PARTITION; DP Knapsack with optimization to avoid TLE; also available at Kattis - tugofwar |
|
0.0 |
| 10125 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
SUBSET-SUM; 4-SUM variant; use unordered_map to map sum of a and b in S and their two indices; also available at Kattis - sumsets |
|
0.0 |
| 10160 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
optimization version of Min Vertex Cover on general graph; Dominating Set; which is NP-Hard; strategies: backtracking; sort by decreasing degrees; heavy pruning |
|
0.0 |
| 10571 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
hard backtracking problem; it has similar flavor as Su Doku puzzle |
|
0.0 |
| 11065 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
optimization version of MAX-INDEPENDENT-SET problem on general graph; also report the number of Independent Sets; bitmask helps in speeding up the solution |
|
0.0 |
| 11095 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
optimization version of Min Vertex Cover on general graph which is NP-Hard |
|
0.0 |
| 12911 |
Fetching from uHunt |
8.6b, NP-hard/C, small, Harder |
SUBSET-SUM; we cannot use DP as 1 ≤ N ≤ 40 and -10^9 ≤ T ≤ 10^9; use meet in the middle |
|
0.0 |
| 01194 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
LA 2523 - Beijing02; Min Vertex Cover/MVC |
|
0.0 |
| 01347 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
LA 3305 - SoutheasternEurope05; this is the pure version of Bitonic TSP problem; you may want to start from here |
|
0.0 |
| 10243 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
this problem can be reduced to the Min Vertex Cover problem on Tree; there is a polynomial DP solution for this variant |
|
0.0 |
| 10349 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
MIS: V-MCBM; also available at Kattis - antennaplacement |
|
0.0 |
| 10859 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
Min-Vertex-Cover; on several trees; maximize number of edges with its two endpoints covered |
|
0.0 |
| 11159 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
MAX-INDEPENDENT-SET; on Bipartite Graph; ans equals to its MCBM |
|
0.0 |
| 11357 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
not a pure CNF SAT(isfiability) problem; it is a special case as only one clause needs to be satisfied |
|
0.0 |
| 11419 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
MVC; Konig theorem |
|
0.0 |
| 12083 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
LA 3415 - NorthwesternEurope05; MIS; also available at Kattis - guardianofdecency |
|
0.0 |
| 12168 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
LA 4288 - NorthwesternEurope08; MIS; also available at Kattis - catvsdog |
|
0.0 |
| 13115 |
Fetching from uHunt |
8.6c, NP-hard/C, special, Easier |
just a SUDOKU solution verifier; an NP-problem |
|
0.0 |
| 01086 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 4452 - WorldFinals Stockholm09; can be modeled as a 2-SAT problem |
|
0.0 |
| 01096 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 4791 - WorldFinals Harbin10; Bitonic TSP variant; print the actual path |
|
0.0 |
| 01184 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 2696 - Dhaka02; MPC on DAG ~ MCBM |
|
0.0 |
| 01201 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 3126 - NorthwesternEurope04; MPC on DAG; also available at Kattis - taxicab |
|
0.0 |
| 01212 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 3483 - Hangzhou05; MWIS on Bipartite Graph |
|
0.0 |
| 01220 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
LA 3794 - Tehran06; Maximum Independent Set (MIS) problem on tree; DP; also check if the MIS is unique |
|
0.0 |
| 10319 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
can be modeled as a 2-SAT problem |
|
0.0 |
| 11294 |
Fetching from uHunt |
8.6d, NP-hard/C, special, Harder |
can be modeled as a 2-SAT problem; also available at Kattis - wedding |
|
0.0 |
| 00714 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and greedy |
|
0.0 |
| 10566 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
bisection method |
|
0.0 |
| 10606 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
the solution is simply the highest square number <= N but this problem involves BigInteger; we can use a (rather slow) binary search the answer technique to obtain sqrt(N) |
|
0.0 |
| 10668 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
bisection method; also available at Kattis - expandingrods |
|
0.0 |
| 10804 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and MCBM; similar with UVa 11262 |
|
0.0 |
| 10816 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and Dijkstra's |
|
0.0 |
| 11262 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and MCBM; similar with UVa 10804 |
|
0.0 |
| 11646 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
the circle is at the center of track |
|
0.0 |
| 12097 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and geometric formula |
|
0.0 |
| 12851 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and 3D geometry volume of cone; inclusion-exclusion |
|
0.0 |
| 12853 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and circumferences of two related circles |
|
0.0 |
| 12908 |
Fetching from uHunt |
8.7a, BSTA+Other, Easier |
binary search the answer and sum of arithmetic progression formula |
|
0.0 |
| 01221 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
LA 3795 - Tehran06; +MCBM |
|
0.0 |
| 01577 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
LA 6398 - WorldFinals StPetersburg13; BSTA+greedy; also available at Kattis - low |
|
0.0 |
| 10372 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
binary search the answer and Physics |
|
0.0 |
| 10537 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
+Dijkstra's on State-Space graph |
|
0.0 |
| 10983 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
binary search the answer and max flow |
|
0.0 |
| 11516 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
+greedy; also available at Kattis - wifi |
|
0.0 |
| 11670 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
binary search the answer and O(N) greedy simulation |
|
0.0 |
| 12255 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
LA 5000 - KualaLumpur10; binary search the answer and greedy |
|
0.0 |
| 12428 |
Fetching from uHunt |
8.7b, BSTA+Other, Harder |
binary search the answer and a bit of graph theory about bridges |
|
0.0 |
| 10789 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
check if a letter's frequency (using DAT) is a prime |
|
0.0 |
| 11960 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
modified Sieve; number of divisors; static Range Maximum Query; use Sparse Table data structure |
|
0.0 |
| 11966 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
use union find to keep track of the number of disjoint sets/constellations; if Euclidian dist <= D; union the two stars |
|
0.0 |
| 11967 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
brute force; use map as we cannot store the actual tic-tac-toe board; remember n coordinates and check if there are k consecutive coordinates that belong to any one player |
|
0.0 |
| 12318 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
brute force with unordered_set |
|
0.0 |
| 12460 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
a simple BFS problem; use set of string data structure to speed up the check if a word is inside dictionary |
|
0.0 |
| 13135 |
Fetching from uHunt |
8.7c, Fast DS+Other, Easier |
simple DP; use unordered_map to map the (large) answer S back to (small) N, which turns out to be not more than 10 000 |
|
0.0 |
| 00843 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
backtracking; try mapping each letter to another letter in alphabet; use Trie data structure for speed up |
|
0.0 |
| 00922 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
compute the area of the polygon; define a rectangle with every pair of points; use set to see if a third point of the rectangle is on the polygon; keep the current best |
|
0.0 |
| 10150 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
s: (string); BFS; use trie to quickly identify neighbor that is one Hamming distance away; also available at Kattis - doublets |
|
0.0 |
| 10734 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
involving triangle/cosine rule; use a data structure that tolerates floating point error due to triangle side normalization so that we count each triangle only once |
|
0.0 |
| 11474 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
UFDS; connect all tree branches; connect two reachable trees (use geometry); connect trees that can reach doctor |
|
0.0 |
| 11525 |
Fetching from uHunt |
8.7d, Fast DS+Other, Harder |
use Fenwick Tree and binary search the answer to find the lowest index i that has RSQ(1;i) = Si |
|
0.0 |
| 00142 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force; point-in-rectangle; dist |
|
0.0 |
| 00184 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force; collinear test |
|
0.0 |
| 00201 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
counting square of various sizes; try all |
|
0.0 |
| 00270 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
gradient sorting; complete search |
|
0.0 |
| 00356 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
Euclidean distance; brute force |
|
0.0 |
| 00638 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force 4 corner points |
|
0.0 |
| 00688 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force; chop the region into small rectangles and decide if a small rectangle is covered by an antenna or not; if it is; add the area of that small rectangle to the answer |
|
0.0 |
| 10012 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
try all 8! permutations; Euclidean dist |
|
0.0 |
| 10167 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force A and B; ccw tests |
|
0.0 |
| 10301 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
circle-circle intersection; backtracking |
|
0.0 |
| 10310 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
complete search; Euclidean distance dist; also available at Kattis - doggopher |
|
0.0 |
| 10823 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
complete search; check if point inside circles/squares |
|
0.0 |
| 11227 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
brute force; collinear test |
|
0.0 |
| 11515 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
circle-circle intersection; backtracking or brute force subsets with bitmask; also available at Kattis - cranes |
|
0.0 |
| 11574 |
Fetching from uHunt |
8.7e, Geometry+Complete Search |
try all pairs of boats; 0.0 if one pair collide; or, use a quadratic equation; also available at Kattis - collidingtraffic |
|
0.0 |
| 10514 |
Fetching from uHunt |
8.7f, Geometry+Other |
use basic geometry to compute edge weights of the graph of islands and the two riverbanks; SSSP; Dijkstra's |
|
0.0 |
| 11008 |
Fetching from uHunt |
8.7f, Geometry+Other |
collinear test; DP bitmask |
|
0.0 |
| 12322 |
Fetching from uHunt |
8.7f, Geometry+Other |
first; use atan2 to convert angles to 1D intervals; then sort it and use a greedy scan to get the answer |
|
0.0 |
| 00273 |
Fetching from uHunt |
8.7g, Graph+Other |
line segment intersection and Warshall's transitive closure algorithm |
|
0.0 |
| 00393 |
Fetching from uHunt |
8.7g, Graph+Other |
build the small visibility graph with line segment intersection checks; run Floyd-Warshall routine to get the answer |
|
0.0 |
| 00521 |
Fetching from uHunt |
8.7g, Graph+Other |
vertices = drivers; add an edge between two drivers if they can meet (determined with mathematical rule (gcd)); if the graph is connected, then the answer is 'yes' |
|
0.0 |
| 01039 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 3270 - WorldFinals Shanghai05; build the graph with simple geometry; then use Floyd-Warshall |
|
0.0 |
| 01092 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 4787 - WorldFinals Harbin10; compress graph; traversal from exit with S/W direction; inclusion-exclusion |
|
0.0 |
| 01243 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 4272 - Hefei08; Warshall's transitive closure; SCC; transitive reduction of a directed graph |
|
0.0 |
| 01263 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 4846 - Daejeon10; geometry; SCC; see two related problems: UVa 11504 and 11770 |
|
0.0 |
| 10068 |
Fetching from uHunt |
8.7g, Graph+Other |
use BFS from each position to create the APSP data; use backtracking with bitmask and pruning to get the best solution |
|
0.0 |
| 10075 |
Fetching from uHunt |
8.7g, Graph+Other |
Great Circle Distance (gcDistance) with APSP |
|
0.0 |
| 11267 |
Fetching from uHunt |
8.7g, Graph+Other |
bipartite check; MST; accept -ve weight |
|
0.0 |
| 11635 |
Fetching from uHunt |
8.7g, Graph+Other |
Dijkstra's BFS (or 2 Dijkstra's) |
|
0.0 |
| 11721 |
Fetching from uHunt |
8.7g, Graph+Other |
find nodes that can reach SCCs with neg cycle |
|
0.0 |
| 11730 |
Fetching from uHunt |
8.7g, Graph+Other |
factoring; BFS |
|
0.0 |
| 12070 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 3290 - Dhaka05; BFS brute force |
|
0.0 |
| 12101 |
Fetching from uHunt |
8.7g, Graph+Other |
BFS; involving prime numbers |
|
0.0 |
| 12159 |
Fetching from uHunt |
8.7g, Graph+Other |
LA 4407 - KualaLumpur08; use simple CCW tests (geometry) to build the bipartite graph; MCBM |
|
0.0 |
| 12797 |
Fetching from uHunt |
8.7g, Graph+Other |
iterative subset; pick subset of UPPERCASE letters for this round; BFS to find the SSSP; pick the best |
|
0.0 |
| 01069 |
Fetching from uHunt |
8.7h, Mathematics+Other |
LA 4119 - WorldFinals Banff08; string parsing, divisibility of polynomial, brute force, and modPow |
|
0.0 |
| 01195 |
Fetching from uHunt |
8.7h, Mathematics+Other |
LA 2565 - Kanazawa02; use sieve to generate the list of primes; brute force each prime p; and use binary search to find the corresponding pair q |
|
0.0 |
| 10325 |
Fetching from uHunt |
8.7h, Mathematics+Other |
inclusion exclusion principle; brute force subset for small M <= 15; lcm-gcd |
|
0.0 |
| 10419 |
Fetching from uHunt |
8.7h, Mathematics+Other |
print path; prime |
|
0.0 |
| 10427 |
Fetching from uHunt |
8.7h, Mathematics+Other |
numbers in [10^(k-1)..10^k-1] has k digits |
|
0.0 |
| 10539 |
Fetching from uHunt |
8.7h, Mathematics+Other |
sieve; get 'almost primes' by listing the powers of each prime, sort them; binary search |
|
0.0 |
| 10637 |
Fetching from uHunt |
8.7h, Mathematics+Other |
involving prime numbers and gcd |
|
0.0 |
| 10717 |
Fetching from uHunt |
8.7h, Mathematics+Other |
complete search + GCD/LCM |
|
0.0 |
| 11099 |
Fetching from uHunt |
8.7h, Mathematics+Other |
generate list of small primes; generate all multiples of each prime factor starting from base using backtracking; do not forget to use use long long |
|
0.0 |
| 11282 |
Fetching from uHunt |
8.7h, Mathematics+Other |
derangement and binomial coefficient; Big Integer |
|
0.0 |
| 11415 |
Fetching from uHunt |
8.7h, Mathematics+Other |
count the number of factors for each integer; find the number of factors for each factorial number and store it in an array; for each query; use binary search |
|
0.0 |
| 11428 |
Fetching from uHunt |
8.7h, Mathematics+Other |
complete search and binary search |
|
0.0 |
| 12218 |
Fetching from uHunt |
8.7h, Mathematics+Other |
brute force recursive bitmask with prime check; also available at Kattis - industrialspy |
|
0.0 |
| 12802 |
Fetching from uHunt |
8.7h, Mathematics+Other |
actually a very easy problem; given n; just output 2n; but it has two components: primality check of n and checking if n is a palindrome that requires a bit of string operations |
|
0.0 |
| 00976 |
Fetching from uHunt |
8.7i, Graph+DP |
flood fill to separate North and South banks; compute the cost of installing a bridge at each column; DP |
|
0.0 |
| 10917 |
Fetching from uHunt |
8.7i, Graph+DP |
counting paths in DAG; build the DAG; Dijkstra's from 'home'; also available at Kattis - walkforest |
|
0.0 |
| 10937 |
Fetching from uHunt |
8.7i, Graph+DP |
BFS -> APSP information for TSP; then DP or backtracking |
|
0.0 |
| 10944 |
Fetching from uHunt |
8.7i, Graph+DP |
BFS -> APSP information for TSP; then use DP as n <= 16 |
|
0.0 |
| 11284 |
Fetching from uHunt |
8.7i, Graph+DP |
SSSP pre-processing; TSP variant = we can go home early; tweak DP TSP recurrence a bit: at each state, we have one more option: go home early |
|
0.0 |
| 11324 |
Fetching from uHunt |
8.7i, Graph+DP |
LONGEST-PATH on DAG; first, transform the graph into DAG of its SCCs; toposort |
|
0.0 |
| 11331 |
Fetching from uHunt |
8.7i, Graph+DP |
bipartite graph checks; compute size of left/right sets per bipartite component; DP SUBSET-SUM |
|
0.0 |
| 11405 |
Fetching from uHunt |
8.7i, Graph+DP |
BFS from k and each P---max 9 items to get APSP information for TSP; then use DP-TSP |
|
0.0 |
| 11643 |
Fetching from uHunt |
8.7i, Graph+DP |
distance between any 2 interesting positions are computed using a pre-calculated BFS table (corner cases exist); DP TSP |
|
0.0 |
| 11693 |
Fetching from uHunt |
8.7i, Graph+DP |
compute shortest paths information using Floyd-Warshall; then use DP; also available at Kattis - speedyescape |
|
0.0 |
| 11813 |
Fetching from uHunt |
8.7i, Graph+DP |
Dijsktra's -> APSP information for TSP; then use DP; n <= 10 |
|
0.0 |
| 00967 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
similar to UVa 00897; but this time the output part can be speed up using DP 1D range sum |
|
0.0 |
| 10200 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
complete search; test if isPrime(n^2 n 41) for all n in [a..b]; finally use DP 1D RSQ to speed up the solution |
|
0.0 |
| 10533 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
sieve; check if a prime is a digit prime; DP 1D range sum |
|
0.0 |
| 10871 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
need 1D Range Sum Query |
|
0.0 |
| 10891 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
Double DP; 1D RSQ plus another DP to evaluate decision tree; s: (i, j); try all splitting points; minimax |
|
0.0 |
| 11032 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
observation: sod(i) can be only from 1 to 63; use 1D Range Sum Query for fun(a; b) |
|
0.0 |
| 11105 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
need 1D Range Sum Query; also available at Kattis - hnumbers |
|
0.0 |
| 11408 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
need 1D Range Sum Query |
|
0.0 |
| 12028 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
generate the array; sort it; prepare 1D Range Sum Query; then the solution will be much simpler |
|
0.0 |
| 12904 |
Fetching from uHunt |
8.7j, Other+DP 1D RSQ/RMQ |
3 nested loops; brute force a; b; c; use prefix sum to speed up the checks |
|
0.0 |
| 00295 |
Fetching from uHunt |
8.7k, Three++ Components, Easier |
BSTA x: if the person has diameter x, can he go from left to right? graph connectivity; similar with UVa 10876 |
|
0.0 |
| 01250 |
Fetching from uHunt |
8.7k, Three++ Components, Easier |
LA 4607 - SoutheastUSA09; geometry; SSSP on DAG -> DP; DP 1D range sum |
|
0.0 |
| 10856 |
Fetching from uHunt |
8.7k, Three++ Components, Easier |
compute number of prime factors of each integer in the desired range; use 1D RSQ DP; binary search |
|
0.0 |
| 10876 |
Fetching from uHunt |
8.7k, Three++ Components, Easier |
binary search the answer and graph connectivity (geometry/Euclidian distance and union find); similar with UVa 295 |
|
0.0 |
| 11610 |
Fetching from uHunt |
8.7k, Three++ Components, Easier |
first; reverse primes less than 10^6; then; append zero(es) if necessary; use Fenwick Tree and binary search |
|
0.0 |
| 00811 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
LA 5211 - WorldFinals Eindhoven99; get CH and perimeter of polygon; generate all subsets iteratively with bitmask |
|
0.0 |
| 01040 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
LA 3271 - WorldFinals Shanghai05; try all subsets of 2^20 cities; MST; complex output formatting |
|
0.0 |
| 01079 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
LA 4445 - WorldFinals Stockholm09; iterative complete search (permutation); BSTA + greedy |
|
0.0 |
| 01093 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
LA 4788 - WorldFinals Harbin10; try all possible roots; DP on tree |
|
0.0 |
| 11288 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
Floyd-Warshall/APSP; iterative brute force subset and permutation; DP; also available at Kattis - carpool |
|
0.0 |
| 12392 |
Fetching from uHunt |
8.7l, Three++ Components, Harder |
brute force permute up to 5!; recursive string parsing (simple BNF) |
|
0.0 |
| 00588 |
Fetching from uHunt |
9.artg, Art Gallery |
cutPolygon |
|
0.0 |
| 01304 |
Fetching from uHunt |
9.artg, Art Gallery |
LA 2512 - SouthEasternEurope02; cutPolygon and area of polygon |
|
0.0 |
| 01571 |
Fetching from uHunt |
9.artg, Art Gallery |
LA 3617 - Yokohama06; cutPolygon |
|
0.0 |
| 10078 |
Fetching from uHunt |
9.artg, Art Gallery |
isConvex |
|
0.0 |
| 00652 |
Fetching from uHunt |
9.asta, A* or IDA* |
classic sliding block 8-puzzle; IDA* |
|
0.0 |
| 00656 |
Fetching from uHunt |
9.asta, A* or IDA* |
we can use IDDFS with pruning |
|
0.0 |
| 10181 |
Fetching from uHunt |
9.asta, A* or IDA* |
similar with UVa 652 but larger (now 15 instead of 8); we can use IDA* |
|
0.0 |
| 11163 |
Fetching from uHunt |
9.asta, A* or IDA* |
another puzzle game solvable with IDA* |
|
0.0 |
| 10296 |
Fetching from uHunt |
9.chi1, Chinese Postman Problem |
basic Chinese Postman Problem; also available at Kattis - joggingtrails |
|
0.0 |
| 00756 |
Fetching from uHunt |
9.chi2, Chinese Remainder Theorem |
CRT or brute force |
|
0.0 |
| 10245 |
Fetching from uHunt |
9.clos, Closest Pair Problem |
classic |
|
0.0 |
| 11378 |
Fetching from uHunt |
9.clos, Closest Pair Problem |
also a closest pair problem |
|
0.0 |
| 10165 |
Fetching from uHunt |
9.comb, Combinatorial Game Theory |
Nim game; application of Sprague-Grundy theorem |
|
0.0 |
| 11311 |
Fetching from uHunt |
9.comb, Combinatorial Game Theory |
there are 4 heaps; Nim sum |
|
0.0 |
| 01266 |
Fetching from uHunt |
9.cons, Construction Problem |
LA 3478 - LatinAmerica05; follow the given construction strategy |
|
0.0 |
| 10741 |
Fetching from uHunt |
9.cons, Construction Problem |
similar idea as 2D Magic Square; but now in 3D; just follow the given construction strategy |
|
0.0 |
| 10506 |
Fetching from uHunt |
9.debr, De Bruijn Sequence |
any valid solution is AC; generate all possible next digit (up to base 10/digit [0..9]); check if it is still a valid Ouroboros sequence |
|
0.0 |
| 11439 |
Fetching from uHunt |
9.edmo, Edmonds' Matching |
BSTA (the minimum weight); use it to reconstruct the graph; perfect matching on medium-sized general graph |
|
0.0 |
| 10934 |
Fetching from uHunt |
9.eggd, Egg Dropping Puzzle |
Egg dropping puzzle; interesting DP; try all possible answers |
|
0.0 |
| 01185 |
Fetching from uHunt |
9.form, Formulas or Theorems |
LA 2697 - Dhaka02; number of digits of factorial; use logarithm to solve it; log(n!) = log(n * (n-1) * ... * 1) = log(n) plus log(n-1) plus ... plus log(1) |
|
0.0 |
| 01645 |
Fetching from uHunt |
9.form, Formulas or Theorems |
LA 6368 - Chengdu12; number of rooted trees with n vertices in which vertices at the same level have the same degree |
|
0.0 |
| 10088 |
Fetching from uHunt |
9.form, Formulas or Theorems |
Pick's Theorem |
|
0.0 |
| 10178 |
Fetching from uHunt |
9.form, Formulas or Theorems |
Euler's Formula; a bit of union find |
|
0.0 |
| 10213 |
Fetching from uHunt |
9.form, Formulas or Theorems |
Moser's circle; the formula is hard to derive; g(n) = nC4 nC2 1 |
|
0.0 |
| 10219 |
Fetching from uHunt |
9.form, Formulas or Theorems |
count the length of nCk; BigInteger |
|
0.0 |
| 10720 |
Fetching from uHunt |
9.form, Formulas or Theorems |
similar to UVa 11414 and 12786; Erdos-Gallai Theorem |
|
0.0 |
| 10843 |
Fetching from uHunt |
9.form, Formulas or Theorems |
Cayley's Formula to count the number of spanning trees of a graph with n vertices is n^n-2; use Java BigInteger |
|
0.0 |
| 11414 |
Fetching from uHunt |
9.form, Formulas or Theorems |
similar to UVa 10720 and 12786; Erdos-Gallai Theorem |
|
0.0 |
| 11719 |
Fetching from uHunt |
9.form, Formulas or Theorems |
count the number of spanning tree in a complete bipartite graph; use Java BigInteger |
|
0.0 |
| 12786 |
Fetching from uHunt |
9.form, Formulas or Theorems |
similar to UVa 10720 and 11414; Erdos-Gallai Theorem |
|
0.0 |
| 12876 |
Fetching from uHunt |
9.form, Formulas or Theorems |
LA 6854 - Bangkok14; involving degree of vertex; Handshaking lemma |
|
0.0 |
| 12967 |
Fetching from uHunt |
9.form, Formulas or Theorems |
OEIS A173033 |
|
0.0 |
| 13108 |
Fetching from uHunt |
9.form, Formulas or Theorems |
Moser's circle; the formula is hard to derive; g(n) = nC4 + nC2 + 1 |
|
0.0 |
| 00684 |
Fetching from uHunt |
9.gaus, Gaussian Elimination |
modified Gaussian elimination to find (integral) determinant of a square matrix |
|
0.0 |
| 11319 |
Fetching from uHunt |
9.gaus, Gaussian Elimination |
solve the system of the first 7 linear equations; then use all 1500 equations for 'smart sequence' checks |
|
0.0 |
| 01045 |
Fetching from uHunt |
9.kuhn, Kuhn-Munkres Algorithm |
LA 3276 - WorldFinals Shanghai05; try all configurations; weighted matching; pick the best; Kuhn-Munkres |
|
0.0 |
| 10746 |
Fetching from uHunt |
9.kuhn, Kuhn-Munkres Algorithm |
min weighted bipartite matching |
|
0.0 |
| 10888 |
Fetching from uHunt |
9.kuhn, Kuhn-Munkres Algorithm |
BFS/SSSP; min weighted bipartite matching |
|
0.0 |
| 11553 |
Fetching from uHunt |
9.kuhn, Kuhn-Munkres Algorithm |
brute force; DP bitmask; or Hungarian |
|
0.0 |
| 10938 |
Fetching from uHunt |
9.lowe, Lowest Common Ancestor |
basic LCA problem |
|
0.0 |
| 12238 |
Fetching from uHunt |
9.lowe, Lowest Common Ancestor |
similar to UVa 10938 |
|
0.0 |
| 00348 |
Fetching from uHunt |
9.matr, Matrix Chain Multiplication |
DP; s(i, j); output the optimal solution; the optimal sequence is not unique |
|
0.0 |
| 10594 |
Fetching from uHunt |
9.minc, Min Cost (Max) Flow |
basic min cost max flow problem |
|
0.0 |
| 10806 |
Fetching from uHunt |
9.minc, Min Cost (Max) Flow |
send 2 edge-disjoint flows with min cost |
|
0.0 |
| 11301 |
Fetching from uHunt |
9.minc, Min Cost (Max) Flow |
modeling; vertex capacity; MCMF |
|
0.0 |
| 12821 |
Fetching from uHunt |
9.minc, Min Cost (Max) Flow |
similar to UVa 10806 |
|
0.0 |
| 00120 |
Fetching from uHunt |
9.panc, Pancake Sorting |
greedy pancake sorting |
|
0.0 |
| 11476 |
Fetching from uHunt |
9.poll, Pollard's rho Algorithm |
basic integer factorization problem that requires Pollard's rho algorithm |
|
0.0 |
| 00261 |
Fetching from uHunt |
9.slid, Sliding Window |
sliding window variant |
|
0.0 |
| 01121 |
Fetching from uHunt |
9.slid, Sliding Window |
LA 2678 - SouthEasternEurope06; sliding window variant |
|
0.0 |
| 11536 |
Fetching from uHunt |
9.slid, Sliding Window |
sliding window variant |
|
0.0 |
| 00254 |
Fetching from uHunt |
9.towe, Tower of Hanoi |
define a recursive formula |
|
0.0 |
| 10017 |
Fetching from uHunt |
9.towe, Tower of Hanoi |
classical problem |
|
0.0 |
| 10254 |
Fetching from uHunt |
9.towe, Tower of Hanoi |
find pattern; use Java BigInteger |
|
0.0 |