Codeforces Round 900 (Div. 3)（A-F)

最新推荐文章于 2024-07-27 10:53:07 发布

Unlimitedz

最新推荐文章于 2024-07-27 10:53:07 发布

阅读量365

点赞数 4

分类专栏： cf补题文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/Unlimited_ci/article/details/133363071

版权

cf补题专栏收录该内容

25 篇文章 1 订阅

订阅专栏

文章目录

A. How Much Does Daytona Cost?

签到，只要有k就行

#include <bits/stdc++.h>

using namespace std;
const int N = 3e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 998244353;
const int maxv = 4e6 + 5;

void solve()
{
    int n,c;
    cin>>n>>c;
    vector<int> a(n+5);
    for(int i=1;i<=n;i++) cin>>a[i];
    for(int i=1;i<=n;i++){
        if(a[i]==c) {
            cout<<"YES"<<endl;
            return ;
        }
    }
    cout<<"NO"<<endl;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    t = 1;
    cin>>t;
    while (t--)
    {
        solve();
    }
    system("pause");
    return 0;
}

B. Aleksa and Stack

思路：按照奇数序列构造即可，即 $\cdots n*2-1$ 这种构造方法。
证明：因为所有数都是奇数，对于 $a_i,a_{i+1},a_{i+2}$ 而言， $a_i+a_{i+1}$ 为偶数， $a_{i+2}\times3$ 依旧为奇数，偶数不能被奇数整除，原式得证。

#include <bits/stdc++.h>

using namespace std;
const int N = 3e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 998244353;
const int maxv = 4e6 + 5;


void solve()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;i++){
        cout<<i*2-1<<" ";
    }
    cout<<endl;

}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    t = 1;
    cin>>t;
    while (t--)
    {
        solve();
    }
    system("pause");
    return 0;
}

C. Vasilije in Cacak

思路：若给定的 $x$ 小于前 $k$ 个或者大于后 $k$ 个，那么则一定不合法。否则一定可以通过相关替换拼凑出该数。

#include <bits/stdc++.h>

using namespace std;
const int N = 3e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 998244353;
const int maxv = 4e6 + 5;

void solve()
{
    ll n,k,x;
    cin>>n>>k>>x;
    ll c1=(1+k)*k/2;
    if(x<c1){
        cout<<"NO"<<endl;
        return ;
    }
    ll c2=(n-k+1+n)*k/2;
    if(x>c2){
        cout<<"NO"<<endl;
        return ;
    }
    cout<<"YES"<<endl;

}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    t = 1;
    cin>>t;
    while (t--)
    {
        solve();
    }
    system("pause");
    return 0;
}

D. Reverse Madness

思路：我们可以发现，所有区间都是不相交的，每次进行的翻转操作，即是对于 $[l, r]$ 的区间，以 $x$ 为边界，以区间中心为对称轴进行翻转。所以具体怎么翻转我们并不关系，我们只用记录每个点的翻转次数即可。

#include <bits/stdc++.h>

using namespace std;
const int N = 1e6 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 1e9+7;
const int maxv = 4e6 + 5;



void solve()
{	
	int n,k;
	cin>>n>>k;
	string s;
	cin>>s;
	vector<int> a(k+5),b(k+5),d(n+5);
	for(int i=1;i<=k;i++) cin>>a[i];
	for(int i=1;i<=k;i++) cin>>b[i];
	s=" "+s;
	int q;
	cin>>q;
	for(int i=1;i<=q;i++){
		int x;
		cin>>x;
		int loc=(lower_bound(b.begin()+1,b.begin()+k+1,x)-b.begin());//用二分去找x所在的区间
        int l=min(x,a[loc]+b[loc]-x);
        int r=max(x,a[loc]+b[loc]-x);
		d[l]++,d[r+1]--;//进行差分
	}
	for(int i=1;i<=n;i++) d[i]+=d[i-1];
	for(int i=1;i<=k;i++){
		int l=a[i],r=b[i];//对给定的k个区间进行遍历
		for(int j=l;j<=(l+r)/2;j++){//因为翻转前半部分和后半部分是等价的，所以只用计算前半部分
			if(d[j]%2){//如果当前点的翻转次数为奇数次
				swap(s[j],s[r-(j-l)]);
			}
		}
	}
	for(int i=1;i<=n;i++) cout<<s[i];
	cout<<endl;
}

