2020牛客多校第八场于2020/8/3

于 2020-08-04 16:14:45 发布
阅读量115 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44643155/article/details/107781781
版权

今天是第一次品尝到了差一点点就能过题的悲哀
主要是榜单被带歪了，真正的签到题G开题太晚了，加上我对字符输入的不熟悉，把两个循环都写出了低级错误，最后在比赛结束五分钟时才检查出来，遗憾至极。

G

模拟
由于题意稍微稍微有点难理解，榜单有点歪
看不懂题意的先去搜索一下set牌的规则

#include<bits/stdc++.h>
using namespace std;
struct node
{
	int a,b,c,d;	
}nod[305];
bool hanshu(int j,int k,int q)
{
	if(nod[j].a!=4&&nod[k].a!=4&&nod[q].a!=4)
	{
		if(nod[j].a==nod[k].a&&nod[k].a!=nod[q].a)return 0;
		if(nod[j].a==nod[q].a&&nod[j].a!=nod[k].a)return 0;
		if(nod[k].a==nod[q].a&&nod[j].a!=nod[k].a)return 0;
	}
	if(nod[j].b!=4&&nod[k].b!=4&&nod[q].b!=4)
	{
		if(nod[j].b==nod[k].b&&nod[k].b!=nod[q].b)return 0;
		if(nod[j].b==nod[q].b&&nod[j].b!=nod[k].b)return 0;
		if(nod[k].b==nod[q].b&&nod[j].b!=nod[k].b)return 0;
	}
	if(nod[j].c!=4&&nod[k].c!=4&&nod[q].c!=4)
	{
		if(nod[j].c==nod[k].c&&nod[k].c!=nod[q].c)return 0;
		if(nod[j].c==nod[q].c&&nod[j].c!=nod[k].c)return 0;
		if(nod[k].c==nod[q].c&&nod[j].c!=nod[k].c)return 0;
	}
	if(nod[j].d!=4&&nod[k].d!=4&&nod[q].d!=4)
	{
		if(nod[j].d==nod[k].d&&nod[k].d!=nod[q].d)return 0;
		if(nod[j].d==nod[q].d&&nod[j].d!=nod[k].d)return 0;
		if(nod[k].d==nod[q].d&&nod[j].d!=nod[k].d)return 0;
	}
	return 1;
}
int main()
{
	int t;
	cin>>t;
	for(int i=1;i<=t;i++)
	{
		string s;
		int n;
		cin>>n;
		for(int j=1;j<=n;j++)
		{
			cin>>s;
			int cnt=0;
			for(int k=1;k<s.length();k++)
			{
				
				if(s[k-1]=='[')
				{
					cnt++;
					
					if(cnt==1)
					{
						
						if(s[k]=='o')nod[j].a=1;
						else if(s[k+1]=='w')nod[j].a=2;
						else if(s[k+1]=='h')nod[j].a=3;
						else nod[j].a=4;
					//	cout<<nod[j].a<<endl;
					}
					if(cnt==2)
					{
						
						if(s[k]=='*')nod[j].b=4;
						else if(s[k]=='d')nod[j].b=1;
						else if(s[k]=='s')nod[j].b=2;
						else nod[j].b=3;
					//	cout<<nod[j].b<<endl;
					}
					if(cnt==3)
					{
						
						if(s[k]=='*')nod[j].c=4;
						else if(s[k]=='o')nod[j].c=3;
						else if(s[k+1]=='o')nod[j].c=1;
						else nod[j].c=2;
					//	cout<<nod[j].c<<endl;
					}
					if(cnt==4)
					{
						if(s[k]=='*')nod[j].d=4;
						else if(s[k]=='r')nod[j].d=1;
						else if(s[k]=='g')nod[j].d=2;
						else nod[j].d=3;
					//	cout<<nod[j].d<<endl;
					}
					
				}
				
			}
			//cout<<cnt<<endl;
																	
		}
		bool leap=0;
		
		for(int j=1;j<=n;j++)
		{
			if(leap==1)break;
			for(int k=j+1;k<=n;k++)
			{
				if(leap==1)break;
				for(int q=k+1;q<=n;q++)
				{
					if(hanshu(j,k,q)==1)
					{
						leap=1;
						cout<<"Case #"<<i<<": "<<j<<" "<<k<<" "<<q<<endl;
						break;
					}
				}
			}
		}
		
		if(leap==0)cout<<"Case #"<<i<<": -1"<<endl;
	}
}

K

