题目链接

• 题意：
  n个数字，范围是1-s，需要将1-s分成k段，使得每个数字必然只属于一段。分别计算每段的正序对，求和即为答案，现在需要让这个和最小，求最小值
• 分析：
  既然有k段这个限制，那么采用DP的时候必然需要将k作为一个状态：所以状态表示为dp[i][j]，以i为分段的最后一个数字，一共j段的答案。因为状态转移一定是dp[i][j] -> dp[k][j + 1]，所以将第二维优化。
  状态转移的时候，需要求一下在[i + 1, j]区间内的正序对个数，这个可以预处理解决：对于一个正序对x - y，在二维坐标中将（x，y）值加一。最后求得时候，其实就是要x和y均在给定的区间内的正序对个数，就是在一个正方形内的点的个数，预处理出每个点到原点的矩形中点的个数即可。
• tips：
  这题目本来是在湖南大学OJ上做的，不加离散化会超时。。。表示无奈。找到的原OJ是正常的，不加离散化更快
  

const int MAXN = 1010;

int S[MAXN][MAXN];
int ipt[MAXN];
int dp[MAXN];

inline int query(int l, int r)
{
    return S[r][r] - S[l - 1][r] - S[r][l - 1] + S[l - 1][l - 1];
}

int xx[MAXN], tot = 0, to[MAXN];
int main()
{
    tot = 1;
    int n, Max, k;
    RIII(n, Max, k);
    REP(i, n)
    {
        RI(ipt[i]);
        xx[tot++] = ipt[i];
    }
    sort(xx, xx + tot);
    int idx = 1;
    FF(i, 1, tot)
        if (xx[i] != xx[i - 1])
            xx[idx++] = xx[i];
    tot = idx;
    REP(i, tot)
        to[xx[i]] = i;
    Max = tot;
    REP(i, n)
        ipt[i] = to[ipt[i]];

    for (int i = 0; i <= Max; i++)
        dp[i] = INF;
    dp[0] = 0;

    REP(i, n) FF(j, i + 1, n)
        if (ipt[i] < ipt[j])
            S[ipt[i]][ipt[j]]++;
    FE(i, 1, Max) FE(j, 1, Max)
        S[i][j] += S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1];

    REP(kase, k)
    {
        FED(i, Max, 0)
        {
            for (int j = Max; j >= i + 1; j--)
            {
                int nxt = dp[i] + query(i + 1, j);
                if (nxt < dp[j])
                    dp[j] = nxt;
            }
        }
    }
    WI(dp[Max]);
    return 0;
}

const int MAXN = 1010;

int S[MAXN][MAXN];
int ipt[MAXN];
int dp[MAXN];

inline int query(int l, int r)
{
   return S[r][r] - S[l - 1][r] - S[r][l - 1] + S[l - 1][l - 1];
}

int main()
{
   int n, Max, k;
   scanf("%d%d%d", &n, &Max, &k);
   REP(i, n)
       scanf("%d", &ipt[i]);
   for (int i = 0; i <= Max; i++)
       dp[i] = INF;
   dp[0] = 0;
   REP(i, n) FF(j, i + 1, n)
       if (ipt[i] < ipt[j])
           S[ipt[i]][ipt[j]]++;
   FE(i, 1, Max) FE(j, 1, Max)
       S[i][j] += S[i - 1][j] + S[i][j - 1] - S[i - 1][j - 1];

   REP(kase, k)
   {
       FED(i, Max, 0)
       {
           for (int j = Max; j >= i + 1; j--)
           {
               int nxt = dp[i] + query(i + 1, j);
               if (nxt < dp[j]) dp[j] = nxt;
           }
       }
   }
   WI(dp[Max]);
   return 0;
}