Codeforces-3D Least Cost Bracket Sequence

最新推荐文章于 2020-08-07 10:29:32 发布

MMMyrcellaaa

最新推荐文章于 2020-08-07 10:29:32 发布

阅读量188

点赞数

分类专栏：数据结构——线段树算法——贪心文章标签：贪心线段树

本文链接：https://blog.csdn.net/qq_42158832/article/details/89043948

版权

数据结构——线段树同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

算法——贪心

1 篇文章 0 订阅

订阅专栏

首先需要明确的是括号序列合法的条件：

如果令左括号为1，右括号为-1， $w_{i}$ 为这个1 -1序列到第i个位置的前缀和，那么必须保证对于每一个i， $w_{i}$ 的值都是非负的，且 $w_{n}=0$

这道题首先想到的是dp的做法。

f[i][j] 表示考虑到第i个位置左括号与右括号差为0的情况。转移也是非常简单的。但时间空间似乎都是不太行的。因为dp状态跑不满所以侥幸心理尝试了一下，失败。评测结果为mle 31，正确性应该是有保障的。

#include<bits/stdc++.h>
using namespace std;

#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int,int>
#define mod 998244353
#define debug(x) cerr<<#x<<"="<<x<<'\n'

int lowbit(int x) {return x&(-x);}

const int maxn=4e5+10;
const long long INF=1e11+19;

string s;
int cnt=0;
int l[maxn],r[maxn];
int n;
map <int,ll> f[maxn];
map <int,int> ans[maxn];
ll a[maxn],b[maxn];

long long getf(int x,int y) {
	if (y<0||y>r[x]) return INF;
	if (f[x].find(y)!=f[x].end()) return f[x][y];
	if (x==0) {
		if (y==0) return f[x][y]=0;
		return f[x][y]=INF;
	}
	f[x][y]=INF;
	if (s[x]=='(') f[x][y]=getf(x-1,y-1);
	else if (s[x]==')') f[x][y]=getf(x-1,y+1);
	else {
		if (getf(x-1,y-1)+a[x]<f[x][y]) {
			f[x][y]=getf(x-1,y-1)+a[x];
			ans[x][y]=0;
		}
		if (getf(x-1,y+1)+b[x]<f[x][y]) {
			f[x][y]=getf(x-1,y+1)+b[x];
			ans[x][y]=1;
		}
	}
	return f[x][y];
}

char ss[maxn];
int cur=0;

void trace(int x,int y) {
	if (x==0) return;
	if (s[x]!='?') {
		if (s[x]=='(') trace(x-1,y-1);
		else trace(x-1,y+1);
		cout<<s[x];
	}
	else if (ans[x][y]==0) {
		trace(x-1,y-1);
		cout<<'(';
	}
	else {
		trace(x-1,y+1);
		cout<<')';
	}
	
}

int main(){
	cin>>s;
	int n=s.size();
	s=" "+s;
	r[0]=0;
	for (int i=1;i<=n;i++) {
		if (s[i]=='(') r[i]=r[i-1]+1;
		else if (s[i]==')') r[i]=r[i-1]-1;
		else {
			r[i]=r[i-1]+1;
			scanf("%d%d",&a[i],&b[i]);
		}
	}
	cout<<getf(n,0)<<endl;
	trace(n,0);
	return 0;
}

这道题的正解是贪心。我们可以把所有问号先全部改为右括号。接下来我们要做的就是遵从某些规则将问号处的右括号选择性地改成左括号。

具体做法是从左向右扫描，每次进行以下操作：

如果该位置原来是问号，我们就将该位置上a[i]-b[i]的值连同位置一起扔到优先队列里
如果改动后该位置是左括号，cur++，反之cur--
如果cur<0，即到当前位置似乎出现非法情况，那么取出优先队列（小的排在前面）队首的位置，将该位置修改成左括号，cu+=2

几点说明：

