Bittipeli

input/code.cpp: In function 'std::vector<std::vector<bool> > removableSets(std::vector<bool>)':
input/code.cpp:29:7: warning: unused variable 'last' [-Wunused-variable]
  bool last;
       ^

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <exception>
#include <limits.h>
using namespace std;
unsigned long getSubsetBegin(vector<bool> arr, vector<bool> subset){
	unsigned long match = 0;
	unsigned long subInd = 0;
	for (unsigned long i = 0; i < arr.size(); i++){
		if (arr.at(i) == subset.at(subInd)){
			match++;
			if (match == subset.size()){
				return i - subset.size() + 1;
			}
			subInd++;
		}
		else{
			match = 0;
			subInd = 0;
		}
	}
	return ULONG_MAX;
}
std::vector<std::vector<bool> > removableSets(std::vector<bool> bits){
	std::vector<std::vector<bool> > beginSets;
	bool last;
	unsigned long trueSetLen = 0;
	unsigned long falseSetLen = 0;
	/*if ( std::adjacent_find( myvector.begin(), myvector.end(), std::not_equal_to<int>() ) == myvector.end() )
	{
	std::cout << "All elements are equal each other" << std::endl;
	}*/
	if (bits.size() < 2){
		return beginSets;
	}
	if (std::adjacent_find(bits.begin(), bits.end(), std::not_equal_to<bool>()) == bits.end()){//All elements are equal to each other
		beginSets.push_back(bits);
		return beginSets;
	}
	

	for (unsigned long i = 0; i < bits.size() - 1; i++){

		if (bits.at(i) && bits.at(i + 1)){
			trueSetLen++;
		}
		if (!bits.at(i) && !bits.at(i + 1)){
			falseSetLen++;
		}
		else if (bits.at(i) != bits.at(i + 1)){//Set breaks
			if (trueSetLen > 0){
				std::vector<bool> vect;
				vect.resize(trueSetLen + 1, true);
				vect.at(0) = true;
				//vec.insert(vec.begin(), true, trueSetLen + 1);
				beginSets.push_back(vect);
			}
			if (falseSetLen > 0){
				std::vector<bool> vecf;
				vecf.resize(falseSetLen + 1, false);
				vecf.at(0) = false;
				//vec.insert(vec.begin(), false, falseSetLen + 1);
				beginSets.push_back(vecf);
			}
			trueSetLen = 0;
			falseSetLen = 0;
		}
	}
	//TODO take smaller than maximum removable blocks into account
	/*for (unsigned long i = 0; i < beginSets.size(); i++){
		vector<bool> b = beginSets.at(i);
		if (b.size() > 2){
			vector<bool> v;
			v.resize(b.size() - 1, b.front());
			beginSets.push_back(v);
		}
	}*/
	return beginSets;
}
vector<bool> remove(vector<bool> in, vector<bool> remSet){
	vector<bool> copy = in;
	unsigned long index = getSubsetBegin(copy, remSet);
	if (index == ULONG_MAX){ throw 0; }
	copy.erase(copy.begin() + index, copy.begin() + index + remSet.size());
	return copy;
}
class Tracker{
public:
	Tracker(){}
	Tracker(unsigned long depth, unsigned long i){
		this->depth = depth; this->i = i; leadsToSuccess = false;
	}
	operator bool() const {
		return this->leadsToSuccess;
	}
	unsigned long depth, i;
	bool leadsToSuccess;
};
bool LeadsToSuccess(Tracker t){
	return t.leadsToSuccess;
}
vector<Tracker> possiblePaths(Tracker* t, vector<bool> in, vector<vector<bool> > remSets){
	vector<bool> copy = in;
	vector<Tracker> paths;
	for (unsigned long i = 0; i < remSets.size(); i++/*std::vector<bool> remSet : remSets*/){
		vector<bool> remSet = remSets.at(i);
		std::vector<bool> remOut = remove(copy, remSet);
		/*if (remOut.size() == 1){
		return paths;
		}*/
		Tracker newT(t->depth + 1, i);
		paths.push_back(newT);
		if (remOut.empty()){
			paths.back().leadsToSuccess = true;
			t->leadsToSuccess = true;
			return paths;
		}
		//Calculate new rem sets
		auto rs = removableSets(remOut);
		vector<Tracker> newPaths = possiblePaths(&(paths.back()), remOut, rs);
		if (!newPaths.empty()){
			if (std::find(newPaths.begin(), newPaths.end(), true) != newPaths.end()){
				t->leadsToSuccess = true;
				//paths.back().leadsToSuccess = true;
				paths.insert(paths.end(), newPaths.begin(), newPaths.end());
				return paths;
			}
		}
	}
	return paths;
}
bool DoesNotSucceed(Tracker t){
	return !t.leadsToSuccess;
}
int main() {
	std::cin.sync_with_stdio(false);//Faster execution
	std::string str;
	std::cin >> str;
	//1001001001
	std::vector<bool> bits;
	for (char c : str){
		if (c == '1'){
			bits.push_back(true);
		}
		else{
			bits.push_back(false);
		}
	}
	//Figure out how this set was formed by inserting set of two or more trues or falses
	std::vector<bool> copy(bits);

	std::vector<std::vector<bool> > remSets = removableSets(copy);
	Tracker t(0, 0);
	std::vector<Tracker> paths = possiblePaths(&t, copy, remSets);
	if (!t.leadsToSuccess){
		cout << "QAQ";
		return 0;
	}
	vector<Tracker>::iterator it = std::remove_if(paths.begin(), paths.end(), DoesNotSucceed);
	paths.resize(it - paths.begin());
	cout << paths.size() << std::endl;
	for (Tracker t : paths){
		cout << t.i + 1 << ' ';
	}
	return 0;
}

