Algorithm 匹配大小的动态规划（最小差异）

我发现，在一场比赛中，使用动态规划来最小化n个男孩和m个女孩身高之间的绝对差异

---

如果我理解正确的话，我们将按照身高（上升？还是下降？）对第一个j男孩和k女孩进行排序。其中j你可以将该问题转化为一个二分图，其中女孩和男孩之间的边是他们身高之间的绝对差，如abs（hG-hB）。然后可以使用二分匹配算法来求解最小匹配。更多信息请参见此

如您提供的答案中所述，当所有男孩和女孩的身高按升序排序时，如果两个匹配之间存在交叉边，则始终有更好的匹配可用

因此，一个复杂度为

O（n*m）

的动态规划解决方案是可能的

因此，我们有一个由两个索引表示的状态，让我们称它们为

i

和

j

，其中

i

表示男孩，

j

表示女孩，然后在每个状态

（i，j）

我们可以移动到状态

（i，j+1）

，也就是说，当前

ith

男孩不选择当前

jth

女孩，或者可以移动到状态

（i+1，j+1）

，即当前

jth

女孩由当前

ith

男孩选择，我们在每个级别上选择这两个选择中的最小值

这可以使用DP解决方案轻松实现

再次发生：

DP[i][j] = minimum(
                    DP[i+1][j+1] + abs(heightOfBoy[i] - heightofGirl[j]),
                    DP[i][j+1] 
               );

下面是递归DP解决方案C++中的代码：

#include<bits/stdc++.h>
#define INF 1e9

using namespace std;

int n, m, htB[100] = {10,10,12,13,16}, htG[100] = {6,7,9,10,11,12,17}, dp[100][100];

int solve(int idx1, int idx2){
    if(idx1 == n) return 0;
    if(idx2 == m) return INF;

    if(dp[idx1][idx2] != -1) return dp[idx1][idx2];

    int v1, v2;

    //include current
    v1 = solve(idx1 + 1, idx2 + 1) + abs(htB[idx1] - htG[idx2]);

    //do not include current
    v2 = solve(idx1, idx2 + 1);

    return dp[idx1][idx2] = min(v1, v2);
}


int main(){

    n = 5, m = 7;
    sort(htB, htB+n);sort(htG, htG+m);
    for(int i = 0;i < 100;i++) for(int j = 0;j < 100;j++) dp[i][j] = -1;
    cout << solve(0, 0) << endl;
    return 0;
}

 4        4        4        1000000000      1000000000      1000000000       1000000000       
-1        3        3        3               1000000000      1000000000       1000000000       
-1       -1        3        3               3               1000000000       1000000000       
-1       -1       -1        2               2               2                1000000000       
-1       -1       -1       -1               1               1                1 

---

答案存储在

DP[0][0]

状态。

在我看来，该算法解决了未加权变量，而这里我们需要给出边的权重，并最小化总和。这也可以做到，但TTBOMK不在O（n^2）中。你是对的。我在上面发布的实现链接没有考虑权重。这可以用匈牙利算法解决，但不能用O（n^2）来解决。OP提供的链接中提到的reccurrence与我写的reccurrence相同，只是计算的拓扑顺序不同。谢谢！你知道在绘制的矩阵中基本情况是什么样的吗？条目的位置取决于什么？这将有助于可视化。我想递归也可以被替代使用。为什么动态规划在这里是一个很好的解决方案？递归解的复杂性是指数级的，这将是非常低效的。

#include<bits/stdc++.h>
#define INF 1e9

using namespace std;

int n, m, htB[100] = {10,10,12,13,16}, htG[100] = {6,7,9,10,11,12,17}, dp[100][100];

int solve(int idx1, int idx2){
    if(idx1 == n) return 0;
    if(idx2 == m) return INF;

    if(dp[idx1][idx2] != -1) return dp[idx1][idx2];

    int v1, v2;

    //include current
    v1 = solve(idx1 + 1, idx2 + 1) + abs(htB[idx1] - htG[idx2]);

    //do not include current
    v2 = solve(idx1, idx2 + 1);

    return dp[idx1][idx2] = min(v1, v2);
}


int main(){

    n = 5, m = 7;
    sort(htB, htB+n);sort(htG, htG+m);
    for(int i = 0;i < 100;i++) for(int j = 0;j < 100;j++) dp[i][j] = -1;
    cout << solve(0, 0) << endl;
    return 0;
}

 4        4        4        1000000000      1000000000      1000000000       1000000000       
-1        3        3        3               1000000000      1000000000       1000000000       
-1       -1        3        3               3               1000000000       1000000000       
-1       -1       -1        2               2               2                1000000000       
-1       -1       -1       -1               1               1                1