JSOI2018R2题解

D1T1:潜入行动

裸的树上DP。f[i][j][0/1][0/1]表示以i为根的子树放j个设备，根有没有放，根有没有被子树监听，的方案数。转移显然。

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 typedef long long ll;
 using namespace std;

 const int N=,mod=1e9+;
 ll tmp[][][];
 int n,k,cnt,u,v,sz[N],dp[N][][][],h[N],to[N<<],nxt[N<<];

 void ins(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }
 void add(int &x,ll y){ if (x+y>=mod) x=x+y-mod; else x=x+y; }

 void dfs(int x,int fa){
     sz[x]=; dp[x][][][]=; dp[x][][][]=;
     for (int i=h[x]; i; i=nxt[i]){
         int v=to[i];
         if (v==fa) continue;
         dfs(v,x);
         int tx=min(k,sz[x]),tv=min(k,sz[v]);
         rep(j,,tx) rep(a,,) rep(b,,)
             tmp[j][a][b]=dp[x][j][a][b],dp[x][j][a][b]=;
         rep(j,,tx){
             for(int a=; a<=tv && j+a<=k; a++){
                 add(dp[x][j+a][][],tmp[j][][]*dp[v][a][][]%mod);
                 add(dp[x][j+a][][],(tmp[j][][]*dp[v][a][][]+tmp[j][][]*(dp[v][a][][]+dp[v][a][][]))%mod);
                 add(dp[x][j+a][][],tmp[j][][]*(dp[v][a][][]+dp[v][a][][])%mod);
                 add(dp[x][j+a][][],(tmp[j][][]*(dp[v][a][][]+dp[v][a][][])+tmp[j][][]*(dp[v][a][][]+dp[v][a][][])+tmp[j][][]*(dp[v][a][][]+dp[v][a][][]))%mod);
             }
         }
         sz[x]+=sz[v];
     }
 }

 int main(){
     freopen("action.in","r",stdin);
     freopen("action.out","w",stdout);
     scanf("%d%d",&n,&k);
     rep(i,,n) scanf("%d%d",&u,&v),ins(u,v),ins(v,u);
     dfs(,-);
     printf("%d\n",(dp[][k][][]+dp[][k][][])%mod);
     return ;
 }

D1T1

D2T2:防御网络

https://blog.csdn.net/scar_lyw/article/details/80410420

首先连接环的桥边的贡献很好算，tarjan过程中可直接求出。然后对于每一个环，求出环上被选中边数的期望。
一个环被选中的边，一定是环长减去最大的一个空隙。我们枚举环上的[s,s+len]中的点被选中（一个点被选中当且仅当子图S中包含这个点或这个点连出的外向树中的点）。设DP状态dp[s][len][k]表示[s,s+len]中有点且这段的最大空隙为k的方案数。求出dp数组后贡献就很容易求得了，注意还有一个空隙是环长-len。

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 #define For(i,x) for (int i=h[x],k; i; i=nxt[i])
 using namespace std;

 const int N=,mod=1e9+;
 int n,m,u,v,cnt,ans,f[N],p2[N],sz[N],vis[N],fa[N];
 int dp[N][],sm[N][],h[N],to[N],nxt[N],dep[N];
 void add(int u,int v){ to[++cnt]=v; nxt[cnt]=h[u]; h[u]=cnt; }

 int ksm(int a,int b){
     int res=;
     for (; b; a=1ll*a*a%mod,b>>=)
         if (b & ) res=1ll*res*a%mod;
     return res;
 }

 void calc(int s,int len,int n){
     rep(i,s-,n) dp[i][]=dp[i][]=sm[i][]=sm[i][]=;
     dp[s][]=sm[s][]=f[s];
     rep(i,s+,n){
         int l=max(s,i-len+)-;
         if (i-len>=s) dp[i][]=(dp[i][]+1ll*(dp[i-len][]+dp[i-len][])*f[i])%mod;
         dp[i][]=(dp[i][]+1ll*f[i]*(sm[i-][]-sm[l][]+mod))%mod;
         dp[i][]=(dp[i][]+1ll*f[i]*(sm[i-][]-sm[l][]+mod))%mod;
         sm[i][]=(sm[i-][]+dp[i][])%mod; sm[i][]=(sm[i-][]+dp[i][])%mod;
         ans=(ans+1ll*min(i-s,n-len)*dp[i][])%mod;
     }
 }

 void solve(int u,int v){
     int cur=v,lst=,tot=;
     for (; cur!=u; lst=cur,cur=fa[cur])
         f[++tot]=p2[sz[cur]-sz[lst]],vis[cur]=;
     f[++tot]=p2[n-sz[lst]];
     rep(i,,tot-) rep(j,,tot-i) calc(i,j,tot);
 }

 void dfs(int x){
     dep[x]=dep[fa[x]]+; sz[x]=;
     For(i,x) if (!dep[k=to[i]]) fa[k]=x,dfs(k),sz[x]+=sz[k];
         else if (dep[k]>dep[x]) solve(x,k);
 }

 int main(){
     freopen("defense.in","r",stdin);
     freopen("defense.out","w",stdout);
     scanf("%d%d",&n,&m);
     rep(i,,m) scanf("%d%d",&u,&v),add(u,v),add(v,u);
     p2[]=; rep(i,,n) p2[i]=p2[i-]*2ll%mod;
     rep(i,,n) p2[i]--;
     dfs();
     rep(i,,n) if (!vis[i]) ans=(ans+1ll*p2[sz[i]]*p2[n-sz[i]])%mod;
     ans=1ll*ans*ksm(p2[n]+,mod-)%mod;
     printf("%d\n",ans);
     return ;
 }

