Educational Codeforces Round 109 (Rated for Div. 2)D. Armchairs （DP）

There are 𝑛 armchairs, numbered from 1 to 𝑛 from left to right. Some
armchairs are occupied by people (at most one person per armchair),
others are not. The number of occupied armchairs is not greater than
𝑛2.

For some reason, you would like to tell people to move from their
armchairs to some other ones. If the 𝑖-th armchair is occupied by
someone and the 𝑗-th armchair is not, you can tell the person sitting
in the 𝑖-th armchair to move to the 𝑗-th armchair. The time it takes
a person to move from the 𝑖-th armchair to the 𝑗-th one is |𝑖−𝑗|
minutes. You may perform this operation any number of times, but these
operations must be done sequentially, i. e. you cannot tell a person
to move until the person you asked to move in the last operation has
finished moving to their destination armchair.

You want to achieve the following situation: every seat that was
initially occupied must be free. What is the minimum time you need to
do it?

Input The first line contains one integer 𝑛 (2≤𝑛≤5000) — the number
of armchairs.

The second line contains 𝑛 integers 𝑎1,𝑎2,…,𝑎𝑛 (0≤𝑎𝑖≤1). 𝑎𝑖=1
means that the 𝑖-th armchair is initially occupied, 𝑎𝑖=0 means that
it is initially free. The number of occupied armchairs is at most 𝑛2.

Output Print one integer — the minimum number of minutes you have to
spend to achieve the following situation: every seat that was
initially occupied must be free.

Examples inputCopy 7 1 0 0 1 0 0 1 outputCopy 3 inputCopy 6 1 1 1 0 0
0 outputCopy 9 inputCopy 5 0 0 0 0 0 outputCopy 0 Note In the first
test, you can perform the following sequence:

ask a person to move from armchair 1 to armchair 2, it takes 1 minute;
ask a person to move from armchair 7 to armchair 6, it takes 1 minute;
ask a person to move from armchair 4 to armchair 5, it takes 1 minute.
In the second test, you can perform the following sequence:

ask a person to move from armchair 1 to armchair 4, it takes 3
minutes; ask a person to move from armchair 2 to armchair 6, it takes
4 minutes; ask a person to move from armchair 4 to armchair 5, it
takes 1 minute; ask a person to move from armchair 3 to armchair 4, it
takes 1 minute. In the third test, no seat is occupied so your goal is
achieved instantly.

思路

数据范围 n<=5000 应该立马想到是一道dp题
我们就相当于求每一个人坐在那个椅子上是最优的。
这种问题我们一般都定义dp[i][j]为前i个人，坐在前j个椅子上的最小能量，每次就是看多一个人以后，应该怎么来选椅子。
每次选椅子肯定是两种选择，要么就是i不选椅子j，要么就是选椅子j，不选椅子j的话就是
dp[i][j]=dp[i][j-1].
如果选椅子j的话就是.
dp[i][j]=dp[i-1][j-1]＋人i和椅子j的距离（可以维护出来）。
这样就可以把题写出来了。

设原先情况下坐着人的座位有a个，不坐人的座位有b个，将前二者的位置信息分别存放至两个大小为a和b的数组中。

令DP第一维为空座位的位置，第二维为已分配座位的数目，可得以下状态转移方程：

1. dp[i][0]=0 (分配0个座位的花费当然是0)

2. dp[i][j]=min(dq[i-1][j],dq[i-1][j-1]+abs(p[i]-s[j])) (分配至第i位置时，可以分配位置并加上当前的位置花费，也可以不分配)

3. 其他的都设置成inf

#include<iostream>
#define ll long long
using namespace std;
ll s[5001],p[5001],dp[5001][5001];
int main(){
	ll n,i,j,k,zc,sl1=0,sl2=0;
	cin>>n;
	for(i=1;i<=n;i++){
		cin>>zc;
		if(zc==1) s[++sl1]=i;
		else p[++sl2]=i;
	}
	for(i=0;i<=sl2;i++){
		for(j=1;j<=sl1;j++){
			dp[i][j]=1e12;
		}
	}
	for(i=1;i<=sl2;i++) dp[i][0]=0;
	for(i=1;i<=sl2;i++){
		for(j=1;j<=sl1;j++){
			dp[i][j]=min(dp[i][j],dp[i-1][j-1]+abs(p[i]-s[j]));
			dp[i][j]=min(dp[i][j],dp[i-1][j]);
		}
	}
	cout<<dp[sl2][sl1];
    return 0;
}

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<map>
#include<cmath>
#include<cstdlib>
#include<string>
#include<vector>
using namespace std;
#define scd(n) scanf("%d",&n)
#define scdd(a,b) scanf("%d%d",&a,&b)
#define lowbit(x) x&(-x)
typedef long long LL;
typedef pair<int,int>PII;
const int N = 5000+10;
const int INF = 0x3f3f3f3f;
int one[N],zero[N];
int dp[N][N];

void solve()
{
    int n;
    int cnt1=0,cnt2=0;
    scd(n);
    for(int i=1;i<=n;i++){
        int x;
        scd(x);
        if(x==1) one[++cnt1]=i;
        else zero[++cnt2]=i;
    }
   memset(dp,0x3f,sizeof dp);
   for(int i=0;i<=cnt2;i++) dp[0][i]=0;
    for(int i=1;i<=cnt1;i++){
        for(int j=1;j<=cnt2;j++){
            dp[i][j]=min(dp[i][j-1],dp[i-1][j-1]+abs(one[i]-zero[j]));
        }
    }
    cout << dp[cnt1][cnt2] << endl;
}

int main()
{
    solve();
    return 0;
}