The problem was fairly easy but the statement was bit confusing.

solution link — https://code.hackerearth.com/1144e5D

Again the main problem was decoding the statement. The only place that mentioned that the graph was undirected was when the statement said the relation is mutual. But while reading the problem you will feel like the graph is directed.

solution link — https://code.hackerearth.com/c2f17dC

It was a basic mathematics problem that used mod inverse and factorial.

solution link — https://code.hackerearth.com/eddc17Y

The problem required to find the kth ancestor with dynamic insertion and deletion. I used an array to keep track of active elements. Then, for insertion and deletion, I used dp on that particular node. It only required logN steps. Finding the solution was then easy. For insertion in beginning, I used level order traversal to insure that the parent are inserted before the child. Good problem to practice.

solution link — https://code.hackerearth.com/3332f9b

It was a simple problem of finding the LCA of a given pair of nodes. I used dp to solve the problem. Another possible way is to do an euler tour of the tree and then use RMQ to find the LCA. sparse tree can answer RMQ in constant time, so that will be faster.

solution link — http://paste.ubuntu.com/24622053/

First increase the count of the nodes that are given to you. The decrease the count of their LCA by 2. The thing is, we are going up level by level. At any given level at a time. We see how many fools can go up a level. That is equal to fool that came to that level minus the fool that stay at that level node. The number of fool staying was done by subtracting at LCA as they want to meet at a path of minimum distance.

solution link — http://codeforces.me/contest/192/submission/27263078

It requires simple counting of one and zero. Giving it some time will directly lead to this conclusion

solution link — http://codeforces.me/contest/556/submission/27264409

The problem was really simple. It only required implementation. One can easily come up with an N*N solution. As soon as one come up with an N*N solution, One can easily reduce it to an O(N) solution. link for both solution —

link1 — http://codeforces.me/contest/556/submission/27266299

link2 — http://codeforces.me/contest/556/submission/27266356

It was among the most confusing problem statement that I can across in my life. Even after reading it 4 — 5 time, I was unable to understand what actually was going on. So here is a simple problem statement. One can remove one doll at a time and that too only the uppermost. It means that the only chain that we don't have to break is the chain 1, 2, 3, 4 ... k. and then break every other doll and the n assemble over the k length chain.

solution link — http://codeforces.me/contest/556/submission/27266874

It was an amazingly good problem of greedy using binary search as a sub routine. It took some time to come up with the solution. I made an array that had distance (max distance b/w boundaries, min distance b/w boundaries). Then sorted them according to the max distance. Then while traversing, I gave the shortest possible length of bridge to the required gap. If it was not possible, then answer was no.

solution link — http://codeforces.me/contest/556/submission/27270654

The problem was easy, But I took a lot of time to code. Just had to check whether there we some points greater equal 4. If not then alien, otherwise can be checked for bear and elephant.

solution link — http://codeforces.me/contest/471/submission/27301710

Again an easy problem with more coding at least for me. Direct implementation.

solution link — http://codeforces.me/contest/471/submission/27301694

An easy problem with observation. Just found out the minimum card required for any height and then checked whether other cards can be arranged accordingly. Easy for C.

solution link — http://codeforces.me/contest/471/submission/27301680

The D problem was easier than C. Can be solved using string matching. Instead of matching the strings, just match the steps. Solution will be clearer.

solution link — http://codeforces.me/contest/471/submission/27301654

An easy problem for E. Can be solved just with dfs and binary search. I have two solutions

solution1 — http://codeforces.me/contest/208/submission/27306354

solution2 — http://codeforces.me/contest/208/submission/24803199

The best problem I solved in day. Try to put minimum number node in as early index as possible. That is it.

solution link — http://paste.ubuntu.com/24640971/

The problem was of finding mst including a particular edge. The problem required finding the maximum length path joining the the two vertices. Let us say the edge weight cam out to be x, and the weight of the included edge is y, The cost of mst is z. Then ans is z — x + y.

solution — http://codeforces.me/contest/609/submission/27330146

Coming up with a solution is an easy task. The hard part lies only in the implementation. Just need to find an equidistance path from both nodes and then count all node reachable from the node such that we do not go in the path of the given two vertices.

solution — http://codeforces.me/contest/519/submission/27330636

The problem was of geometry and we just had to convert the hexagon in a triangle by drawing triangle on any three alternate edges.

solution link — http://codeforces.me/contest/560/submission/27331484

Just needed to convert both the string into lexicographical smallest. Then compare whether the given two string are equal.

solution link — http://codeforces.me/contest/560/submission/27333242

The problem was of combinatorics. Just needed to find the ways of going to a particular point without going on any other point that lies before it. the ans was C(x+y, x);

solution — http://codeforces.me/contest/560/submission/27340300

Simple Maximum spanning tree.

solution — http://paste.ubuntu.com/24675192/

We just have to traverse in reverse direction. If we get x+1 for any x, we replace that x by x+1 in the multiset.

