TopCoder SRM 589 Div2 第3题

类型：dp  难度：2.5

题意：给定一个字符串数组，每个字符串都由0或1构成，先把他们连起来成一个大字符串，给定整数M，M能被字符串总长度n整除，然后指定可以进行的三种操作：

1、翻转一个字符，0->1或1->0

2、翻转左边k*M个字符，k为任意正整数(k*M<=n)

3、翻转右边k*M个字符，k为任意正整数(k*M<=n)

问：最少需要进行几次操作，才能将全部字符串全置为1

 

分析：一开始绕了一大圈，想了很复杂的方法，最后发现是dp题目。。还是对dp不熟悉。

把字符串看成若干长为M的子字符串的串联，cnt[i][0]记录第i个子串翻转为全0需要几次（即1的个数），cnt[i][1]记录第i个子串翻转为全1需要几次（0的个数）

dp[i][0]记录将第i个全0子串变为1的累计次数（0-i子串代价叠加），

dp[i][1]记录将第i个全1子串变为1的累计次数（0-i子串代价叠加）

状态转移方程：

dp[i][0] = cnt[i][0]+MIN(dp[i-1][0],dp[i-1][1]+2);
dp[i][1] = cnt[i][1]+MIN(dp[i-1][1],dp[i-1][0]);

即：若当前子串为全0，它的累计代价为当前翻转次数+前一个子串为0的翻转次数和前一个子串为1的翻转次数+2的最小值，+2是因为若前一个子串为1，当前子串为0，则将当前子串翻转为1需要先翻转前0-i个子串，再翻转0- i-1个子串，翻转2次

若当前子串为全1，它的累计代价为当前翻转次数+前一个子串为0的翻转次数和前一个子串为1的翻转次数的最小值，这个好理解，就是当前已经为1了，去前面最小值即可

注意初始化dp[0][0] = cnt[0][0]+1,dp[0][1] = cnt[0][1]，+1因为第1个子串只需翻转1次即可

还要考虑从最后开始翻的也是翻转一次，所以要记录从开始一共持续多少为0的子串，若持续到最后，则不用处理，若未持续到最后，需将最后一个dp[n/M-1][0]-1，因为每个连0串都默认翻转2次，所以-1，用一个flag数组记录即可。

代码如下：

#include<string>
#include<vector>
#include<cstring>
#include<map>
#include<iostream>
#include<algorithm>
using namespace std;

#define MIN(x,y) ((x)<(y)?(x):(y))

const int MAX = 2505;
class FlippingBitsDiv2
{
	public:
		int getmin(vector <string> S, int M)
		{
			int n = 0;
			string str = "";
			
			for(int i=0;i<S.size();i++)
			{
				str += S[i];
			}
			n = str.length();
			
			int dp[MAX][2];
			int cnt[MAX][2];
			int flag[MAX]; 
			
			memset(dp,0,sizeof(dp));
			memset(cnt,0,sizeof(cnt));
			memset(flag,0,sizeof(flag));
			
			for(int i=0; i<n/M; i++)
			{
				for(int j=0; j<M; j++)
				{
					if(str[i*M+j] == '0') cnt[i][1]++;
					else cnt[i][0]++;
				}
			}
			
			dp[0][0] = cnt[0][0]+1;
			flag[0] = 1;
			dp[0][1] = cnt[0][1];			
			
			for(int i=1; i<n/M; i++)
			{				
				dp[i][0] = cnt[i][0]+MIN(dp[i-1][0],dp[i-1][1]+2);
				dp[i][1] = cnt[i][1]+MIN(dp[i-1][1],dp[i-1][0]);
				
				if(dp[i-1][0] < dp[i-1][1]+2) flag[i] = flag[i-1];
			}
			if(flag[n/M-1] == 0)
				dp[n/M-1][0]--;
			/*
			for(int i=0; i<2; i++)
			{
				for(int j=0; j<n/M; j++)
					cout<<dp[j][i]<<" ";
				cout<<endl;
			}*/
			
			return MIN(dp[n/M-1][0],dp[n/M-1][1]);
		}
};