CodeForces 913 E. Logical Expression

最新推荐文章于 2022-01-26 22:41:42 发布
最新推荐文章于 2022-01-26 22:41:42 发布
阅读量408 收藏 1
点赞数 1
分类专栏： dp 字符串 贪心 技巧 经典
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yzyyylx/article/details/79023969
版权
经典 同时被 3 个专栏收录
212 篇文章 1 订阅
订阅专栏
技巧
190 篇文章 2 订阅
订阅专栏
dp
84 篇文章 2 订阅
订阅专栏

题面

题意

给出x=1111B,y=110011B,z=1010101B,输出一个由x,y,z组成的字符串使其结果为给出的数,且最短,若长度相同,则输出字典序最小的一个.

方法

首先按符号的优先级来划分等级:
0 – (),!
1 – &
2 – |
dp[i][j]表示优先级为i,值为j时的最优表达式.
因此,dp[0][x]=x,dp[0][y]=y,dp[0][z]=z.
一开始想到的做法是BFS,将已知状态通过&(x或y或z),|(x或y或z)来更新.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
using namespace std;

int n,k,k1,k2,a,b,x=0b00001111,y=0b00110011,z=0b01010101;
string dp[5][300],tmp,tmp2;
bool in[3000];
queue<int>que;
//0 -- (),!
//1 -- &
//2 -- |
bool operator < (string u,string v)
{
	if(u==""||v=="") return v=="";
	if(u.size()!=v.size()) return u.size()<v.size();
	int i;
	for(i=0; i<u.size(); i++)
	{
		if(u[i]!=v[i]) return u[i]<v[i];
	}
	return 0;
}

