2021-07-15

Codeforces Round #693 (Div. 3) A~G

A题
题意：给你a*b的纸，a%2=0||b%2=0则可以切开，问能切成的最大值能不能大于n

容易想到 横着切和竖着切没有关联，每次切会让纸的数量*2，所以可以先一直横着切，再一直竖着切

#include<iostream>
using namespace std;
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		long long a,b,n;
		cin>>a>>b>>n;
		long long now=1;
		while(a%2==0)
		{
			a/=2;
			now*=2;
		}
		while(b%2==0)
		{
			b/=2;
			now*=2;
		}
		if(now>=n)cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
}

B题
题意：n个数 只有1或者2，问能否分成两半，使得两边数字和相等
1 sum为奇数 NO
2 sum为偶数 且sum/2为偶数 YES
3 sum为偶数 sum/2 为奇数 此时需要有1个1才能分成两半

#include<iostream>
using namespace std;
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
	int n,a=0,b=0,x,sum=0;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>x;
		if(x==1) a++;
		else b++;
	}
		sum=a+2*b;
		if(sum%2!=0)cout<<"NO"<<endl;
		else if(sum%2==0&&sum%4==0)cout<<"YES"<<endl;
		else if(sum%2==0&&sum%4!=0)
		{
			if(a)cout<<"YES"<<endl;
			else cout<<"NO"<<endl;
		}
	}
}

C题
题意：选择一个位置 每次可以向右跳a[i]格，跳出n则停止，在一个位置上，sum+=a[i]，求sum的最大值
可以发现每个位置的下一个位置是固定的，容易想到 从最后一个位置开始往前求，这时在求任意一个位置时，后面的sum都是知道的，所以sum[i]=sum[i+a[i]]+a[i]，如果超过了n则sum[i]=a[i]
答案则是每个位置sum的最大值

#include<iostream>
#include<string.h>
using namespace std;
long long a[200010],ans[200010];
int main()
{
	int t,n;
	cin>>t;
	while(t--)
	{
		memset(a,0,sizeof a);
		memset(ans,0,sizeof ans);
		cin>>n;
		for(int i=1;i<=n;i++)
		cin>>a[i];
		for(int i=n;i>=1;i--)
		{
			if(i+a[i]>n)
			ans[i]=a[i];
			else
			{
				ans[i]=a[i]+ans[i+a[i]];
			}
		}
		long long res=0;
		for(int i=1;i<=n;i++)
		res=max(res,ans[i]);
		cout<<res<<endl;
	}
}

D题
题意：有一个数组 A和B玩游戏 A先开始，可以删除一个偶数，sumA+=这个偶数，或者删除一个奇数，B可以删除一个奇数，sumB+=这个奇数，或者删除一个偶数
对于A 删除偶数 sumA+=x，删除奇数sumA不变，但是相当于sumB-x,最终是要比大小，所以等价于 sumA+=x
这时发现A每次都会选择最大值删去
B同理

#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
long long a[200010],ans[200010],ji[200010],ou[200100];
int main()
{
	int t,n;
	cin>>t;
	while(t--)
	{
	cin>>n;
	for(int i=1;i<=n;i++)
	cin>>a[i];
	sort(a+1,a+1+n);
	long long suma=0,sumb=0;
		for(int i=n,j=1;i>=1;i--,j++)
		{
			if(j%2==1)//alice选择 
			{
				if(a[i]%2==0)suma+=a[i];
			}
			else//bob选择 
			{
				if(a[i]%2!=0)sumb+=a[i];
			}
		}
		if(suma==sumb)cout<<"Tie"<<endl;
		if(suma>sumb)cout<<"Alice"<<endl;
		if(suma<sumb)cout<<"Bob"<<endl;
	}
}

E题
题意：有n个元素 每个元素有两个值a，b，对于每个元素x询问是否有其他元素y使得x.a>y.a&&x.b>y.b，注意对于每个元素，a和b可以交换
可以证明所有元素按照a>b排序不影响正确性

这时问题就比较明确了 按照每个元素最大值排序，然后二分，具体看代码

#include<iostream>
#include<string.h>
#include<algorithm>
#include<map>
using namespace std;
struct node
{
	int x,y,i;
}a[200010];
int k[200010];
bool cmp(node a,node b)
{
	return a.x<b.x;
}
int main()
{
	int t,n;
	cin>>t;
	while(t--)
	{
		map<int,int>ha,ans;
	cin>>n;
	for(int i=1;i<=n;i++)
	{
	cin>>a[i].x>>a[i].y;
	a[i].i=i;
	if(a[i].x<a[i].y)
	swap(a[i].x,a[i].y);
	}
	sort(a+1,a+1+n,cmp);

	int minn=1e9+7,add;
	for(int i=1;i<=n;i++)
	{
		if(minn<=a[i].y)
		{
			ans[a[i].x]=add;
			ha[a[i].x]=minn;
		}
		else
		{
			minn=a[i].y;
			add=a[i].i;
			ans[a[i].x]=add;
			ha[a[i].x]=minn;
		}
	}
		for(int i=1;i<=n;i++)
		{
			int l=1,r=n;
			while(l<r)
			{
				int mid=l+r+1>>1;
				if(a[mid].x<a[i].x)
				l=mid;
				else r=mid-1;
			}
			if(a[l].x<a[i].x&&a[i].y>ha[a[l].x])
			{
				k[a[i].i]=ans[a[l].x];
			}
			else
			k[a[i].i]=-1;
		}
		for(int i=1;i<=n;i++)
		cout<<k[i]<<' ';
		cout<<endl;
	}
}

