NOIP模拟33

T1：

　　考虑状压dp，发现传统转移需要记录当前猎人状态

数据范围显然不可行

　　考虑转化思路，发现问题所求期望可以进行转化，

利用期望线性性质对期望进行分解，具体表现为：

转化题意：1号猎人死亡轮数期望等价于其余猎人在1号前

死亡期望 + 1，由于其余猎人在1号前死亡贡献为1，故可

直接转化为概率，由于概率期望问题均匀性，故i号猎人比

1号猎人先死概率为W[i] / (W[i] + W[1])，累加即可

#include <bits/stdc++.h>
using namespace std;
#define I int
const I N = 1e5 + 7;
const I mod = 998244353;
I n,res,base;
inline I qpow (I a,I b) { I res (1);
    for ( ; b ;a = 1ll * a * a % mod, b >>= 1) 
      if (b & 1) res = 1ll * res * a % mod; return res;
}
signed main () { 
    scanf ("%d%d",&n,&base);
    for (I i(2),tmp;i <= n; ++ i) scanf ("%d",&tmp), 
      res = (res + 1ll * tmp * qpow ((base + tmp) % mod,mod - 2) % mod) % mod;
    printf ("%lld\n", 1ll * ++ res);
}

期望求解：定义式：概率乘贡献，线性分解

T2：

　　考虑记录子节点状态转移到父节点，利用bitset维护，

发现空间复杂度过高，考虑使用内存池或分块进行维护，

发现事实上每个节点求解过程中都需要其所有子节点信息

故无法用上述方法进行空间维护

　　考虑转化思路，发现问题本质在于子节点信息的继承

考虑使用合并类思想，实际采用线段树合并或set启发式合

并，于是发现设L为前缀0数，R为后缀0数，MID为中缀0数

则问题实际上是求max (MID,R + L) 线段树维护即可

#include <bits/stdc++.h>
using namespace std;
#define I int
#define V void
const I N = 1e5 + 7;
I n,m,q,u,v,p,tot,head[N],to[N],nxt[N],root[N],out[N];
vector <I> s[N];
inline V found (I x,I y) {
    to[++tot] = y, nxt[tot] = head[x], head[x] = tot;
}
struct SGT {
    #define mid (l + r >> 1)
    I sgt,pre[N*80],nxt[N*80],middle[N*80],lc[N*80],rc[N*80];
    inline V update (I x,I l,I r) {
        if (!lc[x] && !rc[x]) {
            pre[x] = nxt[x] = middle[x] = r - l + 1;
        }  else
        if ( lc[x] &&  rc[x]) {
            pre[x] = pre[lc[x]], nxt[x] = nxt[rc[x]];
            middle[x] = max (middle[lc[x]],middle[rc[x]]);
            middle[x] = max (middle[x],pre[rc[x]] + nxt[lc[x]]);
        }  else 
        if ( lc[x] && !rc[x]) {
            pre[x] = pre[lc[x]], nxt[x] = nxt[lc[x]] + r - mid;
            middle[x] = max (middle[lc[x]],nxt[x]);
        }  else 
        if ( rc[x] && !lc[x]) {
            pre[x] = pre[rc[x]] + mid - l + 1, nxt[x] = nxt[rc[x]];
            middle[x] = max (middle[rc[x]],pre[x]);
        }
    }
    V insert (I &x,I l,I r,I pos) {
        if (!x) x = ++ sgt; if (l == r) return ;
        pos <= mid ? insert (lc[x],l,mid,pos) : insert (rc[x],mid + 1,r,pos);
        update (x,l,r);
    }
    I merge (I x,I y,I l,I r) {
        if (!x || !y) return x + y; if (l == r) return x;
        lc[x] = merge (lc[x],lc[y],l,mid);
        rc[x] = merge (rc[x],rc[y],mid + 1,r);
        update (x,l,r);
        return x;
    }
}SGT;
V dfs (I x) {
    for (I i(head[x]),y(to[i]); i ;i = nxt[i],y = to[i])
      dfs (y), root[x] = SGT.merge (root[x],root[y],1,m);
    for (auto y : s[x]) SGT.insert (root[x],1,m,y);
    if (!root[x]) return (V) (out[x] = -1);
    out[x] = max (SGT.middle[root[x]],SGT.pre[root[x]] + SGT.nxt[root[x]]);
}
signed main () {
    cin >> n >> m >> q;
    for (I i(1);i <  n; ++ i) cin >> u >> v, found (u,v);
    while (q -- ) cin >> u >> p, s[u].push_back (p); dfs (1);
    for (I i(1);i <= n; ++ i) cout << out[i] << endl;
}

