Challenges in school №41 CodeForces - 1333D（思维）

There are n children, who study at the school №41. It is well-known that they are good mathematicians. Once at a break, they arranged a challenge for themselves. All children arranged in a row and turned heads either to the left or to the right.

Children can do the following: in one second several pairs of neighboring children who are looking at each other can simultaneously turn the head in the opposite direction. For instance, the one who was looking at the right neighbor turns left and vice versa for the second child. Moreover, every second at least one pair of neighboring children performs such action. They are going to finish when there is no pair of neighboring children who are looking at each other.

You are given the number n, the initial arrangement of children and the number k. You have to find a way for the children to act if they want to finish the process in exactly k seconds. More formally, for each of the k moves, you need to output the numbers of the children who turn left during this move.

For instance, for the configuration shown below and k=2 children can do the following steps:

At the beginning, two pairs make move: (1,2) and (3,4). After that, we receive the following configuration:

At the second move pair (2,3) makes the move. The final configuration is reached. Good job.

It is guaranteed that if the solution exists, it takes not more than n2 “headturns”.

Input
The first line of input contains two integers n and k (2≤n≤3000, 1≤k≤3000000) — the number of children and required number of moves.

The next line contains a string of length n and consists only of characters L and R, where L means that the child looks to the left and R means that the child looks to the right.

Output
If there is no solution, print a single line with number −1.

Otherwise, output k lines. Each line has to start with a number ni (1≤ni≤n2) — the number of pairs of children, who turn at this move. After that print ni distinct integers — the numbers of the children who will turn left during this move.

After performing all “headturns”, there can’t be a pair of two neighboring children looking at each other.

If there are many solutions, print any of them.

Examples
Input
2 1
RL
Output
1 1
Input
2 1
LR
Output
-1
Input
4 2
RLRL
Output
2 1 3
1 2
Note
The first sample contains a pair of children who look at each other. After one move, they can finish the process.

In the second sample, children can’t make any move. As a result, they can’t end in k>0 moves.

The third configuration is described in the statement.
一开始接触这个题目，一点思路都么得。
思路：每次把能反转的都翻转一遍和每次只翻转一个，这两种做法，一个是最少的次数，一个是最多的次数。这样的话，我们就可以判断k能否实现了。我们在求最大和最少次数的时候，就可以把每次都翻转一遍的情况保存起来，保存翻转向左的编号。
在打印可行的情况的时候，我们已经知道了最少的操作次数_min，对于k来讲，我们可以这样去做：首先将_min补成k，然后再输出剩下的翻转情况。假如第一次有五处需要翻转，这五次可以一秒完成，也可以五秒完成。我们可以拿出这五次中的三次来，这三次花费三秒去完成，剩下的那两次一秒就完成了。就是这样的一个意思。这里有一点需要注意的是，如果这一轮翻转的已经用完了，例如：总共2个需要翻转，而这两个都已翻转了，那么这一次就没有可以再利用了。对于整体的来说，就相当于减去了一秒，然后按道理再加一秒，就不执行操作了。这里需要注意一下。
代码如下：

#include<bits/stdc++.h>
#define ll long long
using namespace std;

const int maxx=3e6+100;
vector<int> p[maxx];
string s;
int n,k;
int _min=0,_max=0;

inline void fcs(int id)
{
	for(int i=0;i<n-1;i++)
	{
		if(s[i]=='R'&&s[i+1]=='L') 
		{
			p[id].push_back(i);
			swap(s[i],s[i+1]);
			i++;
		}
	}
}
inline void solve()
{
	int uu=_min;
	int i=0,j=0;
	while(uu<k)
	{
		printf("1 %d\n",p[i][j]+1);
		j++;
		if(j==p[i].size()) i++,j=0;//这里要注意！！！可以自己假设一种情况试一下，挺难理解的一处。
		else uu++;
	}
	printf("%d ",p[i].size()-j);
	for(int o=j;o<p[i].size();o++) printf("%d ",p[i][o]+1);printf("\n");
	i+=1;
	while(i<_min)
	{
		printf("%d ",p[i].size());
		for(int o=0;o<p[i].size();o++) printf("%d ",p[i][o]+1);
		printf("\n");
		i++;
	}
}
int main()
{
	scanf("%d%d",&n,&k);
	cin>>s;
	fcs(0);
	while(p[_min].size()&&_min<=k)
	{
		_max+=p[_min].size();
		_min++;
		fcs(_min);
	}
	if(!(_min<=k&&k<=_max)) cout<<-1<<endl;
	else solve();
	return 0;
}

很不错的一道题目，还是太嫩啊。
努力加油a啊，(^o)/~