solution — http://paste.ubuntu.com/24675209/

Can make a hash for every node using some random value. then check whether the hash value of r and l-1 are same.

solution — http://paste.ubuntu.com/24675224/

Direct implementation

solution — http://codeforces.me/contest/811/submission/27392467

Can be solved by storing frequency, first occurrence and last occurrence.

solution — http://codeforces.me/contest/558/submission/27391836

simple greedy.

solution — http://codeforces.me/contest/557/submission/27367632

just sort the array. find minimum size for both boys and girls. Using this we can find the amount x. Then print minimum of 3*x or w.

solution — http://codeforces.me/contest/557/submission/27367886

Can be solved using simple brute force. Find total sum, and for every length find the maximum sum that you can save.

solution — http://codeforces.me/contest/557/submission/27389540

Direct brute force.

solution — http://codeforces.me/contest/811/submission/27371224

had to come up with a linear state to save memory limit exceed. N*N complexity. For every possible end, search for the corresponding start.

solution — http://codeforces.me/contest/811/submission/27385042

The best hint for this question would be to first try for upto 100000 and then try to find the pattern. Also there are few diversions from regular pattern at few places.

solution — http://paste.ubuntu.com/24703147/

Direct brute force

solution — http://paste.ubuntu.com/24703165/

It is actually a dp problem. Try to find the number of even sequence starting and ending at a particular point.

solution — http://paste.ubuntu.com/24703194/

Just Greedily allocate first to first.

solution — http://paste.ubuntu.com/24703210/

Just store the frequency in a pair then sort and print.

solution — http://paste.ubuntu.com/24717004/

Just direct Implementation

solution — http://paste.ubuntu.com/24717024/

The question was fun to try due to some unusual constraints.

solution — http://paste.ubuntu.com/24717043/

Direct implemetation

# solution — http://paste.ubuntu.com/24717066/

Direct Implementation

solution — http://paste.ubuntu.com/24717079/

Make sure that the variables are not always space separated from = sign.

solution — http://paste.ubuntu.com/24717087/

This problem has wrong solution. Just check whether the string don't match.

solution — http://paste.ubuntu.com/24717093/

If the string don't match at a particular pair position, then one can add any number of possible and equal characters on either side.

solution — http://paste.ubuntu.com/24717104/

just store the first m characters and the index in a pair and then sort.

solution — http://paste.ubuntu.com/24717116/

The idea is to use two pointer and then keep updating the answer on the go.

solution — http://paste.ubuntu.com/24728003/

Direct Implementation

solution — http://paste.ubuntu.com/24728021/

The idea is to do the bfs over all values

solution — http://codeforces.me/contest/558/submission/27440146

The idea was to convert every level to leaf level and then sort and combine the range accordingly. Then check over all possible feasible combination.

solution — http://codeforces.me/contest/558/submission/27450439

Just make 26 segment tree, one for each letter. And then use lazy update for sorting.

solution — http://codeforces.me/contest/558/submission/27458416

Direct implementation

solution — http://codeforces.me/contest/567/submission/27471653

Direct Implementation

solution — http://codeforces.me/contest/567/submission/27471986

Basic dp problem

solution — http://codeforces.me/contest/567/submission/27472315

Just find all prime powers and that will be enough.

solution — http://codeforces.me/contest/577/submission/27526007

By pegion hole principle, Whenever n >= m, and is yes. Or you can do an exhaustive search using set.

solution — http://codeforces.me/contest/577/submission/27525462

Just for all i check whether j is in range

solution — http://codeforces.me/contest/577/submission/27524959

Can be solved using bridge. Make a separate graph that contains only shortest path vertices, and make it undirected. now find all bridges. Since there can be multiple loops, instead of direct checking parent, check whether index matches or not.

solution — http://codeforces.me/contest/567/submission/27524686

Direct Implementation

solution — http://paste.ubuntu.com/24791044/

Direct Implementation

solution — http://paste.ubuntu.com/24791048/

Direct Implementation

solution — http://codeforces.me/contest/570/submission/27613674

Direct Implementation

solution — http://codeforces.me/contest/221/submission/27613838

Just generate all numbers and then for every range, add the required number.

solution — http://codeforces.me/contest/121/submission/27614195

Create all possible range, then according to every query, update the ranges and ans accordingly.

solution — http://codeforces.me/contest/570/submission/27665459

Direct implementation of trie. Make loose and win accordingly and then decide for the answer.

solution — http://codeforces.me/contest/456/submission/27677006

Standard problem of square root decomposition. Just divide the array in block of size sqrt(n) and solve for each block. Then combine the ans for each query.

solution — http://codeforces.me/contest/13/submission/27678054

direct implementation

solution — http://codeforces.me/contest/404/submission/27686991

Binary search over the max possible length, Then try to break that triangle in smaller part again using binary search

solution — http://codeforces.me/contest/579/submission/27710780