This way

题意：

给你一个字符串，有些位置是已知的，有些是未知的，从位置1开始，如果有连续的0或者1大于等于k个，那么就算一轮游戏，然后0,1重新计数。问你当k=1~n的时候，游戏轮数最多是多少。

题解：

首先发现，这个是可以用调和级数做的，并且感觉也是正确的，于是考虑这个做法：对于当前位置，至少要多少个数才能进行一轮游戏。我们可以发现贪心必定是正确的，因为01数量会清空，所以结束的越早越好。
那么对于这个做法，我们考虑从后往前DP：
dp[i][j]表示到了第i个位置，连续的0/1数量最多是多少
然后枚举k，从前往后做，如果我们每次暴力的去查找dp值，时间复杂度是 O ( n 2 ) O(n^2) O(n2)，然后的话可以考虑使用线段树查询区间第一个大于等于x的数的位置。

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
int dp[N][2];
int mx[N*4];
void build(int l,int r,int root){
    if(l==r){
        mx[root]=max(dp[l][0],dp[l][1]);
        return ;
    }
    int mid=l+r>>1;
    build(l,mid,root<<1);
    build(mid+1,r,root<<1|1);
    mx[root]=max(mx[root<<1],mx[root<<1|1]);
}
int query(int l,int r,int root,int ql,int qr,int v){
    if(mx[root]<v)return -1;
    if(l==r)return l;
    int mid=l+r>>1;
    if(l>=ql&&r<=qr){
        if(mx[root<<1]>=v)return query(l,mid,root<<1,ql,qr,v);
        return query(mid+1,r,root<<1|1,ql,qr,v);
    }
    int ans=-1;
    if(mid>=ql&&mx[root<<1]>=v)
        ans=query(l,mid,root<<1,ql,qr,v);
    if(ans==-1&&mid<qr)
        ans=query(mid+1,r,root<<1|1,ql,qr,v);
    return ans;
}
char s[N];
int main()
{
    int n;
    scanf("%d",&n);
    scanf("%s",s+1);
    for(int i=n;i;i--){
        if(s[i]=='?')
            dp[i][0]=dp[i+1][0]+1,dp[i][1]=dp[i+1][1]+1;
        else if(s[i]=='0')
            dp[i][0]=dp[i+1][0]+1,dp[i][1]=0;
        else
            dp[i][0]=0,dp[i][1]=dp[i+1][1]+1;
    }
    build(1,n,1);
    printf("%d ",n);
    for(int i=2;i<=n;i++){
        int p=1,ans=0;
        while(p<=n){
            int ne=query(1,n,1,p,n,i);
            if(ne==-1)break;
            ans++;
            p=ne+i;
        }
        printf("%d ",ans);
    }
    printf("\n");
    return 0;
}