省选前的th题

沙茶博主终于整完了知识点并学完了早该在NOIP之前学的知识们

于是终于开始见题了，之前那个奇怪的题单的结果就是这个了

题目按沙茶博主的做题顺序排序

个人感觉(暂时)意义不大的已被自动忽略

---

洛谷 4917 天守阁的地板

套路(?)反演题，看反演总结

洛谷 4233 射命丸文的笔记

这题好的 orz oscar

推式子+多项式求逆

看那个省选前的多项式总结

洛谷 4918 信仰收集

据说是个套路题，wsl

奇怪的拓扑排序

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int N=,K=;
 int n,m,k,f,b,ma,mb,ca,cb,t1,t2,cnt,ans;
 int p[N],noww[N],goal[N],val[N],deg[N],dp[N][K],que[N];
 void Maxi(int &x,int y)
 {
     if(x<y) x=y;
 }
 void Link(int f,int t)
 {
     noww[++cnt]=p[f],p[f]=cnt;
     goal[cnt]=t,deg[t]++;
 }
 int main()
 {
     scanf("%d%d%d",&k,&n,&m);
     scanf("%d%d%d%d",&ma,&mb,&ca,&cb);
     for(int i=;i<=k;i++) scanf("%d%d",&t1,&t2),val[t1]+=t2;
     for(int i=;i<=m;i++) scanf("%d%d",&t1,&t2),Link(t1,t2);
     memset(dp,0xc0,sizeof dp);
     dp[][]=val[],que[f=b=]=;
     for(int i=;i<=n;i++) if(!deg[i]) que[++b]=i;
     while(f<=b)
     {
         int tn=que[f++];
         for(int i=p[tn],g;i;i=noww[i])
         {
             if(!(--deg[g=goal[i]])) que[++b]=g;
             Maxi(dp[g][],dp[tn][ma-]-ca+val[g]);
             Maxi(dp[g][],dp[tn][mb-]-cb+val[g]);
             for(int j=;j<mb;j++) Maxi(dp[g][j],dp[tn][j-]);
         }
     }
     for(int i=;i<=n;i++) Maxi(ans,dp[i][]);
     printf("%d",ans);
     return ;
 }

洛谷 3921 小学数学题

感觉只会2^(2n)+剪枝，咕咕咕

SHOI2016 黑暗前的幻想乡

矩阵树定理+容斥，没啥可说的=。=

 #include<cstdio>
 #include<vector>
 #include<cstring>
 #include<algorithm>
 #define vpii vector<pair<int,int> >
 #define vpit vector<pair<int,int> > ::iterator
 using namespace std;
 const int N=,mod=1e9+;
 int n,m,t1,t2,all,ans,tmp,deg[N],mat[N][N]; vpii ve[N];
 void Add(int &x,int y)
 {
     x+=y;
     if(x>=mod) x-=mod;
 }
 int Bitcount(int x)
 {
     int ret=;
     while(x)
         ret++,x-=x&-x;
     return ret;
 }
 void exGCD(int a,int b,int &x,int &y)
 {
     if(!b) x=,y=;
     else exGCD(b,a%b,y,x),y-=a/b*x;
 }
 int Inv(int x)
 {
     int xx,yy;
     exGCD(x,mod,xx,yy);
     return (xx%mod+mod)%mod;
 }
 void Guass()
 {
     for(int i=;i<n;i++)
         for(int j=;j<n;j++)
             if(i!=j)
             {
                 int tmp=1ll*mat[j][i]*Inv(mat[i][i])%mod;
                 for(int k=i;k<=n;k++)
                     Add(mat[j][k],mod-1ll*tmp*mat[i][k]%mod);
             }
 }
 int main()
 {
     scanf("%d",&n),all=(<<(n-))-;
     for(int i=;i<n;i++)
     {
         scanf("%d",&m);
         for(int j=;j<=m;j++)
         {
             scanf("%d%d",&t1,&t2);
             ve[i].push_back(make_pair(t1,t2));
         }
     }
     for(int i=;i<=all;i++)
     {
         int tmp=;
         memset(deg,,sizeof deg);
         memset(mat,,sizeof mat);
         for(int j=;j<=n;j++)
             if(i&(<<(j-)))
                 for(vpit it=ve[j].begin();it!=ve[j].end();it++)
                 {
                     int x=it->first,y=it->second;
                     Add(mat[x][y],mod-),Add(mat[y][x],mod-),deg[x]++,deg[y]++;
                 }
         for(int j=;j<=n;j++) mat[j][j]+=deg[j]; Guass();
         for(int j=;j<n;j++) tmp=1ll*tmp*mat[j][j]%mod;
         if((n--Bitcount(i))&) Add(ans,mod-tmp); else Add(ans,tmp);
     }
     printf("%d",ans);
     return ;
 }