D2T2

D1T3:绝地反击

如果确定这个正n边形的话，二分+Dinic就好了。退火/爬山旋转正n边形即可。

正解是网络流退流，未看。

D2T1:部落战争

https://www.cnblogs.com/HocRiser/p/10268249.html

D2T2:扫地机器人

留坑。

D2T3:军训列队

显然集合后每个人的相对位置可以不改变，那么把所求的式子列出来就会发现是一些定值加上关于每个人的坐标和集合点的差的绝对值的数。拆成两部分，显然左半部分向右走，右半部分向左走。

在主席树上二分这个分界点，维护区间中点的坐标和，剩下的直接求解。

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=(l); i<=(r); i++)
 #define lson ls[x],L,mid
 #define rson rs[x],mid+1,R
 typedef long long ll;
 using namespace std;

 const int N=,M=;
 ll c,sum[N],sm[M];
 int n,Q,m,l,r,k,K,nd,a[N],rt[N],v[M],ls[M],rs[M];

 void ins(int y,int &x,int L,int R,int k){
     x=++nd; ls[x]=ls[y]; rs[x]=rs[y]; v[x]=v[y]+; sm[x]=sm[y]+k;
     if (L==R) return;
     int mid=(L+R)>>;
     if (k<=mid) ins(ls[y],lson,k); else ins(rs[y],rson,k);
 }

 int que(int x,int y,int L,int R,int k){
     if (L==R){ c+=sm[x]-sm[y]; return v[x]-v[y]; }
     int mid=(L+R)>>,t=v[ls[x]]-v[ls[y]];
     if (k+t-<mid) return que(ls[x],ls[y],L,mid,k);
     else{
         c+=sm[ls[x]]-sm[ls[y]];
         return v[ls[x]]-v[ls[y]]+que(rs[x],rs[y],mid+,R,k+t);
     }
 }

 int main(){
     freopen("line.in","r",stdin);
     freopen("line.out","w",stdout);
     scanf("%d%d",&n,&Q);
     rep(i,,n) scanf("%d",&a[i]),m=max(m,a[i]),sum[i]=sum[i-]+a[i];
     rep(i,,n) ins(rt[i-],rt[i],,m,a[i]);
     while (Q--){
         scanf("%d%d%d",&l,&r,&k); c=;
         int tot=que(rt[r],rt[l-],,m,k),len=r-l+;
         ll s1=1ll*tot*k+1ll*tot*(tot-)/-c;
         ll s2=sum[r]-sum[l-]-c-1ll*(len-tot)*k-1ll*(tot+len-)*(len-tot)/;
         printf("%lld\n",s1+s2);
     }
     return ;
 }

D2T3