10.06 WZZX Day1总结

今天迎来了WZZX的模拟。打开pdf的时候我特别震惊，出题的竟然是神仙KCZ！没错，就是那个活跃于各大OJ，在各大OJ排名靠前（LOJ Rank1），NOI2018 Rank16进队的kczno1！！！（无限膜拜%%%）

然而KCZ神仙出的题使我挂的特别惨……

T1.rps

期望得分100，实际得分30.

这道题一开始没看出来咋做，先去做后面的题了。

结果我整场基本都在拍第二题的期望DP，然后还没对orz。

大概剩了40分钟回来想这道题。发现，如果赢家确定了那么其实所有比赛的结果都被确定了，那么序列的大致情况我们就知道了。然后我自己画了几棵树，发现其实一场比赛参与的情况其实是成一个杨辉三角的……

好像有点奇怪，可以自己画几棵看一下，然后就会发现，如果你以这次的赢家为起点，三个一循环轮番转来转去，你就能确定在总人数=2^n的时候，合法的情况和对于合法情况每次的赢家是谁了。（不过好像没人这么做……可能我是个毒瘤吧orz）

然后我就自以为能做这道题了……然后我就贪心的输出字典序小的，写完的时候考试快结束了也没来得及再试几组数据，结果考试结束之后SZQ告诉我说这是错的……凉凉。

回来自己手画了几棵确实发现贪心是错的，然后自己画了大概1个点找规律，尝试了好多种情况还是没办法，于是就放弃了，学了一种更暴力的方法。

上面的思路没问题，就是我们可以先随便的把这个区间大致求出来。之后对其进行类似归并排序的操作，对于当前两个区间，暴力枚举第一个不一样的，如果有的话就暴力交换两个区间。

这样之后就可以过了……orz，暴力大法好啊……虽然说我写的莫名其妙特别慢，比别人的慢10倍，还是开了1.5s才跑过去的。

看一下代码。

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<iostream>
#include<queue>
#include<set>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('
')

using namespace std;
typedef long long ll;
const int M = 100005;

int read()
{
    int ans = 0,op = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9')
    {
        if(ch == '-') op = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        ans *= 10;
        ans += ch - '0';
        ch = getchar();
    }
    return ans * op;
}

int r,p,s,n,maxn,cnt,f[50][50],g[50][3];
char h[1500000];
bool pd[1500000];

void cal()
{
    f[1][1] = 1;
    rep(i,2,21)
    rep(j,1,i) f[i][j] = f[i-1][j] + f[i-1][j-1];
    rep(i,1,n+1)
    {
        rep(j,1,i)
        {
            int k = j % 3;
            if(!k) k = 3;
            g[i][k] += f[i][j];
        }
    }
}

void print(char c,int a)
{
    if(a == n) 
    {
        h[++cnt] = c;
        return;
    }
    if(c == 'S') print('P',a+1),print('S',a+1);
    if(c == 'P') print('P',a+1),print('R',a+1);
    if(c == 'R') print('S',a+1),print('R',a+1);
}

