牛客寒假基础训练营4

牛客寒假基础训练营4

A：略

---

B：略

---

C：子段乘积

---

这一题的区段乘积，一开始我的思路就被带到了前缀积（不知道有没有这个东西）的思路上面一直在想怎么通过可知的左右模数求区间模数，尝试了欧几里得算法但是无奈这个算法不是很会，而且起初的思考方向就不对，所以从这题开始这场基本就崩了。下面说说正确解法，题解说了三种解法（线段树，分治，和尺取）我个人觉得还是线段树和分支比较好写毕竟我讨厌乘法逆元之类的。看到线段树的解法后细心想了想，发现真的是自己太弱了。用线段树维护区间积就可以了，写起来也很容易，基本就是线段树板子。

/*************************************************
* @Author: maple
* @Date:   2020-02-13 08:14:50
* @Last Modified by:   maple
* @Last Modified time: 2020-02-13 08:54:04
* @Mark 
*************************************************/
#include <bits/stdc++.h>
#define CSE(x,y) memset(x,y,sizeof(x))
#define lowbit(x) x&(-x)
#define Abs(x) x>=0?x:(-x)
#define FAST ios::sync_with_stdio(false);cin.tie(0);
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int maxn=2*1e5+100;
const ll mod = 998244353;
ll tree[maxn<<2],arr[maxn],n,k;

void build_tree(int ad,int l,int r){
    if(l==r){
        tree[ad]=arr[l]%mod;
        return;
    }
    int mid=(l+r)>>1;
    build_tree(ad<<1,l,mid);
    build_tree(ad<<1|1,mid+1,r);
    tree[ad]=(tree[ad<<1]*tree[ad<<1|1])%mod;
    return;
}

ll get_ans(int ad,int l,int r,int be,int ed){
    if(l>ed||r<be)
        return 1;
    if(l<=r&&l>=be&&r<=ed)
        return tree[ad]%mod;
    int mid=(l+r)>>1;
    ll ans=1;
    ans=(ans*get_ans(ad<<1|1,mid+1,r,be,ed))%mod;
    ans=(ans*get_ans(ad<<1,l,mid,be,ed))%mod;
    return ans;
}

int main()
{
    FAST;
    #ifndef ONLINE_JUDGE
    freopen("in.in","r",stdin);
    #endif
    cin>>n>>k;
    for(int i=1;i<=n;i++){
        cin>>arr[i];
    }
    build_tree(1,1,n);
    ll ans=0;
    for(int i=1;i+k-1<=n;i++){
        ans=max(ans,get_ans(1,1,n,i,i+k-1));
    }
    cout<<ans<<endl;
    return 0;
}

太长时间未写线段树的习题真的是都快把板子忘掉了

---

扩展欧几里得算法

扩展欧几里得算法是欧几里得算法（又叫辗转相除法）的扩展。除了计算a、b两个整数的最大公约数，此算法还能找到整数x、y（其中一个很可能是负数）。通常谈到最大公因子时, 我们都会提到一个非常基本的事实: 给予二整数 a 与 b, 必存在有整数 x 与 y 使得ax + by = gcd(a,b)。有两个数a,b，对它们进行辗转相除法，可得它们的最大公约数——这是众所周知的。然后，收集辗转相除法中产生的式子，倒回去，可以得到ax+by=gcd(a,b)的整数解。（From：百度百科）

---

D:子段异或

这个是个水题，直接前缀和维护异或值由异或计算特点可知如果a^b=0 可推出a==b 所以计算前缀和的同时不断统计在他之前由多少个和这个相同的前缀和就可以了。

/*************************************************
* @Author: maple
* @Date:   2020-02-13 08:57:13
* @Last Modified by:   maple
* @Last Modified time: 2020-02-13 09:09:23
* @Mark 
*************************************************/
#include <bits/stdc++.h>
#define CSE(x,y) memset(x,y,sizeof(x))
#define lowbit(x) x&(-x)
#define Abs(x) x>=0?x:(-x)
#define FAST ios::sync_with_stdio(false);cin.tie(0);
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int maxn=222222;
int arr[maxn],n;
map<int,int>num;

int main()
{
    FAST;
    #ifndef ONLINE_JUDGE
    freopen("in.in","r",stdin);
    #endif
    cin>>n;
    arr[0]=0;
    num[arr[0]]++;
    for(int i=1;i<=n;i++){
        cin>>arr[i];
        arr[i]=arr[i-1]^arr[i];
    }
    ll ans=0;
    for(int i=1;i<=n;i++){
        ans+=num[arr[i]];
        num[arr[i]]++;
    }
    cout<<ans<<endl;
    return 0;
}

