2019牛客暑期多校训练营（第二场）

传送门

参考资料：

　　[1]:官方题解（提取码：ar7y）

　　[2]:标程（提取码：3qb2）

A.Eddy Walker（概率+打表找规律）

•题意

　　有一个圆，圆上有 n 个点，编号为 0~n-1；

　　初始，Eddy 处于 0 位置，每次他独立地均匀随机选择是向前（0+1）还是向后（0-1 = n-1）走；

　　现给你 n,m ，让你求 Eddy 在走 n 步后停留在 m 处的概率；

　　最终结果输出前缀积；

•题解

　　在补这道题前，补了补概率论的相关概念；

　　1.频率定义

　　　　若在相同的条件下进行的 n 次试验中，事件 A 发生了 m 次，则称比值 m / n 为事件 A 发生的频率；

　　2.概率的统计定义

　　　　在相同条件下进行大量重复试验，当试验次数充分大时，事件 A 的频率将在某个常数 p 附近摆动，
　　　　这个常数 p 称为事件 A 的概率，记为 P(A)；

　　有了这些概念后，找了几篇博文看，发现，要么是达标找规律，要么就是直接写结论，没有严格的数学证明；

　　哎，本蒟蒻太菜，并不擅长概率论方面的题，暂且补补打表找规律的；

#include<bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn=100;

int n;
bool vis[maxn];
int k[maxn];

