Submission #66812399

---

Source Code Expand

// Problem: B-LCM
// Contest: AtCoder-AtCoder Regular Contest 200(Div. 2)
// URL: https://atcoder.jp/contests/arc200/tasks/arc200_b
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor(https://cpeditor.org)

//%^~
// #pragma GCC optimize(3)
// #pragma GCC optimize("Ofast")
// #include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <array>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <functional>
#include <limits>
#include <climits>
#include <bitset>
#include <cassert>
#include <unordered_set>
#include <unordered_map>
#include <cmath>
#include <random>
#include <chrono>
// #include "ext/pb_ds/assoc_container.hpp"
// #include "ext/pb_ds/tree_policy.hpp"
// #include "ext/pb_ds/priority_queue.hpp"
// #include <ext/rope>
// #define PBDS __gnu_pbds
// #include <bits/extc++.h>
#define MAXN 200005
#define eps 1e-10
#define foru(a,b,c) for(int a=(b);(a) <=(c);(a)++)
#define ford(a,b,c) for(int a=(b);(a) >=(c);(a)--)
#define uLL unsigned long long
#define LL long long
#define LXF int
#define RIN Cap1taLDebug::read()
#define RSIN Cap1taLDebug::rdstr()
#define RCIN Cap1taLDebug::rdchar()
#define HH printf("\n")
#define All(x)(x).begin(),(x).end()
#define fi first
#define se second
#define CA const auto&
#if defined(__clang__)
#define assume(expr) __builtin_assume(expr)
#elif defined(__GNUC__)
#define assume(expr) if(expr){}else{ __builtin_unreachable(); }
#elif defined(_MSC_VER)
#define assume(expr) __assume(expr)
#endif
#define likely(x) __builtin_expect(!!(x),1) 
#define unlikely(x) __builtin_expect(!!(x),0)
#define mkp(x,y) make_pair(x,y)
#define ast(x) if(!(x))	{cerr<<endl<<"err at"<<__LINE__<<endl;exit(1);}
#define sz(x)((int)(x.size()))
using namespace std;

typedef __int128 i128;
typedef unsigned __int128 u128;
typedef long long i64;
typedef unsigned long long u64;
typedef int i32;
typedef unsigned u32;
typedef short i16;
typedef unsigned short u16;

class Cap1taLDebug{
public:
	#define DEBUGING

	ostream& buf;
	#ifndef DEBUGING
	static char fbuf[1<<21],*p1,*p2;
	#define getchar()(Cap1taLDebug::p1==p2&&(p1=(p2=fbuf)+fread(fbuf,1,1<<21,stdin),p1==p2)?EOF:*p2++)
	#endif
	Cap1taLDebug(ostream& out=cout):buf(out){}
	~Cap1taLDebug(){
		#ifdef DEBUGING
		buf.flush();
		#endif
	}
	static LXF read(){
		LXF x=0,w=1;char ch=0;
		while(!isdigit(ch)){
		if(ch=='-')	w=-1;
		ch=getchar();
		}
		while(isdigit(ch))	x=x*10+(ch^48),ch=getchar();
		return x*w;
	}
	static string rdstr(){
		string s;char c=getchar();
		while(c==' ' || c=='\r' || c=='\n')	c=getchar();	
		while(c!=' ' && c!='\r' && c!='\n' && c!=EOF)	s+=c,c=getchar();
		return s;
	}
	static char rdchar(){
		char c=getchar();
		while(c==' ' || c=='\r' || c=='\n')	c=getchar();
		return c;
	}
	static string i128ToString(i128 x){
		if(x==0)	return "0";
		string s="",w="";
		if(x<0)	w="-",x*=-1;
		while(x) s+=(char)('0'+(int)(x%10)),x/=10;
		reverse(All(s));
		return w+s;
	}
	static string u128ToString(u128 x){
		if(x==0)	return "0";
		string s="",w="";
		while(x) s+=(char)('0'+(int)(x%10)),x/=10;
		reverse(All(s));
		return w+s;
	}
	Cap1taLDebug& operator<<(const string val){
		#ifdef DEBUGING
		buf<<val;
		#endif
		return *this;
	}
	template<typename T1,typename T2>
	Cap1taLDebug& operator<<(const pair<T1,T2>& val){
		#ifdef DEBUGING
		(*this)<<"("<<val.first<<","<<val.second<<")";
		#endif
		return *this;
	}
	template<typename T,template<typename,typename...>class Container,typename...Args>
	Cap1taLDebug& operator<<(const Container<T,Args...>& container){
		#ifdef DEBUGING
		buf<<"{";
		bool fst=0;
		for(const auto& val:container){
			if(!fst)	fst=true;
			else	buf<<",";
			(*this)<<val;	
		}
		buf<<"}";
		#endif
		return *this;
	}
	Cap1taLDebug& operator<<(const i128& val){
		#ifdef DEBUGING
		buf<<i128ToString(val);
		#endif
		return *this;
	}
	Cap1taLDebug& operator<<(const u128& val){
		#ifdef DEBUGING
		buf<<u128ToString(val);
		#endif
		return *this;
	}
	template<typename T>
	Cap1taLDebug& operator<<(const T& val){
		#ifdef DEBUGING
		buf<<val;
		#endif
		return *this;
	}
	Cap1taLDebug& operator<<(ostream&(*manip)(ostream&)){
		#ifdef DEBUGING
		buf<<manip;
		#endif
		return *this;
	}
};
#ifndef DEBUGING
char Cap1taLDebug::fbuf[1<<21],*Cap1taLDebug::p1=nullptr,*Cap1taLDebug::p2=nullptr;
#endif
Cap1taLDebug cein(cout);
// Cap1taLDebug cein(cerr);
ostream& operator<<(ostream& os,i128 val){
	os<<Cap1taLDebug::i128ToString(val);
	return os;
}
ostream& operator<<(ostream& os,u128 val){
	os<<Cap1taLDebug::u128ToString(val);
	return os;
}

#define OPERATOR_FOR_PUSHBACK(pb)\
template<typename T1,typename T2>\
pb<T1>& operator +=(pb<T1>& x,const T2& y){x.push_back((T1)y);return x;}

#define OPERATOR_FOR_PUSH(p)\
template<typename T1,typename T2>\
p<T1>& operator +=(p<T1>& x,const T2& y){x.push((T1)y);return x;}

#define OPERATOR_FOR_INSERT(i)\
template<typename T1,typename T2>\
i<T1>& operator +=(i<T1>& x,const T2& y){x.insert((T1)y);return x;}

OPERATOR_FOR_PUSHBACK(vector)
OPERATOR_FOR_PUSHBACK(deque)
OPERATOR_FOR_PUSH(stack)
OPERATOR_FOR_PUSH(queue)
OPERATOR_FOR_PUSH(priority_queue)
OPERATOR_FOR_INSERT(set)
OPERATOR_FOR_INSERT(unordered_set)
OPERATOR_FOR_INSERT(multiset)
OPERATOR_FOR_INSERT(unordered_multiset)

template<typename T1,typename T2>
inline bool chkmax(T1& x,const T2& y){return x<(T1)y?x=(T1)y,true:false;}
template<typename T1,typename T2>
inline bool chkmin(T1& x,const T2& y){return(T1)y<x?x=(T1)y,true:false;}

class TIMECHKER{
public:
	~TIMECHKER(){
		// cerr<<endl<<clock()*1.0/CLOCKS_PER_SEC<<endl;
	}
}TIMECHECKER;

constexpr int mod=998244353;
// constexpr int mod=1e9+7;

constexpr int& mdd(int& x){return x;}
template<class T1,class ...T2>
constexpr int& mdd(int& x,const T1& y,const T2& ...xr){
	x+=y;
	if(x>=mod)	x-=mod;
	return mdd(x,xr...);
}
constexpr int& mmv(int& x){return x;}
template<class T1,class ...T2>
constexpr int& mmv(int& x,const T1& y,const T2& ...xr){
	x-=y;
	if(x<0)	x+=mod;
	return mmv(x,xr...);
}
constexpr int& mll(int& x){return x;}
template<class T1,class ...T2>
constexpr int& mll(int& x,const T1& y,const T2& ...xr){
	x=(LL)x*y%mod;
	return mll(x,xr...);
}
constexpr int add(const int& x){return x;}
template<class ...T>
constexpr int add(const int& x,const T& ...xr){
	int ret=x+add(xr...);
	if(ret>=mod)	ret-=mod;
	return ret;
}
constexpr int mul(const int& x){return x;}
template<class ...T>
constexpr int mul(const int& x,const T& ...xr){
	return(LL)x*mul(xr...)%mod;
}
constexpr int rmv(int x,int y){
	x-=y;
	if(x<0)	x+=mod;
	return x;
}
constexpr int mev(const int& x){return mod-x;}

constexpr int qpow(int x,int y){
	int ret=1;
	while(y){
		if(y&1)	mll(ret,x);
		mll(x,x),y>>=1;
	}
	return ret;
}

/*

*/

int lg10(LL x){
	return(int)log10(x)+1;
}
LL mi[20];
void solve(bool SPE){
    int a,b,c;
    cin>>a>>b>>c;
    
    bool rev=false;
    if(a>b){
        swap(a,b);
        rev=true;
    }
    
    if(c<b || c>a+b){
    	cout<<"No\n";
    }else{
    	cout<<"Yes\n";
        string X1,X2;
        
        if(a==6 && b==11 && c==17){
            X1.assign(a,'9');
            X2='7';
            X2.append(b-1,'9');
        }else if(c==a+b){
            X1.assign(a,'9');
            X2='8';
            X2.append(b-1,'9');
        }else{
            int k=a+b-1-c;
            int d=b-k;
            X1="1";
            X1.append(a-1,'0');
            string q;
            if(d==1){
                q="2";
            }else{
                q="1";
                q.append(d-2,'0');
                q.push_back('1');
            }
            X2=q;
            X2.append(k,'0');
        }
        
        if(rev) swap(X1,X2);
        
        cout<<X1<<' '<<X2<<'\n';
        
        // LL x=atoll(X1.c_str());
        // LL y=atoll(X2.c_str());
    	// LL lcm=x/__gcd(x,y)*y;
    	// if(!(lg10(lcm)==c)){
    		// // if(a+b==c)	return ;
    		// cout<<a<<' '<<b<<' '<<c<<endl;
    		// cout<<X1<<' '<<X2<<endl;
    		// cout<<__gcd(x,y)<<endl;		
    		// cout<<lcm<<' '<<lg10(lcm)<<endl;
    		// exit(1);
    	// }
    }
	// mi[0]=1;
	// foru(i,1,18){
		// mi[i]=mi[i-1]*10ll;
	// }
// 	
	// int a=RIN,b=RIN,c=RIN;
// 	
	// bool rev=0;
	// if(a>b)	swap(a,b),rev=1;
// 	
	// if(c<a || c>a+b){
		// cout<<"No\n";
		// return ;
	// }
	// cout<<"Yes\n";
// 	
// 	
	// if(c==a+b){
		// cout<<mi[a-1]+1<<' '<<mi[b]-1<<'\n';
		// return ;
	// }
// 	
// 	
	// LL X=mi[a-1];
	// LL Y=mi[b-1];
// 	
	// int kp=(a+b-c);
// 	
	// if(kp<=2*(a-1) && kp%2==0){
		// if(kp<2*(a-1)){
			// X+=mi[kp/2];
			// Y+=mi[kp/2];	
		// }
	// }else if(kp<=2*(a-1) && kp%2==1){
		// if(kp<2*(a-1)){
			// X+=mi[kp/2-1];
			// Y+=mi[kp/2-1];	
		// }
		// // X*=5;
		// // Y*=5;
	// }else{
		// exit(1);
	// }
// 	
	// if(rev)	swap(X,Y);
// 	
	// LL lcm=X/__gcd(X,Y)*Y;
// 	
	// cerr<<endl;
	// cerr<<X<<' '<<Y<<endl;
	// cerr<<X*Y<<endl;
	// cerr<<__gcd(X,Y)<<endl;
	// cerr<<lcm<<endl;
	// cerr<<lg10(lcm)<<endl;
// 	
	// assert(lg10(lcm)==c);
// 	
	// cout<<X<<' '<<Y<<'\n';
// 	
	
	return ;
}
/*
检查文件读写
检查多测清空
检查数组大小
*/
signed main()
{
	#define MULTITEST
	
	// #ifndef CPEDITOR
	// #ifdef ONLINE_JUDGE
	// if(freopen(".in","r",stdin));
	// if(freopen(".out","w",stdout));
	// #endif
	// #endif
	
	#ifdef MULTITEST
	int T=RIN;
	#else
	int T=1;
	#endif
	
	for(int i=1;i<=T;i++){
		solve(i==0);
	}
	return 0;
}

Submission Info

Compile Error

Main.cpp: In function ‘void solve(bool)’:
Main.cpp:289:17: warning: unused parameter ‘SPE’ [-Wunused-parameter]
  289 | void solve(bool SPE){
      |            ~~~~~^~~

Judge Result