湖南集训DAY5

博弈论+概率dp

对于第一问：f[i][j]表示前i个数，当前黑板上的数为j的概率

当前有三种情况

1． 当前数不是j的倍数—>黑板上的数字改变。

2． 当前数是j的倍数且当前数在前i个数中(已经选过)

3． 当前数是j的倍数且没有选过

转移:f[i+1][j]=((j的倍数个数-i)*f[i][j]+f[i][gcd(j,k)])的平均值  j的倍数个数-i是没选过的j的倍数

对于第二问，考虑博弈论中sg函数。可知sg[i][1]二维含义同f数组)必定为0(最后黑板上剩下1必败)  sg[n][i]=0(选完了必败) 同样枚举上述三种情况，取后续状态mex值即可。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define eps 1e-8
#define N 1000 
using namespace std;
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int sg[N + 5][N + 5], g[N + 5][N + 5], f[N + 5], n, a[N + 5];
double dp[N + 5][N + 5], ans = 0;
bool getsg(int x, int y) {
    if (x == 1) return 1;
    if (sg[x][y] != -1) return sg[x][y];
    bool flag = 1;
    if (f[x] > y) flag &= getsg(x, y + 1);
    for (int i = 1; i <= n; i++)
        if (g[x][i] != x)
            flag &= getsg(g[x][i], y + 1);
    sg[x][y] = !flag;
    return sg[x][y];
}
int main() {
    freopen("cards.in", "r", stdin);
    freopen("cards.out", "w", stdout);
    scanf("%d", &n);
    int mx = 0;
    for (int i = 1; i <= n; i++) { scanf("%d", a + i); mx = max(mx, a[i]); g[0][i] = a[i]; }
    for (int i = 1; i <= mx; i++)
        for (int j = 1; j <= n; j++)
            f[i] += (a[j] % i == 0), g[i][j] = gcd(i, a[j]);
    dp[0][0] = 1;
    for (int i = 1; i <= n; i++)
        for (int j = 0; j <= mx; j++)
            if (dp[i - 1][j] > eps) {
                dp[i][j] += dp[i - 1][j] * (f[j] - i + 1) / (n - i + 1);
                for (int k = 1; k <= n; k++)
                    if (g[j][k] != j) {
                        if (g[j][k] != 1)
                            dp[i][g[j][k]] += dp[i - 1][j] / (n - i + 1);
                        else 
                            ans += (i + 1 & 1) * dp[i - 1][j] / (n - i + 1);
                    }
            }
    if (n & 1)
        for (int j = 0; j <= mx; j++) ans += dp[n][j];
    printf("%.9lf ", ans);
    memset(sg, -1, sizeof(sg));
    if (getsg(0, 0)) puts("1.000000000"); else puts("0.000000000");
    return 0;
}

 

树形dp+LCA

对于60~80分，可以n^2暴力，断掉每条边时，O(N)求每个部分的直径，然后相乘。

正解：倒序加边，考虑两棵树合并的时候新直径一定是原来两个直径四个断点任意两个的路径。所以可以首先求LCA倍增处理两点间路径，然后求最大。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define N 111111
#define MOD 1000000007
#define LL long long
using namespace std;

int a[N], dep[N], sum[N], par[N][18], h[N], del[N];
int endpoint[N][2], ans[N], f[N], length[N];
int tote, n, product;

struct edge{
    int s, t, n;
}e[N * 2];

void adde(int u, int v) {
    e[++tote].t = v;
    e[tote].s = u;
    e[tote].n = h[u];
    h[u] = tote;
    return ;
}

void dfs(int u, int fa) {
    par[u][0] = fa;
    dep[u] = dep[fa] + 1;
    sum[u] = sum[fa] + a[u];
    for (int i = 1; i < 18; i++) par[u][i] = par[par[u][i - 1]][i - 1];
    for (int i = h[u]; i; i = e[i].n) {
        int v = e[i].t;
        if (v != fa) dfs(v, u);
    }
    return ;
}

int lca(int u, int v) {
    if (dep[u] < dep[v]) swap(u, v);
    for (int t = dep[u] - dep[v], i = 0; t > 0; t >>= 1, i++)
        if (t & 1) u = par[u][i];
    int t = 17;
    while (u != v) {
        while (t && par[u][t] == par[v][t]) t--;
        u = par[u][t]; v = par[v][t];
    }
    return u;
}

int getf(int u) {
    if (u == f[u]) return u;
    f[u] = getf(f[u]);
    return f[u];
}

int pw(int a, int b) {
    int ans = 1, t = a;
    for (int i = b; i; i >>= 1) {
        if (i & 1) ans = (LL) ans * t % MOD;
        t = (LL) t * t % MOD;
    }
    return ans;
}

int getlength(int u, int v) {
    int w = lca(u, v);
    return sum[u] + sum[v] - 2 * sum[w] + a[w];
}

int getint()
{
    char ch;
    do
    {
        ch=getchar();
    }while (ch!='-'&&(ch<'0'||ch>'9'));
    int ans=0,f=0;
    if (ch=='-') f=1; else ans=ch-'0';
    while (isdigit(ch=getchar())) ans=ans*10+ch-'0';
    if (f) ans*=-1;
    return ans;
}

