51nod 省选联测 R2

51nod 省选联测 R2

　　上场的题我到现在一道都没A，等哪天改完了再写题解吧，现在直接写第二场的。

　　第二场比第一场简单很多（然而这并不妨碍我不会做）。

　　

　　A.抽卡大赛：http://www.51nod.com/Challenge/Problem.html#!#problemId=1850

　　这题非常的神仙。

　　考试的时候没看见数据范围...以为是1e5，觉得非常不可做。结果其实是200？

　　$N^4$ 的做法挺好想的，首先枚举一个人，再枚举他的牌，然后计算其他人胜过他的概率，最后做一个 $N^2$ 的DP算答案，这里就不细讲了。

　　让我们换一下思路，不要再枚举人了，将所有的牌按从大到小排序后直接枚举牌。

　　下面这部分有一点难理解...在之前的做法中，要计算“i排第j名的概率”，在这里，因为不能枚举人，所以计算的就是“如果出现了一个拿着i这种牌的人，排第j名的概率”。乍一看，这个东西意义何在...但其实还是挺有用的。假设我们可以以 $O(N)$ 的效率从背包中撤出某个物品，那么当计算 $i$ 这个人时就撤掉它自己，算完后再加进去就可以了。因为每次加入一张新牌时，只有一个人“胜过更小的牌的概率”改变了，所以这样做的复杂度是 $N^3$ 的。

　　最后考虑如何删除背包里的物品：

　　最初的状态转移：

　　倒序枚举j，可以消掉一维：

　　考虑一下边界情况：

　　也就是说，如果要撤掉一个数，可以直接算出原来的 $f_1$ ，由此就可以进一步推出所有 $f$ 的原值，实现了删除物品。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <algorithm>
# define R register int

using namespace std;

const int maxn=202;
const int mod=1000000007;
int n,inv_100;
int m,f[maxn],h[maxn],p[maxn],v[maxn],cnt,ans[maxn],b[maxn];
struct card { int a,g,p,id; }k[maxn*maxn];

int qui (int a,int b)
{
    int s=1;
    while(b)
    {
        if(b&1) s=1LL*s*a%mod;
        a=1LL*a*a%mod;
        b>>=1;
    }
    return s;
}

bool cmp (card a,card b) { return a.a>b.a; }

void ins (int p) { for (R i=n;i>=1;--i) f[i]=(1LL*f[i-1]*p+1LL*f[i]*(mod+1-p))%mod; }

void del (int p)
{
    int inv=qui(mod+1-p,mod-2);
    for (R i=1;i<=n;++i)
    {
        f[i]=1LL*f[i]*inv%mod;
        f[i+1]=(f[i+1]-1LL*p*f[i]%mod+mod)%mod;
    }
}

int read()
{
    int x=0;
    char c=getchar();
    while (!isdigit(c)) c=getchar();
    while (isdigit(c)) x=(x<<3)+(x<<1)+(c^48),c=getchar();
    return x;    
}

int main()
{
    n=read();
    inv_100=qui(100,mod-2);
    for (R i=1;i<=n;++i)
    {
        m=read();
        for (R j=1;j<=m;++j)
        {
            k[++cnt].id=i;
            k[cnt].a=read(),k[cnt].g=read(),k[cnt].p=read();
            p[i]=(p[i]+k[cnt].p)%mod;
            k[cnt].g=1LL*(100-k[cnt].g)*inv_100%mod;
        }
        p[i]=qui(p[i],mod-2);
    }
    for (R i=1;i<=cnt;++i) k[i].p=1LL*k[i].p*p[ k[i].id ]%mod;
    for (R i=1;i<=n;++i) v[i]=read();
    sort(k+1,k+1+cnt,cmp);
    f[1]=1;
    for (R i=1;i<=n;++i)
        ins(0);
    for (R i=1;i<=cnt;++i)
    {
        int x=k[i].id;
        del(b[x]);
        for (R j=1;j<=n;++j)
            ans[x]=(ans[x]+1LL*k[i].p*k[i].g%mod*f[j]%mod*v[j])%mod;
        b[x]=(b[x]+k[i].p)%mod;
        ins(b[x]);
    }
    for (R i=1;i<=n;++i) printf("%d
",ans[i]);
    return 0;
}

　　B.异或约数和：http://www.51nod.com/Challenge/Problem.html#!#problemId=1984

　　这题比较简单。

　　首先看看每个数会被算多少次，显然是 $frac{n}{i}$ 次，如果这个数是个奇数，它就会出现在最终答案中，否则就不用管它了。

　　这种分式形式显然上来先套一个除法分块。考虑如何快速计算 $1$ 到 $n$ 的异或和。可以发现 1^2^3=0,(4n)^(4n+1)^(4n+2)^(4n+3)=0，所以就根据 $n \% 4$ 分类讨论即可。

　　

# include <cstdio>
# include <iostream>
# include <cstring>
# include <string>
# include <cmath>
# include <algorithm>
# define ll long long
# define R register int

using namespace std;

ll n,ans; 

inline ll ask (ll l)
{
    if(l%4==0) return l;
    if(l%4==1) return 1;
    if(l%4==2) return l+1;
    return 0; 
}

int main()
{
    scanf("%lld",&n);
    ll l=1,r;
    while(l<=n)
    {
        r=n/(n/l);
        if((n/l)%2) ans^=ask(r)^ask(l-1);
        l=r+1;
    }
    printf("%lld",ans);
    return 0;
}

　　C.小朋友的笑话：http://www.51nod.com/Challenge/Problem.html#!#problemId=2014

　　每个人的状态可以认为只与最后听的那个笑话有关。

　　这里有一个极其神奇（也有可能只是我没见过）的做法：将每个笑话的出现过的区间...维护出来！因为一开始只想到用权值线段树维护区间，但是觉得复杂度不对就弃疗了，其实换成平衡树复杂度就对了。为什么呢？觉得复杂度不对的主要原因就是觉得一种笑话的区间可能很多，如果多次全部访问就会很慢，但其实这个问题是不存在的。如果两个区间出现了重叠，那么我们就把它们删掉，合成一个新的区间再加进去。每次最多加入一个区间，却可能删掉多个，且每个区间被加入后最多被访问一次就被删了，所以复杂度极其科学。

　　因为Set用的很不熟练，代码几乎是照搬这份题解，就不贴了。

---shzr