想到了是用前缀和与优先队列（但是放给我写我估计写不来），但是数据范围超过了long long，虽然我刚学了高精度算法，但是板子是不带负数的，队友改板子+搜板子整整三个小时以上…辛苦辛苦，佩服佩服
然而！出题人轻易地说用两个long long做？我就仔细研究了一下类似代码。
得出结论：人家才是真的把高精度用活了啊啊啊啊啊！两个long long模拟高精度，膜拜。
贴上代码（我方）：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=1e5+5;
ll a[maxn],b[maxn],pre[maxn],tot[maxn];
priority_queue<ll> q;
#define MAXN 999999999
#define MAXSIZE 5000
#define DLEN 9
class BigInt
{
    private:
        int a[500];
        int len;
        bool sign;
        //sign表示符号位的正负~
    protected:
        BigInt add(const BigInt&,const bool)const;
        BigInt subtract(const BigInt&,const bool)const;
         //两个无符号整形的加减法,flag标明结果的符号位~~
    public:
        BigInt() {sign=false;len=1;memset(a,0,sizeof(a));}
        BigInt(const ll);
        BigInt(const char*);
        BigInt(const BigInt&);
        BigInt& operator=(const BigInt&);
        friend istream& operator>>(istream&,BigInt&);
        friend ostream& operator<<(ostream&,const BigInt&);
        friend BigInt abs(const BigInt&);
   
        BigInt operator+(const BigInt&)const;
        BigInt operator-(const BigInt&)const;
        BigInt operator*(const BigInt&)const;
        BigInt operator/(const BigInt&)const;
        BigInt operator/(const int&)const;
   
        BigInt operator^(const int&)const;
        int operator%(const int&)const;
        bool operator<(const BigInt&)const;
        bool operator>(const BigInt&)const;
        bool operator<=(const BigInt&)const;
        bool operator>=(const BigInt&)const;
        bool operator==(const BigInt&)const;
   
