CF79D Password（P3943 星空）

Posted 2021-11-07 Jozky86

CF79D Password（P3943 星空）

题意：

你有 n 个灯泡，一开始都未点亮。
同时你有 l 个长度，分别为 $a_1\sim a_l$
每次你可以选择一段连续的子序列，且长度为某个 $a_i$，并将这些灯泡的明灭状态取反。
求最少的操作次数，使得最后有且仅有 k 个位置是亮的，这些位置已经给定，为 $x_1\sim x_k$
1<=k<=10
1<=n<=10000
1<=l<=100

题解：

k小于等于10，这么小的范围很容易联想到状压dp，我们先试着将问题转换
题目的意思是一开始都没亮，最后指定k个位置亮了，我们可以将题目反过来，一开始有k个地方是亮的，现在要全部熄灭
有l个修改的选择，区间修改可以用线段树，但是本题没必要，线段树常数也大，我们使用差分就可以
我们利用异或差分，$b_i=a_i⨁a_{i+1}$
就比如样例1：

10 8 2
1 2 3 5 6 7 8 9
3 5

原始序列：1110111110
异或差分序列：10011000010
我们想让原序列种翻转[l,r]区间就等于在差分序列种取反$b_{l-1},b_r$，这样修改操作就是O(1)的，题目就变成：
给定一个01串，每次操作为：
从给定的l种长度中选择一种$le{n}_i$，选择序列上相距这个长度$le{n}_i$的两个位同时取反
求让序列归零的最少次数
现在就可以用状压dp了，因为异或差分后的序列中我们只需要关心1的情况，而最多也就2*k个1，直接状压即可
dp[i]表示当前状态为i下所需要的最小次数，x和y为当前状态下未被选过的位，显然有：
$$d{p}_{i|(1<<x)|(1<<y)}=min(d{p}_{i|(1<<x)|(1<<y)},d{p}_i+cost(x,y))$$
$cost(x,y)$表示同时将x和y位同时变为0所需要的最少次数
这个cost咋求？我们可以预处理这个数组，对于异或差分序列中每个1的位置跑一边迪杰斯特拉，这样就解决了

代码：

#include <bits/stdc++.h>
#include <unordered_map>
#define debug(a, b) printf("%s = %d\\n", a, b);
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
clock_t startTime, endTime;
//Fe~Jozky
const ll INF_ll= 1e18;
const int INF_int= 0x3f3f3f3f;
void read(){};
template <typename _Tp, typename... _Tps> void read(_Tp& x, _Tps&... Ar)
{
    x= 0;
    char c= getchar();
    bool flag= 0;
    while (c < '0' || c > '9')
        flag|= (c == '-'), c= getchar();
    while (c >= '0' && c <= '9')
        x= (x << 3) + (x << 1) + (c ^ 48), c= getchar();
    if (flag)
        x= -x;
    read(Ar...);
}
template <typename T> inline void write(T x)
{
    if (x < 0) {
        x= ~(x - 1);
        putchar('-');
    }
    if (x > 9)
        write(x / 10);
    putchar(x % 10 + '0');
}
void rd_test()
{
#ifdef ONLINE_JUDGE
#else
    startTime = clock ();
    freopen("data.in", "r", stdin);
#endif
}
void Time_test()
{
#ifdef ONLINE_JUDGE
#else
    endTime= clock();
    printf("\\nRun Time:%lfs\\n", (double)(endTime - startTime) / CLOCKS_PER_SEC);
#endif
}
const int maxn=2e5+9;
int len[maxn];
int x[maxn];
int cnt[maxn];
int cost[500][500];
int minDis[maxn]; 
int dp[20000003];
int num;
int n,k,l;
void Dijk(int s){
	memset(minDis,INF_int,sizeof(minDis));
	minDis[cnt[s]]=0;
	queue<int>q;
	q.push(cnt[s]);
	while(!q.empty()){
		int now=q.front();
		q.pop();
		for(int i=1;i<=l;i++){
			if(now+len[i]<=n&&minDis[now+len[i]]>minDis[now]+1){
				minDis[now+len[i]]=minDis[now]+1;
				q.push(now+len[i]);
			}
			if(now-len[i]>=0&&minDis[now-len[i]]>minDis[now]+1){
				minDis[now-len[i]]=minDis[now]+1;
				q.push(now-len[i]);
			}
		}
	}
	for(int i=0;i<num;i++){
		cost[s][i]=minDis[cnt[i]];
	}
}
int main()
{
    rd_test();
	
	read(n,k,l);
	for(int i=1;i<=k;i++){//需要点亮的点 
		int t;
		read(t);
		x[t]=1;
	} 
	for(int i=1;i<=l;i++){//所能操作的长度 
		read(len[i]);
	}
	for(int i=0;i<=n;i++){
		x[i]^=x[i+1];
	}
	for(int i=0;i<=n;i++){
		if(x[i])
		{
			cnt[num++]=i;
		}
	}
	
	for(int i=0;i<num;i++)
		Dijk(i);
	
//	for(int i=0;i<num;i++){
//		for(int j=0;j<num;j++){
//			printf("cost[%d][%d]=%d\\n",i,j,cost[i][j]);
//		} 
		cout<<endl;
//	}
	memset(dp,INF_int,sizeof(dp));
	dp[0]=0;
	int state=(1<<num)-1;
	for(int i=0;i<=state;i++){
		for(int x=0;x<num;x++){
			if((i>>x)&1)continue;//如果已经出现x，跳过 
			for(int y=x+1;y<num;y++){
				if((i>>y)&1)continue;//如果已经出现y，跳过 
				dp[i | (1ll << x) | (1ll << y)]= min(dp[i | (1ll << x) | (1ll << y)], dp[i] + cost[x][y]);
			}
		}
		
	}
//	for(int i=0;i<=state;i++)
//		printf("dp[]=%d\\n",dp[i]);
	if(dp[state]==INF_int)puts("-1");
	else cout<<dp[state]<<endl;
    //Time_test();
}