寒武纪camp Day1

补题进度：8/10

A(组合计数)

题意：

　　一个人站在数轴原点，每秒有1/4概率向前走一步，1/4概率向后走一步，1/2概率不动，问t秒后在p位置的概率。

　　t,p<=100000

分析：

　　枚举不动的个数，于是向前走的个数和向后走的个数都确定了，然后就可组合计数了。

B(平面图k小割)

题意：

　　给出一个n个点的树，1是根节点，每个点有点权，输出前k小的包含1节点的连通块的权值。

　　n<=10^5,k<=10^5,点权<=10^9

分析：

　　连通块不好处理，一个连通块实际上对于一个割集，我们可以这样转化：

　　把1当作源点，建一个汇点，把每个叶子向汇点连边，然后树上每条边的边权表示其子树里的点权和，那么这样一个割就对应了包含S点的一个连通块的点权和，所以问题就变成了求该图的k大割

　　求k大割是没法求的，但注意到该问题是平面图，所以可以建出对偶图跑k短路。

　　对于k短路，可以用可持久化堆来实现。

 /*
 可持久化堆优化k短路
 求最短路径树：O(nlogn)
 求k短路：O(mlogm+klogk)
 空间复杂度：O(mlogm)，但具体开数组要注意常数，要看执行merge操作的次数
 */
 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=,maxm=,maxsize=;//maxsize是堆的最大个数
 const long long inf=1000000000000000LL;
 int a[maxn+];
 long long s[maxn+];
 int n,k,m,len,tot;
 int S,T;
 vector<int> g1[maxn+];
 int mi[maxn+],mx[maxn+];
 int head[maxn+],nx[maxm+];
 long long dis[maxn+];
 int pos[maxn+],rt[maxn+];
 struct Edge
 {
     int to;
     long long w;
 }e[maxm+];
 struct node
 {
     /*
     u是当前堆顶的节点编号
     key是当前堆顶对应边的权值,边的权值定义为：走这条边要多绕多少路
     l,r分别是堆左右儿子的地址
     */
     int u;
     long long key;
     int l,r;
 }H[maxsize+];
 struct heapnode
 {
     /*
     求k短路时候用到的数据结构
     len表示1~倒数第二条边的边权和
     root表示倒数第二条边的tail的H[tail]，其中堆顶就是最后一条边
     */
     long long len;
     int root;
     bool operator < (const heapnode& x) const
     {
         return len+H[root].key>x.len+H[x.root].key;
     }
 };
 priority_queue<heapnode> q;
 void addedge(int u,int v,long long w)
 {

     //printf("%d %d %lld\n",u,v,w);
     e[++len]={v,w};
     nx[len]=head[u];
     head[u]=len;
 }
 void dfs(int k,int fa)
 {
     s[k]=a[k];
     bool flag=;
     mi[k]=n+;
     mx[k]=;
     for(int i=;i<g1[k].size();++i)
         if(g1[k][i]!=fa)
         {
             flag=;
             dfs(g1[k][i],k);
             s[k]+=s[g1[k][i]];
             mi[k]=min(mi[k],mi[g1[k][i]]);
             mx[k]=max(mx[k],mx[g1[k][i]]);
         }
     if(!flag) mi[k]=mx[k]=++m;
 }
 int newnode(int u,long long key)
 {
     ++tot;
     H[tot]={u,key,,};
     return tot;
 }
 int merge(int u,int v)
 {
     /*
     merge两个堆u和v
     这里是采用随机堆，方便合并，方便持久化
     */
     if(!u) return v;
     if(!v) return u;
     if(H[v].key<H[u].key) swap(u,v);
     int k=++tot;
     H[k]=H[u];
     if(rand()%) H[k].l=merge(H[k].l,v);
     else H[k].r=merge(H[k].r,v);
     return k;
 }
 void Kshort()
 {
     /*
     求k短路
     */
     dis[T]=;
     for(int i=;i<T;++i) dis[i]=inf;
     tot=;
     for(int i=m-;i>=;--i)
     {
         /*
         DAG图求最短路径树
         */
         int fa=;
         for(int j=head[i];j!=-;j=nx[j])
             if(dis[i]>e[j].w+dis[e[j].to])
             {
                 dis[i]=e[j].w+dis[e[j].to];
                 pos[i]=j;
                 fa=e[j].to;
             }
         rt[i]=rt[fa];
         for(int j=head[i];j!=-;j=nx[j])
             if(j!=pos[i])
             {
                 //printf("ce : %d %d\n",i,e[j].to);
                 rt[i]=merge(rt[i],newnode(e[j].to,e[j].w+dis[e[j].to]-dis[i]));
             }
     }
     //printf("tot : %d\n",tot);
     //printf("len : %d\n",len);
     //printf("m : %d\n",m);
     //for(int i=0;i<=T;++i) printf("%d : %lld %d\n",i,dis[i],pos[i]);
     printf("%lld\n",dis[S]+s[]);
     heapnode now={0LL,rt[S]};
     if(now.root) q.push(now);
     while(--k&&!q.empty())
     {
         /*
         每次从优先队列队首取出最小的边集
         每个边集对对应一种合法的k短路走法
         有两种扩展方法
         第一种：将最后一条边换成所在堆的次小元素（相当于从堆里把堆顶删除）
         第二种：新加一条边，即从最后一条边继续往后走
         */
         now=q.top();
         q.pop();
         printf("%lld\n",now.len+H[now.root].key+dis[S]+s[]);
         int id=merge(H[now.root].l,H[now.root].r);
         //printf("%d : %d %lld\n",id,H[id].u,H[id].key);
         if(id)
             q.push({now.len,id});
         now.len+=H[now.root].key;
         if(rt[H[now.root].u])
             q.push({now.len,rt[H[now.root].u]});
     }
 }
 int main()
 {
     srand(time());
     scanf("%d%d",&n,&k);
     for(int i=;i<=n;++i) scanf("%d",&a[i]);
     for(int i=;i<n;++i)
     {
         int u,v;
         scanf("%d%d",&u,&v);
         g1[u].push_back(v);
         g1[v].push_back(u);
     }
     dfs(,);
     for(int i=;i<=n+;++i) head[i]=-;
     for(int i=;i<=n;++i) addedge(mi[i]-,mx[i],-s[i]);
     for(int i=;i<m;++i) addedge(i,i+,);
     S=,T=m;
     Kshort();
     return ;
 }

