2022牛客寒假算法基础集训营2

E 小沙的长路

链接

完全图： 完全图是一个简单的无向图，其中每对不同的顶点之间都恰连有一条边相连。完全图最多有n*(n-1)/2条边

求最长路径的最小值和最大值：
最小值：首先最长路径不能有环，否则会无限长，所以在无环情况下，每个点经过一次，最长路径的最小值是$n-1$
最大值：走遍每一条边——欧拉回路，又因为无向图的欧拉回路最多有$(n-1)n/2$条边，而欧拉回路要求无向图的奇数度的点最多有2个，分奇偶点情况讨论

1. 奇数点：$n$为奇数，$(n-1)$为偶数，所以$n$个奇数点每个点有$(n-1)$偶数条边，符合欧拉回路，长度为$(n-1)n/2$
2. 偶数点：偶数$n$个点有$(n-1)$奇数条边，因为最多有两个奇数边，所以有$(n-2)$个点要删一条边，因为无向图，所以一共删除$(n-2)/2$条边，长度为$(n-1)n/2-(n-2)/2$

#include<iostream>
using namespace std;

int main()
{
    long long n;
    cin>>n;
    
    if(n&1) cout<<n-1<<" "<<(n-1)*n/2<<endl;
    else cout<<n-1<<" "<<(n-1)*n/2-(n-2)/2<<endl;
    
    return 0;
}

H-小沙的数数

牛客寒假训练营H-小沙的数字
由异或的性质可知，因为各元素的和是m，先把m转化为二进制，
要使各元素异或最大，就要让各元素在二进制下相同位上不能出现重复的1所以当m中出现一个1，只能放在n个数字中某一个数字中的这一位上。
只需要统计m在二进制下有多少个1，每一个1都可以放在n个位置上。最终结果为$n^x$

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

constexpr int mod = 1e9 + 7;
typedef long long LL;
LL n, m;

int main() 
{
    scanf("%lld%lld", &n, &m);

    LL res=1;
    n%=mod;    //这个一定要加,res*n会爆longlong
    while(m)
    {
        if(m&1) res=res*n%mod;
        m>>=1;
    }
    printf("%lld",res);
  return 0;
}

F-并查集/快速幂逆元

1. “$+$”符号将整个算式分成相互独立的各个部分，“$\ast$”连接的数字之间是一体的。所以使用并查集，按照加法符号划分，乘法连接的左右数字加入同一集合，集合内部使用乘法合并，所以$s[i]$储存集合内部乘法的值，最终总值$ans$是各个集合的值相加。
2. 如何对某一位置的元素进行修改
   修改产生影响的顺序是：这一位置的值——>集合的值——>整个算式的值，所以先从大范围删去这个数字的值，将这个数字的值修改，然后再加上这个数字的值。
   1. 将总值$ans$减去这一位置元素$x$所在集合的值$s[find(x)]$——涉及减法，负数取余
   2. 集合的值去除这一元素的值，因为集合内部执行除法，所以用集合的值除以这一元素的值——这里用到快速幂逆元实现 $s[find(x)]=s[find(x)]\ast qmi(a[x],mod-2)$%$mod$
   3. 将这一位置的值修改$a[x]=y$
   4. 集合的值再乘上这一元素的值 $s[find(x)]=s[find(x)]\ast a[x]$%$mod$
   5. 总值重新加上集合的值 $ans=(ans+s[find(x)])$%$mod$

#include<iostream>
using namespace std;
const int N=1e6+100,mod=1000000007;
typedef long long LL;
LL a[N],p[N],s[N];
char str[N];
LL qmi(LL a,LL k)
{
    LL res=1;
    while(k)
    {
        if(k&1) res=res*a%mod;
        k>>=1;
        a=a*a%mod;
    }
    return res;
}
LL find(int x)
{
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int main()
{
    int n,q;
    cin>>n>>q;
    cin>>str+1;
    
    for(int i=1;i<=n;i++) p[i]=i;
    
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        s[i]=a[i]%mod;    //集合初值
    }
    
    for(int i=1;i<n;i++)
    if(str[i]=='*')    //将乘法的数字合并集合
    {
        LL x=find(i),y=find(i+1);
        p[x]=y;
        s[y]=s[y]*s[x]%mod;
    }
    
    LL ans=0;
    for(int i=1;i<=n;i++)    //先计算最初的总值，将所有根结点的s[i]相加
        if(find(i)==i) ans=(ans+s[i])%mod;
    
    while(q--)
    {
        LL x,y;
        cin>>x>>y;
        LL fa=find(x);
        ans=(ans-s[fa]+mod)%mod;    //减去修改位置对应集合的值，注意负数取余
        s[fa]=s[fa]*qmi(a[x],mod-2)%mod;    //集合的值先除去要修改位置的值，
        a[x]=y;    //对应位置的值进行修改
        s[fa]=s[fa]*a[x]%mod;    //修改后重新加入集合
        ans=(ans+s[fa])%mod;    //集合的值重新加入总值
        
        printf("%lld\n",ans);
    }
    return 0;
}

A-二分/思维

题目给定进攻卡$n$，恢复卡$m$，初始体力为1

1. 首先由题目可以得到，我们进攻牌最多使用$min(n,m+1)$次。
2. 当固定使用的进攻卡$n$张时，我们可以通过调整进攻和恢复顺序，得到一个伤害区间，如果小沙血量$x$在这个区间内部时，可以恰好将小沙斩杀。
3. 如何得到伤害区间的左右端点，假设进攻牌固定为$n$张
   1. 如果尽量先打出伤害牌，则顺序为“伤害，恢复，伤害，恢复···”，造成的伤害为：1，3，5··，n，此时得到最小值：$min=n^2$
   2. 先将m张恢复牌全部打出，最后打进攻牌，则顺序为“恢复，恢复，··，伤害，伤害，伤害”，造成的伤害为:$m+1,m+2,m+3,\cdot \cdot \cdot ,m+n$,此时得到最大值：$max=n\ast m+n\ast (n+1)/2$。

**总体思路：**进攻牌使用次数区间为$l=1,r=min(n,m+1)$，我们通过二分进攻牌的使用次数，得到伤害区间，如果满足$x>=min,x<=max$，则可以恰好斩杀。

#include<iostream>
using namespace std;
typedef long long LL;
LL n,m,k,x;
int main()
{
    cin>>n>>m>>k;
    
    while(k--)
    {
        cin>>x;
        LL l=1,r=min(n,m+1);

        while(l<r)
        {
            LL mid=(l+r+1)/2;            
            if(mid*mid<=x) l=mid;	//二分满足x≥min
            else r=mid-1;
        }    
        LL ans=m*r+r*(r+1)/2;	//判断是否x≤max
        
        if(ans>=x) puts("YES");
        else puts("NO");
    }    
    return 0;
}