HNU-Flight Boarding Optimization的一些感想

        题目大意：一架飞机，有s列，n个人按顺序上飞机，每个人都有一个愤怒值（他座位前面的人数，后面和同列的看不到），现在将飞机分成k节，要求得到的愤怒值最小

        数据范围：0<n，s<=1000，k<=50。

        题目链接：HNU  官方oj

        对于这题，其实第一眼看到就很有感觉，用博士的话说，就是看到靶子了，这就是一个区间划分问题，dp转移方程很快就能写出来：

                                                   dp[k][i] = min(dp[k][i],dp[k-1][j]+mapt[j+1][i])（dp数组表示前i列分成k段能取到的最优值，mapt是一段区间内所产生的愤怒值）

        时间复杂度：O（s^2 * k）在接受范围内！！！

        所以，本题的关键并不是在这里。

        该题要想拿到一个好的分数，预处理很关键，一开始我的想法是用线段树维护，因为它求的值和区间息息相关，并且，每一次它都要动态更新数组。于是开始敲起代码。但一到敲代码才发现，没有那么简单。根本无从下手。

        在练习结束后各种度娘，找到一篇官方题解，俄文，标程也看不懂。找了好久才找到一篇看的懂的题解，才发现预处理真的好巧妙。

        对于x,y两个人，如果x<y，且x在y之前上飞机，那么x必定会对y产生影响。对此，我们将它转化为二维坐标上的点，坐标就是（x,y），那么要求出区间【left，right】的愤怒值，就转化为求二维坐标中矩形（left,left）--(right,right)中点的个数（so easy！！！！）求矩形中的点的个数可以直接用mapt[i][j]+=mapt[i-1][j]+mapt[i][j-1]-mapt[i-1][j-1]转移（左下角为原点）

       

#include<iostream>
#include<math.h>
#include<stdlib.h>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<map>
#include<vector>
#include<stack>
using namespace std;
#define sf scanf
#define pf printf
#define rt return
#define ct continue
#define bk break
#define ms memset
#define REP(i,x,y) for(int i=(x);i<=(y);i++)
#define MAXN 1005
#define INF 0x3fffffff
int n,m,k;
int mapt[MAXN][MAXN];
int dp[55][MAXN];
int people[MAXN];
bool init()
{
    if(sf("%d%d%d",&m,&n,&k)==EOF) rt false;
    REP(i,1,m) sf("%d",&people[i]);
    rt true;
}
void doit()
{
    ms(mapt,0,sizeof(mapt));
    REP(i,1,m)
      REP(j,i+1,m)
        if(people[i]<people[j])
            mapt[people[i]][people[j]]++;
    REP(i,1,n)
      REP(j,1,n)
        mapt[i][j]+=mapt[i-1][j]+mapt[i][j-1]-mapt[i-1][j-1];
    REP(i,0,k)
      REP(j,0,n)
        dp[i][j] = INF;
    dp[0][0]=0;
    REP(i,1,n)
      dp[0][i] = mapt[i][i];
    REP(t,1,k-1)
      REP(i,t,n)
        REP(j,t-1,i-1)
          {
              int tt = mapt[i][i]-mapt[j][i]-mapt[i][j]+mapt[j][j];
              if(dp[t][i]>dp[t-1][j]+tt)dp[t][i]=dp[t-1][j]+tt;
          }
    pf("%d\n",dp[k-1][n]);
}
int main()
{
    while(init())
    {
        doit();
    }
    rt 0;
}

这个代码可以过官方oj，但在湖大oj上一直TLE（或许可以用单调队列优化，不过我没试）

再附个标程（我看不懂，如果有大神看懂，请帮忙解释解释）

#include <cstdio>
const int INF = 1 << 30;
int d[1234][1234];
int dp[1234], ne[1234], a[1234];
int main() {
  int n, s, k;
  scanf("%d%d%d", &n, &s, &k);
  for (int i = 0; i < n; i++) {
    scanf("%d", a + i);
    --a[i];
  }
  for (int i = 0; i < n; i++) {
    for (int j = i + 1; j < n; j++) {
      if (a[i] >= a[j]) continue;
      d[a[i]][a[j]]++;
    }
  }
  for (int i = s - 1; i > 0; i--) {
    for (int j = 0; j < s; j++) {
      d[i - 1][j] += d[i][j];
    }
  }
  for (int i = 0; i < s; i++) {
    for (int j = 1; j < s; j++) {
      d[i][j] += d[i][j - 1];
    }
  }
  for (int i = 0; i <= s; i++) {
    dp[i] = INF;
  }
  dp[0] = 0;
  for (int st = 0; st < k; st++) {
    for (int i = 0; i <= s; i++) ne[i] = INF;
    for (int i = 0; i < s; i++) {
      for (int j = i; j < s; j++) {
        if (ne[j + 1] > dp[i] + d[i][j]) {
          ne[j + 1] = dp[i] + d[i][j];
        }
      }
    }
    for (int i = 0; i <= s; i++) dp[i] = ne[i];
  }
  printf("%d\n", dp[s]);
}