NOIP 模拟十三

T1：工业题

　　考虑递推方程，首先以形理解，发现递推方程在矩阵中的表现为：

( i , j )元素由其左方与上方叠加而成，并且初始元素一定，递推过程仅以

一定系数递变，于是考虑初始元素对答案最终的贡献。

　　发现元素( i , j )对于( n , m )的贡献为：

f ( i , j ) * (i j到n m的方案数) * a ^ (m - j) * b ^ (n - i)

于是预处理C与指数幂，分别计算初始元素对( n , m )的贡献累计求和即可

代码如下：

#include<bits/stdc++.h>
using namespace std;
#define I long long
const I mod = 998244353;
const I MAXN = 3e5 + 5;
I n,m,a,b,res,initn[MAXN],initm[MAXN],c1[MAXN],c2[MAXN],J[MAXN << 1],Y[MAXN << 1];
inline I qpow (I a,I b) {
    I res(1);
    while (b) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}
inline I C (I n,I m) {
    if (n < m) return 0;
    if (m == 0 || n == m) return 1;
    return J[n] * Y[m] % mod * Y[n - m] % mod;
}
signed main () {
    cin >> n >> m >> a >> b;
    (a += mod) %= mod; (b += mod) %= mod;
    c1[0] = c2[0] = 1;
    for (I i(1);i <= n; ++ i) {
        cin >> initn[i];
        (initn[i] += mod) %= mod;
        c2[i] = c2[i - 1] * b % mod;
    }
    for (I i(1);i <= m; ++ i) {
        cin >> initm[i];
        (initm[i] += mod) %= mod;
        c1[i] = c1[i - 1] * a % mod;
    }
    J[1] = Y[1] = 1;
    for (I i(2);i <= n + m; ++ i) {
      J[i] = J[i - 1] * i % mod;
      Y[i] = qpow (J[i],mod - 2);
    }
    for (I i(1);i <= n; ++ i)
      (res += initn[i] * C(n + m - i - 1,m - 1) % mod * c1[m] % mod * c2[n - i] % mod) %= mod;
    for (I j(1);j <= m; ++ j)
      (res += initm[j] * C(n + m - j - 1,n - 1) % mod * c1[m - j] % mod * c2[n] % mod) %= mod; 
    cout << res;
}
    

T2：卡常题

　　仍然通过形理解题意，考虑题中Y点仅与两个X点相连，发现可以考虑转化为图论

即：以X为点，每条路径Y连接两个X点，其中点权可以预处理得到

　　于是发现问题转化为，对于一个n个点n条边的图，求解图中最小的带权点覆盖

由于保证图的连通性且无重边，于是原图本质上就是一个基环树

求解有关基环树问题的一般思路为：首先找出树上环，并以环为基环树的广义根节点，

分类讨论分别计算树上问题与有环参与的整体问题

　　由于求解最小点覆盖，即最优性问题，故从任意节点出发得到的结果相同

于是考虑先找到环，并将环上任意一条边删去，分别以此边连接的两个节点出发进行

树形DP，最终整合最优解即可

代码如下：

#include<bits/stdc++.h>
using namespace std;
#define I int
#define V void
const I MAXN = 1e6 + 5;
I n,a,b,B,W,tot,val[MAXN],head[MAXN],f[MAXN][2],p1,p2;
bool jud[MAXN];
struct BRT {I to,nxt;} tree[MAXN << 1];
struct POS {I a,b,c;} pos;
inline V found (I x,I y) {
    tree[++tot].to = y,tree[tot].nxt = head[x],head[x] = tot;
    tree[++tot].to = x,tree[tot].nxt = head[y],head[y] = tot;
}
V dfs (I x,I fa) {    
    for (I i(head[x]),y(tree[i].to); i ;i = tree[i].nxt,y = tree[i].to)
      if (y != fa)
        if (!jud[y]) {  
          jud[y] = 1; dfs (y,x);  
        }
        else {  
          pos = (POS){x,y,i}; return ;  
        }
}
V sol (I x,I fa) {
    f[x][0] = 0;
    f[x][1] = val[x];
    for (I i(head[x]),y(tree[i].to); i ;i = tree[i].nxt,y = tree[i].to)
      if (i != pos.c && (i ^ 1) != pos.c && y != fa) {
        sol (y,x);
        f[x][1] += f[y][1] < f[y][0] ? f[y][1] : f[y][0];
        f[x][0] += f[y][1];
      }
}
signed main () {
    tot = 1;
    cin >> n >> a >> b;
    for (I i(1);i <= n; ++ i) {
      cin >> B >> W;
      found (B,W);
      val[B] += a,val[W] += b;
    }
    jud[1] = 1; dfs (1,0);
    sol (pos.a,0);
    p1 = f[pos.a][1];
    sol (pos.b,0);   
    p2 = f[pos.b][1];
    cout << min (p1,p2);
}

T3：玄学题

　　很容易发现该数学式的特殊点为底数为-1，发现该式的值仅与指数的奇偶性有关

观察数据范围很容易想到正解复杂度为O(n)，由发现d(i * j)值为偶数对答案无影响

只有d(i * j)为奇数时才会对答案造成贡献，于是问题转化为在该种情况下d(i * j)为奇数

的情况有多少种，此时考虑数学式意义即：数x约数个数为奇数情况，容易发现当且仅当

x为完全平方数时满足该条件，于是问题转化为在该种情况下i * j为完全平方数的个数

　　对于i * j这种简洁式性质的研究很容易想到数论，即唯一分解，于是发现若i为完全平方数

则当且仅当j为完全平方数时符合条件，当i非完全平方数时，设i唯一分解为p * q^2

发现当且仅当j唯一分解为p * r^2时符合条件，故只需要对于每个i有多少个j对答案造成贡献即可

（容易发现i为完全平方数有sqrt(m)个j满足条件，推出i非完全平方数时有sqrt(m/p)个数满足条件）

代码如下：

#include<bits/stdc++.h>
using namespace std;
#define I int
#define LL long long
const I MAXN = 1e7 + 5;
I n,res,aux[MAXN];
LL m;
signed main () {
    cin >> n >> m;
    for (I i(1);i * i <= n; ++ i)
      for (I j(1);i * i * j <= n; ++ j)
        aux[i * i * j] = j;
    for (I i(1);i <= n; ++ i)
      (I)sqrt (m / aux[i]) & 1 ? res -- : res ++ ;
    cout << res;
}