int main() {
    freopen("forest.in", "r", stdin);
    freopen("forest.out", "w", stdout);
    n = getint();
    product = 1;
    for (int i = 1; i <= n; i++) {
        a[i] = getint();
        f[i] = i;
        product = (LL) product * a[i] % MOD;
        endpoint[i][0] = endpoint[i][1] = i;
        length[i] = a[i]; 
    }

    for (int i = 1; i < n; i++) {
        int u = getint(), v = getint();
        adde(u, v); adde(v, u);
    }

    dfs(1, 0);

    int t = n;
    ans[t] = product;

    for (int i = 1; i < n; i++) del[i] = getint();

    for (int i = n - 1; i; i --) {
        int id = del[i], u = e[id * 2 - 1].s, v = e[id * 2 - 1].t;
        u = getf(u); v = getf(v);
        if (length[u] < length[v]) swap(u, v);
        int tmax = length[u], end[2];
        for (int j = 0; j < 2; j++) end[j] = endpoint[u][j];
        for (int j = 0; j < 2; j++)
            for (int k = 0; k < 2; k++) {
                int l = getlength(endpoint[u][j], endpoint[v][k]);
                if (l > tmax) {
                    tmax = l;
                    end[0] = endpoint[u][j]; 
                    end[1] = endpoint[v][k];
                }
            }
        product = (LL) product * pw(length[u], MOD - 2) % MOD;
        product = (LL) product * pw(length[v], MOD - 2) % MOD;
        f[v] = u;
        length[u] = tmax;
        for (int j = 0; j < 2; j++) endpoint[u][j] = end[j];
        product = (LL) product * length[u] % MOD;
        ans[--t] = product;
    }
    for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
    return 0;
}

组合数学

考虑两列的情况。若两列颜色分别为A,B,则A独有的颜色就是A—A∩B ，B同理。

若是多列那还是设两边两列为A,B，中间多列为C，那根据题目结论可以知道C一定是A∩B的子集。枚举A中独有颜色个数，B中独有颜色个数与A中相同。若有i中独有，j中共有C(K，i)*C(k-i+1，j)*C(k-i-j，j)

因为每次选择都必须是恰好那些颜色，不能少，所以用总方案数减去不是恰好的就可以了。

# include<iostream>
# include<cstdio>
# include<cstring>
# include<cstdlib>
using namespace std;
const int pp=1000000007;
int c[2008][2008],f[2008],p[2008],ni[2008];
int n,m,k,nn;
inline int power(int x,int n)
{
    int ans=1,tmp=x;
    while (n)
    {
          if (n&1) ans=(long long)ans*tmp%pp;
          tmp=(long long)tmp*tmp%pp;n>>=1;
    }    
    return ans;
}
void Count_c()
{
     for (int i=0;i<=nn;i++) c[i][0]=1;
     for (int i=1;i<=nn;i++)
      for (int j=1;j<=i;j++)
      {
          c[i][j]=c[i-1][j-1]+c[i-1][j];
          if (c[i][j]>=pp) c[i][j]-=pp;
      }
}
void Count_p()
{
     int mm=(m-2)*n;
     for (int i=0;i<=nn;i++)
      p[i]=power(i,mm);
}
void Count_f()
{
     f[0]=0;f[1]=1;
     for (int i=2;i<=nn;i++)
     {
         f[i]=power(i,n);
         for (int j=1;j<i;j++)
         {
             f[i]-=(long long)f[j]*c[i][j]%pp;
             if (f[i]<=-pp) f[i]+=pp;
         }
         if (f[i]<0) f[i]+=pp;
     }
}
void Count_ni()
{
     ni[1]=1;
     for (int i=2;i<=nn;i++)
     ni[i]=power(i,pp-2);
}
int main()
{
    freopen("photo.in","r",stdin);
    freopen("photo.out","w",stdout);
    scanf("%d%d%d",&n,&m,&k);
    nn=min(n,k);
    if (m==1)
       printf("%d\n",power(k,n));
    else
    {
        Count_c();
        Count_p();
        Count_f();
        Count_ni();
        long long tmp=1,tmp1=1,sum=0,sum1;
        for (int s=1;s<=nn;s++)
        {
            tmp=tmp*ni[s]%pp;
            tmp=tmp*(k-s+1)%pp;
            tmp1=1;sum1=0;
            for (int j=0;j<=s;j++)
            {
                sum1+=tmp1*c[s][s-j]%pp*p[s-j]%pp;
                if (sum1>=pp) sum1-=pp;
                tmp1=tmp1*ni[j+1]%pp; 
                if (k-s<j+1) break;
                tmp1=tmp1*(k-s-j)%pp;
            }
            sum+=tmp*f[s]%pp*f[s]%pp*sum1%pp;
            if (sum>=pp) sum-=pp;
        }
        printf("%d\n",sum);
    }
    fclose(stdin);
    fclose(stdout);
    return 0;
}