7.16 NOIP模拟测试4 礼物+通讯+奇袭

T1 礼物

题目大意：n个物品，每次有pi的概率买到，可以重复买，也可以什么都没买到，但算一次购买，问把所有东西都买到的期望次数。对于10%的数据，N = 1;对于30%的数据，N ≤ 5;对于100%的数据，N ≤ 20 ，0 < Wi ≤ 10^9 ，0 < Pi ≤ 1且∑Pi ≤ 1

刚看到这道题，我去，概率与期望，心凉了一半（太菜了。。）放到了最后做。

n很小，所以考虑状压，f[i]表示当前n种物品的状态为i的期望购买次数，0表示买了，1表示没买（我正好跟别人反着QAQ），根据以往期望题的惯例，考虑倒着转移，所以f[i]就是状态为i，到全买到的期望购买次数。f[0]表示全买了，到全买的期望是0，f[1<<n+1)-1]表示都没买，即最终答案。

转移方程就是f[i]=Σ(f[j]+1)*p[k]+(1-Σp[k])*（f[i]+1）   j比i多一个0就是多买到一种，k就是那种物品

意思就是从f[j]转移的期望与这次购买什么都没买到或买到了重的的期望，Σp[k]表示买到新物品的概率，1-Σp[k]就是买旧的或不买，这是状态不会改变，从f[i]转移过来。

两边都有f[i]，高斯消元？假的，移一下项就得到了f[i]=Σf[j]*p[k]/Σp[k].

考试的时候推式子没有考虑买一样的东西，期望题真是弱爆了，而且n==1那个点也没想到要输出1/p[1]  谁知道想啥呢，而且考试时一个题思路不是很清晰而且样例一直过不去，做了1小时以上了，就先把它放一放，努力拿最高分。

#include<iostream>
#include<cstdio>
#define ll long long
using namespace std;
int n,b[(<<)+];
ll w[],ans;
double p[],pp,pi,f[(<<)+];
int lowbit(int x)
{
    return x&(-x);
}
int main()
{
    scanf("%d",&n);
    for(int i=;i<=n;i++){
        scanf("%lf%lld",&p[i],&w[i]);
        if(p[i]>) ans+=w[i];
    }
    printf("%lld\n",ans);
    for(int i=;i<=n;i++){
        b[<<i]=i;
    }
    for(int i=;i<=(<<n+)-;i++){
        double h=;
        for(int j=i;j;j-=lowbit(j)){
            int tmp=lowbit(j);
            f[i]+=f[i-tmp]*p[b[tmp]];
            h+=p[b[tmp]];
        }
        if(h) f[i]=(f[i]+)/h;
    }
    printf("%.3lf\n",f[(<<n+)-]);
    return ;
}

礼物

T2 通讯

题意：以0为起点的一张带权有向图，保证联通，有环的话环里的边权可以忽略，有重边，求从0开始遍历整张图的最小代价。

题解：有环而且可以忽略，tarjan缩点再建新图就可以，然后贪心的从每个点的入边里选一条最小的连上。（其实就考了一个tarjan的模板）

考试的时候一直在想最小生成树，但是最小生成树只适用于无向图，无向图并不适用，反例很好举。结果wa10，直接导致这次考试崩掉，以后一定要注意每种算法的适用条件。

真的很水，考完试5分钟A掉。。。。。。。。考试的时候为什么打不出来呢。。。（想扇自己）

