hdu 5691 Sitting in Line(百度之星A轮) 状压_旅行商问题变型

/*
2016.5.22 22:43
hdu5691
题意：给定n个数，及其对应的位置，位置为-1，表示位置任意，否则其位置是固定的。
1 <= n <= 16
求max(a1 * a2 + a2 * a3 + a3 * a4 + ... + an-1 * an)
分析：
使用状态dp，旅行商问题的变型。
首先对数字按输入的顺序编号，第一个输入的编号0，第二个输入的编号1,...
对于状态i，用二进制形式表示（从低位到高位依次编号，与上述编号的数字一一对应）。
如果该位是1，则表示该编号的数字被选择。假设该状态中1的个数有x个，这x个数与排列队伍中的前x个一一对应。
1. 如果第(x - 1)个位置，也就是最后一个位置，已经被占据，那么当前只能以占据该位置的数字编号结尾。
不以该编号结尾的状态都是非法的，即j不等于该编号，dp[i][j]非法，可能当前状态i的编号位不为1，即i & (1 << 编号) == 0
此时所有状态都非法。
dp[i][j] 表示将编号j放到x - 1位。
2. 如果第(x - 1)个位置可以填任意编号，那么该位也只能填那些没有固定位置的编号，有固定位置的编号是非法的，
dp[i][j]，如果编号j被占用（在其他位置，不能用于第(x - 1)位），非法。
对于合法的状态i，以j作为第(x - 1)个位置的编号，那么另一种状态i - (1 << j)，同样以一种合法的编号k结尾，
则dp[i][j] = max(dp[i - (1 << j)][k] + a[k] * a[j]，所有合法的结尾编号k);
3. 特别注意只有一个1的情况，此时状态合法则置0，作为初始化。
说一下为什么要多一维，表示该状态以哪编号结尾：
(1) 事实上，我们完全可以
dp[i] = max(dp[i], dp[i - (1 << j)] + a[k] * a[j]，其中k(select[i - (1 << j)])
为dp[i - (1 << j)]取得最大值时对应的结尾编号,枚举所有合法j)
此时状态i有对应的最优选择select[i]
这时候k直接确定，是唯一的，不需要另外枚举。这种做法忽视了动态规划的特点：无后效性，后一项a[j]显然依赖于a[k]。
虽然我们保证了dp[i - (1 << j)]是以所有合法编号结尾中值最大的，但是却不能保证这个k是合适的，例如
这时候a[k]是所有合法结尾中数值最小的，但a[j]却非常大，显然如果a[k]能够大一点，则a[k] * a[j]占主要比重，
将使得dp[i]的值越大。当然，这种缺陷可能可以通过枚举j来弥补。
(2) 为了方便找到a[k]，同时也枚举了(i - (1 << j))的所有可能的结尾，来计算a[k] * a[j]，这种计算是相当全面的。
(3) 相当于一条相连接的路径，一步一步走。
举例：
1
4
10 1
5 -1
20 -1
15 2
编号10 --> 0 5 --> 1 20 --> 2 15 --> 3
vis[0] = 1, vis[3] = 1，即编号0和编号3都已经固定，不能随意使用到其他位置。
显然pos[1] = 0, pos[2] = 3，即位置1被编号0占据，位置2被编号3占据

对所有二进制状态求值：
1. 把编号0放到位置0
dp[1][0] = 非法，因为编号0已经有主...

2. 把编号1放到位置0，合法，因为编号1无主，且位置０没被占据。
dp[10][1] = 0

3. 把编号0和1放到位置0和1
3.1 把编号0放到位置1
dp[11][0] = dp[10][1] + a[1] * a[0] = 50
3.2 把编号1放到位置1
dp[11][1] = dp[01][0] + a[0] * a[1]，非法，因为编号0不能放到位置0
4. 把编号2放到位置0，合法
dp[100][2] = 0
5. 把编号0和2放到位置0和1
5.1 把编号0放到位置1，合法，因为编号0固定在位置1
dp[101][0] = dp[100][2] + a[2] * a[0] = 200
5.2 把编号2放到位置1，不合法，因为位置1已经有了编号0
dp[101][2] = dp[001][0] + a[0] * a[2] 非法
6. 把编号1和2放到位置0和1
6.1 把编号1放到位置1，非法，因为位置1已经有编号0
dp[110][1] = dp[100][2] + a[2] * a[1]非法
6.2 把编号2放到位置1，非法，因为位置1已经有编号0
dp[110][2] = dp[010][1] + a[1] * a[2]非法
7. 把编号0,1,2放到位置0, 1, 2
7.1 把编号0放到位置2，非法，编号0已经有主
dp[111][0] = dp[110][1] + a[1] * a[0]
dp[110][2] + a[2] * a[0]
7.2 把编号1放到位置2，非法，因为位置2已经有编号3
dp[111][1]
7.3 把编号2放到位置2，非法，因为位置2已经有编号3
dp[111][2]
8. 把编号3放到位置0
dp[1000][3]非法，因为编号3已经有主
9. 把编号0和3放到位置位置0和1
9.1 把编号0放到位置1，合法，编号0固定在位置1
dp[1001][1] = dp[1000][3] + a[3] * a[1]非法
9.2 把编号3放到位置1，非法，编号3已经固定在位置2
dp[1001][3] = dp[0001][0] + a[0] * a[3]非法
10. 把编号1和3放到位置0和1
10.1 把编号1放到位置1，非法，位置1已经有编号0
dp[1010][1] = dp[1000][3] + a[3] * a[1]非法
10.2 把编号3放到位置1，非法，位置1已经有编号0
dp[1010][3] = dp[0010][1] + a[1] * a[3]非法
11. 把编号0,1,3放到位置0,1,2
10.1 把编号0放到位置2，位置2已经有编号3了
dp[1011][0] = dp[1010][1]
dp[1010][3]都非法
10.2 把编号1放到位置2，位置2已经有编号3了
dp[1011][1] = dp[1001][0]
dp[1001][3]都非法
10.3 把编号3放到位置2，合法
dp[1011][3] = dp[0011][0] +  a[0] * a[3] = 50 + 10 * 15 = 200　(位置0,1,2依次为5, 10, 15)
dp[0011][1] 非法
12. 把编号2和3放到位置0和1
12.1 把编号2放到位置1，非法，位置1已经有编号0
dp[1100][2] = dp[1000][3] + a[3] * a[2]
12.2 把编号3放到位置1，非法，位置1已经有编号0
dp[1100][3] = dp[0100][2] + a[2] * a[3]
13. 把编号0,2,3放到位置0,1,2
13.1 把编号0放到位置2，非法，编号0已经固定在位置1，且位置2只能放置编号3
dp[1101][0]
13.2 把编号2放到位置2，非法，位置2只能放置编号3
dp[1101][2]
13.3 把编号3放到位置2，合法
dp[1101][3] = dp[0101][0] + a[0] * a[3] = 200 + 10 * 15 = 350(位置0,1,2依次为20, 10, 15)
dp[0101][2]非法
14. 把编号1,2,3放到位置0,1,2
14.1 把编号1放到位置2，非法，位置2只能放置编号3
dp[1110][1]
14.2 把编号2放到位置2，非法，位置2只能放置编号3
dp[1110][2]
14.3 把编号3放到位置2，合法
dp[1110][3] = dp[0110][1]
dp[0110][2]都非法
15. 把编号0,1,2,3放到位置0,1,2,3
15.1 把编号0放到位置3，非法，编号0固定在位置1
dp[1111][0]
15.2 把编号1放到位置3，合法
dp[1111][1] = dp[1101][0]非法
dp[1101][2]非法
dp[1101][3] + a[3] * a[1] = 350 + 15 * 5 = 425(位置0,1,2依次为20, 10, 15, 5)
15.3 把编号2放到位置3，合法
dp[1111][2] = dp[1011][0]非法
dp[1011][1]非法
dp[1011][3] + a[3] * a[2] = 200 + 15 * 20 = 500 (位置0,1,2依次为5, 10, 15, 20)
15.4 把编号3放到位置3，非法，编号3固定在位置2
dp[1111][3]
最后的结果为max(dp[1111][0~3]) = 500
*/

