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[];

 int mp[][];
 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 = ( << )+;
 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] > ) ans.push_back(rec[s] / );//第一个扩展的点

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

 int main()
 {
     int n;

     node tmp;

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

     scanf("%d",&n);

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

     a[n] = tmp;

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

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

     dp[] = ;

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

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

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

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

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

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

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

     ans.clear();

     output((<<n)-);

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

     printf("0 ");

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

     return ;
 }