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('\n')

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

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

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

void cal()
{
    f[][] = ;
    rep(i,,)
    rep(j,,i) f[i][j] = f[i-][j] + f[i-][j-];
    rep(i,,n+)
    {
        rep(j,,i)
        {
            int k = j % ;
            if(!k) k = ;
            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+),print('S',a+);
    if(c == 'P') print('P',a+),print('R',a+);
    if(c == 'R') print('S',a+),print('R',a+);
}

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

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

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

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('\n')
#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 = ;
const int N = ;

int read()
{
    int ans = ,op = ;
    char ch = getchar();
    while(ch < '' || ch > '')
    {
    if(ch == '-') op = -;
    ch = getchar();
    }
    while(ch >='' && ch <= '')
    {
    ans *= ;
    ans += ch - '';
    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,,n) scanf("%lf",&p[i]);
    sort(p+,p++n);
    pre[][] = ,suf[n+][] = ;
    rep(i,,n)
    {
    rep(j,,n) pre[i][j] = p[i] * pre[i-][j-] + (-p[i]) * pre[i-][j];
    pre[i][] = (-p[i]) * pre[i-][];
    }
    per(i,n,)
    {
    rep(j,,n) suf[i][j] = p[i] * suf[i+][j-] + (-p[i]) * suf[i+][j];
    suf[i][] = (-p[i]) * suf[i+][];
    }
    m = k >> ;
    rep(i,,k)
    {
    cur = ;
    rep(j,,m) cur += pre[i][j] * suf[n++i-k][m-j];
    ans = max(ans,cur);
    }
    printf("%.9lf\n",ans);
    return ;
}

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=+,U=2e5;
int n;
char s[N][N];
int dp[U][N];
pii q[N*];int m,cnt[N*],w[N*];
bool vis[N*];

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,,n)scanf("%s",s[i]+);
        m=;
        rep(i,,n*)vis[i]=;
        rep(i,,n*)
        if(!vis[i])
        {
            deque<int>nq;
            auto push=[&](int x) { if(!vis[x]){nq.push_back(x);vis[x]=;} };
            push(i);
            pii now=pii(,);
            while(!nq.empty())
            {
                int x=nq.front();nq.pop_front();
                if(x<=n)
                {
                    ++now.first;
                    rep(y,,n)
                    if(s[x][y]=='')push(y+n);
                }
                else
                {
                    ++now.second;
                    rep(y,,n)
                    if(s[y][x-n]=='')push(y);
                }
            }
            //cerr<<i<<" "<<now.first<<" "<<now.second<<endl;
            q[++m]=now;
        }
        sort(q+,q+m+);
    //    rep(i,1,m)cerr<<q[i].first<<" "<<q[i].second<<endl;
        int m0=m;m=;
        cnt[]=;
        rep(i,,m0)
        {
            if(q[i]==q[m])++cnt[m];
            else
            {
                q[++m]=q[i];
                cnt[m]=;
            }
        }
    //    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[]=;
        rep(i,,m+)w[i]=w[i-]*(cnt[i-]+);
        rep(s,,w[m+]-)
        rep(i,,n)dp[s][i]=N*N;
        dp[][]=;
        cerr<<w[m+]<<endl;
        rep(s,,w[m+]-)
        {
            pii sum=pii(,);
            rep(i,,m)sum+=q[i]*(s%w[i+]/w[i]);
        //    cerr<<sum.first<<" "<<sum.second<<endl;
            if(sum.first==sum.second)
            {
                rep(i,,sum.first-)chmin(dp[s][sum.first],dp[s][i]+sqr(sum.first-i));
            }
            rep(i,,m)
            if(s%w[i+]/w[i]<cnt[i])
            rep(j,,n)chmin(dp[s+w[i]][j],dp[s][j]);
        }
        int sum=;
        rep(i,,n)
        rep(j,,n)sum+=s[i][j]=='';
        printf("%d\n",dp[w[m+]-][n]-sum);
}