这题感觉有点小问题，题目中给出了子段的左右范围 l<=r 按这个条件，那么每个元素单一算起来也是一个子段，但题解里没有计算它。。。。。。。

E:最小表达式

这个体主要的思想是贪心，对于输入的表达式我们统计数字个数和加号个数，加号个数加一，代表我们需要凑齐的数字个数。对于所有的数字我们进行排序，然后从大的向小的取，每取出一个就放到一个数的最高未填的位上，对于全部加数我们循环顺次放置，直到用完所有数字，这样保证了表达式成立的情况下，使每个加数的值降到了最低，是最优策略。

/*************************************************
* @Author: maple
* @Date:   2020-02-13 09:43:42
* @Last Modified by:   maple
* @Last Modified time: 2020-02-13 10:22:17
* @Mark 
*************************************************/
#include <bits/stdc++.h>
#define CSE(x,y) memset(x,y,sizeof(x))
#define lowbit(x) x&(-x)
#define Abs(x) x>=0?x:(-x)
#define FAST ios::sync_with_stdio(false);cin.tie(0);
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int maxn=511111;
string str;
std::vector<int> box;
int ans[maxn];

int main()
{
    FAST;
    #ifndef ONLINE_JUDGE
    freopen("in.in","r",stdin);
    #endif
    cin>>str;
    int num=0;
    for(auto &k:str){
        if(k>='0'&&k<='9'){
            box.push_back(int(k-'0'));
        }
        else
            num++;
    }
    num++;
    sort(box.begin(), box.end(),greater<int>());
    CSE(ans,0);
    int bs=0,use=0;
    for(auto &k:box){
        if(use==num){
            ans[bs+1]+=ans[bs]/10;
            ans[bs]%=10;
            bs++;
            use=0;
        }
        ans[bs]+=k;
        use++;
    }
    if(use==0)
        bs--;
    for(int i=bs;i>=0;i--)
        cout<<ans[i];//因为数据过大所以用数组处理
    cout<<endl;
    return 0;
}

---

F：树上博弈

这题其实还是一个类似于博弈的问题，对于牛牛和牛妹，二者出发点的距离为D，题目中说牛牛是否存在必胜策略，我们可以看作牛牛一直向牛妹靠近，开始时D为偶数时无论怎么走每当轮到牛牛时二者的距离都是偶数总有一个时间二者距离缩短为2且牛妹处于叶子节点，此时轮到牛牛，牛牛靠近牛妹，牛妹无出可走，牛牛胜，若D为奇数时每次轮到牛牛时距离都为奇数，所以总有一个时刻牛牛和牛妹的距离为1且牛牛在叶子节点处，此时轮到牛牛，牛牛无路可走，无法胜出，所以题目简化成了寻找使牛牛和牛妹初始距离为偶数的出发点，因为路径为一棵树，所以计算每个点到根节点的距离即深度，深度均为偶数的点和均为奇数的点可以组成距离D为偶数的出发情况

/*************************************************
* @Author: maple
* @Date:   2020-02-14 08:43:34
* @Last Modified by:   maple
* @Last Modified time: 2020-02-14 14:32:33
* @Mark 
*************************************************/
#include <bits/stdc++.h>
#define CSE(x,y) memset(x,y,sizeof(x))
#define lowbit(x) (x&(-x))
#define Abs(x) (x>=0?x:(-x))
#define FAST ios::sync_with_stdio(false);cin.tie(0);
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int maxn=1111111;
int n,tree[maxn],even=0,odd=0,dep[maxn];

int get_depth(int ad){//用这种求深度的办法会超时
    if(tree[ad]==-1)
        return 0;
    return get_depth(tree[ad])+1;
}

int main()
{
    FAST;
    #ifndef ONLINE_JUDGE
    freopen("in.in","r",stdin);
    #endif
    CSE(tree,-1);
    CSE(dep,0);
    dep[1]=0;
    even++;
    cin>>n;
    for(int i=2;i<=n;i++){
        cin>>tree[i];
        dep[i]=dep[tree[i]]+1;
        if(dep[i]%2==0)
            even++;
        else
            odd++;
    }
    cout<<1ll*odd*(odd-1)+1ll*even*(even-1)<<endl;
    return 0;
}