UVA - 10118 Free Candies（记忆化搜索/状压）

传送门

---

方法一

一开始我确实是这样想的，设$d[i][j][k][p][S]$为四堆分别拿了$i,j,k,p$个，当前已拿糖果用状态压缩为$S$，但是很明显，最多20种糖果，最后的空间为$40\ast 40\ast 40\ast 40\ast (1<<20)$，内存爆了啊，然后就GG了

后来去洛谷看到一篇题解，和上述思路类似。也就是说如果我们想知道当前口袋的糖果集合，那么我们只需要知道一共拿了多少糖果，然后使用数组保存每一堆拿到了第几个，然后记忆化搜索即可

• 下面代码在传递参数时使用了数组作为形参，这样每次四堆下一个该取的糖果可以动态的传入每个搜索的阶段
• 搜索时注意要恢复状态，以及恢复取过的糖果

#include <set>
#include <map>
#include <stack>
#include <queue>
#include <math.h>
#include <cstdio>
#include <string>
#include <bitset>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define ins insert
#define lowbit(x) (x&(-x))
#define mkp(x,y) make_pair(x,y)
#define mem(a,x) memset(a,x,sizeof a);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int,int> P;
const double eps=1e-8;
const double pi=acos(-1.0);
const int inf=0x3f3f3f3f;
const ll INF=1e18;
const int Mod=1e9+7;
const int maxn=45;

int a[4][maxn];
int d[maxn][maxn][maxn][maxn];
int n;

int cal(int x){
    int ans=0;
    while(x){
        ans++;
        x-=lowbit(x);
    }
    return ans;
}

int dp(int *t,int cur){
    int i=t[0],j=t[1],k=t[2],p=t[3];
    int &ans=d[i][j][k][p];
	if(ans!=-1) return ans;
	if(cal(cur)>=5)
		return ans=0;
	ans=0;
	for(int q=0;q<4;q++)
		if(t[q]!=n){
			int res=0;
			if(cur & (1<<(a[q][t[q]+1]-1)))
				res=1;
			cur^=(1<<(a[q][1+t[q]++]-1));
			res+=dp(t,cur);
			cur^=(1<<(a[q][--t[q]+1]-1));
			ans=max(ans,res);
		}
	return ans;
}

int main(){
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    //ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    while(cin>>n && n){
        memset(d,-1,sizeof d);
        for(int i=1;i<=n;i++)
            for(int j=0;j<4;j++)
                cin>>a[j][i];
        int t[4]={0,0,0,0};
        cout<<dp(t,0)<<endl;

    }
    return 0;
}

方法二

自从第六章训练参考嫌写的慢暂时跳过后，复杂状态的搜索就很难下手，等这本书完结后再去补一下前面落下的搜索

实际上就是普通的搜索，加上记忆化。使用$vis$数组记录每个颜色的糖果是否取过，没取过就取，否则就放在口袋，继续取下面的，注意状态恢复

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 40 + 10;
int d[maxn][maxn][maxn][maxn];
int vis[maxn],n;
int mp[maxn][4];
int top[4];

int dp(int k) {
	int &ans = d[top[0]][top[1]][top[2]][top[3]];
	if (ans != -1)return ans;
	ans = 0;
	if (k >= 5)return ans;
	for (int i = 0; i < 4; i++) {
		if (top[i] == n)continue;
		++top[i];
		if (vis[mp[top[i]][i]]) {
			vis[mp[top[i]][i]] = 0;
			ans = max(ans, dp(k - 1) + 1);
			vis[mp[top[i]][i]] = 1;
		}
		else {
			vis[mp[top[i]][i]] = 1;
			ans = max(ans, dp(k+1));
			vis[mp[top[i]][i]] = 0;
		}
		--top[i];
	}
	return ans;
}


int main() {
	while (cin >> n && n) {
		for (int i = 1; i <= n; i++) {
			for (int j = 0; j < 4; j++)
				cin >> mp[i][j];
		}
		memset(vis, 0, sizeof(vis));
		memset(d, -1, sizeof(d));
		memset(top, 0, sizeof(top));
		cout << dp(0) << endl;
	}
	return 0;
}