C(随机算法)

题意：

　　给出一个n个点的树，每个点有自己的颜色，选出一个包含点数最少的连通块，使得其中有k种不同的颜色。

　　n<=10000,k<=5,每个点颜色<=n

分析：

　　如果每个点的颜色是1~5，那就很好办了，我们只需要做树形dp就可以了，dp[i][j]表示以i为根的子树，颜色包含情况为j的最少点数

　　那么这个dp就是n*4^5的

　　但现在颜色数量有很多，无法表示状态

　　考虑随机算法，我们将1~n颜色随机映射到1~k，我们来分析下正确的概率：

　　分母很明显是$k^n$

　　成功当且仅当作为答案的那一组颜色被染成了k种不同的颜色，所以分子就是$k!*k^{n-k}$

　　所以成功的概率是$\frac{k^n}{k!*k^{n-k}} = 0.2$

　　于是随个30次就行了

D(递推)

题意：

　　k-left tree指的是一类树，需要满足两个性质：

　　　　1、从根向每个叶子走的过程中经过的左孩子的个数<k

　　　　2、除叶子节点外的其它节点都有2个孩子

　　求n个叶子节点的k-left tree有多少种

　　n,k<=5000

分析：

　　一个k-left tree的左子树一定是k-1 left tree 右子树一定是k left tree树，只需要枚举左右两边分配的叶子节点个数就行了，O(n^3)的算法是显然的。

　　我们通过O(n^3)的算法算出了所有的ans[1..n][1..k]，已经不能再优化了，但该题只需要求固定k下的ans[1..n]，所以我们只能换思路用O(n^2)的去解决。

　　考虑已经知道了k限制下，有n个节点的所有树，如何更新到n+1的答案

　　我们发现该树有n个叶子说明有n-1个非叶子，我们只需要去考虑这些非叶子的形状就行了

　　从n更新到n+1实际上给n对应的树里面添加一个树枝，但为了不重复计数，我们人为规定该树枝只能添加到先序遍历最后的位置（如果在中间添加，可以看成删去最后的那个树枝，保留目前这个树枝，将这个树作为n的答案）

　　于是dp[i][j]表示i个树枝，从根到最后一个树枝经过了j个左儿子的树的总数，那么显然对于i+1，我们可以在这j个左儿子那添加一条向右的树枝，所以可以转移到dp[i+1][j+1],dp[i+1][j],....,dp[i+1][1]，前缀和优化即可。

 #include<bits/stdc++.h>
 using namespace std;
 const int N=,Mod=1e9+;
 int k,n,f[N][N];
 void inc(int &x,long long y)
 {
     x=(x+y+Mod)%Mod;
 }
 int main()
 {

     cin>>k>>n;
     /*for(int i=2;i<=k;++i) f[1][i]=1;
     for(int j=3;j<=k;++j)
         for(int i=1;i<=n;++i)
             for(int l=1;l<i;++l)
                 inc(f[i][j],1LL*f[l][j-1]*f[i-l][j]%Mod);*/
     /*for(int j=1;j<=k;++j)
         for(int i=1;i<=n;++i)
             printf("%d %d : %d\n",i,j,f[i][j]);*/
     k-=;
     f[][]=;
     f[][]=;
     for(int i=;i<n;++i)
     {
         for(int j=;j<=k;++j)
             inc(f[i+][min(j+,k)],f[i][j]);
         for(int j=k-;j>=;--j) inc(f[i+][j],f[i+][j+]);
     }
     for(int i=;i<=n;i++)
     {
         int ans=;
         for(int j=;j<=k;++j) inc(ans,f[i][j]);
         printf("%d\n",ans);
     }
     return ;
 }

