迭代加深:
搜索范围一层一层扩大,可以快速某些分支比较深,但是答案比较浅的问题。
https://www.acwing.com/problem/content/172/
通过观察可以发现:
1.搜索时最坏情况可能搜到100层,比较深,但是答案应该比较浅,于是考虑迭代加深。
2.剪枝:
(1)搜索顺序:我们从后往前枚举
(2)等效冗余:枚举前面选2个,等值的不用重复算。
AC代码:
#include<bits/stdc++.h>
using namespace std;
int path[110];
int n;
int dfs(int c,int len){
if(path[c]==n&&c==len) return 1;
if(c>=len) return 0;
bool st[500]={0};
for(int i=c;i>=1;i--){
for(int j=i;j>=1;j--){
int ck=path[i]+path[j];
if(ck>n) continue;
if(st[ck]) continue;
if(ck<=path[c]) continue;
st[ck]=1;
path[c+1]=ck;
if(dfs(c+1,len)) return 1;
}
}
return 0;
}
int main(){
while(cin>>n,n){
path[1]=1;
int len=1;
while(dfs(1,len)==0) len++;
for(int i=1;i<=len;i++){
cout<<path[i]<<" ";
}
cout<<endl;
}
}
双向DFS:
https://www.acwing.com/problem/content/173/
我们先想想直接DFS,那么差不多是1e12多的级别,于是我们对于考虑枚举前
个,对于剩下的
个我们枚举一个再二分一下前
个中与它最接近W的值即可。
我们考虑复杂度:,我们考虑选取合适的K来最小化复杂度即可(一般直接对半开即可)
AC代码:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll w1,n;
const int N=(1<<24);
ll a[101];
ll w[N];
ll cnt=0;
ll ans=0;
void dfs1(ll u,ll len,ll fk){
if(u==len+1){
w[++cnt]=fk;
return;
}
dfs1(u+1,len,fk);
if(fk+a[u]<=w1) dfs1(u+1,len,fk+a[u]);
}
void dfs2(ll u,ll len,ll fk){
if(u==len+1){
ll l=0,r=cnt-1;
while(l<r){
int mid=(l+r+1)/2;
if(fk+w[mid]<=w1) l=mid;
else r=mid-1;
}
ans=max(ans,fk+w[l]);
return;
}
dfs2(u+1,len,fk);
if(fk+a[u]<=w1) dfs2(u+1,len,fk+a[u]);
}
int main(){
cin>>w1>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1,a+n+1);
reverse(a+1,a+n+1);
ll len=n/2;
dfs1(1,len,0);
sort(w+1,w+cnt+1);
cnt=unique(w+1,w+cnt+1)-w;
//for(int i=1;i<=cnt-1;i++) cout<<w[i]<<" ";
dfs2(len+1,n,0);
cout<<ans;
}
IDA*:
其实就是迭代加深上加了个评估函数,假如预估到最深层还是不行就退出。
https://www.acwing.com/problem/content/182/
整体就是一个迭代加深,现在我们考虑构造评估函数:
类似逆序对,我们考虑连接对(每一个后继点为前一个+1视为正确),每一次操作一共断开3个连接点,因此最多一次矫正3个。
于是我们设当前错误的连接对有个,那么评估函数就是:
。
下面是AC代码:
#include<bits/stdc++.h>
using namespace std;
int t,n;
int a[16];
int dep[6][16];
int f()
{
int res = 0;
for (int i = 1; i + 1 <= n; i ++ )
if (a[i + 1] != a[i] + 1)
res ++ ;
return (res + 2) / 3;
}
bool check()
{
for (int i = 1; i <= n; i ++ )
if (a[i] != i)
return false;
return true;
}
int dfs(int d,int len){
if(d+f()>len) return 0;
if(check()) return 1;
for(int l=1;l<=n;l++){
for(int r=l;r<=n;r++){
for(int k=r+1;k<=n;k++){
memcpy(dep[d], a, sizeof a);
int x,y;
for(x=r+1,y=l;x<=k;x++,y++) a[y]=dep[d][x];
for(x=l;x<=r;x++,y++) a[y]=dep[d][x];
if(dfs(d+1,len)) return 1;
memcpy(a, dep[d], sizeof a);
}
}
}
return 0;
}
int main(){
cin>>t;
while(t--){
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
int len=0;
while(len<5&&!dfs(0,len)) len++;
if(len>=5) cout<<"5 or more"<<endl;
else cout<<len<<endl;
}
}
https://www.acwing.com/problem/content/183/
和上一题类似,我们直接考虑评估函数的构造:
我们发现,假如中间8个里出现次数最多的是个,那么我们最少通过
来实现。
同时,为了操作的方便,我们采用打表的方式:
具体来说,我们人为的对这个“容器”的位置标号(从上到下,从左到右),同时我们把每一次操作对应的编号记下来,这样每次操作都可以快速找到进行操作位置的下标了。
AC代码:
/*
0 1
2 3
4 5 6 7 8 9 10
11 12
13 14 15 16 17 18 19
20 21
22 23
*/
#include<bits/stdc++.h>
using namespace std;
const int N = 24;
int q[N];
int op[8][7] = {
{0, 2, 6, 11, 15, 20, 22},
{1, 3, 8, 12, 17, 21, 23},
{10, 9, 8, 7, 6, 5, 4},
{19, 18, 17, 16, 15, 14, 13},
{23, 21, 17, 12, 8, 3, 1},
{22, 20, 15, 11, 6, 2, 0},
{13, 14, 15, 16, 17, 18, 19},
{4, 5, 6, 7, 8, 9, 10}
};
int center[8] = {6, 7, 8, 11, 12, 15, 16, 17};
int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2};
int path[100];
int f()
{
int sum[4]={0};
for (int i = 0; i < 8; i ++ ) sum[q[center[i]]] ++ ;
int s = 0;
for (int i = 1; i <= 3; i ++ ) s = max(s, sum[i]);
return 8 - s;
}
void operation(int x)
{
int t = q[op[x][0]];
for (int i = 0; i < 6; i ++ ) q[op[x][i]] = q[op[x][i + 1]];
q[op[x][6]] = t;
}
bool dfs(int depth, int max_depth, int last)
{
if (depth + f() > max_depth) return false;
if (f()==0) return true;
for (int i = 0; i < 8; i ++ )
{
if (opposite[i] == last) continue;
operation(i);
path[depth] = i;
if (dfs(depth + 1, max_depth, i)) return true;
operation(opposite[i]);
}
return false;
}
int main()
{
while (scanf("%d", &q[0]), q[0])
{
for (int i = 1; i < N; i ++ ) scanf("%d", &q[i]);
int depth = 0;
while (!dfs(0, depth, -1)) depth ++ ;
if (!depth) printf("No moves needed");
for (int i = 0; i < depth; i ++ ) printf("%c", 'A' + path[i]);
printf("\n%d\n", q[6]);
}
}