int main()
{
    ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);
	int t;
	t=1;
	cin>>t;
	while(t--){
		solve();
	}
    system("pause");
    return 0;
}

E. Iva & Pav

思路：st表维护区间与，因为与运算只会越与越小，所以可以用二分去维护能到达的最右端点。对于区间的维护，不一定需要使用st表，线段树，前缀和均可。

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 998244353;
const int maxv = 4e6 + 5;


int f[N][30];

int query(int l,int r)
{
    int len=__lg(r-l+1);
    int ans=f[l][len]&f[r-(1<<len)+1][len];
    return ans;
}

void st()
{
    int n,q;    
    cin>>n;  
    vector<int> a(n+5);
    for(int i=1;i<=n;i++){
        int x;
        cin>>x;
        a[i]=x;
        f[i][0]=x;
    }
    for(int j=1;j<=25;j++){
        for(int i=1;i+(1<<j)-1<=n;i++){
            f[i][j]=f[i][j-1]&f[i+(1<<(j-1))][j-1];
        }
    }
    cin>>q;
    for(int i=1;i<=q;i++){
        int l,k;
        cin>>l>>k;
        if(a[l] < k)
		{
			cout << -1 << ' ';
			continue;
		}
		int L = l, R = n;
        int ans=0;
        while(L<=R){
            int mid=(L+R)/2;
            int res=query(l,mid);
            if(res>=k) {
                ans=mid;
                L=mid+1;
            }
            else R=mid-1;
        }
        cout<<ans<<" ";
    }   
    cout<<endl;
}

void solve()
{
    st();

}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    t = 1;
    cin>>t;
    while (t--)
    {
        solve();
    }
    system("pause");
    return 0;
}

F. Vasilije Loves Number Theory

思路：
当且仅当 $d (n)$ 除以 $n$ 时才存在解。

证明：考虑数 $p_1^{\alpha_1} \cdot p_2^{\alpha_2} \cdots p_k^{\alpha_k}$ 的质因数分解，其中 $p_i$ 表示 $i$ th质数， $\alpha_i$ 表示 $i$ th质数的最高幂，使得 $p_i^{\alpha_i}$ 除以 $n$ 。知道了这一点，我们就可以用下面的公式计算出 $n$ 的被除数： $(\alpha_1+1) \cdot (\alpha_2+1) \cdots (\alpha_k+1)$ .

现在让我们考虑一下我们正在进行的运算。我们正在用数字 $n$ 乘以一个与 $n$ 没有公共质因数的数字 $a$ （条件 $g c d (a, n) = 1$ ）。(条件 $g c d (a, n) = 1$ ）。

$n$ 乘以任何与 $n$ 没有公共质因数的数字都只会给 $n$ 带来新的质因数，因此， $d (n)$ 永远是数字 $d(n\cdot a)$ 的被除数。因此，我们可以写出 $\cdot a) = v \cdot d(n)$ 。任选一个不是 $n$ 因数的素数 $p$ （这样的素数是存在的，因为素数的个数是无限的，而 $n$ 的素数因数是有限的）。用 $n$ 乘以 $a = p^{k-1}$ ，得到 $d(n\cdot a) = d(n) \cdot k = n$ 。

我们可以预处理出每个小于 $10^6$ 的正整数的最小质因数。这样，我们就能在对数时间内对所有小于或等于 $10^6$ 的数字进行因式分解。我们还利用上述公式对 $n$ 进行因式分解并找出其除数个数，然后为每个质因数存储其仍能整除 $n$ 的最高幂次。我们都把这个结构称为 $p o w er$ 。