#include <cstdio>
#include <climits>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAXN = 16 + 1;
int dp[1 << MAXN][MAXN], pos[MAXN], a[MAXN], b[MAXN], vis[MAXN];
//计算data中二进制1的个数
int getBits(int data){
int res = 0;
while(data){
res += (data & 1);
data >>= 1;
}
return res;
}
int main(){
int t, n, i, up, j, k, cnt, ans, cas = 1;
scanf("%d", &t);
while(t--){
scanf("%d", &n);
fill(pos, pos + n, INT_MIN);
memset(vis, 0, sizeof(vis));
for(i = 0; i < n; i++){
scanf("%d%d", &a[i], &b[i]);
if(b[i] >= 0){
pos[b[i]] = i;//位置b[i]已经被编号i占据
vis[i] = 1;//编号i不能随意使用
}
}
up = 1 << n;
for(i = 1; i < up; i++){
cnt = getBits(i);//获取二进制状态i中1的个数
for(j = 0; j < n; j++){
if(!(i & (1 << j))){
continue;
}
dp[i][j] = INT_MIN;//不满足条件者，或者没被下面更新者，都是不合法状态
if(cnt == 1){
//位置0没被占据，且编号j没被使用，或者位置0固定放置编号j，则编号j可以放到位置0
if(pos[0] == INT_MIN && !vis[j] || pos[0] == j){
dp[i][j] = 0;
}
//printf("i = %d, j = %d, dp = %d \n", i, j, dp[i][j]);
break;
}
//位置cnt - 1没被占据，且编号j没被使用，或者位置cnt - 1固定放置编号j，则编号j可以放到位置cnt - 1
if(pos[cnt - 1] == INT_MIN && !vis[j] || j == pos[cnt - 1]){
for(k = 0; k < n; k++){
//枚举i - (1 << j)中的二进制1(编号)，作为结尾，不能与j相同
//且该状态必须合法
if(k == j || !((1 << k) & i) || dp[i - (1 << j)][k] == INT_MIN){
continue;
}
dp[i][j] = max(dp[i][j], dp[i - (1 << j)][k] + a[k] * a[j]);
}
}
//printf("i=%d, j = %d, dp = %d \n", i, j, dp[i][j]);
}
//puts("");
}
//求取最终所有位置排满时的最值。
ans = INT_MIN;
for(i = 0; i < n; i++){
ans = max(ans, dp[up - 1][i]);
}
printf("Case #%d:\n%d\n", cas++, ans);
}
return 0;
}