先全部改成右括号意在使每一个位置的 $w_{i}$ 尽可能小，防止左括号多于右括号的情况出现（已知的左括号数量已超过序列长度一半另当别论）。每次在出现非法情况非改不可时在进行修改也是这个道理。
每一次修改只会使w值变大，不会使前面的位置非法。

实现还是比较容易的：

#include<bits/stdc++.h>
using namespace std;

#define pb push_back
#define fi first
#define se second
#define ll long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int,int>
#define mod 998244353
#define debug(x) cerr<<#x<<"="<<x<<'\n'

int lowbit(int x) {return x&(-x);}

const int maxn=4e5+10;
string s;
int n;
priority_queue<pii,vector<pii>,greater<pii> > q;
int a[maxn],b[maxn];
bool c[maxn];
ll ans=0ll;

int main(){
	memset(c,false,sizeof(c));
	cin>>s;
	n=s.size();
	int cnt=0;
	for (int i=0;i<n;i++) {
		if (s[i]=='?') {
			c[i]=true;
			scanf("%d%d",&a[i],&b[i]);
			s[i]=')';
			ans+=(ll)b[i];
		}
	}
	for (int i=0;i<n;i++) {
		if (c[i]) q.push(mp(a[i]-b[i],i));
		if (s[i]=='(') cnt++;
		else cnt--;
		if (cnt<0) {
			cnt+=2;
			if (q.empty()) {
				puts("-1");
				return 0;
			}
			int x=q.top().fi,pos=q.top().se;
			q.pop();
			s[pos]='(';
			ans+=(ll)x;
		}
	}
	if (cnt!=0) puts("-1");
	else cout<<ans<<endl<<s<<endl;
	return 0;
}

还有一种线段树的做法，写起来显然就是比较麻烦的了。

对于固定的左括号,a[i]=0,b[i]=INF;对于固定的右括号,a[i]=INF,b[i]=0.同样处理出a[i]-b[i]，排序
先将序列变为左右括号数量合法且花费最小的序列，那么接下来的任务就是用尽量少的花费将序列改为合法
每次找出最靠左的非法位置，将其左边的一个右括号改为左括号。为保证数量合法，同样也需要将其右边的一个左括号改为右括号。因为我们需要花费最小，所以左边选择a[i]-b[i]最小的位置，右边选择a[i]-b[i]最大的位置，更新序列。这一步中的单点修改和区间查询可以利用线段树或树状数组实现，具体见代码（线段树解法）。

#include<bits/stdc++.h>
using namespace std;

#define pb push_back
#define fi first
#define se second
#define LL long long
#define pq priority_queue
#define mp make_pair
#define pii pair<int,int>
#define mod 998244353
#define debug(x) cerr<<#x<<"="<<x<<'\n'

const LL INF=1e11+19;
const int maxn=5e4+10;
int lowbit(int x) {return x&(-x);}

char s[maxn];
int n;
LL a[maxn],b[maxn],d[maxn];
int ans[maxn];
pair<LL,int> dd[maxn];

struct Node{
	int s_delta;//总的1 -1和 
	int min_delta; //从字符串最左端到该区间内点最小的1 -1和 
	int max_value; //该区间内为左括号且d值最大的位置 
	int min_value; //该区间内为右括号且d值最小的位置 
} tree[maxn*4];

void build (Node &node,int key) {
	node.s_delta=ans[key];
	node.min_delta=min(0,ans[key]);
	node.min_value=(ans[key]<0)?key:-1;
	node.max_value=(ans[key]>0)?key:-1;
}

int MIN(int x,int y) {
	if (x<0) return y;
	if (y<0) return x;
	return (d[x]<d[y])?x:y;
}

int MAX(int x,int y) {
	if (x<0) return y;
	if (y<0) return x;
	return (d[x]>d[y])?x:y;
}

Node unite (Node x, Node y) {
	Node cur;
	cur.s_delta=x.s_delta+y.s_delta;
	cur.min_delta=min(x.min_delta,x.s_delta+y.min_delta);
	cur.min_value=MIN(x.min_value,y.min_value);
	cur.max_value=MAX(x.max_value,y.max_value);
	return cur;
}

