First option: Use web arena https://arena.topcoder.com .
Second option: Download applet from https://www.topcoder.com/community/competitive-programming/ . After that, watch some first part (~10:00 or ~15:00?) of this youtube video https://www.youtube.com/watch?v=A5vnkkFGOo0 .

This link was shared by one of our seniors to begin with topcoder, I think it may help you.

And I personally use KawigiEdit as plugin for c++. Download it from here

You are solving for a, b, c ,

let it be ans(a, b, c)[assume a >  = b >  = c]. Let the highest power of 2 <  = a be 2^x. We know that x^th bit will be set in your answer no matter what. And number of bits in your answer will be x + 1.

case 1: If 2^x  <  = b,

We can always make 2^x + 1 - 1 , and this is your answer, a = 2^x, b = 2^x - 1, c = 0.

case 2: Else

ans(a, b, c) = 2^x|ans(a - 2^x, b, c).

I think it was an overkill, but, I wrote a DP solution for this problem: https://pastebin.com/BYknMGXH during the contest. It should be self-explanatory.

A single loop over the bit positions of the binary representations of A, B, C starting from 30 (the maximum possible in a positive integer) and down to 0. Let i be the current bit position, we want every bit position to be 1 after the XOR operation if possible to get the maximum result. We can count the number of 1s in the i^th position in A, B, C. There are 3 cases

case 1: number of 1s at position i = 0 We can't get a one in that position in the result

case 2: number of 1s at position i = 1 We simply get a one in that position in the result

case 3: number of 1s at position i = 2 or 3 In that case we can "sacrifice" (clear) one 1 (in the case of 2) or two 1s (in the case of 3) from any of A, B or C and still get a one in that position in the result because the number of ones will be odd for XOR, and after that position it is possible to get all 1s, so you can just end the loop here and set all the 1s after this position in the result to 1. The reason is once you clear a 1, any combination of 0s and 1s is possible to get after it because they all form a smaller number which is within the interval, so you'll form the combination that gets the maximum possible result

In what sense that would be a better problem? What do we want to achieve by raising constraints?

Most of the solutions (including mine) append a character to the longest "buffalo". This means the array of "completed prefixes" is non-decreasing. The number of states is a lot less than 8^14 (it can be proven as being the number of increasing arrays of size 14 and sum <= 100). On input equal to all '?'s (7 * 14 of them, to be exact), the number of states checked is ~65k.

function name = variable name = f?

After contest I found some funny idea how to omit possibility of making a lot of bugs here. Probably for every x1 so that there is a vertical line (x1,y1)-(x1,y2) you cut this polygon using this line and calculated what part is on left and what is on right etc. But since this infinite line coincides with side it makes it somehow troublesome. But if we stretch polygon 3 times and ask about cutting it with lines x=3*x1+1 and x=3*x1+2 we never coincide with any vertical line and get all needed information :). I hope overflows are not becoming a problem after this xD.

The solution is simple that can write in one line.
The answer mod 1000000007 equals to 666666691x⁵ - 333333332x³ mod 1000000007.
How can we get the answer polynomial? I'll explain the way of solving.
1. There are O(n²) number of vertices, so there are O(n⁴) pair of vertices. Distance for each pair is at most O(n) so you can guess that the answer can be a polynomial with degree equals to 5.
2. Now you have to calculate the polynomial. If you can calculate for the six different n (0 ≤ n < 1000000007), you can get the polynomial. So how to get value for six n's? Of course, "writing naive solution + getting answer for n = 0, 1, 2, 3, 4, 5" is enough.
3. Do interpolation. Using Newton's polynomial interpolation with modulo 1000000007 is a good way to do it. Then, you get 666666691x⁵ - 333333332x³. This is the final answer.

#include <queue>
#include <vector>
#include <iostream>
using namespace std;
long long solve(int n) {
	vector<int> x, y;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			x.push_back(i);
			y.push_back(j + n);
			x.push_back(i + n);
			y.push_back(j);
			x.push_back(i + n);
			y.push_back(j + n);
			x.push_back(i + n);
			y.push_back(j + 2 * n);
			x.push_back(i + 2 * n);
			y.push_back(j + n);
		}
	}
	int V = x.size();
	vector<vector<int> > d(V, vector<int>(V, 1012345678));
	for (int i = 0; i < V; i++) {
		for (int j = i + 1; j < V; j++) {
			if (abs(x[i] - x[j]) + abs(y[i] - y[j]) == 1) {
				d[i][j] = 1;
				d[j][i] = 1;
			}
		}
	}
	for (int i = 0; i < V; i++) d[i][i] = 0;
	for (int i = 0; i < V; i++) {
		for (int j = 0; j < V; j++) {
			for (int k = 0; k < V; k++) {
				d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
			}
		}
	}
	long long ret = 0;
	for (int i = 0; i < V; i++) {
		for (int j = 0; j < V; j++) {
			ret += d[i][j];
		}
	}
	return ret / 2;
}
vector<int> interpolation(vector<int> x, int m) {
	int n = x.size() - 1;
	vector<int> inv(n + 1); inv[1] = 1;
	for (int i = 2; i <= n; i++) inv[i] = 1LL * inv[m % i] * (m - m / i) % m;
	vector<vector<int> > dp(n + 1, vector<int>(n + 2));
	for (int i = 0; i <= n; i++) dp[i][i + 1] = x[i];
	for (int i = 2; i <= n + 1; i++) {
		for (int r = i; r <= n + 1; r++) {
			int l = r - i;
			dp[l][r] = 1LL * (dp[l + 1][r] - dp[l][r - 1] + m) * inv[i - 1] % m;
		}
	}
	vector<int> ret(n + 1); ret[0] = x[0];
	vector<int> mul({ 1 });
	for (int i = 0; i < n; i++) {
		vector<int> mul2(i + 2, 0);
		for (int j = 0; j <= i; j++) mul2[j + 1] = mul[j];
		for (int j = 0; j <= i; j++) mul2[j] = (mul2[j] + 1LL * (m - i) * mul[j]) % m;
		mul = mul2;
		for (int j = 0; j <= i + 1; j++) ret[j] = (ret[j] + 1LL * mul[j] * dp[0][i + 2]) % m;
	}
	return ret;
}
int main() {
	vector<int> v;
	for (int i = 0; i <= 5; i++) {
		int res = solve(i);
		cout << i << ' ' << solve(i) << endl;
		v.push_back(res);
	}
	vector<int> ret = interpolation(v, 1000000007);
	for (int i = 0; i < 6; i++) {
		if (i >= 1) cout << " + ";
		cout << ret[i] << "x^" << i;
	}
	return 0;
}