E(找规律)

略

F(Fibonacci树递推)

题意：

　　问深度为n的fibonacci树的白点距离情况，即相距1,2,...,,2*n的白点对分别有多少对。

　　n<=5000

　　fibonacci树指的是根是白点，一个白点下面一个黑点，一个黑点下面一个白点和一个黑点形成的树。

分析：

　　fibonacci树有这样的性质：每个深度的点的个数、每个深度的黑点个数、每个深度的白点个数分别都是fibonacci数列

　　dp[i][0/1]表示深度为i的fibonacci树，根节点是白/黑点情况下的白色点对相距情况（保存的是1~2*i的数组）

　　很明显dp[i][0]=dp[i-1][1],dp[i][1]=dp[i-1][0]+dp[i-1][1]+两个子树之间贡献的答案

　　两个子树之间的贡献的答案就是两个fibonacci的卷积，所以这样是O(n^3)

　　如果卷积用FFT，那么是O(n^2logn)也是不能通过的

　　实际上两个fibonacci的卷积可以这样做：

　　我们枚举a的下标j，然后将a[j]*b[1,2,...,i-1]放到对应的ans[j+1,j+2,...,j+i-1]位置上，问题就变成了给区间加上一个fibonacci数列，最终求区间的每一个位置的数字

　　这我们可以用类似差分的做法来O(1)修改，O(n)询问

　　所以时间复杂度就是降到O(n^2)，但是常数有点大，大概是std的1.5倍，在某oj上不能通过。

G(可持久化线段树优化建边)

题意：

　　有n个人，每个人三个属性a,b,c，若一个人的某两项属性大于另外一个人的对应两项属性，那么这个人可以击败另一个人。问有多少个人可以击败其它所有人。

　　n<=100000

分析：

　　如果n比较小，那么就暴力建图然后缩点就行了。

　　这里需要用数据结构优化建边。

　　对于三个属性，我们每次提取两维考虑，假设这两维是x,y

　　按照x从小到大排序，然后从左往右扫，假设现在来到了第i个人，那么连边就是“向1~i-1个人中y属性小于自己的人建边”

　　如果只有“向y属性小于自己的人建边”，那么建一个权值线段树，把每个线段树节点作为辅助节点就行了

　　现在有了“向1~i-1个人中”这个限制，那也很简单，我们建可持久化线段树就行了

　　建可持久化线段树唯一注意的是，新点u向旧点u也要连一条边

　　这样边数就从O(n^2)下降到了O(nlogn)，点数从O(n)上升到了O(nlogn)

　　然后缩点，问题变成了有一个DAG图，有一些关键节点(1~n)，我们想知道这关键节点当中有哪些点可以到达其它关键节点