ZJOI2015 地震后的幻想乡

神题，orz CLJ

Yousiki的博客好啊

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int M=,S=(<<)+;
 int n,m,t1,t2,all,bit[S],edg[S];
 long long C[M][M],unc[S][M],con[S][M];
 void Pre()
 {
     all=(<<n)-;
     for(int i=;i<=m;i++) C[i][]=;
     for(int i=;i<=m;i++)
         for(int j=;j<=i;j++)
             C[i][j]=C[i-][j-]+C[i-][j];
     for(int i=;i<=all;i++) bit[i]=bit[i>>]+(i&);
 }
 int main()
 {
     scanf("%d%d",&n,&m),Pre();
     for(int i=;i<=m;i++)
     {
         scanf("%d%d",&t1,&t2);
         int s=(<<(t1-))|(<<(t2-));
         for(int j=;j<=all;j++)
             if((j&s)==s) edg[j]++;
     }
     for(int i=;i<=all;i++)
         if(bit[i]==) con[i][]=;
         else
         {
             int lbt=i&-i;
             for(int j=i&(i-);j;j=(j-)&i)
                 if(j&lbt)
                     for(int k=;k<=edg[j];k++)
                         for(int h=;h<=edg[i^j];h++)
                             unc[i][k+h]+=con[j][k]*C[edg[i^j]][h];
             for(int j=;j<=edg[i];j++)
                 con[i][j]=C[edg[i]][j]-unc[i][j];
         }
     double ans=;
     for(int i=;i<=m;i++)
         ans+=(1.0*unc[all][i])/(1.0*C[m][i]);
     printf("%.6f",ans/(1.0*(m+)));
     return ;
 }

ZOJ3522 Hide and seek

YJC -> 秒切人

用LCT把两个端点连成的链提出来(边权转为点权处理)，当然我们只需要分别考虑两个点，这里就都按照从下往上走考虑

