集合上的动态规划--最优配对问题

 转自此博客

题目：刘汝佳《算法竞赛入门经典》，集合上的动态规划---最优配对问题 题意：空间里有n个点P0,P1,...,Pn-1，你的任务是把它们配成n/2对（n是偶数），使得每个点恰好在一个点对中。所有点对中两点的距离之和应尽量小。状态：d(i,S)表示把前i个点中，位于集合S中的元素两两配对的最小距离和 状态转移方程为：d(i,S)=min{|PiPj|+d(i-1,S-{i}-{j}} 

#include <iostream>
#include <cstring>
#include <cstdio>
#include <math.h>
#include <algorithm>
using namespace std;
const int N = 20;
const int INF = 0x3f3f3f3f;
double d[N + 5][(1 << N) + 10];
struct Node
{
    int x, y, z;
}node[N + 10];
double dist(int n1, int n2)
{
    return sqrt( double( (node[n1].x - node[n2].x) * (node[n1].x - node[n2].x) + (node[n1].y - node[n2].y) * (node[n1].y - node[n2].y) + (node[n1].z - node[n2].z) * (node[n1].z - node[n2].z)));
}
int main()
{
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++)
    {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].z);
    }
    for(int i = 0; i < n; i++)
    {
        for(int S = 0; S < (1 << (i + 1) ); S++)
        {
            if(S == 0)
                d[i][S] = 0;
            else
                d[i][S] = INF;
            if(S & (1 << i))
            {
                for(int j = 0; j < i; j++)
                {
                    if(S & (1 << j) )
                        d[i][S] = min(d[i][S], dist(i, j) + d[i - 1][S ^ (1 << i) ^ (1 << j)]);
                }
            }
            else if(i != 0)
            {
                d[i][S] = d[i - 1][S];
            }
        }
    }
    printf("%.3lf
", d[n - 1][(1 << n) - 1]);
    return 0;
}

状态可以进行压缩，i的值其实隐藏在S中，S中最高位为1的即为i，所以需要一次查找,从n-1到0进行一次历编即可，整个运算下来，平均查找次数仅为2。而且方法二比方法一情况简单很多，也比较容易理解。 

#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
const int N = 20;
const int INF = 0x3f3f3f3f;
double d[(1 << N) + 10];
struct Node
{
    int x, y, z;
}node[N + 10];
int n, S;
double dist(int n1, int n2)
{
    return sqrt( double( (node[n1].x - node[n2].x) * (node[n1].x - node[n2].x) + (node[n1].y - node[n2].y) * (node[n1].y - node[n2].y) + (node[n1].z - node[n2].z) * (node[n1].z - node[n2].z)));
}
void input()
{
    for(int i = 0; i < n; i++)
    {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].z);
    }
    S = 1 << n;
    d[0] = 0;
}
void solve()  
{
    for(int s = 1; s < S; s++)
    {
        int i, j;
        d[s] = INF;
        for(i = n - 1; i >= 0; i--)  //d[s]就是前i个位于集合s中距离最小，只要找到i,再从i往前找j不就行了。
            if(s & (1 << i))
                break;
        for(j = i - 1; j >= 0; j--)
            if(s & (1 << j))
                d[s] = min(d[s], dist(i, j) + d[s ^ (1 << i) ^ (1 << j)]);
    }
}
int main()
{
    scanf("%d", &n);
    input();
    solve();
    printf("%0.3lf
", d[S - 1]);
    return 0;
}

这道题用递归实现更好一些，因为只需要判断n为偶数的情况，这就是递归运算的好处，而非递归则需要全部都进行一次运算。 

#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
const int N = 20;
const int INF = 0x3f3f3f3f;
double d[(1 << N) + 10];
struct Node
{
    int x, y, z;
}node[N + 10];
int n, S;
double dist(int n1, int n2)
{
    return sqrt( double( (node[n1].x - node[n2].x) * (node[n1].x - node[n2].x) + (node[n1].y - node[n2].y) * (node[n1].y - node[n2].y) + (node[n1].z - node[n2].z) * (node[n1].z - node[n2].z)));
}
void input()
{
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    {
        scanf("%d%d%d", &node[i].x, &node[i].y, &node[i].z);
    }
    S = 1 << n;
    //memset(d, INF, sizeof(d)); 慎用emset()
    for(int i = 0; i < S; i++)
        d[i] = INF;
    d[0] = 0;

}
double dp(int s)
{
    if(d[s] != INF)
        return d[s];
    int i, j;
    for(i = n - 1; i >= 0; i--)
        if(s & (1 << i))
            break;
    for(j = i - 1; j >= 0; j--)
        if(s & (1 << j))
            d[s] = min(d[s], dp(s ^ (1 << i) ^ (1 << j)) + dist(i, j));
    return d[s];
}
int main()
{
    input();
    printf("%0.3lf
", dp(S - 1));
    return 0;
}