HDU4385Moving Bricks【状压DP】

Moving Bricks

Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 724    Accepted Submission(s): 280

Problem Description

Brickgao used to be a real tall, wealthy, handsome man and you might know him well. If you don't, please draw attention to the details below.
Brickgao tried his fortune in investment of golden bricks with his two partners LS and Jne. Because he knew little about investment he gave his total trust and bank savings to his two partners who looked smart. 
However, due to the bad luck and lack of business skills, LS and Jne used up Brickgao's fund, and nothing in return. Their investment failed and the three become diaosi. 
Brickgao had no other choice but to earn a living as a construction worker and he found his place on a building site moving bricks which of course was not golden ones. There were many brick fragment scattered on the site and workers had to move them to the building that under construction. Brickgao was made to cope with the task.
The problem is that the Brickgao couldn’t carry more than two bricks at a time since they were too heavy. Also, if he had taken a brick, he couldn’t put it anywhere except the goal building — his inherent sense of order does not let him do so.
You are given N pairs of coordinates of the bricks and the coordinates of the goal building. It is known that the Brickgao covers the distance between any two points in the time equal to the squared length of the segment between the points. It is also known that initially the coordinates of the Brickgao and the goal building are the same. You are asked to find such an order of bricks, that the Brickgao could move all the bricks to the building in a minimum time period. You can assume the no two bricks shared the same coordinates. If more than one optimum moving sequence Brickgao could find, he would choose the smallest lexicographic one because of the inherent sense of order.

 

Input

The first line of the input file contains an integer T which indicates the number of test cases. The first line of each case contains the building's coordinates x ,y. The second line contains number N (1<= N < 20) — the amount of bricks on the building site. The following N lines contain the bricks' coordinates. All the coordinates do not exceed 100 in absolute value. All the given positions are different. All the numbers are integer.

 

Output

For each test case, first you should print "Case x:" in a line, where x stands for the case number started with 1. Then two lines follow: the first line output the only number — the minimum time Brickgao needed to move the bricks to building, and the second line output the optimum order for Brickgao to move the bricks. Each brick in the input is described by its index number (from 1 to N).

 

Sample Input

2 0 0 2 1 1 -1 1 1 1 3 4 3 3 4 0 0

 

Sample Output

Case 1: 8 1 2 Case 2: 32 1 2 3

Hint

In the first test, Brickgao gets brick 1 and brick 2 and returns to the building. In the second test, Brickgao first moves brick 1 and brick 2 to the building and then gets the third and returns to the building.

 

Author

WHU

 

Source

2012 Multi-University Training Contest 9

这个题说实话也卡了很多天了  原因是 字典序最小之前没有处理好

之前做过一个很像的题  是一次训练赛德题  

那题是这样的  告诉你n个点n 《= 15  的坐标  问一笔画下来最少的路程

那个是这样的dp[i][j]代表状态为i  以第j个点位结尾的最短路

由于|的性质  所以直接往后枚举状态进行转移就可以了

这个题很像  

题意是有n个点n<20  每次从初始点出发取回一个或两个点上的石头   取回需要的价值是 距离的平方和

然后问取回所有点的最小价值

这个题dp[i]代表到大i状态的最短路  然后用一个数组表示最短路的最后一个点是啥 

最后 由于每次只取回一或者两个点  只要把它拍一下序就好了

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 20;
int dp[1 << maxn];
int x[maxn], y[maxn];
int dist[maxn][maxn];
int n, t;
int fa[maxn];

struct Node {
    int pr;
    int x1, x2;
}node[1 << maxn];
struct Ans {
    int flag;
    int x1, x2;
}ans[maxn];
bool cmp(Ans a1, Ans a2) {
    return a1.x1 < a2.x1;
}
int xx[1 << maxn];
int an[maxn];

void init() {
    for(int i = 0; i <= n; i++) {
        for(int j = i; j <= n; j++) {
            dist[i][j] = dist[j][i] = (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])*(y[i] - y[j]);
            dist[j][i] = dist[i][j];
        }
    }
}

void DP() {
    memset(dp, 0x3f, sizeof(dp));
    dp[0] = 0; xx[0] = 0;
    fa[0] = 0;
    int Max = 1 << n;
    for(int i = 0; i < Max; i++) {
        if(dp[i] > 1000000000) continue;
        for(int j = 1; j <= n; j++) {
            if((i & ( 1 << ( j - 1 ) ) ) == 0 ) {
                int num = i | ( 1 << ( j - 1 ) );
                if(dp[num] > dp[i] + dist[j][0] * 2) {
                    dp[num] = dp[i] + dist[j][0] * 2;
                    xx[num] = j;
                    node[num] = (Node) { i, 0, 0 };
                }
            }
        }
        for(int j = 1; j <= n; j++) {
            for(int k = j + 1; k <= n; k++) {
                if((i & ( 1 << ( j - 1 ) ) ) == 0 && ( i & ( 1 << ( k - 1) ) ) == 0) {
                    int num = i | ( 1 << ( j - 1 ) );
                    num |= ( 1 << ( k - 1) );
                    if(dp[num] > dp[i] + dist[0][j] + dist[j][k] + dist[k][0]) {
                        dp[num] = dp[i] + dist[0][j] + dist[j][k] + dist[k][0];
                        xx[num] = j;
                        node[num] = (Node) { i, 1, k };
                    }
                }
            }
        }
    }
}

void P() {
    int Max = 1 << n;
    printf("%d
", dp[Max - 1]);
    int id = Max - 1;
    int cnt = 0;
    for(int i = 1; i <= n; i++) {
        if(node[id].x1 == 0) {
            ans[cnt++] = (Ans) { 1, xx[id], 0 };
        } else {
            ans[cnt++] = (Ans) { 2, min(xx[id],node[id].x2), max(xx[id],node[id].x2)};
            i++; 
        }
        id = node[id].pr;
    }
    sort(ans, ans + cnt, cmp);
    int cn = 0;
    for(int i = 0; i < cnt; i++) {
        if(ans[i].flag == 1) {
            an[cn++] = ans[i].x1;
        } else {
            an[cn++] = ans[i].x1;
            an[cn++] = ans[i].x2;
        }
    }
    for(int i = 0; i < cn; i++) {
        printf(i == 0 ? "%d" : " %d", an[i]);
    } puts("");
}

int main() {
    scanf("%d",&t);
    for(int kase = 1; kase <= t; kase++) {
        scanf("%d %d",&x[0], &y[0]);
        scanf("%d",&n);
        for(int i = 1; i <= n; i++) {
            scanf("%d %d",&x[i], &y[i]);
        }
        init();
        DP();
        printf("Case %d:
", kase);
        P();
    }
    return 0;
}