They probably forgot to update the blog. It's confirmed to be 150 minutes.

just curious, why didn't you just switch over?

No, the fifth term doesn't match.

No, we oeised the sequence and it wasn't found.

Testcases are published at https://atcoder.jp/post/21.

Here's a method for B that was easier to code:

    vector<int> nums;
    for(int j = 1; j <= 30000; j++){
        if(j % 2 == 0 || j % 3 == 0 || j % 5 == 0){
            nums.push_back(j);
        }
    }
    while(1){
        // try
        random_shuffle(nums.begin(), nums.end());
        int g = 0;
        int sum = 0;
        for(int j = 0; j < n; j++){
            g = __gcd(g, nums[j]);
            sum += nums[j];
        }
        if(sum % 30 != 0) continue;
        if(g != 1) continue;
        for(int j = 0; j < n; j++){
            cout << nums[j] << " ";
        }
        cout << endl;
        break;
    }

zscoder watches anime to make up for that

Yes, I'm sorry for the weak testcases for D. I tried hard to fail some wrong greedy solutions but am not aware that bounding the parameter of the O(n²) dp passes.

Also, it is intended for F that any polynomial solution that you can precalculate in time to pass. Initially, the constraints were set to N ≤ 100 but we decided to lower it to N ≤ 50.

Anyway, congratulations on the win.

Try out small cases and also find some observations (invariants, necessary conditions etc...). For example, for this problem, I noted that if the string has 4 or more consecutive ones, then it must be beautiful, and so we only need to consider strings with  ≤ 3 consecutive ones. It also helps if you wrote a brute force and print out all possible small cases to either analyze the pattern or verify your conjectures.

For this particular question I observed a few greedy rules that help me reduce strings. For example it is always good move to replace 000 with 0. I analyzed problem a bit more and observed more such rules and then concluded that there is finitely many equivalence classes of prefixes and I can identify them with partially reduced strings. For example, if I'm dealing with prefix and I don't know my future, I know that if I see 001 I can reduce it to 0, but I can't reduce 100 to 0 because 0 may come next. Or when put in other words, this can be simulated by constructing an automaton and counting number of partial paths ending at every state. My automaton had 10 states, but I didn't built it explicitly, I just had map<string, int> dp and function string Reduce(string) that searches for patterns that can be greedily reduced.

However I don't think this is a general way of dealing with such problems, I found my approach pretty unique. I did not try to find some general way of describing good strings (or, I tried but failed) and I don't think bruteforce would have helped me to observe any patterns.