2021牛客多校第五场

Boxes

第一种情况是：不花c知道有多少个黑球，全部打开，那么所花就是箱子价值总和。
第二种情况是：将 wi 从小到大排序，先花c知道有多少个黑球，再剩下的就相当于一个随机 01 序列，
那么每次打开一个球，结束的概率为(1/2)^(n-i).所以如果从前往后遍历的话，
代价就为：C + Σ wi*(1-(1/2)^(n-i)). 两者取较小值即可。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n;
double v[N],C,ans,e=0.5,m=0;
int main()
{
    scanf("%d%lf",&n,&C);
    for(int i=1;i<=n;i++)
    {
        scanf("%lf",&v[i]);
        m+=v[i];
    }
    sort(v+1,v+n+1);
    ans=C;
    for(int i = n - 1;i >= 1;i -- )
    {
        ans=ans+v[i]*(1-e);
        e/=2.0;
    }
    printf("%.8lf",min(ans,m));
}

Holding Two

签到题。构造010101… 010101…101010…就满足条件了。

#include<bits/stdc++.h>

using namespace std;

int n,m;

int main()
{
    cin >> n >> m;
    int cnt = 0, f = 0;
        for(int i = 0;i < n;i += 2 )
        {
            if(f & 1)
            {
                for(int j = 0;j < m;j ++ )
                {
                    if(j & 1) cout << "0";
                    else cout << "1";
                }
                cout << endl;
                cnt ++;
                if(cnt == n) break;
                for(int j = 0;j < m;j ++ )
                {
                    if(j & 1) cout << "0";
                    else cout << "1";
                }
                cout << endl;
                cnt ++;
                if(cnt == n) break;
                f ++;
            }
            else
            {
                for(int j = 0;j < m;j ++ )
                {
                    if(j & 1) cout << "1";
                    else cout << "0";
                }
                cout << endl;
                cnt ++;
                if(cnt == n) break;
                for(int j = 0;j < m;j ++ )
                {
                    if(j & 1) cout << "1";
                    else cout << "0";
                }
                cout << endl;
                cnt ++;
                if(cnt == n) break;
                f ++;
            }
        }

}

Jewels

有n个宝石 有n个时刻去捞他们 每个宝石有一个vi 对于时刻j 宝石的z轴等于 vi*j+zi，问你捞所有的宝石要走的距离 其中di=xi2+yi2+zi‘2
这个题其实很简单， n个时刻挖走n个宝石 每个时刻挖走宝石的消耗可很轻松的计算出 然后变成二分图的边权 只要想到了二分图就很好解决这个问题 由于是一个完备匹配 所以可以用km算法去解决这个问题，km之前也不会。。。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const ll inf_ll = 1ll * inf * inf;
const int maxn=3e2+10;
const int N=3e2+10;
int n,m;
ll w[maxn][maxn];
struct ndoe{
	int x,y,z,v;
}e[maxn];
ll mb[N+7],vb[N+7],ka[N+7],kb[N+7],p[N+7],c[N+7];
ll qf,qb,q[N+7];

void Bfs(int u){
    ll a,v=0,vl=0,d;
    for(int i=1;i<=n;i++) p[i]=0,c[i]=inf_ll;
    mb[v]=u;
    do {
        a=mb[v],d=inf_ll,vb[v]=1;
        for(int b=1;b<=n;b++)if(!vb[b]){
            if(c[b]>ka[a]+kb[b]-w[a][b])
                c[b]=ka[a]+kb[b]-w[a][b],p[b]=v;
            if(c[b]<d) d=c[b],vl=b;
        }
        for(int b=0;b<=n;b++)
            if(vb[b]) ka[mb[b]]-=d,kb[b]+=d;
            else c[b]-=d;
        v=vl;
    } while(mb[v]);
    while(v) mb[v]=mb[p[v]],v=p[v];
}
ll KM(){
    for(int i=1;i<=n;i++) mb[i]=ka[i]=kb[i]=0;
    for(int a=1;a<=n;a++){
        for(int b=1;b<=n;b++) vb[b]=0;
        Bfs(a);
    }
    ll res=0;
    for(int b=1;b<=n;b++) res+=w[mb[b]][b];
    return res;
}
int main()
{
	scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d%d%d%d",&e[i].x,&e[i].y,&e[i].z,&e[i].v);
    }
	for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            w[i][j] = 1ll * e[i].x * e[i].x + 1ll * e[i].y * e[i].y + 1ll * (e[i].z+(j-1)*e[i].v) * (e[i].z+(j-1)*e[i].v);
            w[i][j] *= -1;
        }
    }
    
    cout<<-KM()<<endl;
	return 0;
}

