2020牛客寒假算法基础集训营4

https://ac.nowcoder.com/acm/contest/3005#question

比赛里感觉比前几天难？也许吧。又是经典2小时理论...后面墨迹出一题。

补题发现还是有可做的题没出？

或许是题解写的太好，实际上我想不到嘻嘻。

记录一下补题和思维。

 

B.括号序列  栈模拟即可。

A.欧几里得  斐波那契？我感觉我是找规律做的，就加上去就行了。不过我还是做完了B才想到的A的做法的。

 

C.子段乘积   叫啥尺取来着，经典按K尺取。这里需要注意特判0有在的区间，这里白WA了两发，有点急，发现没特判0有点晚，0的逆元还是0，左右更新的时候都会有影响。

我的做法是，标记0出现的位置，尺取更新的时候只 * 右边的非0，* 左边的非0逆元，同时特判离上个0的位置距离是否满足k。 

 

D.子段异或   刚开始无从下手，以为要止步于此。后来沉思了十几分钟，又看了标签有前缀和，就感觉 区间异或和 的性质实际上有点像区间加减法。就是你一段的异或，和前缀的一段异或如果相同，那么剪掉前缀（实际上是再和前缀做一遍异或，异或自己就是0，就没了），剩下的部分就是异或和为0的一段。

然后分别维护个前缀和，map记录统计一下就过了，

 

E.最小表达式 看了一眼，虽然很裸，但没看清不存在0，是1~9的数字，感觉不太好码，就去看了F，后来发现大家E都过得很快，那我也做E。发现不存在0，无需特判。

贪心分配数字即可，然后我还模拟了string数字的加法，实际上似乎没有必要，不过我写起来倒还挺快的，越来越熟练了哈哈哈。

实际上直接从低位几个数字加起来，维护进位，一次性搞定就可以了。不过我想的是从高位分配的小的数字开始的，思维就固化成了字符串加法。可以注意一下。

 

F.树上博弈  看到这个，感觉又止步于此。树上的题，有一说一做的真的少，看到树就慌。玩了样例开始以为距离为2的点对的数量，目的就是把牛妹赶到叶子上动不了。

还画了第三个样例30个点的图，差不多确认就是树上距离点对，立马找点分治板子改。。。然后改不来，以为止步于此，但我又感觉按层数统计就行了，用不着点分治啊。后来过了题的同学的提示，是距离为偶数的点对的数量。

按层数统计过了。不过T了好多发，由于我的统计复杂度应该过大（每个点向下找能不大伐）。搞了2个小时似乎。

点分治似乎更加实用于树上带边权的图？不带边权按层数直接搞距离就行了。

实际上题解的做法，因为奇数+奇数=偶数，偶数+偶数=偶数，树上距离为偶数的点对，就是层数为奇数的点的数量，和偶数的点的数量内部各自的 排列 A (n,2)即可。

然后树上距离为奇数的点对数量你也会了吧。

由于这题树的边给的方式十分的特别，下次看到应当注意，甚至不需要建边dfs，省了O(n)的一遍dfs统计层数，就可以算出每个点所在的层数。

 

G.音乐鉴赏

概率期望题，感觉自己也挺弱的，每次都是赛中懵逼题，赛后傻逼题。好像有点夸张，反正赛中很少做出来就是了。

这题告诉我们一个道理：大胆设出来，此处@ajj。

有两种做法：

1.二分，实际上更好想，似乎不需要推式子就可以上手码，没往这里想，我有问题，事实上这种正面比较难求，给定答案就能够反向check的题，应该往这里想的。这里check就是算在这个p下，最终的优秀率的期望与目标10%的差异。 而最终的优秀率的期望 ->  就是优秀的人数的期望 / 总人数 -> 优秀人数的期望就是每个人优秀概率的和 -> 

每个人的优秀概率怎么求？ 你优秀所需要的随机分数  y= (90 - score*(1-p))/p，你需要随机分数>=y，那你的优秀概率就是 1 - (   (90 - score*(1-p))/p  ) /90，因为随机分数均匀分布嘛，1- (<=y的分数概率) 就是 >=y 的分数的概率。

然后就结束了。就贴个二分的代码吧。

#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#define debug(x) cout << #x << ": " << x << endl
#else
#define debug(x)
#endif
using namespace std;
typedef long long ll;
const int maxn=2e5+7;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
 
int n,a[maxn];
 
double check(double p)
{
    double sum=0;
    for(int i=0;i<n;++i)
    {
        double need = (90-a[i]*(1-p))/p;
        sum += 1-need/90;
    }
    return sum/n;
}
int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;++i) scanf("%d",&a[i]);
    double l=0,r=1;
    double ans;
    for(int i=0;i<100;++i)
    {
        double m=(l+r)/2;
        if(check(m)>0.1)
        {
            l=m;
            ans=m;
        }
        else r=m;
    }
    printf("%.2f%\n",100*ans);
    return 0;
}

 