void solve()
{
    if(r == g[n+1][1] && p == g[n+1][3] && s == g[n+1][2]) print('R',0);
    else if(r == g[n+1][3] && p == g[n+1][2] && s == g[n+1][1]) print('S',0);
    else if(s == g[n+1][3] && p == g[n+1][1] && r == g[n+1][2]) print('P',0);
    else 
    {
        printf("IMPOSSIBLE
");
        return 0;
    }
}

void merge(int l,int r,int len)
{
    if(len == 1) return;
    int mid = (l+r) >> 1;
    merge(l,mid,len>>1),merge(mid+1,r,len>>1);
    rep(i,l,mid) 
    {
        if(h[i] <= h[mid-l+i+1]) continue;
        rep(j,l,mid) swap(h[j],h[mid-l+j+1]);
        return;
    }
}

int main()
{
//    freopen("rps.in","r",stdin);
//    freopen("rps.out","w",stdout);
    r = read(),p = read(),s = read();
    while(1<<n < r+p+s) n++;
    cal(),solve();
    merge(1,cnt,cnt);
    rep(i,1,cnt) printf("%c",h[i]);enter;
    return 0;
}

T2.vote

期望得分70，实际得分20.

这道题一开始感觉是个期望DP，然后自己写了转移方程，写上去之后发现数不对……然后改了改能把样例过了，不过一直不知道咋对拍有点慌……

然后出分了发现自己凉凉，莫名挂掉。然后这本来是一个O（n^3）的算法结果T了5个点orz。

看了题解发现真心巧妙。我们把所有人按照概率从小到大排序，可以证明一定取得是一段连续前缀和一段连续后缀。

我们假设有一个孩子，ta被选中了而ta的前后有人没被选中，我们能保证选择ta前后的人一定不劣。我们以两个人为例，其中一个是待选择的，其概率为p，另一个是已经选定的，概率为q，是一个常量。

这两个人对概率的贡献是f(p) = p * (1-q) + (1-p) * q,即f(p) = (1-2*q) * p + q,是一个关于p的一次函数，所以这个人移动到左或者右一定不劣，具体往哪边移就是斜率控制了。

然后我们只要进行从前向后和从后向前两次概率DP，然后每次计算对应两次积之和，取最大值即可。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<queue>
#include<cstring>
#define rep(i,a,n) for(int i = a;i <= n;i++)
#define per(i,n,a) for(int i = n;i >= a;i--)
#define enter putchar('
')
#define pr pair<int,int>
#define mp make_pair
#define fi first
#define sc second
using namespace std;
typedef long long ll;
const int M = 2005;
const int N = 10000005;
 
int read()
{
    int ans = 0,op = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9')
    {
    if(ch == '-') op = -1;
    ch = getchar();
    }
    while(ch >='0' && ch <= '9')
    {
    ans *= 10;
    ans += ch - '0';
    ch = getchar();
    }
    return ans * op;
}

int n,k,m;
double p[M],pre[M][M],suf[M][M],ans,cur;

int main()
{
    n = read(),k = read();
    rep(i,1,n) scanf("%lf",&p[i]);
    sort(p+1,p+1+n);
    pre[0][0] = 1,suf[n+1][0] = 1;
    rep(i,1,n)
    {
    rep(j,1,n) pre[i][j] = p[i] * pre[i-1][j-1] + (1-p[i]) * pre[i-1][j];
    pre[i][0] = (1-p[i]) * pre[i-1][0];
    }
    per(i,n,1)
    {
    rep(j,1,n) suf[i][j] = p[i] * suf[i+1][j-1] + (1-p[i]) * suf[i+1][j];
    suf[i][0] = (1-p[i]) * suf[i+1][0];
    }
    m = k >> 1;
    rep(i,0,k)
    {
    cur = 0;
    rep(j,0,m) cur += pre[i][j] * suf[n+1+i-k][m-j];
    ans = max(ans,cur);
    }
    printf("%.9lf
",ans);
    return 0;
}

T3.factory

期望得分10，实际得分20。

这题我确实不会，看数据范围大概是网络流或者状压DP。我啥也不会就写了一个特判和一个求二分图补图的最大匹配，然后骗了20.

这题的题解我也确实没看懂……std是用C++11写的也没看明白……（话说为啥版本不同就感觉像换了个语言啊orz）

把题解抄在这里吧……

首先把问题转化为二分图模型，左边 个点表示工人，右边 个点表示机 器，左右两个点有边当且仅当对应工人会操作对应机器。无论哪种情况下 所有机器都能有人操作，就等价于，任意一个极大匹配都是完美匹配。

考虑问题的一个弱化版本:判断是否任意一个极大匹配都是完美匹配。 观察发现，任意一个极大匹配都是完美匹配(a) iff 任意一个联通块都是左右

点数相等的完全二分图(b)。

证明:

从b推出a是显然的，下面只用证明从a推出b。

反证法。

假设存在一张二分图，存在一个联通块不是左右点数相等的完全二分图，
同时满足任意一个极大匹配都是完美匹配。

如果这个联通块左右点数不相等，那么它就不存在完美匹配，显然矛盾。

否则这个联通块不是完全二分图，设左边的a点和右边的b点之间没有边， 随便找一条从a到b的简单路径，记作p。选择p上的奇数边，再随便选一些 边构造一个极大匹配，那么这个极大匹配必定是完美匹配。把奇数边改成 偶数边，其他的边不变，那么除了a,b以外的点都在匹配上，所以得到了一 个非完美匹配的极大匹配，矛盾。

Q.E.D.

std：

#include<bits/stdc++.h>
using namespace std;

template <typename T> void chmin(T &x,const T &y)
{
    if(x>y)x=y;
}
typedef pair<int,int> pii;
#define rep(i,l,r) for(int i=l;i<=r;++i)
const int N=30+2,U=2e5;
int n;
char s[N][N];
int dp[U][N];
pii q[N*2];int m,cnt[N*2],w[N*2];
bool vis[N*2];

pii operator +(const pii &a,const pii &b)
{
    return pii(a.first+b.first,a.second+b.second);
}
pii operator *(const pii &a,int x)
{
    return pii(a.first*x,a.second*x);
}
void operator +=(pii &a,const pii &b)
{
    a=a+b;
}
int sqr(int x)
{
    return x*x;
}

int main()
{
    freopen("factory.in","r",stdin);freopen("factory.out","w",stdout);
        scanf("%d",&n);
        rep(i,1,n)scanf("%s",s[i]+1);
        m=0;
        rep(i,1,n*2)vis[i]=0;
        rep(i,1,n*2)
        if(!vis[i])
        {
            deque<int>nq;
            auto push=[&](int x) { if(!vis[x]){nq.push_back(x);vis[x]=1;} }; 
            push(i);
            pii now=pii(0,0);
            while(!nq.empty())
            {
                int x=nq.front();nq.pop_front();
                if(x<=n)
                {
                    ++now.first;
                    rep(y,1,n)
                    if(s[x][y]=='1')push(y+n);
                }
                else
                {
                    ++now.second;
                    rep(y,1,n)
                    if(s[y][x-n]=='1')push(y);
                }
            }
            //cerr<<i<<" "<<now.first<<" "<<now.second<<endl;
            q[++m]=now;
        }
        sort(q+1,q+m+1);
    //    rep(i,1,m)cerr<<q[i].first<<" "<<q[i].second<<endl; 
        int m0=m;m=1;
        cnt[1]=1;
        rep(i,2,m0)
        {
            if(q[i]==q[m])++cnt[m];
            else
            {
                q[++m]=q[i];
                cnt[m]=1;
            }
        }
    //    cerr<<m<<endl;
    //    rep(i,1,m)cerr<<cnt[i]<<" ";cerr<<endl;
    //    rep(i,1,m)cerr<<q[i].first<<" "<<q[i].second<<endl; 
        w[1]=1;
        rep(i,2,m+1)w[i]=w[i-1]*(cnt[i-1]+1);
        rep(s,0,w[m+1]-1)
        rep(i,0,n)dp[s][i]=N*N;
        dp[0][0]=0;
        cerr<<w[m+1]<<endl;
        rep(s,0,w[m+1]-1)
        {
            pii sum=pii(0,0);
            rep(i,1,m)sum+=q[i]*(s%w[i+1]/w[i]);
        //    cerr<<sum.first<<" "<<sum.second<<endl;
            if(sum.first==sum.second)
            {
                rep(i,0,sum.first-1)chmin(dp[s][sum.first],dp[s][i]+sqr(sum.first-i));
            }
            rep(i,1,m)
            if(s%w[i+1]/w[i]<cnt[i])
            rep(j,0,n)chmin(dp[s+w[i]][j],dp[s][j]);
        }
        int sum=0;
        rep(i,1,n)
        rep(j,1,n)sum+=s[i][j]=='1';
        printf("%d
",dp[w[m+1]-1][n]-sum);
}