【hdu4281状态压缩+01背包+多旅行商问题】

题意：有n道题，每道题在二维平面内的不同位置且给出每道题的坐标，同时给出处理每道题所需的时间p，现在已知裁判的耐心有限，之会花费m个单位时间去做事，做完后回到起始点。
现在的要求是，我要多少个裁判才能对每个问题都处理完，并且同一道题不能有两个裁判进行处理，并求出总路径最小的值。
总复杂度O(2^(2*n)+(2^n*n^2))

#include <bits/stdc++.h>
#include<cstdio>
#include<iostream>
#include <iostream>
#include <cstring>
#define X 10005
#define inf 0x3f3f3f3f
#define PI 3.141592653589793238462643383
#define IO  ios::sync_with_stdio(false),cin.tie(0), cout.tie(0);
#pragma comment(linker, "/STACK:1024000000,1024000000")
#define MIN (1<<17)
using namespace std;
const int maxn = (int)1e5 + 10;
typedef long long ll;
int greedy();
int TSP_SECOND();
int n,m;
int tot;//总的合法物品数
int ans1;//第一问答案
int ans2;//第二问答案
int x[20],y[20];//坐标
int val[20];//权花费的时间
int dp[MIN],state[MIN];//求最少多少个教练
int mp[20][20],isok[MIN];//边权、合法物品集合
int cost[17][MIN],np[MIN];//多旅行商问题用到
void init()
{
    tot=0;
    //memset(map,0,sizeof(map));
    for(int i=0;i<(1<<n);++i)   np[i]=inf;
    ///
    for(int i=0;i<=n;++i)
        for(int j=0;j<(1<<n);++j)
        cost[i][j]=inf;
    cost[0][1]=0;

}
int Enumeration_subset(int x)
{
    int sum=0;
    for(int i=0;i<n;++i)//所在的集合i
        if(x&(1<<i))
            sum+=val[i];
    return sum<=m;
}
//将2^n种地点的选择集合压缩成2^n个物品(2^n个状态,因为每个任务在一个教练的下有被选择和不被选择两种状态)，物品的权值为集合内的点权之和，
//如果总和<=m，那么他是一种合法的组合(说明是一个裁判可以在m的范围内可以把这些任务完成)，存起来。
//这样就得到tot种合法组合，对这tot种组合进行01背包(注意是对合法的组合进行01背包)，dp[i]表示容量为i时的最小费用(转化为对应得前i个二进制位位1得状态所需要的教练数），和常规的背包不同(但本质是一样的。)
//状态转移方程:dp[i] = min(dp[i],dp[j]+1)
//(j为i的子集(注意j是i的子集),i = j | state[k]并且j和state[k]没有交集，state[k]表示第k个合法物品)
int DP_FIRST()
{
    //int mmin=inf;
    for(int i=0;i<(1<<n);++i) dp[i]=inf;
    dp[0]=0;
    for(int i=0;i<tot;++i)
    {
        for(int j=(1<<n)-1;j>=0;--j)
        {
            if(dp[j]==inf)continue;
            if((j+state[i])!=(j|state[i]))continue;//两种状态不能有交集 也可写成if((j&state[i])!=0) 在poj2923中可以看到
            dp[j+state[i]]=min(dp[j+state[i]],dp[j]+1);//
        }
    }
    return dp[(1<<n)-1];
}
int main()
{
    while(cin>>n>>m)
    {
        init();
        for(int i=0;i<n;++i)cin>>x[i]>>y[i];
        for(int i=0;i<n;++i)cin>>val[i];

        for(int i=1;i<(1<<n);++i)
        {
            isok[i]=Enumeration_subset(i);
            if(isok[i])
                state[tot++]=i;
        }

      ans1=DP_FIRST();  //状态压缩01背包去求最少多少个教练
      //ans1=greedy();    //greedy求解
      if(ans1==inf){cout<<-1<<' '<<-1<<endl;continue;}//不能完成所有的任务
      ans2=TSP_SECOND();
        cout<<ans1<<' '<<ans2<<endl;
    }
    return 0;
}
/*
贪心得思想去求解最少要用多少个教练的个数，每次一个教练都是从任务花费的时间最大的时候开始进行计算，直到不能解决新的任务结束
之后在对下一个教练进行op，
*/
int greedy()
{
    int temp[20],vis[20];
    for(int i=0;i<n;++i)
        temp[i]=val[i],vis[i]=0;
    sort(temp,temp);
    for(int i=1;i<=n;++i)
    {
        int rest=m;
        for(int j=n-1;j>=0;--j)
            if(!vis[j]&&temp[j]<=rest)
                rest-=temp[j],vis[j]=1;
        for(int j=n-1;j>=0&&vis[j]==1;--j)
        {
              if(j==0)return i;
        }
    }
    return inf;
}
/*
第二问：多旅行商问题即mTsp，感觉挺经典的，思路是将mtsp转化成普通的tsp，然后再将各个tsp合并成答案。
先要O(2^n*n^2)的预处理得到np[i]表示一个裁判走的集合为i的所有地点又回到最初的点的最少权值和，
然后np[i] = min(np[i],np[k|(1<<0)]+np[(i-k)|(1<<0)])(i必须包含0节点，因为子集可能不含0节点，所以要和1<<0或起来，这样才是将两个裁判所走的边权和合并)。
*/
void GetDist()
{
    for(int i=0;i<n;++i)
    {
        for(int j=i+1;j<n;++j)
        {
            mp[i][j]=mp[j][i]=ceil(sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])));
        }
    }
}
int TSP_SECOND()
{
    GetDist();
    for(int i=1;i<(1<<n);++i)//求出各种路径一种裁判的消费
        if(isok[i])
        {
            for(int j=0;j<n;++j)
            {
                if(i&(1<<j))
                {
                    np[i]=min(np[i],cost[j][i]+mp[j][0]);
                    for(int k=0;k<n;++k)
                        if((i&(1<<k))==0)
                        cost[k][i|(1<<k)]=min(cost[k][i|(1<<k)],cost[j][i]+mp[j][k]);
                }
            }

        }
    for(int i=1;i<(1<<n);++i)//多裁判消费
        if(i&1)
        for(int j=(i-1)&i;j;j=(j-1)&i)
            np[i]=min(np[i],np[j|1]+np[(i-j)|1]);
    return np[(1<<n)-1];
}