SRM627 div2 1000pt DP

Problem Statement
	The pseudocode shown below is an implementation of BubbleSort. Note that the array A used in the implementation is 0-based. That is, elements of A have indices 0 through Length(A)-1, inclusive. BubbleSort(A): Repeat Length(A)-1 times: For every i from 0 to Length(A)-2, inclusive: If A[i] > A[i+1] then: Swap A[i] and A[i+1] We are going to sort the array A using the above algorithm. However, before we do that, you are allowed to reverse at most K disjoint subarrays of A. For example, suppose that A={10, 20, 30, 40, 50, 60, 70} and that K=1. In this case you may, for example, reverse the subarray [2,5] - that is, the elements at (0-based) indices 2 through 5. This would produce the array {10, 20, 60, 50, 40, 30, 70}. We are interested in minimizing the number of swaps executed by our BubbleSort. You are given the vector <int> A and the int K. Return the smallest possible number of swaps performed by our BubbleSort after you reverse at most K disjoint subarrays of A.
Definition
	Class: BubbleSortWithReversals Method: getMinSwaps Parameters: vector <int>, int Returns: int Method signature: int getMinSwaps(vector <int> A, int K) (be sure your method is public)
Limits
	Time limit (s): 2.000 Memory limit (MB): 256
Constraints
-	A will contain between 2 and 50 elements.
-	K will be between 1 and 50.
-	Each element of A will be between 1 and 1000, inclusive.
Examples
0)
	{6,8,8,7,7} 1 Returns: 0 By reversing the subarray [1,4] we obtain a new array {6,7,7,8,8}. This array is already sorted and we can easily verify that our BubbleSort never swaps anything.
1)
	{7,2,2,13,5,5,2} 2 Returns: 3
2)
	{12,5,1,10,12,6,6,10,6,8} 2 Returns: 12
3)
	{2,3,1} 2 Returns: 1 Note that the subarrays we are reversing must all be disjoint. For example, it is not allowed to reverse first the subarray [0,1] and then the subarray [0,2].
4)
	{482,619,619,601,660,660,691,691,77,77,96,77} 9 Returns: 22

This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved. 

题目大意：给一个A数组和一个数字K，求最多做K次不相交连续子区间的翻转，使得最终得倒的数组冒泡排序的交换次数最少

题目模型：逆序数+DP

对于一次区间交换，改变的只是该区间的逆序数

用dp[i][j]表示前i个数做了j次交换的最小答案，考虑之前的区间[k+1,j],是否做交换，再从dp[i][k]转移过来即可。

#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#define inf 0x3f3f3f3f
using namespace std;
class BubbleSortWithReversals{
	public:
    int dp[55][55];
    vector<int> B;
    int calc(int x,int y){
        int d=0,c=0;
        for(int i=x;i<=y;i++){
            for(int j=i+1;j<=y;j++){
                if(B[j]>B[i]) d++;
            }
            for(int j=0;j<x;j++){
                if(B[j]>B[i]) c++;
            }
        }
        return d+c;
    }
    int calc2(int x,int y){
        int d=0;
        for(int i=x;i<=y;i++){
            for(int j=0;j<i;j++){
                if(B[j]>B[i]) d++;
            }
        }
        return d;
    }
	int getMinSwaps(vector <int> A, int K){
	    this->B=A;
		int n=A.size();
        memset(dp,0x3f,sizeof dp);
        dp[0][0]=0;
        for(int i=1;i<=n;i++){
            for(int j=0;j<i;j++){
                for(int k=0;k<=K;k++){
                    if(k<K) dp[i][k+1]=min(dp[i][k+1],dp[j][k]+calc(j,i-1));
                    dp[i][k]=min(dp[i][k],dp[j][k]+calc2(j,i-1));
                }
            }
        }
        int ret=inf;
        for(int i=0;i<=K;i++){
            ret=min(ret,dp[n][i]);
        }
        return ret;
	}
};