现在我们需要处理查询：

对于类型 2 的查询，我们只需重置所有内容。

对于第一个查询，我们在 $\mathcal{O}(\log{x})$ 运算中对 $x$ 进行因式分解，并让 $r_1^{\beta_1} \cdot r_2^{\beta_2} \cdots r_\ell^{\beta_\ell}$ 成为数字 $x$ 的因式分解。我们通过以下操作更新 $d (n)$ ：对于 $x$ 中的每个素数 $r_i$ ，用 $d (n)$ 除以 $power[r_i]+1$ ，然后将 $\beta_i$ 加到 $power[r_i]$ ，再用 $d (n)$ 乘以 $power[r_i]+1$ 。计算出 $d (n)$ 后，我们应该检查 $n$ 是否能被它整除。我们可以用两种方法来做这件事：

因为 $d (n)$ 不会超过 $10^9$ ，但是 $n$ 的范围会很大很大，我们无法使用long long类型存下，我们考虑换一种存法，即对 $n$ 进行质因数分解，用 $r_1^{\beta_1} \cdot r_2^{\beta_2} \cdots r_\ell^{\beta_\ell}$ 这种形式储存，具体使用map或者vector进行维护都可以。
对于检查是否能被 $n$ 整除，对于我们计算出的每一个值 $m u l$ ，我们让这个值去对 $n$ 的所有质因子进行遍历，若最终能够变成1，那么就代表肯定能够整除，因为 $n$ 若是能够整除 $m u l$ ，那么代表n的每一个质因子的个数肯定是大于等于 $m u l$ 质因子的个数的，只要最终 $m u l$ 能变为 1 (注，此时不一定需要把 $n$ 的因子全部耗尽），那么肯定合法。

#include <bits/stdc++.h>

using namespace std;
const int N = 2e5 + 5;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef array<ll, 3> p3;
int mod = 998244353;
const int maxv = 4e6 + 5;

const int MAX = 1e6;
int f[MAX+5];
int prime[MAX+5];
int st[MAX+5];
int cnt=0;
void ol()//欧拉筛预处理每个数的最小因子
{
    int i,j;
    for(i=2;i<=MAX;i++){
        if(!st[i]){
            prime[cnt++]=i;
            f[i]=i;
        }
        for(j=0;i*prime[j]<=MAX&&j<cnt;j++){
            st[i*prime[j]]=1;
            f[i*prime[j]]=prime[j];
            if(i%prime[j]==0){
                
                break;
            }
        }
    }
}
 
void solve()
{
    int n,q;
    cin>>n>>q;
    ll mul=1;
    map<int,int> mp;
    while(n>1){
        int p=f[n];
        while(n%p==0){
            mp[p]++;
            n/=p;
        }
    }
    for(auto [x,y]: mp){
        mul*=(y+1);
    }
    ll tar=mul;//记录一开始n的因子个数值
    auto init=mp;//记录一开始n的因子信息
    while(q--){
        int op;
        cin>>op;
        if(op==1){
            int x;
            cin>>x;
            //vector c=factor_small(x);
            while(x>1){//对于每一个x，在logx的时间复杂度内处理出其所有因子
                int p=f[x];
                if(x%p==0){
                    mul/=(mp[p]+1);
                while(x%p==0){
                    mp[p]++;
                    x/=p;
                }
                mul*=(mp[p]+1);
                }
            }
            ll c=mul;
            for(auto [a,b]: mp){//检验是否整除
                while(c%a==0&&b>0) {
                    c/=a;
                    b--;
                }
            }
            if(c==1) cout<<"YES"<<endl;
            else cout<<"NO"<<endl;
        }
        else{
            mul=tar;
            mp=init;
        }
    }
    cout<<endl;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    t = 1;
    cin>>t;
    ol();
    while (t--)
    {
        solve();
    }
    system("pause");
    return 0;
}