F题
题意：2n的方格 有些已经被填上了，问能否用12或者2*1的方格填满
加入一开始填入的个数是奇数一定不可能填满
是偶数可以发现 每两个填满的区间是相互独立的

下面只要考虑只填了两个的情况下是否能填满
在同一行：中间间隔要是偶数
不在同一行：中间间隔要是奇数
注意考虑一种特殊情况

这种也是不能拼成的，这相当于中间一列将大格子完全分成了两个部分，这两个部分内只填了一个数

#include<iostream>
#include<string.h>
#include<algorithm>
using namespace std;
int t,n,m;
struct node
{
	int x,y;
}a[200010];
bool cmp(node a,node b)
{
	return a.y<b.y;
}
int main()
{
	cin>>t;
	while(t--)
	{
		cin>>n>>m;
		for(int i=1;i<=m;i++)
		cin>>a[i].x>>a[i].y;
		if(m%2==1)
		{
			cout<<"NO"<<endl;
			continue;
		}
		sort(a+1,a+1+m,cmp);
		int f=0;
		for(int i=1;i<=m;i+=2)
		{
			int x1=a[i].x,y1=a[i].y;
			int x2=a[i+1].x,y2=a[i+1].y;
			if(i+2<=m&&a[i+2].y==y2)
			{
				f=1;
				break;
			}
			if(x1==x2)
				{
					if(abs(y1-y2)%2==0)
					f=1;
				}
				else
				{
					if(abs(y2-y1)%2==1)
					f=1;
				}
				if(f==1)break;
		}
		if(f==1)cout<<"NO"<<endl;
		else cout<<"YES"<<endl;
	}
}

G题
题意：一个有向图，1为起点，先求出到所有点的最短路di，然后对于每一个点有三种选择
1 di<dj 跳到j
2 di>=dj 跳到j
3 停止
2只能进行0或者1次
求所有点到1的最小值
首先肯定求最短路，然后进行dp
dp[i][0]表示从i到1不进行2操作的最小值
dp[i][1]表示进行了2操作的最小值
ansi就等于min(dp[i][0],dp[i][1])
下面考虑怎么转移
dp[i][0]不会变化，始终等于d[i]
dp[i][1]表示进行了一次2操作，对于i到j的边 di>dj,dp[i][1]=min(dp[i][1],dp[j][1])
di<=dj 说明要进行2操作了 dp[i][1]=min(dp[i][1],dp[j][0])
第二种情况没有问题
第一种情况的dp[i][1]是未知的 所以考虑记忆化搜索求dp
为什么正确呢？ 能dp的前提是有拓扑序的，这题满足拓扑序，因为di>dj才会转移 说明无环
即可记忆化搜索dp

#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
int h[300010],e[300010],ne[300010],w[300010],idx,n,m;
long long st[300010],dist[300010];
int f[200010][2];
int sk[200010];
void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}
int dijkistar()
{
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>heap;
    heap.push({0,1});
    for(int i=0;i<=n;i++)dist[i]=1e9,st[i]=0;
    dist[1]=0;
    while(heap.size())
    {
        auto k=heap.top();
        heap.pop();
        int id=k.second;
        int num=k.first;
        if(st[id])continue;
        st[id]=1;
        for(int i=h[id];i!=-1;i=ne[i])
        {
            if(num+w[i]<dist[e[i]])
            dist[e[i]]=num+w[i],heap.push({dist[e[i]],e[i]});
        }
    }
    if(dist[n]==1000000000)return -1;
    return dist[n];
}
int find(int x)
{
	//求f[k][1]
	if(sk[x]==1)return f[x][1];
	sk[x]=1;
	for(int i=h[x];i!=-1;i=ne[i])
	{
		int j=e[i];
		if(dist[x]>=dist[j])
    		{
    			f[x][1]=min(f[x][1],f[j][0]);
			}
			else
			f[x][1]=min(f[x][1],find(j));
	 } 
	 return f[x][1];
}
int anss[100010];
int main()
{
	int t;
	cin>>t;
	while(t--)
	{
		idx=0;
		memset(sk,0,sizeof sk);
    cin>>n>>m;
    for(int i=0;i<=n;i++)h[i]=-1;
    for(int i=1;i<=m;i++)
    {
        int a,b,c;
        cin>>a>>b;
        add(a,b,1);
    }
    dijkistar();
    for(int i=1;i<=n;i++)
    f[i][0]=dist[i],f[i][1]=1e9;
    //f[i][1]=min(f[i][1],f[k][1])
    for(int i=1;i<=n;i++)
    {
    	if(!sk[i])
    	find(i);
	}
	for(int i=1;i<=n;i++)
	cout<<min(f[i][0],f[i][1])<<' ';
	cout<<endl; 
	}
}