做的那么多都是一些比较怎么说呢，都是在数网格一类的题目之中，这些题目有些有点固定的套路，而一些需要状态压缩的题目呢，则么是真正对状态转移的考验。
这道题呢，被彻底打脸了，以后一定要任性一点一道题做不出来就要坚持啃，不管你干什么，先a了再说。
但这道题我是真的伤，拿头去写估计也想不出来最后的解法。
第一眼，这不是很简单的dp么？设f[i]表示第i个状态得到的最大价值那么这个状态就是由i这个状态的所有子集所构成。当然本人哪想的出来什么子集直接暴力枚举了。
复杂度2^n^2^n没错这就是复杂度。只能的30分。
//#include<bits/stdc++.h>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<deque>
#include<vector>
#include<set>
#include<bitset>
#include<cctype>
#include<utility>
#include<map>
#include<algorithm>
#include<stack>
using namespace std;
inline int read()
{
int x=,f=;char ch=getchar();
while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
return x*f;
}
inline void put(int x)
{
x<?putchar('-'),x=-x:;
int num=;char ch[];
while(x)ch[++num]=x%+'',x/=;
num==?putchar(''):;
while(num)putchar(ch[num--]);
putchar('\n');return;
}
const int maxn=;
int n,state,t=;
int v[<<maxn];//v[i]表示第i个状态的价值
int f[<<maxn];//f[i]表示到达第i个状态的最优解
void dfs(int x,int sum,int now)
{
if(now==x){f[x]=max(f[x],sum);return;}
for(int i=;i<=x;i++)
{
if(now&i)continue;
dfs(x,sum+v[i],now|i);
}
}
int main()
{
//freopen("1.in","r",stdin);
n=read();state=(<<n)-;
for(int i=;i<=state;i++)v[i]=read();
dfs(state,,);
//for(int i=1;i<=state;i++)dfs(i,0,0);
put(f[state]);
return ;
}
然后也没心情听那所谓的数学课，觉得是在浪费时间，学长也不讲什么那还不如自己学。
所以干脆就一直想，然后一直没想到优化的方法，然后叫了个学长帮我看看，康神看一眼就秒a了。
真的是强，帮我找出代码中TLE的原因的是wydalao 他说我的dfs应该枚举子集，对哦。
这是康神打的递推枚举子集然后成功AC的代码，跑的挺快的。
//#include<bits/stdc++.h>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<deque>
#include<vector>
#include<set>
#include<bitset>
#include<cctype>
#include<utility>
#include<map>
#include<algorithm>
#include<stack>
using namespace std;
inline int read()
{
int x=,f=;char ch=getchar();
while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
return x*f;
}
inline void put(int x)
{
x<?putchar('-'),x=-x:;
int num=;char ch[];
while(x)ch[++num]=x%+'',x/=;
num==?putchar(''):;
while(num)putchar(ch[num--]);
putchar('\n');return;
}
const int maxn=;
int n,state,t=;
struct node{
int v;
int num;
}e[<<maxn];
//v[i]表示第i个状态的价值
int f[<<maxn];//f[i]表示到达第i个状态的最优解
int count(int x){
int res=;
for(;x;x>>=){
if(x&) res++;
}
return res;
}
bool cmp(node a,node b){
return a.num<b.num;
}
int main()
{
//freopen("1.in","r",stdin);
n=read();state=(<<n)-;
for(int i=;i<=state;i++)f[i]=read(),e[i].v=i;
for(int i=;i<=state;i++)e[i].num=count(i);
sort(e+,e+state+,cmp);
for(int i=;i<=state;i++){
int s=e[i].v;
for(int s1=s;s1!=;s1=s&(s1-)){
int s2=s^s1;
f[s]=max(f[s1]+f[s2],f[s]);
}
}
//for(int i=1;i<=state;i++)dfs(i,0,0);
put(f[state]);
return ;
}
细节处理也很对。敬佩三尺，真强啊。然后我十分的不服。
自己学了一下下枚举当前状态的子集，怒打了一个记搜，也算是A了这道题，自己思考的程度很深了，这道题没白费。
//#include<bits/stdc++.h>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<string>
#include<ctime>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<deque>
#include<vector>
#include<set>
#include<bitset>
#include<cctype>
#include<utility>
#include<map>
#include<algorithm>
#include<stack>
using namespace std;
inline int read()
{
int x=,f=;char ch=getchar();
while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
return x*f;
}
inline void put(int x)
{
x<?putchar('-'),x=-x:;
int num=;char ch[];
while(x)ch[++num]=x%+'',x/=;
num==?putchar(''):;
while(num)putchar(ch[num--]);
putchar('\n');return;
}
const int maxn=;
int n,state,t=;
int v[<<maxn];//v[i]表示第i个状态的价值
int f[<<maxn];//f[i]表示到达第i个状态的最优解
int dfs(int x)
{
if(f[x]!=)return f[x];
for(int i=x;i;i=(i-)&x)
{
if(i==x)continue;
int s1=x^i;
dfs(i);dfs(s1);
f[x]=max(f[x],f[s1]+f[i]);
}
return f[x]=max(f[x],v[x]);
}
int main()
{
//freopen("1.in","r",stdin);
n=read();state=(<<n)-;
for(int i=;i<=state;i++)v[i]=read();
dfs(state);
put(f[state]);
return ;
}
代码中记搜和一些状态初始值刚好形成嵌套关系，我也不知道自己则么写的把细节处理的这么好，自己还是可以的。
学长的枚举子集方法比较难一点这里不再赘述。放一下枚举子集的方法。
for(int i=x;i;i=(i-)&x)
{
int s1^i;
}
i是当前集合的子集，s1是当前集合的补集。这样复杂度就大大降低了。
这道题的话也是很简单自己想的了状压dp，但是状态的设置和转移打了几个h都整不好，最后是qydalao教的，但是我不认同他的状态转移，但是a了就是事实。
//#include<bits/stdc++.h>
#include<iomanip>
#include<iostream>
#include<cstdio>
#include<cmath>
#include<ctime>
#include<cstdlib>
#include<cstring>
#include<string>
#include<set>
#include<bitset>
#include<queue>
#include<deque>
#include<stack>
#include<cctype>
#include<utility>
#include<algorithm>
#include<map>
#include<vector>
#define INF 214748364
using namespace std;
inline long long read()
{
long long x=,f=;char ch=getchar();
while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
return x*f;
}
inline void put(long long x)
{
x<?x=-x,putchar('-'):;
long long num=;char ch[];
while(x)ch[++num]=x%+'',x/=;
num==?putchar(''):;
while(num)putchar(ch[num--]);
return;
}
const int MAXN=;
int n,m;
int f[<<];//f[i]表示第i个编码形成所需要的最小次数。
char a[][],an[];
int b[],cnt=,ans,maxx=,sum=,c[],t=;
int p[]={,,,,,,,,,,,,,,,,};
int contrast(int x,int y)
{
int xx=;
while()
{
if(x==&&y==)break;
if((x&)!=(y&))xx++;
x=x>>;y=y>>;
}
return xx;
}
int main()
{
//freopen("1.in","r",stdin);
m=read();n=read();
scanf("%s",an+);
for(int i=;i<=n;i++)scanf("%s",a[i]+);
for(int i=m,j=;i>=;i--,j++)cnt+=an[i]==''?p[j]:;
for(int i=;i<=(<<m);i++)f[i]=INF;
for(int i=;i<=n;i++)
{
for(int j=m,t=;j>=;j--,t++)
{
b[i]+=a[i][j]==''?p[t]:;
}
}
for(int i=;i<=n;i++)
{
for(int j=;j<=n;j++)
{
f[b[i]^b[j]]=min(f[b[i]^b[j]],);
}
f[b[i]]=;
}
for(int i=;i<=n;i++)
for(int j=;j<(<<m);j++)
{
if(f[j]>)continue;
f[j^b[i]]=min(f[j^b[i]],f[j]+);
}
for(int i=(<<m)-;i>=;i--)
{
if(f[i]!=INF)
{
int u=contrast(cnt,i);
if(u==maxx){if(f[i]<sum)sum=f[i],ans=i;if(f[i]==sum)ans=min(ans,i);}
if(u<maxx){maxx=u;sum=f[i];ans=i;}
}
}
put(sum);puts("");
while(ans)
{
if(ans&)c[++t]=;
else c[++t]=;
ans=ans>>;
}
if(t<m)t+=m-t;
for(int i=t;i>=;i--)put(c[i]);
return ;
}
关键是状态转移之处，最后的细节处理当然是简单的了。
这道题是本人自己亲自相出来的思路，那天可能太聪明了，导致推出了正解，看着数据范围是状压。
也可以是状压，但是不免的是随机化搜索什么的，模拟退火好像也可以A了这道题。
但是本人亲自相出的思路那肯定是不一样的。对思维的真实锻炼。
大体思路就是设f[i][j]表示第i个状态到达了第j个节点所需费用的最小值。
那么这样的话考虑填表法得出，枚举当前状态到达了哪个节点，由哪个节点到达这个节点的一堆状态的转移可以得出最优解。
自己的思路，AC了就是很爽呢。
//#include<bits/stdc++.h>
#include<iomanip>
#include<utility>
#include<cctype>
#include<vector>
#include<deque>
#include<map>
#include<stack>
#include<queue>
#include<bitset>
#include<set>
#include<cstdlib>
#include<algorithm>
#include<iostream>
#include<cstdio>
#include<ctime>
#include<cmath>
#include<cstring>
#include<string>
#define INF 214748364.5
inline int read()
{
int x=,f=;char ch=getchar();
while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
return x*f;
}
inline void put(int x)
{
x<?x=-x,putchar('-'):;
int num=;char ch[];
while(x)ch[++num]=x%+'',x/=;
num==?putchar(''):;
while(num)putchar(num--);
putchar('\n');return;
}
const int MAXN=;
int n,s1,s2,w;
double ans=INF,a[MAXN][MAXN];
int x[MAXN],y[MAXN];
int p[]={,,,,,,,,,,,,,,,,,};
double f[<<][];//f[i][j]表示达到第i个状态时所在的节点那么答案就是MIN{f[(1<<n)-1][j]};
int b[MAXN],t=;
double distance(int u1,int u2,int x1,int x2)
{
return sqrt(((u1-x1)*(u1-x1)*1.0+(u2-x2)*(u2-x2)*1.0)*1.0);
}
void getstate(int x)
{
int cnt=;
while(x)
{
if(x&)b[++t]=cnt;
x=x>>;cnt++;
}
}
double min(double x,double y){return x<y?x:y;}
int main()
{
//freopen("1.in","r",stdin);
n=read();
for(int i=;i<=n;i++){x[i]=read();y[i]=read();}
x[]=read();y[]=read();
for(int i=;i<=(<<n);i++)for(int j=;j<=n;j++)f[i][j]=INF;
f[][]=;
for(int i=;i<=n;i++)
for(int j=;j<=n;j++)
a[i][j]=distance(x[i],y[i],x[j],y[j]);
for(int i=;i<(<<n);i++)
{
t=;
getstate(i);
for(int j=;j<=t;j++)
for(int k=;k<=t;k++)
{
if(b[j]!=b[k])f[i][b[j]]=min(f[i][b[j]],f[i-p[b[j]]][b[k]]+a[b[k]][b[j]]);
}
}
for(int i=;i<=n;i++)ans=min(ans,f[(<<n)-][i]);
printf("%.2lf",ans);
return ;
}
状压dp学的还行，自己dp的水平也在不断上涨呢，觉得自己越来越强了。
加油！