int findBad(int node,int l,int r,int cur) {
	if (cur+tree[node].min_delta>=0) return -1;
	if (l==r) return l;
	int mid=(l+r)/2;
	int p=findBad(node*2,l,mid,cur);
	if (p!=-1) return p;
	return findBad(node*2+1,mid+1,r,cur+tree[node*2].s_delta);
}

int findMax(int node,int l,int r,int ll,int rr) {
	if (rr<l||ll>r) return -1;
	if (l>=ll&&r<=rr) return tree[node].max_value;
	int mid=(l+r)/2;
	return MAX(findMax(node*2,l,mid,ll,rr),findMax(node*2+1,mid+1,r,ll,rr));
}

int findMin(int node,int l,int r,int ll,int rr) {
	if (rr<l||ll>r) return -1;
	if (l>=ll&&r<=rr) return tree[node].min_value;
	int mid=(l+r)/2;
	return MIN(findMin(node*2,l,mid,ll,rr),findMin(node*2+1,mid+1,r,ll,rr));
}

void update(int node,int l,int r,int key) {
	if (l==r) {
		build(tree[node],key);
		return;
	}
	int mid=(l+r)>>1;
	if (key>mid) update(node*2+1,mid+1,r,key);
	else update(node*2,l,mid,key);
	tree[node]=unite(tree[node*2],tree[node*2+1]);
	return;
}

void init(int cur,int l,int r) {
	if (l==r) {
		build(tree[cur],l);
		return;
	}
	int mid=(l+r)/2;
	init(cur*2,l,mid);
	init(cur*2+1,mid+1,r);
	tree[cur]=unite(tree[cur*2],tree[cur*2+1]);
	return;
}

void solve(){
	sort(dd,dd+n);
	for (int i=0;i<n;i++) ans[i]=-1;
	for (int i=0;i<n/2;i++) ans[dd[i].se]=1;
	init(1,0,n-1);
	while (1) {
		int p=findBad(1,0,n-1,0);
		if (p==-1) return;
		int x=findMin(1,0,n-1,0,p);
		if (x<0) return;
		ans[x]=1;
		update(1,0,n-1,x);
		int y=findMax(1,0,n-1,p+1,n-1);
		if (y<0) return;
		ans[y]=-1;
		update(1,0,n-1,y);
	}
}

int main(){
	scanf("%s",s);
	n=strlen(s);
	for (int i=0;i<n;i++) {
		if (s[i]=='(') a[i]=0,b[i]=INF;
		else if (s[i]==')') a[i]=INF,b[i]=0;
		else scanf("%d%d",&a[i],&b[i]);
		d[i]=a[i]-b[i];
		dd[i]=mp(d[i],i);
	}
	solve();
	LL res=0ll;
	for (int i=0;i<n;i++) {
		LL delta;
		if (ans[i]==1) s[i]='(',delta=a[i];
		else s[i]=')',delta=b[i];
		if (delta==INF) {
			puts("-1");return 0; 
		}
		res+=delta;
	}
	cout<<res<<endl;
	for (int i=0;i<n;i++) {
		if (ans[i]==1) cout<<"(";
		else cout<<")";
	}
	return 0;
}

MMMyrcellaaa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces-3D Least Cost Bracket Sequence

首先需要明确的是括号序列合法的条件：如果令左括号为1，右括号为-1，为这个1 -1序列到第i个位置的前缀和，那么必须保证对于每一个i，的值都是非负的，且这道题首先想到的是dp的做法。表示考虑到第i个位置左括号与右括号差为0的情况。转移也是非常简单的。但时间空间似乎都是不太行的。因为dp状态跑不满所以侥幸心理尝试了一下，失败。评测结果为mle 31，正确性应该是有保障的。#incl...
复制链接

扫一扫