　　我们只需要对这个DAG图把所有非关键节点都拓扑掉，剩下关键节点就被剥出来了，若关键节点是唯一入度为0的节点，那么该关键节点对应强连通分量里面的所有原来的节点答案就是1，其它答案是0。

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn=,maxsize=**,maxm=*maxsize;
 int a[maxn+],b[maxn+],c[maxn+],id[maxn+];
 int rt[maxn+];
 int n,tot,num,sz,len;
 int head[maxsize+],head1[maxsize+];
 int nx[maxm+],e[maxm+];
 int t[maxsize+],color[maxsize+];
 bool v[maxsize+];
 int ans[maxsize+],d[maxsize+];
 struct tree
 {
     int lc,rc;
 }T[maxsize+];
 void addedge(int u,int v)
 {
     if(!u||!v) return;
     //printf("%d %d\n",u,v);
     ++len;
     e[len]=v;
     nx[len]=head[u];
     head[u]=len;
     ++len;
     e[len]=u;
     nx[len]=head1[v];
     head1[v]=len;
 }
 void adde(int u,int v)
 {
     ++len;
     e[len]=v;
     nx[len]=head1[u];
     head1[u]=len;
 }
 int build(int last,int l,int r,int x,int id)
 {
     int k=++tot;
     T[k]=T[last];
     addedge(k,last);
     if(l==r)
     {
         addedge(k,id);
         return k;
     }
     int mid=(l+r)>>;
     if(x<=mid) T[k].lc=build(T[last].lc,l,mid,x,id),addedge(k,T[k].lc);
     else T[k].rc=build(T[last].rc,mid+,r,x,id),addedge(k,T[k].rc);
     return k;
 }
 void add(int k,int l,int r,int x,int id)
 {
     if(!k) return;
     if(l==r)
     {
         addedge(id,k);
         return;
     }
     int mid=(l+r)>>;
     if(x<=mid) add(T[k].lc,l,mid,x,id);
     else addedge(id,T[k].lc),add(T[k].rc,mid+,r,x,id);
 }
 void work(int *x,int *y)
 {
     for(int i=;i<=n;++i) id[x[i]]=i;
     for(int i=;i<=n;++i)
     {
         rt[i]=build(rt[i-],,n,y[id[i]],id[i]);
         add(rt[i],,n,y[id[i]],id[i]);
     }
 }
 void dfs(int k)
 {
     v[k]=;
     for(int i=head[k];i!=-;i=nx[i])
         if(!v[e[i]]) dfs(e[i]);
     ++sz;
     t[sz]=k;
 }
 void dfs1(int k)
 {
     v[k]=;
     color[k]=num;
     for(int i=head1[k];i!=-;i=nx[i])
         if(!v[e[i]]) dfs1(e[i]);
 }
 queue<int> q;
 int main()
 {
     int size =  << ; // 256MB
     char *p = (char*)malloc(size) + size;
     __asm__("movl %0, %%esp\n" :: "r"(p));
     scanf("%d",&n);
     for(int i=;i<=n;++i) scanf("%d%d%d",&a[i],&b[i],&c[i]);
     for(int i=;i<=maxsize;++i) head[i]=head1[i]=-;
     tot=n;
     work(a,b);
     //printf("%d %d\n",tot,len);
     work(a,c);
     //printf("%d %d\n",tot,len);
     work(b,c);
     //printf("%d %d\n",tot,len);
     for(int i=;i<=tot;++i) if(!v[i]) dfs(i);
     memset(v,,sizeof(v));
     for(int i=sz;i>=;--i) if(!v[t[i]]) ++num,dfs1(t[i]);
     memset(v,,sizeof(v));
     for(int i=;i<=n;++i)
         v[color[i]]=;
     for(int i=;i<=num;++i) head1[i]=-;
     for(int i=;i<=tot;++i)
         for(int j=head[i];j!=-;j=nx[j])
         {
             int u=color[i],vv=color[e[j]];
             if(u==vv) continue;
             ++d[vv];
             adde(u,vv);
                 //printf("ok : %d\n",color[vv]);
         }
     for(int i=;i<=num;++i)
         if(!d[i]&&!v[i]) q.push(i);
     while(!q.empty())
     {
         int u=q.front();
         q.pop();
         for(int i=head1[u];i!=-;i=nx[i])
         {
             int to=e[i];
             --d[to];
             if(d[to]==&&!v[to]) q.push(to);
         }
     }
     //printf("num : %d\n",num);
     //for(int i=1;i<=n;++i) printf("%d : %d\n",i,color[i]);
     int sum=;
     int winner=;
     for(int i=;i<=num;++i)
         if(v[i]&&d[i]==) ++sum,winner=i;
     if(sum==)
         for(int i=;i<=n;++i)
             if(color[i]==winner) ans[i]=;
     for(int i=;i<=n;++i) printf("%d\n",ans[i]);
     //cout<<clock();
     return ;
 }

H(贪心+set)

题意：

　　你有n个商品，Alice买第i件商品花ai元，Bob买第i件商品花bi元，一个商品只有一个，显然一个商品不能被两人同时买，Alice可以最多买A个，Bob可以最多买B个，问他们该如何买，你才能获得最大的收益。

　　A+B<=n<=10^5

　　ai,bi可正可负

分析：

　　我们先把所有负权值修改为0，那么“最多买”就变成了“恰好买”

　　我们按照ai从大到小排个序，首先Alice买前A个，Bob买后n-A个中bi最大的B个

　　然后我们去枚举Alice买的最后一个商品i，那么1~i每个商品都被Alice或者Bob买了，不会有商品没有被买（假如这样，那么Alice去买那个没人买的一定比买现在的第i个要来的划算）

　　很显然这样的答案就是1~i里面a[i]的和加上i-A个最大的b[i]-a[i]的和（即i个商品里面Alice买A个，Bob买i-A个，Bob买的这i-A个一定是b[i]-a[i]最大的i-A个），然后Bob还可以买B-(i-A)个，就是从i+1~n里面挑b[i]最大的B-(i-A)个买，这个显然可以用两个平衡树去维护

　　但当然因为个数恰好是递增、递减的，所以我们也可以在i递增的过程中用两个set来维护

　　时间复杂度O(nlogn)

I(推导+容斥计算)

待填坑

K(推导+杜教筛)

待填坑