King of Range

给出一个序列，对m次询问，每次给出一个常数k,求有多少个序列满足范围大于k(范围指的是这段序列的极差（最大值-最小值）。
用两个单调队列分别维护最大值和最小值；每次固定左边界，那么只需要寻找满足条件的最小的右边界，后面的都满足，加上差值即可。比赛的时候后面也写得单调队列，不过怎么维护没想到，一直在想维护维护窗口大小，还是想错了。

#include <bits/stdc++.h>
using namespace std;
#define N 100005
typedef long long ll;
int n,m,k,a[N],h1,t1,h2,t2;
int pa[N],pi[N];//分别为维护最大值的递减序列和最小值的递增队列 
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	while(m--){
		scanf("%d",&k);
		ll ans=0;
		h1=h2=1;t1=t2=0;//h1,t1为pa的头和尾，h2,t2为pi的头和尾 
		int l=1;//固定左端点 
		for(int i=1;i<=n;i++){
			while(h1<=t1&&a[pa[t1]]<=a[i]) t1--;//维护单调递减队列 
			pa[++t1]=i;
			while(h2<=t2&&a[pi[t2]]>=a[i]) t2--;//维护单调递增队列 
			pi[++t2]=i;
			while(a[pa[h1]]-a[pi[h2]]>k){//得到了以l为左端点时的满足条件的最小右端点 
				ans+=1ll*(n-i+1);//累加和，后面的都满足 
				l++;//左端点++ 
				if(l>pa[h1]) h1++;//维护pa的队首 
				if(l>pi[h2]) h2++;//维护pi的队首
			}
		}
		printf("%lld\n",ans);
	}
	return 0;
} 

Double Strings

给定两个字符串A，B求长度相同的AB子串，使得子串的前面部分相等，且第一个不相等的位置B>A。求这样的子串个数。
f[i][j]表示A的前i个字符与B的前j个字符能组成多少相等的子串。
若AB不相等，f[i][j]=f[i–1][j]+f[i][j-1]-f[i-1][j-1];
若AB相等，f[i][j]额外加上f[i-1][j-1]，表示一定带有当前这两个字符的相等子串,求完f之后再利用f求解
dp[i][j]表示A前i个字符与B前j个字符的解数。
dp[i][j]=dp[i-1][j]+dp[i][j-1] ,如果b[j]>a[i] dp[i][j]额外加上f[i-1][j-1].
又是一道dp，每次都没做起，太难了。。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
char a[5005],b[5005];
int dp[5005][5005],f[5005][5005];
ll res=0;
const int mod=1e9+7;
int main(){
     scanf("%s%s",a+1,b+1);
     int n=strlen(a+1),m=strlen(b+1);
     memset(f,0,sizeof(f));
     f[0][0]=1;
     for (int i=1; i<=m; i++) f[0][i]=1;
     for (int i=1; i<=n; i++) f[i][0]=1;
     for (int i=1; i<=n; i++){
         for (int j=1; j<=m; j++){
             f[i][j]=((f[i-1][j]+f[i][j-1])%mod-f[i-1][j-1]+mod)%mod;
             if (a[i]==b[j]){
                 f[i][j]=(f[i-1][j-1]+f[i][j])%mod;
             }  
         }
     }
     for (int i=1; i<=n; i++){
         for (int j=1; j<=m; j++){
             dp[i][j]=(dp[i-1][j]+dp[i][j-1])%mod;
             if (a[i]<b[j]) dp[i][j]=(dp[i][j]+f[i-1][j-1])%mod;
         }
     }
     printf("%lld",dp[n][m]);
 }