信息继承的合并思路，问题不仅要微观思考细节，还要宏观

把控其本质。动态开点线段树与线段树合并的思想

T3：

　　数据范围提示状压，考虑问题本质状态为有且仅有一条

链连接1-n，于是考虑记录点集状态，考虑新加入点的影响

　　first：加入点位于当前链末端，second：加入点位于某

点集，于是需要记录链末元素，分别进行转移即可

　　预处理点集信息降低复杂度

#include <bits/stdc++.h>
using namespace std;
#define I int
const I N = 15;
I n,m,u,v,w,dis[N + 1][N + 1],dp[1 << N][N + 1],sum1[1 << N],sum2[1 << N][N + 1];
signed main () {
    cin >> n >> m;
    while (m -- ) cin >> u >> v >> w, dis[u][v] = dis[v][u] = w;
    for (I i(1);i < 1 << n; ++ i) for (I j(1);j <= n; ++ j)
     for (I k(j + 1);k <= n; ++ k) if (i & 1 << j - 1 && i & 1 << k - 1)
      sum1[i] += dis[j][k];
    for (I i(1);i < 1 << n; ++ i) for (I j(1);j <= n; ++ j) if (!(i & 1 << j - 1))
     for (I k(1);k <= n; ++ k) if (i & 1 << k - 1 && dis[j][k])
      sum2[i][j] += dis[j][k];   
    memset (dp,-1,sizeof dp); dp[1][1] = 0;
    for (I i(1);i < 1 << n; ++ i)
     for (I j(1);j <= n; ++ j) if (dp[i][j] != -1) {
      for (I k(1);k <= n; ++ k) if (!(i & 1 << k - 1) && dis[j][k])
       dp[i | 1 << k - 1][k] = max (dp[i | 1 << k - 1][k],dp[i][j] + dis[j][k]);
      I state (i ^ (1 << n) - 1);
      for (I k(state); k ; -- k &= state)
       dp[i | k][j] = max (dp[i | k][j],dp[i][j] + sum1[k] + sum2[k][j]);
     }       
    printf ("%d\n",sum1[(1 << n) - 1] - dp[(1 << n) - 1][n]);
}

dp过程的方向性使得转移过程中省去冗余判断，另一种解释

为为了保证dp转移的方向性，在转移过程中不能出现后向转

移实际降低了问题复杂度。考虑dp设计原理，预处理降低复

杂度但要注意分析预处理的状态的需求量，实际分析。

拓展：子集枚举

设全集为 N = (1 << n) - 1;
tps1：全集枚举
    正序：for (int i = 1;i <= N; ++ i)
    倒序：for (int i = N; i ; -- i)
设目标集为 N = s;
tps2:倒序枚举
    for (int i = N; i ;i = i - 1 & N)
    原理：状态合并
    事实上存在冗余枚举，为保证枚举N的子集
    在枚举过程中通过 & N保证状态合法性
tps3:正序枚举状态数为k子集
    int M = (1 << m) - 1;
    int tmp1, tmp2;
    for (int i = M;i <= N;i = (i & ~tmp2) / tmp1 >> 1 | tmp2)
      tmp1 = lowbit(i), tmp2 = i + tmp1;
    原理：模拟进位（手模即可）,详见如下：
first : tmp2 = i + tmp1    --> 将最后一位左移（注意存在进位情况）
second: i & ～tmp2         --> 左移的变化位置（预处理进位的情况）
third : second / tmp1 >> 1 --> 将变化位置移动到末尾（保证状态数）
forth : third | tmp2       --> 生成正序下状态数为k子集