hdu 4923 Room and Moor

输入由1和0组成的A序列，求一个长度与A序列相同的、在实数[0,1]之间的不下降序列B，使得sum of (Ai-Bi)^2最小，输出这个最小的sum。

首先可以先把A开头的0和结尾的1去掉，因为B串可以是000000.........1111111111。

然后我们考虑对于一个序列A 000001111 那么它期望得到的B序列为 xxxxxyyyy 其中在满足题意的情况下（B为不下降序列）x尽可能趋向0 y尽可能趋向1 此时是可以满足x <= y 的。

但是当我们考虑序列A 111110000 那么它期望得到的B序列为 yyyyyxxxx ，x y如上所述。但是此情况下不一定能满足 y <= x 。

所以我们令这个区间为[l.r]   ，求导后得到x取A序列的均值可使结果最小。

所以对于每一段形如11111110000000的区间求均值，这个均值就是这个区间对应的B值。如果当前的均值小于上一个区间的均值，那么我们就要合并这两个区间（因为要满足B为不下降序列）。如果合并后还小于上上个区间的均值那么就要再次合并。

#include <iostream>
#include<stdio.h>
#include<stack>
#define maxn 100010
using namespace std;
int a[maxn];
struct node
{
    int sum,len;
    node() {}
    node(int ss,int l)
    {
        sum = ss;
        len = l;
    }
};
stack<node>s;

int main()
{
    int t,n;
    double ans;
    scanf("%d",&t);
    while(t--)
    {
        while(!s.empty()) s.pop();
        ans = 0;
        scanf("%d",&n);
        for(int i = 0; i < n; i++) scanf("%d",&a[i]);
        int start = 0,e = n-1; //第一个1的位置，最后一个0的位置
        for(int i = 0; i < n; i++) if(a[i]==0) start++;
            else break;
        for(int i = n - 1; i >= 0; i--) if(a[i]) e--;
            else break;
        if(start == n || e == -1) ans = 0; //A是全为0或全为1的序列
        else
        {
            int sum = 0; //区间和
            int len = 0; //区间长度
            for(int i = start; i <= e; i++)
            {
                sum+=a[i];
                len++;
                if(i==e || (a[i]==0 && a[i+1]== 1))
                {
                    int cur_sum = sum;
                    int cur_len = len;
                    if(s.empty())
                    {
                        s.push(node(sum,len));
                    }
                    else
                    {
                        //如果栈顶元素的均值大于当前均值（或者是合并后的均值）则取出
                        while(!s.empty()&& s.top().sum*1.0/s.top().len > cur_sum*1.0/cur_len)
                        {
                            node nn = s.top();
                            s.pop();
                            cur_sum+=nn.sum;
                            cur_len+=nn.len;
                        }
                        s.push(node(cur_sum,cur_len));
                    }
                    sum = 0;
                    len = 0;
                }
            }
            while(!s.empty()) //计算差的平方
            {
                node nn = s.top();
                s.pop();
                double tmp = nn.sum*1.0/nn.len;
                ans+=(1.0-tmp)*(1.0-tmp)*nn.sum;
                ans+=tmp*tmp*(nn.len-nn.sum);
            }
        }
        printf("%.6lf\n",ans);
    }
    return 0;
}