What I have Learnt

	A	B	C	D	E
1	http://usaco.org/index.php?page=viewproblem2&cpid=1113				Sum of a/i for all i < a is a * log a
2	https://codeforces.com/problemset/problem/1615/D				xoring in a tree cancels out the path
3	https://codeforces.com/problemset/problem/600/E				Small to Large Merging
4	http://www.usaco.org/index.php?page=viewproblem2&cpid=1235#				Bound!
5	https://cses.fi/problemset/task/1734				Offline Queries and such
6	https://cses.fi/problemset/task/2101/				The MST = MBST (MST minimizes maximum edge weight)
7	https://codeforces.com/problemset/problem/1528/A				Try to prove something to make the problem easier
8
9
10
11	Link	Time	Coding Time	Solution?	Concept
12	http://usaco.org/index.php?page=viewproblem2&cpid=227	5	45	Yes	Implement Correctly the First Time
13	http://usaco.org/index.php?page=viewproblem2&cpid=621	?	?	Yes	Make sure your code does what you think it does; plan better; think about arguments that simplify the problem
14	http://usaco.org/index.php?page=viewproblem2&cpid=283	18	-----------	Yes
15	http://usaco.org/index.php?page=viewproblem2&cpid=363	5	20	Yes	Plan More
16	http://usaco.org/index.php?page=viewproblem2&cpid=228	5	5	Yes
17	http://www.usaco.org/index.php?page=viewproblem2&cpid=1233				Try working out the sample input and then checkpoints when running
18	http://www.usaco.org/index.php?page=viewproblem2&cpid=1210				Think about how doubles work and that chooses are large
19	Problem 1. Paired Up				Keep track of all cases; make sure that everything is calculated correctely
20	Problem 3. Bracelet Crossings				Think through ALL cases
21	https://codeforces.com/contest/1789/problem/E				initializing vectors is O(n)!
22	https://codeforces.com/problemset/problem/1658/E				You can turn manhattan distance into cheybvev distance or something (i.e. x-y, x+y); the manhattan distance becomes max(\|x1-x2\|, \|y1-y2\|)
23	http://www.usaco.org/index.php?page=viewproblem2&cpid=1065				remember that bfs only works if edges are 1 and at any point, queue has only 2 different distances
24	https://codeforces.com/problemset/problem/1778/D				ALGEBRA
25	https://codeforces.com/problemset/problem/1761/D				think about restrictions and how they work
26	http://usaco.org/index.php?page=viewproblem2&cpid=1090				Read code line by line; if using bfs, check if all edges are weight 1
27	http://usaco.org/index.php?page=viewproblem2&cpid=1091				initializing vectors is O(n)!
28	https://codeforces.com/problemset/problem/1780/F				# of prime divisors of N < 1e5 is only 10
29	https://codeforces.com/problemset/problem/1730/D				Simplify concretely
30	https://codeforces.com/problemset/problem/1657/E				undefinted behaviour is undefined! and planning out how code will work on sample is always a good thing
31	https://codeforces.com/contest/1710/problem/B				Plan + Speed
32	https://codeforces.com/problemset/problem/1693/C				Make arguments to simplify problem
33	http://www.usaco.org/index.php?page=viewproblem2&cpid=947				look for integer overflow!
34	http://usaco.org/index.php?page=viewproblem2&cpid=1210				cout << setprecision(12); arrays global
35	https://codeforces.com/problemset/problem/1637/E				maps have bad constant and look for simplifying assumptions
36	https://cses.fi/problemset/task/1147				monotonic stack
37	https://codeforces.com/problemset/problem/1790/F				memoize!
38	https://codeforces.com/problemset/problem/1810/E				Small constant factors add up a lot
39	https://codeforces.com/problemset/problem/1811/G1				Calculate inverse factorials correctly
40	https://codeforces.com/problemset/problem/1815/C				Ignoring back edges is powerful (cycle preventing edges)
41	https://codeforces.com/problemset/problem/1795/E				Plan!
42	https://codeforces.com/problemset/problem/1736/D				look for an obvious solution
43	https://codeforces.com/problemset/problem/1056/E				You can hash suffixes and then finding hashes of substrings is trivial
44	Problem 1. Bovine Genomics				Binary Searching on ranges is powerful
45	https://dmoj.ca/user/beaboss/solved				When working with modulos, usually M^2 must fit in the integer you are using
46	Problem - 1773B - Codeforces				There are 2 types of hashes, polynomial and "associative" (order does not matter)
47	https://cses.fi/problemset/result/5875659/				Just practice
48	Problem - 1725F - Codeforces				Working with Ints is 2x as working with long longs
49	https://szkopul.edu.pl/problemset/problem/lGqKS9urITMjTXhpdaHqyoEL/site/?key=submissions				You can take logarithms if values don't fit into long longs and you are working with products; For backtracking with knapsack, think about when it is not completely full
50	https://usaco.guide/problems/coci-2016burza/solution				If bitmasking is not possible, try to see if you can find some constraint where the answer is non-bitmaskable and another where it is bitmaskable
51	https://usaco.guide/problems/cf-make-it-one/solution				Sometimes finding whether something is possible is just thinking if the # of ways to do that is > 0
52					pow function is hella slow and subtracting with modulos, make sure to add the MOD back
53	https://cses.fi/107/result/5927893/				Rotate graphs
54	https://usaco.guide/problems/joi-2018commuter-pass/solution
55	https://oj.uz/problem/view/IOI11_crocodile				Not too bad
56	https://codeforces.com/contest/1394/problem/D				Think about directing edges rather than thinking of a whole DP from scratch
57	https://dmoj.ca/problem/apio11p2/submit				yc.erase(unique(yc.begin(), yc.end()), yc.end());
58	https://codeforces.com/contest/912/problem/E				There are workarounds to integer overflow; i.e. setting a bound and dividing it rather than multiplying to the limit
59	Birthday Paradox				To get all values from 0 => MOD, you only need to try around root(MOD) #s and then pairwise sums
60	https://dmoj.ca/problem/coci16c6p5/editorial				Counting Sort to speed up sorting and DSU is O(1)
61	https://szkopul.edu.pl/problemset/problem/w3YAoAT3ej27YeiaNWjK57_G/site/?key=statement				If you think of an edge case, check if you satisfy it!
62	https://codeforces.com/problemset/problem/1472/G				Not too bad, implementation practice and remember to plan
63	http://www.usaco.org/index.php?page=viewproblem2&cpid=435				Run DP iteratively if it is hard to do any other way
64	https://codeforces.com/problemset/problem/1822/G2				If you access an element of a map that doesn't exist, it is created! This can blow up your maps
65	https://codeforces.com/problemset/problem/1798/E				If you are working with a range, see if you the max/min is good enough as a query
66	https://codeforces.com/problemset/problem/1797/E				Really just a complex segtree + binary lifting + sieve practice impelmentation; You can also sometimes skip nodes in a segtree if they are all pointless! rather than skipping updates
67	http://www.usaco.org/index.php?page=viewproblem2&cpid=576				You can DP upwards on trees!
68	https://codeforces.com/problemset/problem/342/E				Two ancestor-descendant pairs in centroid decomposoition are not necessarily the same in the normal tree.
69					When working with two trees, make sure you know which one's which!
70	https://cses.fi/problemset/result/6056882/				Only do what you have to do; constant speed ups are really valuable
71	https://codeforces.com/problemset/problem/1748/E				Sparse Table Implementation Practice + General Solving Practice
72	https://codeforces.com/problemset/problem/1766/E				Recursive DP is only implementable in certain circumstances; you have to think twice for these
73	https://usaco.guide/problems/ioi-2011race/solution				Centroid decomposition can be helpful when thinking of paths (either it goes through this node, or it does not.
74	https://codeforces.com/contest/1387/problem/B2				Assigning values between centroid groups. Centroid 'edge' does not necessarily exsit, but centroid does.
75	https://cses.fi/problemset/task/2134				During HLD, go to heavy edge first
76	https://codeforces.com/problemset/problem/1794/E				Know how many hashes before implementing! Also know collision probability
77	https://codeforces.com/problemset/problem/1792/E				Sometimes a sketchy solution can work. And read problem VERY carefully before going further
78	https://codeforces.com/problemset/problem/1598/E				Impl. Practice
79	https://codeforces.com/problemset/problem/1593/F				Practice
80	https://codeforces.com/problemset/problem/1538/E				size_t's cannot be negative. substr function takes start point and length
81	https://codeforces.com/problemset/problem/1493/D				Too many sketchy runtimes is bad; ALWAYS use sieve instead of repeatedly factorizing
82	https://codeforces.com/problemset/problem/1628/C				Solution may be complex, but generalize it to easy impl.
83	https://codeforces.com/problemset/problem/1763/D				Practice
84	https://codeforces.com/problemset/problem/1625/D				Lowest Pairwise xor in a set of numbers is lowest xor between adj elements when sorted
85	https://codeforces.com/problemset/problem/1781/E				Plan your implementation, it is really really helpful
86	https://codeforces.com/problemset/problem/1832/E				Read the problem really closely, often there is something small that makes your solution fail
87	https://codeforces.com/problemset/problem/1824/B2				Implementation Practice, mainly just quick problem-solving
88	https://codeforces.com/contest/1806/problem/E				Sometimes we can sacrifice run time for memory
89	https://codeforces.com/problemset/problem/1821/E				Impl/Formalization Pratice
90	https://codeforces.com/contest/1839/problem/D				Formalize Much Better
91	https://codeforces.com/contest/1805/problem/E				If the implementation has multiple parts, test them individually. Implementing is an art, keep it that way!
92	https://codeforces.com/problemset/problem/1768/E				Formalize Better
93	https://codeforces.com/contest/1142/problem/B				Binary Lifting is Very Powerful
94	https://oj.uz/problem/view/BOI19_valley				With binary lifting, lift[i][0] is the parent, not the node itself. Do not mix it up
95	http://www.usaco.org/index.php?page=viewproblem2&cpid=696				a.swap(b) for ordered set
96	http://www.usaco.org/index.php?page=viewproblem2&cpid=921				fixing template
97	https://codeforces.com/contest/1826/problem/E				Bitsets are cool!
98
99
100