        inline int size() {return DLEN*(len-1)+to_string(a[len-1]).size();}
};
//对于负数的处理~~~
BigInt::BigInt(ll b)
{
    ll c,d=abs(b);
    len=0;
    sign=b<0;
    memset(a,0,sizeof(a));
    while(d>MAXN)
    {
        c=d-(d/(MAXN+1))*(MAXN+1);
        d=d/(MAXN+1);
        a[len++]=c;
    }
    a[len++]=d;
}
BigInt::BigInt(const char *in)
{
    const char *s;
    if(in[0]=='-') s=in+1,sign=true;
    else s=in,sign=false;
    int t,k,index,L,i;
    memset(a,0,sizeof(a));
    L=strlen(s);
    len=L/DLEN;
    if(L%DLEN) len++;
    index=0;
    for(i=L-1;i>=0;i-=DLEN)
    {
        t=0;
        k=i-DLEN+1;
        if(k<0) k=0;
        for(int j=k;j<=i;j++)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigInt::BigInt(const BigInt& T):len(T.len),sign(T.sign)
{
    memset(a,0,sizeof(a));
    for(int i=0;i<len;i++)
        a[i]=T.a[i];
}
BigInt& BigInt::operator=(const BigInt& n)
{
    sign=n.sign;
    len=n.len;
    memset(a,0,sizeof(a));
    for(int i=0;i<len;i++)
        a[i]=n.a[i];
    return *this;
}
//MDZZ~不是和字符串转化为BigInt一样么,233333
istream& operator>>(istream& in,BigInt& b)
{
    char ch[MAXSIZE];
    in>>ch;
    b=BigInt(ch);
    return in;
}
ostream& operator<<(ostream& out,const BigInt& b)
{
    out<<(b.sign?"-":"")<<b.a[b.len-1];
    for(int i=b.len-2;i>=0;i--) out<<setw(DLEN)<<setfill('0')<<b.a[i];
    return out;
}
BigInt abs(const BigInt& T)
{
    BigInt t(T);
    t.sign=false;
    return t;
}
BigInt BigInt::add(const BigInt& T,const bool flag)const
{
    BigInt t(*this);
    t.sign=flag;
    int big;
    big=T.len>len?T.len:len;
    for(int i=0;i<big;i++)
    {
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN)
        {
            t.a[i+1]++;
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0) t.len=big+1;
    else t.len=big;
    return t;
}
BigInt BigInt::subtract(const BigInt& T,const bool flag)const
{
    BigInt t(*this);
    t.sign=flag;
    for(int i=0;i<t.len;i++)
    {
        if(t.a[i]<T.a[i])
        {
            //模拟借位运算过程~
            int j=i+1;
            while(t.a[j]==0) j++;
            t.a[j--]--;
            while(j>i) t.a[j--]+=MAXN;
            t.a[i]+=MAXN+1-T.a[i];
        }
        else t.a[i]-=T.a[i];
    }
    while(t.a[t.len-1]==0&&t.len>1) t.len--;
    return t;
}
BigInt BigInt::operator+(const BigInt& T)const
{
    BigInt ret;
    if(sign && T.sign){
        BigInt t1(*this),t2(T);
        ret=t1.add(t2,false);
        ret.sign=true;
    }
    if(sign^T.sign)
    {
        BigInt t1(*this),t2(T);
        if(abs(t1)<abs(t2)) swap(t1,t2);
        ret=t1.subtract(t2,t1.sign);
        if(ret.a[ret.len-1]==0&&ret.len==1) ret.sign=false;
    }
    else ret=this->add(T,sign);
    return ret;
}
BigInt BigInt::operator-(const BigInt& T)const
{
    BigInt ret;
    if(sign^T.sign) ret=this->add(T,sign);
    else
    {
        BigInt t1(*this),t2(T);
        bool sn;
        if(abs(t1)<abs(t2))
        {
            sn=t1.sign^1;
            swap(t1,t2);
        }
        else sn=t1.sign;
        ret=t1.subtract(t2,sn);
        if(ret.a[ret.len-1]==0&&ret.len==1) ret.sign=false;
    }
    return ret;
}
BigInt BigInt::operator*(const BigInt& T)const
{
    BigInt ret;
    long long up;
    long long temp,temp1;
    for(int i=0;i<len;i++)
    {
        up=0;
        for(int j=0;j<T.len;j++)
        {
            temp=(long long)a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN)
            {
                temp1=temp%(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            }
            else
            {
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0) ret.a[i+T.len]=up;
    }
    ret.sign=sign^T.sign;
    ret.len=len+T.len;
    while(ret.a[ret.len-1]==0&&ret.len>1) ret.len--;
    return ret;
}
BigInt BigInt::operator/(const BigInt& T)const
{
    BigInt r(*this),ret((ll)0);
    while(r>=T)
    {
        BigInt down(1);
        while(r-T*down>=(ll)0) down=down*10;
        down=down/10;
        r=r-T*down;
        ret=ret+down;
    }
    ret.sign=sign^T.sign;
    return ret;
}
BigInt BigInt::operator/(const int &b)const
{
    BigInt ret;
    bool sign1=b<0;
    long long down=0;
    for(int i=len-1;i>=0;i--)
    {
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-(long long)ret.a[i]*b;
    }
    ret.sign=sign^sign1;
    ret.len=len;
    while(ret.a[ret.len-1]==0&&ret.len>1) ret.len--;
    return ret;
}
int BigInt::operator%(const int &b)const
{
    int d=0;
    for(int i=len-1;i>=0;i--)
        d=(((long long)d*(MAXN+1))%b+a[i])%b;
    return sign?-d:d;
}
BigInt BigInt::operator^(const int &n)const
{
    BigInt ret(1),t(*this);
    int m=n;
    while(m)
    {
        if(m&1) ret=ret*t;
        t=t*t;
        m>>=1;
    }
    return ret;
}
bool BigInt::operator<(const BigInt& T)const
{
    if(sign&&!T.sign) return true;
    if(!sign&&T.sign) return false;
    //只有sign相同才能作比较~~
    if(len!=T.len) return sign^(len<T.len);
    for(int ln=len-1;ln>=0;ln--)
        if(a[ln]!=T.a[ln]) return sign^(a[ln]<T.a[ln]);
    return false;
}
bool BigInt::operator>(const BigInt& T)const
{
    return T<*this;
}
bool BigInt::operator<=(const BigInt& T)const
{
    if(*this==T) return true;
    return *this<T;
}
bool BigInt::operator>=(const BigInt& T)const
{
    return T<=*this;
}
bool BigInt::operator==(const BigInt& T)const
{
    if(sign!=T.sign||len!=T.len) return false;
    for(int i=len-1;i>=0;i--)
        if(a[i]!=T.a[i]) return false;
    return true;
}
  
int main()
{
    int T;scanf("%d",&T);
    int casenum=1;
    while(casenum<=T)
    {
        int num;scanf("%d",&num);
        pre[0]=0;
        for(int i=1;i<=num;++i)
            scanf("%lld",&a[i]),pre[i]=pre[i-1]+a[i];
        tot[0]=0x3f3f3f3f;
        for(int i=1;i<=num;++i)
            scanf("%lld",&b[i]),tot[i]=min(b[i],tot[i-1]);
        ll ans=0;while(!q.empty()) q.pop();
        int pnum=b[1];
        BigInt a((ll)0);
        for(int i=1;i<=num;++i)
        {
            while(pnum>tot[i]){
                BigInt c(q.top());
                 
                a=a+c;
                pnum--;
            }
            q.push(pre[i]);
        }
        while(pnum>0){
                BigInt c(q.top());
                a=a+c;
                pnum--;
        }
        printf("Case #%d: %lld ",casenum++,b[1]);
        cout<<a<<endl;
    }
}

大佬方代码：

#include<bits/stdc++.h>
using namespace std;
const long long N=1e5+9,mod=1e14;
long long a[N],b[N],s[N],n,m,ans;
int main()
{
    int T,t,l,r,i,j,k;
    scanf("%d",&T);
    for(k=1;k<=T;k++)
    {
        memset(a,0,sizeof(a)),memset(b,0,sizeof(b)),memset(s,0,sizeof(s));
        scanf("%lld",&n);
        for(i=0;i<n;i++) scanf("%lld",&a[i]);
        scanf("%lld",&b[0]);
        for(i=1;i<n;i++) scanf("%lld",&b[i]),b[i]=min(b[i],b[i-1]);
        s[0]=a[0];
        for(i=1;i<n;i++) s[i]=s[i-1]+a[i];
        l=r=t=ans=0,m=s[l]*b[l];
        while(r<n)
        {
            while(r<n && s[r]<=s[l]) r++;
            if(r==n)break;
            m+=b[r]*(s[r]-s[l]),ans+=m/mod,m%=mod;
            l=r,t=0;
        }
        printf("Case #%d: %lld ",k,b[0]);
        if(ans) printf("%lld%014lld\n",ans,m);
        else printf("%lld\n",m);
    }
}

I

该题稍后再补。

XMU_Compton
关注
2020牛客暑期多校集训营第二场题解.pdf
01-20
### 2020牛客暑期多校集训营第二场题解 #### Gromah 题目解析 在本次解析中，我们将逐一探讨各题目的关键算法思想和技术细节。 ### A. All with Pairs (全部配对) 本题讨论了如何利用哈希表来解决一对对字符串的...
2020牛客暑期多校训练营（第八场）A、E、G、I、K题解及补题
hzerotole的博客
11-13 532
文章目录2020牛客暑期多校训练营（第八场）题解及补题比赛过程题解A题意解法代码B题意解法代码C题意解法代码D题意解法代码E题意解法代码F题意解法代码G题意解法代码H题意解法代码I题意解法代码J题意解法代码K题意解法代码 2020牛客暑期多校训练营（第八场）题解及补题 比赛过程 这场打的罚时太高了，一开始没有想到签到题就需要用算法，一直在想贪心策略，冷静下来想用并查集和拓扑排序做了，K题一开始思路没有问题，但是有一些小细节错误和没有及时注意到暴longlong了，导致wa的太多，顺便学习了__int128的
2020牛客多校 G
qq_43559193的博客
07-27 169
题意如图 思路： 判断k是n的因子 k是（n+1）的因子 或者其他情况 把这三种情况枚举即可。 #include<bits/stdc++.h> using namespace std; const int N=1e3+15; typedef long long ll; int main() { ll t; cin>>t; while(t--) { ll n,m,k; cin>>n>>k; .
2020 牛客多校第一场J - Easy Integration（求积分/找规律）
Happig的博客
07-12 469
传送门 首先我们写下每一项： n=1n=1n=1：12−13\frac{1}{2}-\frac{1}{3}21​−31​ n=2n=2n=2：13−24+15\frac{1}{3}-\frac{2}{4}+\frac{1}{5}31​−42​+51​ n=3n=3n=3：14−35+36−17\frac{1}{4}-\frac{3}{5}+\frac{3}{6}-\frac{1}{7}41​−53​+63​−71​ n=4n=4n=4：… 没错，分子就是组合数CniC_n^iCni​，
2020牛客多校7：C A National Pandemic（动态点分治（模板））
qq_41997978的博客
08-02 269
题目大意：一棵无根树，每个点都有一个点权 f(x)，其初值均为 0，有三种操作。 操作1：对所有的 y，修改f(y) 为 w - dist(x,y) 操作2：修改 f(x) 为 min(f(x),0) 操作3：查询 f(x) 拿到这道题时就想到了点分树，太久没写点分树的题，当初学的时候只摸清了点分树的写法和基本原理，在应用上没有深入的理解和思考。对于操作 1 经验告诉我这肯定要像线段树一样打标记，但由于修改的是整棵树，而且修改值又和距离有关，直接打标记这种想法是不太现实的，对点分树的应用也有些遗忘。 点..
2020牛客暑期多校第一场讲课笔记版本题解1
08-03
3. 有向图的生成树计数(Domino Flip Graphs): 提到了Domino翻转图中的距离计算，可以通过"Lagrange Duality"证明，答案是b的转置乘以矩阵A的逆再乘以b。这在图论和网络流问题中常见。 4. 二次型(Quadratic Form): ...
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
正则表达式Regex是一种文本模式.docx
09-14
正则表达式（Regular Expression，简称Regex或Regexp）是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。正则表达式是强大的文本处理工具，广泛用于搜索、编辑或操作文本和数据。 基本组成 普通字符：大多数字符，包括所有大写和小写字母、所有数字、所有标点符号和一些其他符号，都是普通字符。正则表达式中的普通字符表示它们自身。例如，正则表达式test会匹配字符串"test"。 特殊字符（元字符）：一些字符在正则表达式中具有特殊的意义，如^、$、.、*、+、?、{、}、[、]、|、\等。这些特殊字符用于表示在搜索文本时要匹配的一个或多个字符。例如，.匹配除换行符之外的任何单个字符。 字符类：字符类允许你指定一组字符中的任何一个字符。例如，[abc]匹配"a"、"b"或"c"中的任意一个字符。你也可以使用范围，如[a-z]匹配任何小写字母。 预定义字符类：正则表达式提供了一些预定义字符类，用于匹配常见的字符集合。例如，\d匹配任何数字（等价于[0-9]），\s匹配任
基于struts+sqlserver网络购物系统毕业课程源码设计+论文资料
09-14
编号：150 系统功能： 展示网站最新的商品信息。 展示网站特价的商品信息。 为用户提供修改个人资料和查看在网站操作情况的平台。 提供用户在网站上购物的平台。 展示网站发布的公告信息。 展示商品的销量排行。 展示网站的友情链接信息。 对商品详细信息以及分类信息进行管理。 对用户基本资料、交易制度、消费情况及留言信息进行管理。 对用户提交的订单进行管理。 对管理员信息、网站公告信息、商业资讯信息及友情链接信息进行管理。 系统运行稳定，具有强大的数据处理能力。 操作注意事项 （1）本系统的用户名为：admin，密码为：admin （2）admin管理员的信息不能删除。 （3）用户注册登录后，可进行商品购买、商品信息查看以及订单查询操作。 （4）后台登陆地址：http://localhost:8080/WebShopping/bg-land.jsp。
基于ssm的高校毕业生就业管理系统设计与实现.docx
09-14
基于ssm的高校毕业生就业管理系统设计与实现.docx
退工、裁员培训讲义.ppt
09-14
退工、裁员培训讲义.ppt
认知实习decesion tree代码
最新发布
09-14
认知实习decesion tree代码
Java 算法：冒泡，选择，插入排序算法
09-14
Java 算法：冒泡，选择，插入排序算法
网约车出行预约系统数据库设计与数据操作
09-14
本课程设计旨在通过对网约车出行预约系统的数据库设计和数据操作的研究，提高对数据库系统的理解和应用能力。课程内容包括需求分析、数据库设计、数据操作等方面，通过实践操作，使掌握数据库设计的基本方法和技巧，提高实际操作能力。课程将从需求分析开始，明确网约车出行预约系统的功能需求和性能需求，为后续的数据库设计提供依据。接下来进行数据库设计，包括概念结构设计、逻辑结构设计和物理结构设计，确保数据库结构的合理性和高效性。在数据操作方面，将涵盖数据的增删改查、事务处理等内容，使学生能够熟练地进行数据操作和管理。通过理论教学和实践操作相结合的方式，使全面掌握网约车出行预约系统数据库设计和数据操作的方法和技巧，为今后从事相关领域的工作打下坚实的基础。
2020牛客多校(第三场)
10-02
这段代码是一个用于解决2020牛客多校（第三场）的问题的代码。它使用了C++语言，并且通过输入和输出字符数组来处理数据。代码中使用了一个变量pos来记录开始位置，左移操作是将开始位置设置为pos * x，右移操作是将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值