Test 1

Group: 1

Verdict: ACCEPTED

Test 2

Group: 1

Verdict: ACCEPTED

Test 3

Group: 1

Verdict: ACCEPTED

Test 4

Group: 1

Verdict: ACCEPTED

Test 5

Group: 1

Verdict: ACCEPTED

Test 6

Group: 1

Verdict: ACCEPTED

Test 7

Group: 1

Verdict: ACCEPTED

Test 8

Group: 1

Verdict: ACCEPTED

Test 9

Group: 1

Verdict: ACCEPTED

Test 10

Group: 1

Verdict: ACCEPTED

Test 11

Group: 1

Verdict: ACCEPTED

Test 12

Group: 1

Verdict: ACCEPTED

Test 13

Group: 1

Verdict: ACCEPTED

Test 14

Group: 1

Verdict: ACCEPTED

Test 15

Group: 1

Verdict: ACCEPTED

Test 16

Group: 1

Verdict: ACCEPTED

Test 17

Group: 1

Verdict: ACCEPTED

Test 18

Group: 1

Verdict: ACCEPTED

Test 19

Group: 1

Verdict: ACCEPTED

Test 20

Group: 1

Verdict: ACCEPTED

Test 21

Group: 2

Verdict: ACCEPTED

Test 22

Group: 2

Verdict: ACCEPTED

Test 23

Group: 2

Verdict: ACCEPTED

Test 24

Group: 2

Verdict: ACCEPTED

Test 25

Group: 2

Verdict: ACCEPTED

Test 26

Group: 2

Verdict: ACCEPTED

Test 27

Group: 2

Verdict: ACCEPTED

Test 28

Group: 2

Verdict: ACCEPTED

Test 29

Group: 2

Verdict: WRONG ANSWER

Test 30

Group: 2

Verdict: ACCEPTED

Test 31

Group: 2

Verdict: ACCEPTED

Test 32

Group: 2

Verdict: ACCEPTED

Test 33

Group: 2

Verdict: ACCEPTED

Test 34

Group: 2

Verdict: ACCEPTED

Test 35

Group: 2

Verdict: ACCEPTED

Test 36

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 37

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 38

Group: 2

Verdict: TIME LIMIT EXCEEDED

Test 39

Group: 2

Verdict: ACCEPTED

Test 40

Group: 2

Verdict: ACCEPTED

Test 41

Group: 3

Verdict: ACCEPTED

Test 42

Group: 3

Verdict: ACCEPTED

Test 43

Group: 3

Verdict: ACCEPTED

Test 44

Group: 3

Verdict: ACCEPTED

Test 45

Group: 3

Verdict: WRONG ANSWER

Test 46

Group: 3

Verdict: ACCEPTED

Test 47

Group: 3

Verdict: ACCEPTED

Test 48

Group: 3

Verdict: ACCEPTED

Test 49

Group: 3

Verdict: ACCEPTED

Test 50

Group: 3

Verdict: ACCEPTED

Test 51

Group: 3

Verdict: ACCEPTED

Test 52

Group: 3

Verdict: ACCEPTED

Test 53

Group: 3

Verdict: ACCEPTED

Test 54

Group: 3

Verdict: WRONG ANSWER

Test 55

Group: 3

Verdict: ACCEPTED

Test 56

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 57

Group: 3

Verdict: TIME LIMIT EXCEEDED

Test 58

Group: 3

Verdict: RUNTIME ERROR

Test 59

Group: 3

Verdict: ACCEPTED

Test 60

Group: 3

Verdict: RUNTIME ERROR

Test 61

Group: 4

Verdict: ACCEPTED

Test 62

Group: 4

Verdict: ACCEPTED

Test 63

Group: 4

Verdict: ACCEPTED

Test 64

Group: 4

Verdict: ACCEPTED

Test 65

Group: 4

Verdict: ACCEPTED

Test 66

Group: 4

Verdict: ACCEPTED

Test 67

Group: 4

Verdict: ACCEPTED

Test 68

Group: 4

Verdict: ACCEPTED

Test 69

Group: 4

Verdict: ACCEPTED

Test 70

Group: 4

Verdict: ACCEPTED

Test 71

Group: 4

Verdict: ACCEPTED

Test 72

Group: 4

Verdict: ACCEPTED

Test 73

Group: 4

Verdict: ACCEPTED

Test 74

Group: 4

Verdict: ACCEPTED

Test 75

Group: 4

Verdict: ACCEPTED

Test 76

Group: 4

Verdict: RUNTIME ERROR

Test 77

Group: 4

Verdict: RUNTIME ERROR

Test 78

Group: 4

Verdict: RUNTIME ERROR

Test 79

Group: 4

Verdict: TIME LIMIT EXCEEDED

Test 80

Group: 4

Verdict: RUNTIME ERROR