可以发现如果距离变短了一定是链上一个点下面的都变短了，用LCT维护子树大小(为了维护这个还要要先DFS一遍记录原子树的大小来维护虚儿子的大小)，点权和(也就是边权和)每个点上面的下去/下面的上来的距离和(都维护，因为Turnroot的时候会翻转左右子树)，这样找到这个分界点就能求答案了。找分解点时把它Splay上去在Splay上面二分走就可以了

 #pragma GCC optimize(2)
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lli long long
 using namespace std;
 const int N=;
 int fth[N],son[N][],rev[N],stk[N];
 int p[N],noww[N],goal[N];
 int siz[N],vir[N],val[N];
 lli sum[N],ups[N],dws[N];
 int n,m,t1,t2,t3,cnt,top;

 void Clean()
 {
     memset(p,cnt=,sizeof p);
     memset(ups,,sizeof ups);
     memset(dws,,sizeof dws);
     memset(fth,,sizeof fth);
     memset(son,,sizeof son);
     memset(rev,,sizeof rev);
     memset(sum,,sizeof sum);
     memset(vir,,sizeof vir);
     memset(val,,sizeof val);
     memset(siz,,sizeof siz);
 }

 void Link(int f,int t)
 {
     noww[++cnt]=p[f];
     goal[cnt]=t,p[f]=cnt;
     noww[++cnt]=p[t];
     goal[cnt]=f,p[t]=cnt;
 }
 void DFS(int nde,int far)
 {
     fth[nde]=far;
     for(int i=p[nde];i;i=noww[i])
         if(goal[i]!=far)
         {
             DFS(goal[i],nde);
             siz[nde]+=siz[goal[i]];
         }
     vir[nde]=siz[nde];
 }

 bool Nottop(int nde)
 {
     int fa=fth[nde];
     return son[fa][]==nde||son[fa][]==nde;
 }
 void Release(int nde)
 {
     if(rev[nde])
     {
         int &lson=son[nde][],&rson=son[nde][];
         rev[nde]^=,rev[lson]^=,rev[rson]^=;
         swap(ups[nde],dws[nde]),swap(lson,rson);
     }
 }
 void Pushup(int nde)
 {
     int lson=son[nde][],rson=son[nde][];
     Release(nde),Release(lson),Release(rson);
     sum[nde]=sum[lson]+sum[rson]+val[nde];
     siz[nde]=siz[lson]+siz[rson]+vir[nde];
     ups[nde]=ups[lson]+ups[rson]+(sum[lson]+val[nde])*siz[rson]+sum[lson]*vir[nde];
     dws[nde]=dws[lson]+dws[rson]+(sum[rson]+val[nde])*siz[lson]+sum[rson]*vir[nde];
 }
 void Rotate(int nde)
 {
     int fa=fth[nde],gr=fth[fa],isl=nde==son[fa][];
     if(Nottop(fa)) son[gr][fa==gr[son][]]=nde;
     fth[nde]=gr,fth[fa]=nde,fth[son[nde][isl]]=fa;
     son[fa][isl^]=son[nde][isl],son[nde][isl]=fa;
     Pushup(fa),Pushup(nde);
 }
 void Splay(int nde)
 {
     stk[top=]=nde;
     for(int i=nde;Nottop(i);i=fth[i])
         stk[++top]=fth[i];
     while(top) Release(stk[top--]);
     while(Nottop(nde))
     {
         int fa=fth[nde],gr=fth[fa];
         if(Nottop(fa))
             Rotate(((son[fa][]==nde)==(son[gr][]==fa))?fa:nde);
         Rotate(nde);
     }
     Pushup(nde);
 }
 void Access(int nde)
 {
     int mem=nde,lst=;
     while(nde)
     {
         Splay(nde);
         vir[nde]+=siz[son[nde][]]-siz[lst];
         son[nde][]=lst,Pushup(nde);
         lst=nde,nde=fth[nde];
     }
     Splay(mem);
 }
 void Turnroot(int nde)
 {
     Access(nde),rev[nde]^=;
 }
 void Split(int x,int y)
 {
     Turnroot(x),Access(y);
 }
 int Findb(int x,int v)
 {
     int ret=-,nde=x;
     while(nde)
     {
         Release(nde);
         if((val[nde]+sum[son[nde][]])*<=sum[x]+v)
             v-=(val[nde]+sum[son[nde][]])*,ret=nde,nde=son[nde][];
         else
             nde=son[nde][];
     }
     return ret;
 }
 lli Query(int x,int y,int v)
 {
     if(x!=y)
     {
         Split(x,y);
         if(sum[y]<=v) return ;
         int brd=Findb(y,v);
         if(brd==-) return ; else Splay(brd);
         return (sum[brd]-v)*siz[son[brd][]]-dws[son[brd][]]*;
     }
     else return ;
 }

 int main()
 {
     while(scanf("%d",&n)!=EOF)
     {
         Clean();
         for(int i=;i<n;i++)
         {
             scanf("%d%d%d",&t1,&t2,&t3);
             Link(t1,i+n),Link(i+n,t2);
             val[i+n]=sum[i+n]=t3;
         }
         for(int i=;i<=n;i++) val[i]=,siz[i]=; DFS(,);
         scanf("%d",&m);
         for(int i=;i<=m;i++)
         {
             scanf("%d%d%d",&t1,&t2,&t3);
             printf("%lld\n",Query(t1,t2,t3)+Query(t2,t1,t3));
         }
     }
     return ;
 }

ZOJ3229 Shoot the Bullet