2.直接正面推，需要设变量(实际上跟我们做数学题一样，就是需要用形式化的语言去解，而不是空想，比如我~)，我这里码一下 就是 每个人优秀的概率是啥？ 

  一个人优秀的式子(好有喜感)： (score)*(1-p)+y*(p)>=90,  也就是  y >= (90-(score)*(1-p))   （score代表他的平时分，y代表随机到的论文分）

其实跟上面那个式子一样  ，也就是y>=这个式子的概率是啥？  就是这个玩意儿： 1 - (   (90 - score*(1-p))/p  ) /90，就是每个人的优秀率，

最后化简，对每个人求和，就会出来能够O(1)出答案的式子了。

希望自己记住这种概率期望题要敢于设变量，建式子想？

 

H.坐火车

比赛了看了几眼，树状数组啊，啥？要相同颜色的车厢数乘起来？

我只能想到，对每个车厢的每个l,r区间需要分别query然后乘起来，这不是复杂度爆炸嘛。不会做。。。然后就滚去想G了。

实际上如果再深入思考下，发现从一个车厢到下一个车厢，改变的东西十分的有限，就上个的col和当前的col而已。这样的转移变化十分的精简。

树状数组维护每个颜色的组合对数，然后从左到右每个车厢减去当前颜色在左边的总数量，（因为当前这个点颜色的对左边的贡献全没了），然后加上这个当前颜色在右边的总数量（因为当前这个点的颜色对右边的组合的贡献需要加上），同时维护左右区间各种当前颜色的数量即可。

下次见希望会做，主要是这个转移，需要深入想下，每次从上一次来的变化。

#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#define debug(x) cout << #x << ": " << x << endl
#else
#define debug(x)
#endif
using namespace std;
typedef long long ll;
const int maxn=1e6+7;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;

struct BIT
{
    ll sum[maxn];
    void clear(){memset(sum,0,sizeof sum);}
    int lowbit(int x){return x & (-x);}
    void add(int x,int val)
    {
        while (x < maxn)
        {
            sum[x] += val;
            x += lowbit(x);
        }
    }
    ll query(int x)
    {
        if (x <= 0) return 0;
        ll res = 0;
        while (x)
        {
            res += sum[x];
            x -= lowbit(x);
        }
        return res;
    }
    ll query(int l,int r){return query(r) - query(l -1);}
}bit;


int col[maxn],l[maxn],r[maxn];

int rsum[maxn],lsum[maxn];
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin>>n;
    for(int i=1;i<=n;++i)
    {
        cin>>col[i]>>l[i]>>r[i];
        rsum[col[i]]++;
    }
    for(int i=1;i<=n;++i)
    {
        rsum[col[i]]--;
        bit.add(col[i],-lsum[col[i]]);
        cout<<bit.query(l[i],r[i])<<' ';
        lsum[col[i]]++;
        bit.add(col[i],rsum[col[i]]);
    }
    cout<<endl;
    return 0;
}

 

I.匹配星星

比赛里看了，以为这是三维偏序经典题？CDQ分治？？？翻了以前做的，然后发现题目不一样，然后不会做。

实际上完全没注意到范围，z是0~1，然后就变成了贪心傻逼题了。

按其中一维，比如x，sort一下，按x循环的顺序搞，z=0是我们的目标群体，z=1去找配对，显然找比当前y小的最大的一个y最好，因为要把小的y让给别人呀，找到要删除。

于是用类set的multiset维护，因为y可能会重嘛，每次lowerbound二分查一下即可。

这个题解里讲的很清楚，就不赘述（逃~）。

https://ac.nowcoder.com/discuss/365889?type=101&order=0&pos=8&page=3

#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#define debug(x) cout << #x << ": " << x << endl
#else
#define debug(x)
#endif
using namespace std;
typedef long long ll;
const int maxn=2e5+7;
const int inf=0x3f3f3f3f;
const int mod=1e9+7;
 
struct point
{
    int x,y,z;
}p[maxn];
bool cmp(point a,point b)
{
    return a.x<b.x;
}
 
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin>>n;
    for(int i=0;i<n;++i) cin>>p[i].x>>p[i].y>>p[i].z;
    sort(p,p+n,cmp);
    multiset<int>st;
    multiset<int>::iterator it;
    int ans=0;
    for(int i=0;i<n;++i)
    {
        if(p[i].z==1)
        {
            it=st.lower_bound(p[i].y);
            if(it==st.begin()) continue;
            ans++;
            it--;
            st.erase(it);
        }
        else
            st.insert(p[i].y);
    }
    cout<<ans<<endl;
    return 0;
}

 

J.二维跑步

比赛里完全没看，第一次没人ak的场的压轴题？感觉确实挺难的一个计数题。

看题解，前面的都还好，虽然很牛逼，但可以理解。就最后一段，没懂 错位加法是啥，目前还没搞懂。以后也不一定搞懂。。。代码循环内最后一部分不知道在干啥。

他写的取模运算函数感觉还不错噢。

逃~