Here, I'm assuming 1 <= el_id <= no_of_elements and 1 <= grp_id <= no_of_groups to be consistent with score. If this is not true, the code below will need to be changed slightly.

class ds
{
private:
	static int constexpr MAX_SCORE = 5;
	struct element
	{
		int grp_id;
		element *prev, *next;
		element() :
			prev(this),
			next(this)
		{}
	};
	vector<element> elements;
	struct group
	{
		// Each group has a 
		element heads[MAX_SCORE]{};
	};
	vector<group> groups;

	// Append non-empty circular doubly linked lists
	static void append(element *head_a, element *head_b)
	{
		swap(head_a->prev, head_b->prev);
		head_a->prev->next = head_a;
		head_b->prev->next = head_b;
	}
	// Remove a single node from its circular doubly linked list. The resulting list must be nonempty.
	static void remove(element *b)
	{
		b->prev->next = b->next;
		b->next->prev = b->prev;
		b->next = b->prev = b;
	}

public:
	ds(int no_of_elements, int no_of_groups) :
		elements(no_of_elements),
		groups(no_of_groups)
	{}
	void insert(int el_id, int grp_id, int x)
	{
		el_id--;
		grp_id--;
		x--;
		element *el = &elements[el_id];
		el->grp_id = grp_id;
		append(&groups[grp_id].heads[x], el);
	}
	void set_element(int el_id, int x)
	{
		el_id--;
		x--;
		element *el = &elements[el_id];
		remove(el);
		append(&groups[el->grp_id].heads[x], el);
	}
	void set_group(int grp_id, int x)
	{
		grp_id--;
		x--;
		element *head_new = &groups[grp_id].heads[x];
		for (int score = 0; score < MAX_SCORE; score++)
		{
			element *head_old = &groups[grp_id].heads[score];
			element *first = head_old->next;
			if (first == head_old) continue; // Skip empty lists
			remove(head_old);
			append(head_new, first);
		}
	}
	int print(int grp_id) const
	{
		grp_id--;
		for (int score = MAX_SCORE - 1; score >= 0; score--)
		{
			element const *head = &groups[grp_id].heads[score];
			if (head->next != head)
				// head->next - elements.data() is the zero-based index
				return (int)(head->next - elements.data()) + 1;
		}
		assert(false); // Group is empty
	}
};