codeforces Hello 2024 (A-D)

A:Wallet Exchange

这道题就是贪心博弈

如果和为奇数Alice 赢 否则bob赢

​
    #include <bits/stdc++.h>
    using namespace std;
     
    typedef long long ll;
    const int N=1010;
    typedef pair<int,int>pii;
    ll a[N];
    int main(){
        int t ;
        cin>>t;
        while(t--){
        	ll a,b;
        	cin>>a>>b;
        	ll c=a+b;
        	if(c%2) cout<<"Alice"<<endl;
        	else cout<<"Bob"<<endl;
    	}
    }

​

B:Plus-Minus Split

题意是+-相连可以相互抵消，但是我们可以贪心思考到最后肯定都消的只剩其中一种，所以说

只要求加和减差的绝对值即可

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

typedef long long ll;
const int N=1010;
typedef pair<int,int>pii;
ll a[N];
int main(){
    int t ;
    cin>>t;
    while(t--){
    	int n;
    	cin>>n;
    	string s;
    	cin>>s;
    	ll res=0;
    	for(int i=0;i<n;i++){
    		if(s[i]=='+') res++;
    		else res--;
		}
		cout<<abs(res)<<endl;
	}
}

C:Grouping Increases

这道题乍眼一看像求递减子序列的但是如果是递减子序列的话，

我们可以计算出时间复杂度为（n2）
所以不是动态规划，那么它其实就是一道贪心的题
思考一下，如果我们拿两个数组来存储分三种情况，

两个数组的结尾元素是一大一小，与a[i]进行比较
1.如果两者都大于等于a[i],那么更小的放a[i]可以保证浪费的更少
2.如果两者中有一者大于等于a[i],那么就放在他后面
3.否则的话，说明a[i]比两者都大，那么肯定是放在更小的后面，因为大的可能还能继续放

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
typedef pair<int,int>pii;
ll a[N],b[N];
int main(){
    int t ;
    cin>>t;
    while(t--){
        int n;
        scanf("%d",&n);
        ll res=0;
        for(int i=0;i<n;i++) scanf("%lld",&a[i]);
        vector<ll>s,g;
        s.push_back(100000000);
        g.push_back(100000000);
        for(int i=0;i<n;i++){
            if(a[i]<=s.back()&&a[i]<=g.back()){
                if(s.back()>g.back()) g.push_back(a[i]);
                else s.push_back(a[i]);
            }
            else if(s.back()>=a[i]||g.back()>=a[i]){
                if(s.back()>g.back()) s.push_back(a[i]);
                else g.push_back(a[i]);
            }
            else  {
                if(s.back()>g.back()) g.push_back(a[i]);
                else s.push_back(a[i]);
            }
        //    cout<<a[i];
        }
        for(int i=2;i<s.size();i++) {
              if(s[i]>s[i-1] )res++;    
        }
        for(int i=2;i<g.size();i++) {
              if(g[i]>g[i-1] )res++;    
        }
    
        cout<<res<<endl;
    }
}

D 01 Tree

题目给出每个根节点的权值，让我们判断是否可以形成这棵树，让我们反向思考，突然间就感觉特别没有思路
但是对于题目的样例来看
根节点一定是零
那么我们进行反向思考，对于一棵树来说，从根节点往上走，如果相邻的节点的值相差为1，那么说明肯定是相邻的
         那么我们从节点权值更大的来找一步一步往上找根节点就可以找到根节点
         如果最后发现不是零的话，那么就构不成一棵树
         而且一定有一条边权值为0否则也不符合答案
         我们可以用单调栈来维护答案 
         可以正面用一次单调栈
         只要出现相差数值是1说明是成立的
         翻转操作检查只要是1可以
         只要左右没有相差是1的就不成立
         用c【N】表示状态

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

const int N=2e5+10;
int a[N];
int c[N];
int n;
void  check(){
	vector<int>ans;
	for(int i=0;i<n;i++){
		while(ans.size()&&ans.back()>=a[i]) ans.pop_back();
		if(!ans.empty() && ans.back()==a[i]-1) c[i]=1;
		ans.push_back(a[i]);
	}
}
int main(){
	 ios::sync_with_stdio(0), cin.tie(0);
     int t;
	 cin>>t; 
	 while(t--){
	 	for(int i=0;i<n;i++) c[i]=0;
	 	cin>>n;
	 	int  flag=0;
	    for(int i=0;i<n;i++) {
	        cin>>a[i];
			if(a[i]==0) flag++;	    	
    	}
	 	if(flag!=1)	{        
 			cout<<"No"<<endl;
 			continue;
		}
		check();
	    reverse(a,a+n);
		reverse(c,c+n);
	    check();
	    if(accumulate(c,c+n,0)==n-1)cout<<"YES"<<endl;
     	else cout<<"NO"<<endl;
     
	 }   
}