int main()
{
	int i,j;
	dp[0][x]='x';
	dp[0][y]='y';
	dp[0][z]='z';
	que.push(x);
	que.push(y);
	que.push(z);
	in[x]=in[y]=in[z]=1;
	for(; !que.empty();)
	{
		k=que.front();
		k1=k/300;
		k2=k%300;
		in[que.front()]=0;
		que.pop();
		// !
		a=k2^255;
		if(!k1)
		{
			if(dp[k1][k2].size()==1)
			{
				tmp='!'+dp[k1][k2];
				if(tmp<dp[0][a])
				{
					dp[0][a]=tmp;
					if(!in[a])
					{
						in[a]=1;
						que.push(a);
					}
				}
			}
		}
		else
		{
			tmp="!("+dp[k1][k2]+')';
			if(tmp<dp[0][a])
			{
				dp[0][a]=tmp;
				if(!in[a])
				{
					in[a]=1;
					que.push(a);
				}
			}
		}

		// &
		// x
		a=k2&x;
		if(k1<1)
		{
			if("x&"+dp[k1][k2] < dp[k1][k2]+"&x") tmp="x&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("x&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&x") tmp="x&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("x&("+dp[k1][k2]+')' < dp[k1][k2]+"&x") tmp="x&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		// y
		a=k2&y;
		if(k1<1)
		{
			if("y&"+dp[k1][k2] < dp[k1][k2]+"&y") tmp="y&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("y&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&y") tmp="y&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("y&("+dp[k1][k2]+')' < dp[k1][k2]+"&x") tmp="y&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		//z
		a=k2&z;
		if(k1<1)
		{
			if("z&"+dp[k1][k2] < dp[k1][k2]+"&z") tmp="z&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("z&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&z") tmp="z&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("z&("+dp[k1][k2]+')' < dp[k1][k2]+"&z") tmp="z&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}

		// |
		//x
		a=k2|x;
		if(k1==2)
		{
			if("x|("+dp[k1][k2]+')' < dp[k1][k2]+"|x") tmp="x|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("x|"+dp[k1][k2] < dp[k1][k2]+"|x") tmp="x|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//y
		a=k2|y;
		if(k1==2)
		{
			if("y|("+dp[k1][k2]+')' < dp[k1][k2]+"|y") tmp="y|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("y|"+dp[k1][k2] < dp[k1][k2]+"|y") tmp="y|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//z
		a=k2|z;
		if(k1==2)
		{
			if("z|("+dp[k1][k2]+')' < dp[k1][k2]+"|z") tmp="z|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("z|"+dp[k1][k2] < dp[k1][k2]+"|z") tmp="z|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
	}
	cin>>n;
	for(i=1; i<=n; i++)
	{
		scanf("%d",&k);
		k1=0;
		for(j=0; j<=7; j++)
		{
			k1+=k%10*(1 << j);
			k/=10;
		}
		if(dp[0][k1]<dp[1][k1]&&dp[0][k1]<dp[2][k1])
		{
			cout<<dp[0][k1];
		}
		else if(dp[1][k1]<dp[2][k1])
		{
			cout<<dp[1][k1];
		}
		else
		{
			cout<<dp[2][k1];
		}
		puts("");
	}
}

可是11001110就过不了,寻找原因后发现无法在原状态上进行|!x 的操作,于是就天真地增加了&(!x或!y或!z),|(!x或!y或!z)6种操作.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
using namespace std;

int n,k,k1,k2,a,b,x=0b00001111,y=0b00110011,z=0b01010101;
string dp[5][300],tmp,tmp2;
bool in[3000];
queue<int>que;
//0 -- (),!
//1 -- &
//2 -- |
bool operator < (string u,string v)
{
	if(u==""||v=="") return v=="";
	if(u.size()!=v.size()) return u.size()<v.size();
	int i;
	for(i=0; i<u.size(); i++)
	{
		if(u[i]!=v[i]) return u[i]<v[i];
	}
	return 0;
}

int main()
{
	int i,j;
	dp[0][x]='x';
	dp[0][y]='y';
	dp[0][z]='z';
	que.push(x);
	que.push(y);
	que.push(z);
	in[x]=in[y]=in[z]=1;
	for(; !que.empty();)
	{
		k=que.front();
		k1=k/300;
		k2=k%300;
		in[que.front()]=0;
		que.pop();
		// !
		a=k2^255;
		if(!k1)
		{
			if(dp[k1][k2].size()==1)
			{
				tmp='!'+dp[k1][k2];
				if(tmp<dp[0][a])
				{
					dp[0][a]=tmp;
					if(!in[a])
					{
						in[a]=1;
						que.push(a);
					}
				}
			}
		}
		else
		{
			tmp="!("+dp[k1][k2]+')';
			if(tmp<dp[0][a])
			{
				dp[0][a]=tmp;
				if(!in[a])
				{
					in[a]=1;
					que.push(a);
				}
			}
		}

		// &
		// x
		a=k2&x;
		if(k1<1)
		{
			if("x&"+dp[k1][k2] < dp[k1][k2]+"&x") tmp="x&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("x&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&x") tmp="x&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("x&("+dp[k1][k2]+')' < dp[k1][k2]+"&x") tmp="x&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		// y
		a=k2&y;
		if(k1<1)
		{
			if("y&"+dp[k1][k2] < dp[k1][k2]+"&y") tmp="y&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("y&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&y") tmp="y&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("y&("+dp[k1][k2]+')' < dp[k1][k2]+"&x") tmp="y&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		//z
		a=k2&z;
		if(k1<1)
		{
			if("z&"+dp[k1][k2] < dp[k1][k2]+"&z") tmp="z&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("z&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&z") tmp="z&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("z&("+dp[k1][k2]+')' < dp[k1][k2]+"&z") tmp="z&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		// !x
		a=k2&(255^x);
		if(k1<1)
		{
			if("!x&"+dp[k1][k2] < dp[k1][k2]+"&!x") tmp="!x&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&!x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("!x&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&!x") tmp="!x&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&!x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("!x&("+dp[k1][k2]+')' < dp[k1][k2]+"!&x") tmp="!x&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&!x";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		// !y
		a=k2&(255^y);
		if(k1<1)
		{
			if("!y&"+dp[k1][k2] < dp[k1][k2]+"&!y") tmp="!y&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&!y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("!y&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&!y") tmp="!y&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&!y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("!y&("+dp[k1][k2]+')' < dp[k1][k2]+"&!y") tmp="!y&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&!y";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		//!z
		a=k2&(255^z);
		if(k1<1)
		{
			if("!z&"+dp[k1][k2] < dp[k1][k2]+"&!z") tmp="!z&"+dp[k1][k2];
			else tmp=dp[k1][k2]+"&!z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else if(k>1)
		{
			if("!z&("+dp[k1][k2]+')' < '('+dp[k1][k2]+")&!z") tmp="!z&("+dp[k1][k2]+')';
			else tmp='('+dp[k1][k2]+")&!z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}
		else
		{
			if("!z&("+dp[k1][k2]+')' < dp[k1][k2]+"&!z") tmp="!z&("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"&!z";
			if(tmp<dp[1][a])
			{
				dp[1][a]=tmp;
				if(!in[a+300])
				{
					in[a+300]=1;
					que.push(a+300);
				}
			}
		}

		// |
		//x
		a=k2|x;
		if(k1==2)
		{
			if("x|("+dp[k1][k2]+')' < dp[k1][k2]+"|x") tmp="x|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("x|"+dp[k1][k2] < dp[k1][k2]+"|x") tmp="x|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//y
		a=k2|y;
		if(k1==2)
		{
			if("y|("+dp[k1][k2]+')' < dp[k1][k2]+"|y") tmp="y|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("y|"+dp[k1][k2] < dp[k1][k2]+"|y") tmp="y|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//z
		a=k2|z;
		if(k1==2)
		{
			if("z|("+dp[k1][k2]+')' < dp[k1][k2]+"|z") tmp="z|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("z|"+dp[k1][k2] < dp[k1][k2]+"|z") tmp="z|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//!x
		a=k2|(255^x);
		if(k1==2)
		{
			if("!x|("+dp[k1][k2]+')' < dp[k1][k2]+"|!x") tmp="!x|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|!x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("!x|"+dp[k1][k2] < dp[k1][k2]+"|!x") tmp="!x|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|!x";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//!y
		a=k2|(255^y);
		if(k1==2)
		{
			if("!y|("+dp[k1][k2]+')' < dp[k1][k2]+"|!y") tmp="!y|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|!y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("!y|"+dp[k1][k2] < dp[k1][k2]+"|!y") tmp="!y|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|!y";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		//!z
		a=k2|(255^z);
		if(k1==2)
		{
			if("!z|("+dp[k1][k2]+')' < dp[k1][k2]+"|!z") tmp="!z|("+dp[k1][k2]+')';
			else tmp=dp[k1][k2]+"|!z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
		else
		{
			if("!z|"+dp[k1][k2] < dp[k1][k2]+"|!z") tmp="!z|"+dp[k1][k2];
			else tmp=dp[k1][k2]+"|!z";
			if(tmp<dp[2][a])
			{
				dp[2][a]=tmp;
				if(!in[a+600])
				{
					in[a+600]=1;
					que.push(a+600);
				}
			}
		}
	}
	cin>>n;
	for(i=1; i<=n; i++)
	{
		scanf("%d",&k);
		k1=0;
		for(j=0; j<=7; j++)
		{
			k1+=k%10*(1 << j);
			k/=10;
		}
//		cout<<dp[0][k1]<<" "<<dp[1][k1]<<" "<<dp[2][k1];
		//*
		if(dp[0][k1]<dp[1][k1]&&dp[0][k1]<dp[2][k1])
		{
			cout<<dp[0][k1];
		}
		else if(dp[1][k1]<dp[2][k1])
		{
			cout<<dp[1][k1];
		}
		else
		{
			cout<<dp[2][k1];
		}
		puts("");
		//*/
	}
}

可惜过不了01001001,后来发现这种做法无法应对|(…)的形式,因而不得不改变做法.
正确做法是不断地暴力更新状态,将一下几个操作循环进行:
1.将优先级为2的通过加上括号变为优先级为0的:
dp[i][0]=min(dp[i][0], ‘(’+dp[i][2]+’)’ );
为了进行"非"运算

2.枚举并进行"非"运算:
dp[i ^ 255][0]=min(dp[i ^ 255][0], ’ ! '+dp[i][0] );

3.将优先级为0的变为优先级为1的:
dp[i][1]=min(dp[i][1], dp[i][0] );
为了进行"与"运算,且优先级1能做的0都能做

4.枚举并进行"与"运算
dp[i&j][0]=min(dp[i&j][0], dp[i][0]+’&’+dp[j][0] );

5.将优先级为0的变为优先级为1的:
dp[i][2]=min(dp[i][2], dp[i][1] );
为了进行"或"运算,作用与3相似

6.枚举并进行"或"运算
dp[i | j][0]=min(dp[i | j][0], dp[i][0]+’|’+dp[j][0] );

当6个操作均无法操作时就停止循环,每次输入一个数后取3个优先级种的最小值即可.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;

int n,k,k1,k2,a,b,x=0b00001111,y=0b00110011,z=0b01010101;
string dp[5][300],tmp,tmp2;
bool have;
//0 -- (),!
//1 -- &
//2 -- |
bool operator < (string u,string v)
{
	if(u==""||v=="") return v=="";
	if(u.size()!=v.size())return u.size()<v.size();
	int i;
	for(i=0; i<u.size(); i++)
	{
		if(u[i]!=v[i]) return u[i]<v[i];
	}
	return 0;
}

int main()
{
	int i,j;
	dp[0][x]='x';
	dp[0][y]='y';
	dp[0][z]='z';

	for(have=1; have;)
	{
		have=0;
		// ()
		for(i=0; i<=255; i++)
		{
			if(dp[2][i]=="") continue;
			tmp='('+dp[2][i]+')';
			if(tmp<dp[0][i])
			{
				have=1;
				dp[0][i]=tmp;
			}
		}

		// !
		for(i=0; i<=255; i++)
		{
			if(dp[0][i]=="") continue;
			tmp='!'+dp[0][i];
			if(tmp<dp[0][i^255])
			{
				have=1;
				dp[0][i^255]=tmp;
			}
		}

		// &
		for(i=0; i<=255; i++)
		{
			if(dp[0][i]=="") continue;
			if(dp[0][i]<dp[1][i])
			{
				have=1;
				dp[1][i]=dp[0][i];
			}
		}
		for(i=0; i<=255; i++)
		{
			if(dp[1][i]=="") continue;
			for(j=0; j<=255; j++)
			{
				if(dp[1][j]=="") continue;
				tmp=dp[1][i]+'&'+dp[1][j];
				if(tmp<dp[1][i&j])
				{
					have=1;
					dp[1][i&j]=tmp;
				}
			}
		}

		// |
		for(i=0; i<=255; i++)
		{
			if(dp[1][i]=="") continue;
			if(dp[1][i]<dp[2][i])
			{
				have=1;
				dp[2][i]=dp[1][i];
			}
		}
		for(i=0; i<=255; i++)
		{
			if(dp[2][i]=="") continue;
			for(j=0; j<=255; j++)
			{
				if(dp[2][j]=="") continue;
				tmp=dp[2][i]+'|'+dp[2][j];
				if(tmp<dp[2][i|j])
				{
					have=1;
					dp[2][i|j]=tmp;
				}
			}
		}
	}
 
	cin>>n;
	for(i=1; i<=n; i++)
	{
		scanf("%d",&k);
		k1=0;
		for(j=0; j<=7; j++)
		{
			k1+=k%10*(1 << j);
			k/=10;
		}
		if(dp[0][k1]<dp[1][k1]&&dp[0][k1]<dp[2][k1])
		{
			cout<<dp[0][k1];
		}
		else if(dp[1][k1]<dp[2][k1])
		{
			cout<<dp[1][k1];
		}
		else
		{
			cout<<dp[2][k1];
		}
		puts("");
	}
}
yzyyylx
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Codeforces 1312 E. Array Shrinking (区间dp)
01-03
E. Array Shrinking time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output You are given an array a1,a2,…,an. You can perform the following operation...
【CodeForces】913 E. Logical Expression
weixin_33738555的博客
01-10 84
【题目】E. Logical Expression 【题意】令x=11110000(2),y=11001100(2),z=10101010(2)，n次询问，每次要求用[与][或][非][括号]构成含至多各1个xyz的表达式使得结果等于给定的数字（0~255），要求表达式最短（一样短时字典序最小）。n<=10000 【算法】数学+最短路? 【题解】实际上给的数字只有256种情况，所以思路...
Hello 2018 E. Logical Expression（dp）
bibibibi的博客
01-11 272
题目链接：http://codeforces.com/contest/913/problem/E 神奇的dp啊？按照优先级依次更新，每一次迭代用F数组更新T数组，再用T数组更新E数组，然后下一轮对E加括号之后更新F，一直迭代到不能继续更新 这个dalao的博客中有更好的解释图：https://www.cnblogs.com/lzhAFO/p/8253180.html
Codeforces913E. Logical Expression
a2850363633的博客
01-09 81
现有串x=11110000,y=11001100,z=10101010,通过这三个串只用与或非三种操作到达给定的串，优先级非>或>与，可以加括号，问表达式最短的里面字典序最小的是谁，有<=10000个询问。 一个串，经过某种变换，到达另一个串，这种转移关系用图论极其合适。那么问题就转化成了一个最短路问题，其中最短包含题目的两个条件。 然而，“某种变换”，即与或非，能...
[CF913E]Logical Expression
七代目鸽影
08-09 149
玄乎。真玄乎。
CodeForces-Div.2A
04-28
Watermelon: http://codeforces.com/problemset/problem/4/A 2- 71A. Way Too Long Words: http://codeforces.com/problemset/problem/71/A 3- 118A. String Task: ...
Codeforces 1333 F. Kate and imperfection
01-08
题意： 在集合 S=1,2,⋯,nS={1,2,⋯,n}S=1,2,⋯,n 中，对于每个正整数 kkk ，找出一个大小为 kkk 的子集，使得该子集中两两间最大公因数的最大值最小，求这个最小值。 我们考虑如何构造两两间最大公因数的最大值最小...
Codeforces round 678 D2_Codeforces_源码.zip
10-25
Codeforces round 678 D2_Codeforces_源码
CodeForces1230 F. Konrad and Company Evaluation (复杂度分析）
01-03
题意： 有n个人m个敌对关系， 一开始第x个人的工资是x 有q次操作，每次操作会给一个人的编号x 然后将x的工资变为所有人中最多的。 如果a和b是敌对关系，a的工资比b高，那么a会嘲讽 如果a嘲讽b，b嘲讽c，那么（a，b，...
Codeforces 913 Ａ 模拟　Ｂ模拟　C 贪心+位运算 D 优先队列+枚举 （补题）
Dave_lzw的博客
01-11 633
A. Modular Exponentiation time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output The following problem is well-known: given i
BJ 集训测试11 level&& codeforces 700E
Elijahqi
03-27 278
http://www.elijahqi.win/archives/2796 题意：给定一串字符求其等级 对于等级的定义是 字符串中出现至少两次的等级最高的字符串的等级+1 那么有个显然的n^3 暴力dp+hash的做法设dp[i][j]表示i开始长度为j的这段区间的等级是多少 每次直接比较前缀后缀 即可 据说gzez某大佬有hash 的做法可以ac 复杂度o(能过) 我不会.. #in...
codeforces Hello 2018 --------- E Logical Expression
hi_just_do_it的博客
01-19 214
大意和题目介绍： 点击链接 ps：自己太懒了，当时也是参考大神代码才理解的。 题解： 主要是对三个操作优先级的划分，然后要想要可以用dp状态来表示每个操作，这样以后就简单许多了。 还有一个就是直接输入二进制的话就是int tmp = 0b00111; 代码： #include using namespace std; #define LL long long #define fir
CF Hello 2018 913E - Logical Expression
01-11 108
题目大意： 多组数据，给你一张真值表，求字典序最小的表达式。（真值表只有3个变量x,y,z） 我们发现答案不会很长，而且我们只有 256 种不同的输入，那么我们就可以打表。 我们怎么打表呢？我们发现答案不会很长，那么我们搜索表达式至len为20位，再加上最优性剪枝。跑个3min就出来了。 （看起来有8^20 次方种，很多，其实很多是不符合语法的，符合语法的也有可以剪枝的，比如A&...
Logical Expression(C++)
I_Like_S_的博客
01-26 586
题目描述： Given areNstringsS1,...,SN,each of which isANDorOR. Find the number of tuples of N+1variables (x0​,…,xN​), where each element is True or False, such that the following computation results in yNbeing True: y0​=x0​; for i≥1, yi​=yi−1​∧xi​...
Codeforces 913A Modular Exponentiation
七箫.
01-10 458
题目在这里呀！ 模拟。 在计算2^n时如果已经超过m则跳出并输出m。 否则就输出m % 2^n。这样就不会爆了。 #include using namespace std; int main() { int n,m; scanf("%d",&n); scanf("%d",&m); int fac=1,k=0; for(int i=1;im){k=i;break;
D - Logical Expression
qq_43697906的博客
01-24 266
题目来源：https://atcoder.jp/ 一、题目大意 给定N个字符串S1 ，…，Sn ，每个字符串内容为 AND 或 OR 。找到使yn为1的序列（x0 ，…，xn）的数量。 1.y0 = x0 2.对于i >= 1 ,当Si 为AND时，yi =y i-1 ∧xi ；当Si 为OR时，yi =y i-1 ∨xi 二、输入 第一行，一个正整数 N 。 后面N行为S1 …Sn 三、输出 满足条件的序列数量 四、样例 样例一 input: 2 AND OR ou
Codeforces Round 798 (Div. 2)
最新发布
09-08
Codeforces Round 798 (Div. 2)是一个Codeforces竞赛系列中的一场比赛。根据提供的引用内容，我们可以看到一些参赛选手的AC代码链接。这些链接中包含了一些参赛选手在比赛中解答的题目的代码。 其中，AC代码链接是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值