[HDU 4261] Estimation

[题目链接]

http://acm.hdu.edu.cn/showproblem.php?pid=4261

[算法]

首先，有一个结论 ：

| a[1] - k | + | a[2] - k | + ... + | a[n] - k | 当k取(a[1],a[2], ... , a[n])的中位数时，式子的值最小

考虑动态维护中位数

我们用一个大根堆和一个小根堆，大根堆中存放前[1..N/2]（向上取整）小的数,小根堆中存放[N/2 + 1,N]小的数，还需维护两个变量s1和s2，分别为小根堆中所有数的和和大根堆中所有数的和

这样，我们就可以预处理出每一段的最小值

然后，我们用f[i][j]表示前i个数分成j段取得的最小值，有状态转移方程 ：

f[i][j]  = min{ f[k][j - 1] + middle( k + 1,i) ) （其中，middle(k + 1,i)表示[k + 1,i]中每个数与中位数的差值和）

答案即为f[n][k]

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXN 2010
#define MAXK 30
const int INF = 2e9;

int i,j,k,s1,s2,x,y,n,m,middle;
int a[MAXN],sum[MAXN][MAXN];
int f[MAXN][MAXK];

struct Sheap
{
        int tot;
        int a[MAXN];
        inline void clear()
        {
                tot = ;
        }
        inline void up(int now)
        {
                if (now == ) return;
                int fa = now >> ;
                if (a[now] < a[fa])
                {
                        swap(a[now],a[fa]);
                        up(fa);
                }
        }
        inline void down(int now)
        {
                int son = now << ;
                if (son > tot) return;
                if (son +  <= tot && a[son + ] < a[son]) son++;
                if (a[son] < a[now])
                {
                        swap(a[son],a[now]);
                        down(son);
                }
        }
        inline void insert(int x)
        {
                a[++tot] = x;
                up(tot);
        }
        inline void del()
        {
                swap(a[],a[tot]);
                tot--;
                down();
        }
        inline int getroot()
        {
                return a[];
        }
} S;
struct Bheap
{
        int tot;
        int a[MAXN];
        inline void clear()
        {
                tot = ;
        }
        inline void up(int now)
        {
                if (now == ) return;
                int fa = now >> ;
                if (a[now] > a[fa])
                {
                        swap(a[now],a[fa]);
                        up(fa);
                }
        }
        inline void down(int now)
        {
                int son = now << ;
                if (son > tot) return;
                if (son +  <= tot && a[son + ] > a[son]) son++;
                if (a[son] > a[now])
                {
                        swap(a[now],a[son]);
                        down(son);
                }
        }
        inline void insert(int x)
        {
                a[++tot] = x;
                up(tot);
        }
        inline void del()
        {
                swap(a[],a[tot]);
                tot--;
                down();
        }
        inline int getroot()
        {
                return a[];
        }
} B;

int main()
{

        while (scanf("%d%d",&n,&m) && (n || m))
        {
                for (i = ; i <= n; i++) scanf("%d",&a[i]);
                for (i = ; i <= n; i++)
                {
                        B.clear();
                        S.clear();
                        sum[i][i] = ;
                        B.insert(a[i]);
                        s1 = a[i];
                        s2 = ;
                        for (j = i + ; j <= n; j++)
                        {
                                if (B.tot <= (j - i) / )
                                {
                                        B.insert(a[j]);
                                        s1 += a[j];
                                } else
                                {
                                        S.insert(a[j]);
                                        s2 += a[j];
                                }
                                x = B.getroot();
                                y = S.getroot();
                                if (x > y)
                                {
                                        B.del();
                                        s1 -= x;
                                        S.del();
                                        s2 -= y;
                                        S.insert(x);
                                        s2 += x;
                                        B.insert(y);
                                        s1 += y;
                                }
                                middle = B.getroot();
                                sum[i][j]    = middle * B.tot - s1 + s2 - middle * S.tot;
                        }
                }
                for (i = ; i <= n; i++)
                {
                        for (j = ; j <= m; j++)
                        {
                                f[i][j] = INF;
                        }
                }
                for (i = ; i <= n; i++) f[i][] = sum[][i];
                for (i = ; i <= n; i++)
                {
                        for (j = ; j <= m; j++)
                        {
                                for (k = i - ; k >= ; k--)
                                {
                                        f[i][j] = min(f[i][j],f[k][j - ] + sum[k + ][i]);
                                }
                        }
                }
                printf("%d\n",f[n][m]);
        }

        return ;

}