#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;
struct node
{
    int x,to,nxt,w;
}h[];
struct h
{
    int x,to,nxt,w;
}t[];
int n,m,rt,mm,top,cnt,num,dfn[],low[],s[],whos[],tot,nxt[],fa[],tet,nx[],ans[],in[];
bool is[];
ll as;
int read()
{
    int aa=,bb=;char cc=getchar();
    while(cc>''||cc<''){if(cc=='-') bb=-;cc=getchar();}
    while(cc<=''&&cc>=''){aa=aa*+cc-'';cc=getchar();}
    return aa*bb;
}
void init()
{
    top=as=cnt=num=tot=tet=;
    memset(nxt,,sizeof(nxt));
    memset(nx,,sizeof(nx));
    memset(ans,0x5f,sizeof(ans));
    for(int i=;i<=n;i++){
        dfn[i]=;low[i]=;is[i]=;in[i]=;
    }
}
int min(int x,int y)
{
    return x<y?x:y;
}
void add(int x,int y,int w)
{
    h[++tot].to=y;
    h[tot].w=w;
    h[tot].nxt=nxt[x];
    nxt[x]=tot;
    h[tot].x=x;
}
void insert(int x,int y,int w)
{
    t[++tet].to=y;
    t[tet].w=w;
    t[tet].nxt=nx[x];
    nx[x]=tet;
    t[tet].x=x;
}
void tarjan(int x)
{
    dfn[x]=low[x]=++cnt;
    s[++top]=x;is[x]=;
    for(int i=nx[x];i;i=t[i].nxt){
        int y=t[i].to;
        if(!dfn[y]){
            tarjan(y);
            low[x]=min(low[x],low[y]);
        }
        else if(is[y]) low[x]=min(low[x],dfn[y]);
    }
    if(low[x]==dfn[x]){
        num++;
        while(){
            int tmp=s[top--];
            is[tmp]=;
            whos[tmp]=num;
            if(tmp==x) break;
        }
    }
}
bool cmp(node a,node b)
{
    return a.w<b.w;
}
void dfs(int x)
{
    for(int i=nxt[x];i;i=h[i].nxt){
        int y=h[i].to;//cout<<h[i].w<<endl;
        ans[y]=min(ans[y],h[i].w);
        dfs(y);
    }
}
int main()
{
    while(){
        n=read();m=read();
        init();
        if(n==&&m==) break;
        int u,v,w;
        for(int i=;i<=m;i++){
            u=read();v=read();w=read();
            u++,v++;
            insert(u,v,w);
        }
        for(int i=;i<=n;i++){
            if(!dfn[i]) tarjan(i);
        }
        for(int i=;i<=n;i++){
            for(int j=nx[i];j;j=t[j].nxt){
                int y=t[j].to;
                if(whos[y]!=whos[i]){
                    add(whos[i],whos[y],t[j].w);
                    in[whos[y]]++;
                }
            }
        }
        for(int i=;i<=num;i++){
            if(!in[i]){
                rt=i;
                break;
            }
        }
        dfs(rt);ans[rt]=;
        for(int i=;i<=num;i++){
            as+=ans[i];
        }
        printf("%lld\n",as);
    }
    return ;
}

通讯

T3 奇袭

题意：n*n的一张图，每行每列保证有且仅有一个军队，如果有一个k×k的区域里面恰有k个军队，危险程度就+1，求这张图的危险程度。对于30%的数据，N ≤ 100;对于60%的数据，N ≤ 5000;对于100%的数据，N ≤ 50000

题解：因为每行每列保证有且仅有一个军队，所以可以把整张图“拍扁”，a[x][y]=1-->a[x]=y；n方的复杂度这题抗不住，听说减减枝可以卡到91，之后就卡不动了。。

正解是分治或线段树，我打的是分治。

对于一个区间，可以对答案做贡献的条件就是序列是连续的（但顺序可以是乱的），即max-min=k-1。这个区间对答案的贡献可以分为3部分，mid左边，mid右边，横跨mid。mid左右的直接分治就行，关键就在与横跨mid的那部分。

横跨mid又可以分为4中情况max min都在mid左，max min都在mid右，min在mid左max在mid右，max在mid左min在mid右。发现1 2，3 4是对称的，所以只说一种。

max min都在mid左：lmax[l]-lmin[l]+1=r-l+1 发现枚举左端点就可以得到右端点，判断一下右端点是否合法就可以了;

min在mid左max在mid右：rmax[R]-lmin[L]=R-L 移项得rmax[R]-R=lmin[L]-L 用桶存符合情况rmax[R]-R，用左边拿出来就行;判是否符合情况的思想有点类似与单调队列的思想，rmax等数组存的是前缀max或min，具有单调性。注意判R的时候只能用min卡，因为如果rmax[R]>lmax[L],那么a[R]<lmax[l]这种情况在rmax中没有体现，但他却是不合法的;用rmin[R]>lmin[l]的话,一旦a[R]<lmin[l],rmin[R]中也会体现，可以卡住。L同理。

枚举左端点，越往右走lmin越大，lmax越小，就要求R的rmin增大已使继续满足lmin<rmin 所以让R左移同时排除不符合的情况，而对L的rmax的限制就有所放宽，可以稍小一些，所以L也左移，同时把符合的放进去。最后用ans+=t[lmin[L]-L]。值得注意的是，桶里的个数可能是负的，即没有符合的情况，所以加ans的时候需要判一下是否>0。而负的对以后更新没有任何影响，不用管他就行了。

桶的下标可能会出负数，统一+n就可以避免这种情况了。

清空桶的时候不要用memset，因为太慢了，还是手清吧。。

再一个卡我的地方就是进出桶的时候判断下一个是否合法，所以范围应该是开区间，最多到倒数第二个，不然倒数第一个怎么判

奇袭