饼干【贪心确定序列】【类似整数划分DP】【记录中间状态，递归输出路径】

饼干

n个孩子，m个饼干。每个孩子都有一个嫉妒值，嫉妒值=（有多少个孩子的饼干比他多）* g。

求一种分配方式，使得总体嫉妒值最小

思路

先处理嫉妒值：贪心，处理每个孩子的顺序，使得分配的饼干数量单调下降。

贪心流程：g值越大，多分配饼干，然后把孩子编号排序。

排好序之后的题目：

n个孩子，m个饼干的嫉妒最小值，并且这斜孩子的饼干数单调下降。类似整数划分的思想

• f[i] [j] : 前i个孩子，分配了j块饼干的情况
• 状态转移：第i个孩子以及之前的孩子，那段区间都是1块饼干的个数

考虑输出路径：

• 输出路径：用数组记录上一个转移状态
• 然后递归处理
• 判断出这么转移之后，更新path数组

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
typedef long long ll;
typedef pair<int,int>pll;
const int N=5e3+100;
pll g[N];
int n,m;
int f[100][N];
int sum[N];
int path[N],last_n[N][N],last_m[N][N];

void get_path(int n,int m)
{
    if(!n) return ;
    get_path(last_n[n][m],last_m[n][m]);
    if(last_n[n][m]==n)
    {
        for(int i=1;i<=n;i++)
            path[g[i].second]++;
    }
    else{
        for(int i=last_n[n][m]+1;i<=n;i++)
            path[g[i].second]=1;
    }
}

int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int t;
        cin>>t;
        g[i]=make_pair(t,i);
    }
    sort(g+1,g+n+1);
    reverse(g+1,g+n+1);
    memset(f,0x3f,sizeof f);
    f[0][0]=0;
    for(int i=1;i<=n;i++)
        sum[i]=sum[i-1]+g[i].first;

    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(j>=i) {
                f[i][j]=min(f[i][j] , f[i][j-i]);
                last_n[i][j]=i,last_m[i][j] = j-i;
            }
            for(int s=1;s<=i;s++)
                if(j-s>=0)
                    //f[i][j]=min(f[i][j],f[i-s][j-s] + (sum[i] - sum[i-s]) * (i-s) );
                    if(f[i][j]>f[i-s][j-s] + (sum[i] - sum[i-s]) * (i-s))
                    {
                        f[i][j]=f[i-s][j-s] + (sum[i] - sum[i-s]) * (i-s);
                        last_n[i][j]=i-s;
                        last_m[i][j]=j-s;
                    }
        }
    }
    cout<<f[n][m]<<endl;
    int j=m;
    get_path(n,m);
    for(int i=1;i<=n;i++)
        cout<<path[i]<<' ';
    cout<<endl;
    return 0;
}