codeforces626F Group Projects(dp)

Description
There are n students in a class working on group projects. The students will divide into groups (some students may be in groups alone), work on their independent pieces, and then discuss the results together. It takes the i-th student ai minutes to finish his/her independent piece.


If students work at different paces, it can be frustrating for the faster students and stressful for the slower ones. In particular, the imbalance of a group is defined as the maximum ai in the group minus the minimum ai in the group. Note that a group containing a single student has an imbalance of 0. How many ways are there for the students to divide into groups so that the total imbalance of all groups is at most k?


Two divisions are considered distinct if there exists a pair of students who work in the same group in one division but different groups in the other.


Input
The first line contains two space-separated integers n and k (1 ≤ n ≤ 200, 0 ≤ k ≤ 1000) — the number of students and the maximum total imbalance allowed, respectively.


The second line contains n space-separated integers ai (1 ≤ ai ≤ 500) — the time it takes the i-th student to complete his/her independent piece of work.


Output
Print a single integer, the number of ways the students can form groups. As the answer may be large, print its value modulo 109 + 7.


Sample Input
Input
3 2
2 4 5
Output
3
Input

4 3

7 8 9 10
Output
13
Input
4 0
5 10 20 21
Output
1
Hint
In the first sample, we have three options:


The first and second students form a group, and the third student forms a group. Total imbalance is 2 + 0 = 2.
The first student forms a group, and the second and third students form a group. Total imbalance is 0 + 1 = 1.
All three students form their own groups. Total imbalance is 0.

In the third sample, the total imbalance must be 0, so each student must work individually.

题意：有n个人，每人有一定的能力值，让你分为若干组（组数不定），每一组的价值为这一组能力最高的减去能力最低的值，问所有组的价值加起来的和不超过m的方案数。

思路：这题看了题解，题解已经写的非常详细了（虽然看了好久...汗）。

This is a dynamic programming problem. Notice that the total imbalance of the groups only depends on which students are the maximum in each group and which are the minimum in each group. We thus can think of groups as intervals bounded by the minimum and maximum student. Moreover, the total imbalance is the sum over all unit ranges of the number of intervals covering that range. We can use this formula to do our DP.

If we sort the students in increasing size, DP state is as follows: the number of students processed so far, the number of g groups which are currently “open” (have a minimum but no maximum), and the total imbalance k so far. For each student, we first add the appropriate value to the total imbalance (g times the distance to the previous student), and then either put the student in his own group (doesn’t change g), start a new group (increment g), add the student to one of the g groups (doesn’t change g), or close one of the g groups (decrement g).

Runtime: O(n2k)

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
typedef long long ll;
#define inf 99999999
#define pi acos(-1.0)
#define MOD 1000000007
ll dp[2][205][1005];
int a[205];
int main()
{
    int n,m,i,j,k;
    ll t,temp;
    while(scanf("%d%d",&n,&m)!=EOF){
        for(i=1;i<=n;i++){
            scanf("%d",&a[i]);
        }
        sort(a+1,a+1+n);
        a[0]=0;
        int tot=0;
        dp[0][0][0]=1;
        for(i=1;i<=n;i++){
            memset(dp[1^tot],0,sizeof(dp[1^tot] ));
            for(j=0;j<i;j++){
                for(k=0;k<=m;k++){
                    if(dp[tot][j][k]){
                        t=dp[tot][j][k];
                        if(j*(a[i]-a[i-1])+k>m )continue;
                        temp=j*(a[i]-a[i-1])+k;
                        dp[1^tot][j][temp]=(dp[1^tot][j][temp]+t)%MOD;  //one
                        dp[1^tot][j+1][temp]=(dp[1^tot][j+1][temp]+t )%MOD;
                        dp[1^tot][j][temp]=(dp[1^tot][j][temp]+j*t%MOD )%MOD;
                        if(j)dp[1^tot][j-1][temp]=(dp[1^tot][j-1][temp]+j*t%MOD )%MOD;
                    }
                }
            }
            tot=1^tot;
        }
        ll sum=0;
        for(k=0;k<=m;k++){
            sum+=dp[tot][0][k];
            if(sum>=MOD)sum-=MOD;
        }
        printf("%I64d\n",sum);
    }
    return 0;
}

转载于:https://www.cnblogs.com/herumw/p/9464555.html