int main()
{
    srand((unsigned int)(time(NULL)));

    scanf("%d",&n);///n最好不要太大，不然，不能再有限的时间内跑出结果
    for(int i=1;i <= 100000;i++)
    {
        mem(vis,false);
        vis[0]=true;

        int cur=0;
        int t=1;

        while(t < n)
        {
            int x=rand()%2 ? 1:-1;///向前或向后走
            cur=(cur+x+n)%n;

            if(!vis[cur])
            {
                vis[cur]=true;
                t++;
            }
        }
        k[cur]++;
    }
    for(int i=1;i < n;i++)
        printf("%d ",k[i]);
    printf("
");

    return 0;
}

　　当输入的 n = 10 时，大概可以看出除 0 外，其他位置的概率为 1 / (n-1)；

　　0 单独处理；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD=1e9+7;

ll qPow(ll a,ll b)
{
    ll ans=1;
    a %= MOD;

    while(b)
    {
        if(b&1)
            ans=ans*a%MOD;

        a=a*a%MOD;
        b >>= 1;
    }
    return ans;
}
ll Inv(ll a)///返回 a 的逆元
{
    return qPow(a,MOD-2)%MOD;
}
int main()
{
    int T;
    scanf("%d",&T);
    
    ll ans=1;
    while(T--)
    {
        int n,m;
        scanf("%d%d",&n,&m);
        ll cur;
        if(m == 0)
        {
            if(n != 1)
                cur=0;
            else
                cur=1;
        }
        else
            cur=Inv(n-1);///cur = {1/(n-1)}%MOD;
        
        ans=ans*cur%MOD;
        
        printf("%lld
",ans);
    }
    return 0;
}

•想法

　　打表找规律做出的题终究不是正解，只能解决当前题；

---

F.Partition priblem(DFS)

•题意

　　有 2n 个人，任意两个人之间都存在竞争值；

　　定义 v[ i ][ j ] 表示 i 与 j 的竞争值为 v[ i ][ j ]；

　　现让你将这 2n 个人划分成两组，每组有 n 人，组内的成员之间不存在竞争；

　　求最大的竞争值；

　　例如，假设 a 组有成员 1,2 ， b 组有成员 3,4；

　　其竞争值为 v[1][3] + v[1][4] + v[2][3] + v[2][4]；

•题解

　　DFS+剪枝；

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100;

int n;
ll sum;
ll v[maxn][maxn];
///将这2n个人划分成a,b两组，每组有n人
int a[maxn];
int b[maxn];

///a组中的成员为a[1],a[2],...,a[cntA-1];
///b组中的成员为b[1],b[2],...,b[cntB-1];
///当前a,b两组的竞争值为cur
///在向a组或b组中增加新成员时，cur -= x;
///x指的是加入新成员后的组内竞争
void DFS(int cntA,int cntB,ll cur,ll &ans)
{
    if(ans >= cur)
        return ;
    if(cntA-1 > n || cntB-1 > n)
        return ;
    
    int k=cntA+cntB-1;
    if(k == 2*n+1)
    {
        ans=max(ans,cur);
        return ;
    }
    
    ll tmp=cur;
    a[cntA]=k;///k归到a组
    for(int i=1;i < cntA;++i)
        tmp -= v[a[i]][k];///x=∑v[a[i]][k]
    DFS(cntA+1,cntB,tmp,ans);
    
    tmp=cur;
    b[cntB]=k;///k归到b组
    for(int i=1;i < cntB;++i)
        tmp -= v[b[i]][k];///x=∑v[b[i]][k]
    DFS(cntA,cntB+1,tmp,ans);
}
ll Solve()
{
    ll ans=0;
    DFS(1,1,sum,ans);
    
    return ans;
}
int main()
{
    scanf("%d",&n);
    
    sum=0;
    for(int i=1;i <= n*2;++i)
        for(int j=1;j <= n*2;++j)
        {
            scanf("%lld",v[i]+j);
            if(j < i)
                sum += v[i][j];
        }
    printf("%lld
",Solve());
    
    return 0;
}

---

H.Second Large Rectangle(单调栈)

•题意

       给你一个仅由 01 组成的 n×m 组成的矩阵；

       求仅由 1 组成的矩阵中，第二大的矩阵面积；

•题解

      定义二维数组 h，h[ i ][ j ] 表示从(i,j) 位置开始向上连续的 1 的个数；

      例如：

　　 

　　h[1][1] = 1 , h[2][1] = 0 , h[3][3] = 3 , h[4][1] = 1;

      对于第 i 行，首先求出 h[ i ][ j ] 后，然后通过单调栈算法求出以 h[ i ][ j ] 为高的最大的矩阵面积； 

　　定义变量 f,s 分别记录第一大和第二大的矩阵的面积及相应的矩阵坐标；

      每到达一个新位置，判断是否需要更新 f,s ；

      最后，输出 s 矩阵所表示的面积；

•Code

#include<bits/stdc++.h>
using namespace std;
const int maxn=5e3+50;
 
int n,m;
char a[maxn][maxn];
int h[maxn];
int l[maxn];
int r[maxn];
stack<int >sta;
 
struct Data
{
    int a,b;
    int c,d;
    int val;
}f,s;
 
void Clear()
{
    while(!sta.empty())
        sta.pop();
}
void Work()
{
    Clear();
    for(int i=1;i <= m;++i)
    {
        while(!sta.empty() && h[sta.top()] >= h[i])
            sta.pop();
 
        l[i]=sta.empty() ? 1:sta.top()+1;
        sta.push(i);
    }
 
    Clear();
    for(int i=m;i >= 1;--i)
    {
        while(!sta.empty() && h[sta.top()] >= h[i])
            sta.pop();
 
        r[i]=sta.empty() ? m:sta.top()-1;
        sta.push(i);
    }
}
void updata(Data &tmp,int a,int b,int c,int d)
{
    tmp.a=a;
    tmp.b=b;
    tmp.c=c;
    tmp.d=d;
 
    tmp.val=(c-a+1)*(d-b+1);
}
int Solve()
{
    for(int i=0;i <= m;++i)
        h[i]=0;
 
    f=Data{0,0,0,0,0};
    s=Data{0,0,0,0,0};
 
    for(int i=1;i <= n;++i)
    {
        for(int j=1;j <= m;++j)
        {
            if(a[i][j] == '1')
                h[j]++;
            else
                h[j]=0;
        }
 
        Work();
 
        for(int j=1;j <= m;++j)
        {
            int cur=h[j]*(r[j]-l[j]+1);
 
            //(a,b) : cur 矩形左上角坐标
            //(c,d) : cur 矩形右下角坐标
            int a=i-h[j]+1;
            int b=l[j];
            int c=i;
            int d=r[j];
 
            if(cur >= f.val)
            {
                if(!(a == f.a && b == f.b && c == f.c && d == f.d))
                    s=f;//如果当前面积 cur 所表示的矩形不等于 f 所表示的矩形
 
                updata(f,a,b,c,d);
            }
            else if(cur >= s.val)
                updata(s,a,b,c,d);
 
            //cur矩形在减少一行或一列后肯定不等于 f 所表示的矩形
            int cutX=(c-a)*(d-b+1);//减少一行后，判断是否更新 s
            int cutY=(c-a+1)*(d-b);//减少一列后，判断是否更新 s
 
            //判断是否更新 s
            if(cutX > s.val)
                updata(s,a+1,b,c,d);
            if(cutY > s.val)
                updata(s,a,b+1,c,d);
 
        }
    }
    return s.val;
}
int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
 
    scanf("%d%d",&n,&m);
    for(int i=1;i <= n;++i)
        scanf("%s",a[i]+1);
 
    printf("%d
",Solve());
 
    return 0;
}