FZU 2041 Checker （贪心+模拟）

题目地址： FZU 2041

这个题是昨天的队内选拔赛用的套题里的其中一道题，我当时想到方法了，但是没敢写。。一个是对复杂度有些不确定，万一组数很多的话好像就会跪。。而且感觉不太好实现，队里还卡着两道题，就打算等别的该出的题出了之后再写，结果没时间了。。

刚才按照那思路写了一下。。结果就过了。。。真心醉了。。我&……%￥%**……%%

思路是先枚举每个空隙，然后对该空隙向左向右贪心的一步步的去移动，剩下的就是小模拟了。然后找出所有空隙可能扩大的最大值就可以了。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <map>
#include <stack>
#include <cmath>
#define LL __int64
#define INF 0x3f3f3f3f
#define PI acos(-1)
#define eqs 1e-15
const int mod = 1e9+7 ;
using namespace std ;
char s[600];
int a[600], cnt;
struct node {
        int l, r, x;
} fei[600];
int main()
{
        int t, n, m, i, j, flag, lstep, rstep, max1, step, Case=0, mm;
        scanf("%d",&t);
        while(t--) {
                scanf("%d%d",&n,&mm);
                scanf("%s",s+1);
                s[0]=‘1‘;
                s[n+1]=‘1‘;
                cnt=0;
                flag=0;
                max1=0;
                for(i=0; i<=n+1; i++) {
                        if(s[i]==‘1‘) {
                                if(flag) {
                                        flag=0;
                                        fei[cnt].r=i;
                                        cnt++;
                                }
                                fei[cnt].l=i;
                                fei[cnt].x=0;
                        } else {
                                flag=1;
                                fei[cnt].x++;
                                max1=max(max1,fei[cnt].x);
                        }
                }
                for(i=0; i<cnt; i++) {
                        m=mm;
                        for(j=0; j<=n+1; j++) {
                                a[j]=s[j]-‘0‘;
                        }
                        while(m) {
                                lstep=INF;
                                for(j=fei[i].l; j>=0; j--) {
                                        if(!a[j]) {
                                                lstep=fei[i].l-j;
                                                break;
                                        }
                                }
                                rstep=INF;
                                for(j=fei[i].r; j<=n+1; j++) {
                                        if(!a[j]) {
                                                rstep=j-fei[i].r;
                                                break;
                                        }
                                }
                                step=min(lstep,rstep);
                                if(m<step) {
                                        max1=max(fei[i].x,max1);
                                        break;
                                }
                                m-=step;
                                fei[i].x++;
                                if(lstep<=rstep) {
                                        a[fei[i].l]=0;
                                        a[fei[i].l-step]=1;
                                        fei[i].l--;
                                } else {
                                        a[fei[i].r]=0;
                                        a[fei[i].r+step]=1;
                                        fei[i].r++;
                                }
                                if(!m) {
                                        max1=max(max1,fei[i].x);
                                        break;
                                }
                        }
                }
                printf("Case %d: %d\n",++Case,max1);
        }
        return 0;
}