codeforces 8c Looking for Order

https://vjudge.net/problem/CodeForces-8C

题意：

一个平面上放着许多东西，每个东西都有一个坐标，最开始一个人在一个起始坐标，她出发去拿东西，一次要么拿一件东西，要么拿两件东西，拿了之后必须返回起始坐标。

每次花费的时间是两个坐标距离的平方，问拿完所有的东西需要的最少的时间。

思路：

由于数据范围比较小，所以可以考虑用状压dp来写。由于每次拿东西之后都要返回起点，那么其实拿东西的顺序是没有影响的，所以利用题目给定的顺序进行剪枝，即每次进行扩展的时候都考虑在前面的点已经取完了。

然后每次记录的时候，非常巧妙的方法，如果一个点的话，直接记录这个点，如果有两个点的话，那么就用(i+1)*100 + (j+1)来记录，因为点数最多时只有24，输出的时候递归输出就行了，递归输出这里还是比较巧妙的。

代码：（有详细的注释）

#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;

struct node
{
    int x,y;
} a[30];

int mp[30][30];
vector<int> ans;

int cal(int i,int j)
{
    return (a[i].x - a[j].x) * (a[i].x - a[j].x) + (a[i].y - a[j].y) * (a[i].y - a[j].y);
}

const int maxn = (1 << 24)+2;
const int gg = 0x3f3f3f3f;

int dp[maxn],last[maxn],rec[maxn];

void output(int s)
{
    if (~last[s])
        output(last[s]);//递归输出

    if (rec[s])
    {
        if (rec[s] > 100) ans.push_back(rec[s] / 100);//第一个扩展的点

        ans.push_back(rec[s] % 100);
        ans.push_back(0);//每次都要返回起点
    }
}

int main()
{
    int n;

    node tmp;

    scanf("%d%d",&tmp.x,&tmp.y);

    scanf("%d",&n);

    for (int i = 0;i < n;i++)
    {
        scanf("%d%d",&a[i].x,&a[i].y);
    }

    a[n] = tmp;

    for (int i = 0;i <= n;i++)
        for (int j = i + 1;j <= n;j++)
        mp[i][j] = mp[j][i] = cal(i,j);

    memset(dp,gg,sizeof(dp));
    memset(last,-1,sizeof(last));

    dp[0] = 0;

    for (int s = 0;s < (1<<n);s++)
    {
        if (dp[s] >= gg) continue;

        for (int i = 0;i < n;i++)
        {
            if (((1 << i) & s) == 0)//这个点没有被走过
            {
                int val = dp[s] + mp[n][i] * 2;

                if (dp[s|(1 << i)] > val)
                {
                    dp[s|(1 << i)] = val;
                    last[s|(1 << i)] = s;//记录前驱，下同
                    rec[s|(1 << i)] = i+1;
                }

                for (int j = i + 1;j < n;j++)//从i+1开始枚举保证了不会有重复情况
                {
                    if (((1<<j)&s) == 0)
                    {
                        int tmp = dp[s] + mp[n][i] + mp[i][j] + mp[j][n];

                        if (dp[s|(1<<i)|(1<<j)] > tmp)
                        {
                            dp[s|(1<<i)|(1<<j)] = tmp;
                            last[s|(1<<i)|(1<<j)] = s;
                            rec[s|(1<<i)|(1<<j)] = (i+1) * 100 + (j+1);//巧妙的记录
                        }
                    }
                }

                break;//强行顺序剪枝
            }
        }

        //printf("%d\n",dp[s]);
    }


    ans.clear();

    output((1<<n)-1);

    printf("%d\n",dp[(1<<n)-1]);

    printf("0 ");

    for (int i = 0;i < ans.size();i++)
        printf("%d%s",ans[i],i == ans.size() - 1 ? "\n" :" ");

    return 0;
}