纯粹复习网络流用的，没啥可看的

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 const int N=,M=,inf=1e9;
 int p[N],pp[N],noww[M],goal[M],flow[M];
 int dep[N],que[N],ins[N],ots[N],low[M],anss[M];
 int n,m,s,t,f,b,ss,tt,rd,id,ll,rr,tar,lim,cnt,ans,num;
 void Link(int f,int t,int v)
 {
     noww[++cnt]=p[f],p[f]=cnt;
     goal[cnt]=t,flow[cnt]=v;
     noww[++cnt]=p[t],p[t]=cnt;
     goal[cnt]=f,flow[cnt]=;
 }
 void Init()
 {
     s=n+m+,t=s+,ss=t+,tt=ss+,ans=-inf,num=;
     memset(p,,sizeof p),cnt=;
     memset(ins,,sizeof ins);
     memset(ots,,sizeof ots);
 }
 bool Lay(int st,int ed)
 {
     for(int i=;i<=ed;i++) pp[i]=p[i];
     memset(dep,-,sizeof dep);
     que[f=b=]=st,dep[st]=;
     while(f<=b)
     {
         int tn=que[f++];
         for(int i=pp[tn],g;i;i=noww[i])
             if(flow[i]&&dep[g=goal[i]]==-)
                 dep[g]=dep[tn]+,que[++b]=g;
     }
     return ~dep[ed];
 }
 int Aug(int nd,int ed,int mn)
 {
     if(nd==ed||!mn) return mn;
     int tmp=,tep;
     for(int i=pp[nd],g;i;i=noww[i])
     {
         pp[nd]=i;
         if(dep[g=goal[i]]==dep[nd]+)
             if((tep=Aug(g,ed,min(flow[i],mn))))
             {
                 flow[i]-=tep,mn-=tep;
                 flow[i^]+=tep,tmp+=tep;
                 if(!mn) break;
             }
     }
     return tmp;
 }
 bool Able()
 {
     for(int i=p[ss];i;i=noww[i])
         if(flow[i]) return false;
     return true;
 }
 int main()
 {
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         Init(),Link(t,s,inf);
         for(int i=;i<=m;i++)
         {
             scanf("%d",&rd),Link(i+n,t,inf);
             ots[i+n]+=rd,ins[t]+=rd;
         }
         for(int i=;i<=n;i++)
         {
             scanf("%d%d",&tar,&lim),Link(s,i,lim);
             for(int j=;j<=tar;j++)
             {
                 scanf("%d%d%d",&id,&ll,&rr),id++;
                 Link(i,id+n,rr-ll),low[++num]=ll;
                 ots[i]+=ll,ins[id+n]+=ll,anss[num]=cnt;
             }
         }
         for(int i=;i<=t;i++)
             if(ins[i]-ots[i]<) Link(i,tt,ots[i]-ins[i]);
             else Link(ss,i,ins[i]-ots[i]);
         while(Lay(ss,tt)) Aug(ss,tt,inf);
         if(Able())
         {
             p[ss]=p[tt]=p[t]=;
             while(Lay(s,t)) Aug(s,t,inf);
             for(int i=p[s];i;i=noww[i]) ans+=flow[i^];
             printf("%d\n",ans);
             for(int i=;i<=num;i++)
                 printf("%d\n",low[i]+flow[anss[i]]);
         }
         else puts("-1"); puts("");
     }
     return ;
 }

HNOI2015 接水果

DFS序之后变成二维第k大

YJC搞了一个log^3的算法，先DSU on tree+线段树合并把链从一边整合到另一边，然后变成区间第k大

或者好像可以树套树/整体二分+扫描线

这题太tm僵硬了，要是将来有机会再写吧。。。

