CodeForces CF #517 Div.2

A. Golden Plate
水题,公式都不用推,循环就完事了。
http://codeforces.com/contest/1072/problem/A

int n,m,k;
	cin>>n>>m>>k;
	int ans=0;
	while(k--){
		ans+=2*n+2*m-4;
		n-=4;
		m-=4;
	}
	cout<

B. Curiosity Has No Limits
题意是给你两个生成函数和两个生成出来的数列,让你去找原数列(也可能不存在)。我的做法是,对于任意的i,ai和bi总共只有16种不同的可能,穷举他们,去找ti和ti+1可能的存在形式。发现除了一组ai和bi可以得到两组ti和ti+1外,其他的至多只能推出一种。那么我们穷举可能t1和t2,可以在O(n)时间内根据上式推出后面的元素。如果每一种都推不出,那么说明无解。
http://codeforces.com/contest/1072/problem/B

const int maxn=2e5+7;
struct node{
	int x,y;
}c[maxn];
int a[maxn],b[maxn]; 
int n;
int err=0;
int ans[maxn];

void check(){
	if(err==-1)return;
	for(int i=2;i

PS:不过这题我写的麻烦了,因为显然对于每一个ai(或者bi)我们可以把它拆成两位,每一位对应t中间相对的位,这样拆位之后处理就可以更加简便,因为变量更少。当然对复杂度不大。但是这样可以处理更大规模的问题,如果ai的范围是0-255,那么如果不拆位的话难度就过于大了。所以拆位在处理位运算的时候是一种非常重要的思想。

C. Cram Time
贪心题。显然我们不难发现,答案ans的上界满足如下性质:
①(ans+1)*ans/2<=(a+b)
那么接下来我们希望证明该上界就是我们需要的答案。
我一开始想的是dp,但是稍加思索之后发现,这个上界是一定能够取得的,以下给出证明:
1.若MIN(a,b)<=ans,那么我们对把第MIN(a,b)天安排在a和b中较小的那一天,由公式①可知剩下的时间一定可以安排在b里面。
2.若MIN(a,b)>ans,那么把第ans天安排在较小的那一天,就构成了一个ans-1的子问题,重复本步骤即可,最后必定会在步骤1中得到解。

LL n,m,sum,maxn;
LL ans1[100005],ans2[100005],cnt1=0,cnt2=0,sum1=0,sum2=0;

int main()
{
	cin>>n>>m;
	sum=m+n;
	LL l=0,r=n+m+1;
	while(l>1;
		if((mid+1)*mid<=(n+m)*2)l=mid;
		else r=mid;
	}
	maxn=l;
	for(int i=maxn;i;--i){
		if(sum1+i<=n){
			sum1+=i;
			ans1[++cnt1]=i;
		}
		else{
			sum2+=i;
			ans2[++cnt2]=i;
		}
	}
	cout<

D. Minimum path
不难看出,这是很裸的一道dp题。
要这么说其实也对,至少第一个代码段是dp。问题的第一部分还是比较简单,用dp保存还能将多少个非a变成a,然后考虑当前格子是否是a,然后将变掉的字母换成a就可以了。
接下来我们就要找字典序最小的串了,那么很容易想到我们熟悉的dp:

dp[i][j]=min(dp[i-1][j],dp[i][j-1])+c[i][j]
其中dp保存到第i行第j列的字典序最小字符串,c保存图中第i行第j列的字母。

如果这样粗暴的存,那么是一个O(N^3)的空间复杂度,给定的n=2000,大概率会爆空间,所以我把它压缩成了一个一维的dp:

dp[j]=max(dp[j-1],dp[j])+c[i][j]
考虑第i行第j列的状态,那么他或者从左边来,或者从上边来。在没有访问过本格的情况下,dp[j]里面存的其实就是上一上本列的状态,而dp[j-1]则因为已经被更新过,所以存储的是本行j-1列的状态。

然后算算时间复杂度O(N^3),考虑到我的常数非常小,我认为应该可以通过,果不其然,一发WA。

然后我学习到了一种更加巧妙的dp方法,虽然dp本身仍然是O(N^2),但是免去了比较string的时间消耗。我们用一个(bool)used来表示某个点是否可能是最优解中的点,显然,出发点必定在其中。接下来,我们第一重循环穷举k=i+j(0连接上一层中used中的点中最小的点标记为used,显然至少能够找到一个。由循环不变式可以证明,在当前层中,从选入used中的点回溯必定是最优解:

初始化:当k==0时,只有一个元素,显然成立
保持:当在第k-1层满足该性质时,对于每有被选中的数字,无非包括两种情况。一种是未被上层used连接的(无论大小),那么由于字典序的性质,如果他被选上,那么之前一定不是最优的,所以舍去。另一种是被上一层连接但不是最小的,那么当然也不是最优的,所以舍去。剩下的满足条件,且因为上一层至少有一个在used中的,所以本层也至少能找到一个放进used中。
终止:在到达最后一层时停止。

显然每一层放入used的字母是唯一值,我们保存他们加入used的顺序,就可以得到字典序最小的答案。

char c[2005][2005];
int lt[2005][2005];
bool used[2005][2005];
int n;
int now=1;
int maxx=0;

int getlastlt(int i,int j){
	if(!i)return lt[i][j-1];
	if(!j)return lt[i-1][j];
	return MAX(lt[i][j-1],lt[i-1][j]);
}

string MINn(string x,string y){
	int la=x.size(),lb=y.size();
	int p=0;
	while(py[p])return y;
		p++;
	}
	return x;
}

int main()
{
	INI(lt);
	INI(used);
	cin>>n>>lt[0][0];
	for(int i=0;i=0){
				if((rr&&used[rr-1][cc])||(cc&&used[rr][cc-1]))minn=MIN(minn,c[rr][cc]),used[rr][cc]=1;	
				++cc;
				--rr;
			}
			rr=i;
			cc=0;
			while(rr>=0){
				if(c[rr][cc]!=minn)used[rr][cc]=0;
				++cc;
				--rr;
			}
		}
		else{
			rr=n-1;
			cc=i-rr;
			while(cc=0){
				if(c[rr][cc]!=minn)used[rr][cc]=0;
				++cc;
				--rr;
			}
		}
		ans.push_back(minn);
	}
	cout<

你可能感兴趣的:(CF)