HDU

题目链接

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

题意

一撞大楼有N层楼，然后每层楼都有一部分人喜欢打羽毛球，一部分人喜欢打乒乓球
但是每层楼只能选择建一个羽毛球馆或者建一个乒乓球馆 那么每个人到它喜欢的球馆的距离就是一个权值
求出怎么规划 使得所有人到它喜欢的球馆的距离之和最小

思路

其实当时在训练的时候 有在想

当时训练的时候的思路是
dp[i][j] i 表示第几层 j 表示状态 0 表示乒乓球馆 1 表示羽毛球馆
然后每次转移的是从前面那一层转移过来的

因为那时候是这样想的，假设前面的规划是最优解，也就是说 dp[i - 1][0] 或者 dp[i - 1][1] 保存的是最优状态
那么我再加一层 是不是可以根据 这个最优状态转移过来，我加的这一层也就只有两种选择，0 或者 1

那么我只要用一个数组来维护前面状态离它最近的乒乓球馆和羽毛球馆的位置， 然后更新一下就好了。

然后jsw告诉我这样是错的，，然后我现在也不知道这样为什么是错的，。。 它是说 应该是从1 -> i - 1 都更新一遍，才是对的。。。 然后他还是没告诉我，为什么我这样是错的。。。。

然后查了题解，果然是要这样更新，

dp[i][j] i 表示第几层，j 表示状态

dp[i][j] = min(dp[k][j ^ 1] + valuesum(k + 1, i, j)) k < i

valuesum 表示 区间[i,. j] 的人到达他们最近的球馆的距离总和

其实更新是这样的

是 k 层 和 i + 1 层的状态是一样的，， 然后 k + 1 -> i 层的状态是一样的

那么 k + 1 -> i 层的和其楼层状态不同的人 前一半就去 k 层 后一半就去 i + 1 层 这样是最优的

如果暴力更新会T 就要用到前缀和 研究了好久。。

一个是人数的前缀和，一个是距离的前缀和

人数的前缀和很简单，就是前i层的总人数

我们先从低维度进行思考

如果我知道一个人在x 层 ，那么我要求他去y层的距离是多少 那么很显然是不是 abs(x - y)

那么很多人 其实也是一样的，，我们只需要记录每层有多少人，然后求到Y的距离 就是 abs(所有人数所在的楼层和 - 人数 * Y)

sum 数组存放的是人数前缀和， value 数组存放的是每层楼有多少人的前缀和

AC代码

#pragma comment(linker, "/STACK:102400000,102400000")

#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <stack>
#include <set>
#include <list>
#include <numeric>
#include <sstream>
#include <iomanip>
#include <limits>

#define CLR(a, b) memset(a, (b), sizeof(a));
#define pb push_back
#define bug puts("***bug***");
#define fi first
#define se second
#define L(on) ((on)<<1)
#define R(on) (L(on) | 1)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define syn_close ios::sync_with_stdio(false); cin.tie(0);
#define sp system("pause");
//#define gets gets_s 

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef long double ld;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <string, int> psi;
typedef pair <string, string> pss;
typedef pair <double, int> pdi;

const double PI = acos(-1.0);
const double EI = exp(1.0);
const double eps = 1e-8;

const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fll;
const int maxn = (int)4e3 + 10;
const int MAXN = (int)1e2 + 10;
const int MOD = (int)1e9 + 7;

int n;
pll arr[maxn];   // fi 0 se 1
ll sum[2][maxn], value[2][maxn], dp[2][maxn];

int readint()
{
    int num; scanf("%d", &num);
    return num;
}

void input()
{
    n = readint();
    CLR(sum, 0); CLR(value, 0); CLR(dp, 0x3f);
    for (int i = 1; i <= n; i++)
    {
        arr[i].fi = (ll)readint(), arr[i].se = (ll)readint();
        sum[0][i] = sum[0][i - 1] + arr[i].fi;
        sum[1][i] = sum[1][i - 1] + arr[i].se;
        value[0][i] = value[0][i - 1] + arr[i].fi * i;
        value[1][i] = value[1][i - 1] + arr[i].se * i;
    }
}

ll leftcal(int l, int r, int vis)
{
    ll x = value[vis][r] - value[vis][l - 1];
    ll y = sum[vis][r] - sum[vis][l - 1];
    return abs(x - y * (l - 1));
}

ll rightcal(int l, int r, int vis)
{
    ll x = value[vis][r] - value[vis][l - 1];
    ll y = sum[vis][r] - sum[vis][l - 1];
    return abs(x - y * (r + 1));
}

ll valuesum(int l, int r, int vis)
{
    if (l == 1) return rightcal(l, r, vis);
    if (r == n) return leftcal(l, r, vis);
    int mid = (l + r) >> 1;
    return leftcal(l, mid, vis) + rightcal(mid + 1, r, vis);
}

void solve()
{
    for (int i = 1; i < n; i++)
        for (int j = 0; j < 2; j++)
            dp[j][i] = valuesum(1, i, j);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j < i; j++)
            for (int k = 0; k < 2; k++)
                dp[k][i] = min(dp[k][i], dp[k ^ 1][j] + valuesum(j + 1, i, k));
    printf("%lld
", min(dp[0][n], dp[1][n]));
}

int main()
{
    int t = readint();
    for (int tt = 1; tt <= t; tt++)
    {
        printf("Case #%d: ", tt); 
        input(); solve();
    }
}