(你没机会了

COGS2198 帕秋莉的超级多项式

如果我省选没退役，我一定要写一个多项式全家桶.jpg

(你没机会了++

BZOJ 4166-4168

只有第一个可做，因为第二个是没意义的乱搞题，第三个是真·难题

(现在才发现这位奆奆已经过滤了一遍沙茶题和不可做题了(orz)，结果我这个沙茶又看了一遍)

月宫的符卡序列

因为不会回文树，于是从这题直接学习回文树的哈希建法，是不是科技点歪了啊。。。

学manacher的时候应该说过本质不同的回文串的数目只有$O(n)$级别

于是朴素的想法当然是把每个回文串都算一遍

优化一下就是我们先算最长的，然后算被它包含的(其实这样形成的这个树形结构就是回文树)

用哈希搞一搞，叶子的权值单独算，非叶子节点的值就是所有儿子的异或和

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<tr1/unordered_map>
 #define lli long long
 #define umap unordered_map
 using namespace std;
 using namespace std::tr1;
 const int mod1=1e9+,mod2=;
 const int bas1=,bas2=,N=1e6+;
 char str[N],man[N<<];
 int r[N<<],dp[N],fth[N];
 int pw1[N],pw2[N],hsh1[N],hsh2[N];
 int T,n,tot,len,mar,mid,ans; umap<lli,int> mp;
 void Maxi(int &x,int y){if(x<y) x=y;}
 void Init()
 {
     len=strlen(str+),n=*len+;
     man[]=')',man[n+]='(';
     for(int i=;i<=n;i++)
         man[i]=(i&)?'?':str[i>>];
     for(int i=;i<=len;i++)
     {
         hsh1[i]=(1ll*hsh1[i-]*bas1%mod1+str[i])%mod1;
         hsh2[i]=(1ll*hsh2[i-]*bas2%mod2+str[i])%mod2;
     }
     memset(r,,sizeof r);
     memset(dp,,sizeof dp);
     memset(fth,,sizeof fth);
     tot=mar=mid=ans=,mp.clear();
 }
 lli Ghash(int l,int r)
 {
     int ha1=(hsh1[r]-1ll*hsh1[l-]*pw1[r-l+]%mod1+mod1)%mod1;
     int ha2=(hsh2[r]-1ll*hsh2[l-]*pw2[r-l+]%mod2+mod2)%mod2;
     return ((lli)ha1<<)+ha2;
 }
 int main()
 {
     scanf("%d",&T),pw1[]=pw2[]=;
     for(int i=;i<=;i++)
     {
         pw1[i]=1ll*pw1[i-]*bas1%mod1;
         pw2[i]=1ll*pw2[i-]*bas2%mod2;
     }
     while(T--)
     {
         scanf("%s",str+),Init();
         for(int i=;i<=n;i++)
         {
             r[i]=(mar>=i)?min(mar-i+,r[*mid-i]):;
             int lst=r[i]==?:mp[Ghash((i-r[i])/+,(i+r[i]-)/)];
             while(man[i+r[i]]==man[i-r[i]])
             {
                 r[i]++;
                 lli hsh=Ghash((i-r[i])/+,(i+r[i]-)/);
                 if(!mp.count(hsh))
                 {
                     mp[hsh]=++tot;
                     fth[tot]=lst,lst=tot;
                 }
                 else lst=mp[hsh];
             }
             if(i+r[i]->mar) mar=i+r[i]-,mid=i;
             if(lst) dp[lst]^=i/-;
         }
         for(int i=tot;i;i--)
         {
             Maxi(ans,dp[i]);
             dp[fth[i]]^=dp[i];
         }
         printf("%d\n",ans);
     }
     return ;
 }

BZOJ 2553 禁忌

AC自动机上DP，设$dp[i][j]$表示走了i步在点j的期望伤害，每次在AC自动机上走，走到一个禁忌的结尾就连回根节点和一个虚拟节点，虚拟节点表示可以在这里摸着

矩乘优化一下，然后就卡精度了2333

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define double long double
 using namespace std;
 const int N=;
 int n,alp,len,tot; char rd[N];
 int trie[N][],fail[N],endp[N],que[N],vis[N];
 struct a
 {
     double mat[N][N];
     void Clean()
     {
         memset(mat,,sizeof mat);
     }
 }dp;
 a Matime(a x,a y)
 {
     a ret; ret.Clean();
     for(int i=;i<=tot;i++)
         for(int k=;k<=tot;k++)
             for(int j=;j<=tot;j++)
                 ret.mat[i][j]+=x.mat[i][k]*y.mat[k][j];
     return ret;
 }
 a Maqpow(a x,int k)
 {
     if(k==) return x;
     a tmp=Maqpow(x,k>>);
     tmp=Matime(tmp,tmp);
     if(k&) tmp=Matime(tmp,x);
     return tmp;
 }
 void Insert(char *s)
 {
     int len=strlen(s),nde=;
     for(int i=;i<len;i++)
     {
         int ch=s[i]-'a';
         if(!trie[nde][ch])
             trie[nde][ch]=++tot;
         nde=trie[nde][ch];
     }
     endp[nde]=true;
 }
 void Create()
 {
     int f=,b=-,nde=;
     for(int i=;i<alp;i++)
         if(nde=trie[][i])
             fail[nde]=,que[++b]=nde;
     while(f<=b)
     {
         int tn=que[f++];
         endp[tn]|=endp[fail[tn]];
         for(int i=;i<alp;i++)
             if(nde=trie[tn][i])
                 fail[nde]=trie[fail[tn]][i],que[++b]=nde;
             else
                 trie[tn][i]=trie[fail[tn]][i];
     }
 }
 void Getfunc()
 {
     int f=,b=,nde=;
     double pos=1.0/alp;
     vis[que[]=]=true;
     while(f<=b)
     {
         int tn=que[f++];
         for(int i=;i<alp;i++)
         {
             if(!vis[nde=trie[tn][i]])
                 vis[nde]=true,que[++b]=nde;
             if(!endp[nde]) dp.mat[tn][nde]+=pos;
             else dp.mat[tn][tot]+=pos,dp.mat[tn][]+=pos;
         }
     }
     dp.mat[tot][tot]=;
 }
 int main()
 {
     scanf("%d%d%d",&n,&len,&alp);
     for(int i=;i<=n;i++)
         scanf("%s",rd),Insert(rd);
     Create(),tot++,Getfunc();
     dp=Maqpow(dp,len);
     printf("%.7Lf",dp.mat[][tot]);
     return ;
 }

GG COGS凉了，于是暂时就这样吧

( 大 失 败 )