QOJ.ac

QOJ

IDProblemSubmitterResultTimeMemoryLanguageFile sizeSubmit timeJudge time
#408405#7648. 网格图最大流计数qwqwf100 ✓1624ms21376kbC++145.6kb2024-05-10 10:03:382024-05-10 10:03:40

Judging History

你现在查看的是最新测评结果

  • [2024-05-10 10:03:40]
  • 评测
  • 测评结果:100
  • 用时:1624ms
  • 内存:21376kb
  • [2024-05-10 10:03:38]
  • 提交

answer

//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2")
//#pragma GCC optimize("Ofast","unroll-loops","inline")
#include<bits/stdc++.h>
#define ll long long
//#define int ll
#define pb push_back
using namespace std;
const int N=1e3+10,mod=1e9+7;
const int inv2=(mod+1)/2;
inline void Add(int &x,int y){x+=y;if(x>=mod) x-=mod;}
inline void Del(int &x,int y){x-=y;if(x<0) x+=mod;}
inline int del(int x,int y){x-=y;return x<0?x+mod:x;}
inline int add(int x,int y){x+=y;return x>=mod?x-mod:x;}
inline int iep(int x){return x&1?mod-1:1;}
int qpow(int a,int b){
	int res=1;
	while(b){
		if(b&1) res=1ll*res*a%mod;
		a=1ll*a*a%mod;b>>=1;
	}return res;
}
struct Faction{
	int len;vector<int> v;
	inline void init(int l){len=l;v.resize(l+1);}
};
namespace Poly{
	inline Faction operator >>(Faction f,int k){
		int len=f.len;f.init(len+k);
		for(int i=len;~i;i--) f.v[i+k]=f.v[i];
		for(int i=0;i<k;i++) f.v[i]=0;
		return f;
	}
	inline Faction operator <<(Faction f,int k){
		int len=f.len;
		for(int i=k;i<=len;i++) f.v[i-k]=f.v[i];
		for(int i=max(0,len-k+1);i<=len;i++) f.v[i]=0;
		f.init(max(0,len-k));
		return f;
	}
	inline Faction operator *(Faction a,int k){
		Faction c;c.init(a.len);
		for(int i=0;i<=a.len;i++) c.v[i]=1ll*a.v[i]*k%mod;
		return c;
	}
	inline Faction operator +(Faction a,Faction b){
		Faction c;int len=max(a.len,b.len);c.init(len);a.init(len);b.init(len);
		for(int i=0;i<=len;i++) c.v[i]=add(a.v[i],b.v[i]);
		return c;
	}
	inline Faction operator -(Faction a,Faction b){
		Faction c;int len=max(a.len,b.len);c.init(len);a.init(len);b.init(len);
		for(int i=0;i<=len;i++) c.v[i]=del(a.v[i],b.v[i]);
		return c;
	}
	void print(Faction x){
		for(int i=0;i<=x.len;i++) cout<<x.v[i]<<' ';cout<<'\n';
	}
	inline Faction rev(Faction &f){
		for(int i=0;i<=f.len;i++) f.v[i]=del(0,f.v[i]);
		return f;
	}
}
using namespace Poly;
void Print(int a[N][N],int n){
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n;j++) cout<<a[i][j]<<' ';cout<<'\n';
	}
}
Faction f[N];
Faction det(int a[N][N],int n){
	for(int i=2;i<=n;i++){
		if(!a[i][i-1]) for(int j=i+1;j<=n;j++) if(a[j][i-1]){swap(a[i],a[j]);for(int k=1;k<=n;k++) swap(a[k][i],a[k][j]);break;}
		if(a[i][i-1]){
			int inv=qpow(a[i][i-1],mod-2);
			for(int j=i+1;j<=n;j++){
				int res=1ll*a[j][i-1]*inv%mod;
				for(int k=i-1;k<=n;k++) Del(a[j][k],1ll*a[i][k]*res%mod);
				for(int k=1;k<=n;k++) Add(a[k][i],1ll*a[k][j]*res%mod);
			}
		}
	}
	f[0].init(0);f[0].v[0]=1;
	for(int i=1;i<=n;i++){
		f[i]=f[i-1]>>1;
		for(int j=i,w=1;j;w=1ll*w*a[j][j-1]%mod,j--){
			int res=1ll*a[j][i]*w%mod;f[i]=f[i]-(f[j-1]*res);
		}
	}
	return f[n];
}
Faction F;int cnt,D[N][N],E[N];
void solve(int a[N][N],int b[N][N],int c[N][N],int n){
	bool fl=0;
	for(int i=1;i<=n;i++){
		while(!a[i][i]){
			for(int j=i+1;j<=n;j++)if(a[i][j]){for(int k=1;k<=n;k++) swap(a[k][i],a[k][j]),swap(b[k][i],b[k][j]),swap(c[k][i],c[k][j]);fl^=1;break;}
			if(a[i][i]) break;
			for(int k=1;k<=n;k++) a[i][k]=b[i][k],b[i][k]=c[i][k],c[i][k]=0;
			cnt++;
			if(cnt>2*n) return ;
			for(int j=1;j<i;j++){
				int inv=qpow(a[j][j],mod-2),res=1ll*inv*a[i][j]%mod;
				for(int k=1;k<=n;k++) Del(a[i][k],1ll*res*a[j][k]%mod),Del(b[i][k],1ll*res*b[j][k]%mod),Del(c[i][k],1ll*res*c[j][k]%mod);
			}
		}
		int inv=qpow(a[i][i],mod-2);
		for(int j=1;j<=n;j++) if(j!=i){
			int res=1ll*inv*a[j][i]%mod;
			for(int k=1;k<=n;k++) Del(a[j][k],1ll*res*a[i][k]%mod),Del(b[j][k],1ll*res*b[i][k]%mod),Del(c[j][k],1ll*res*c[i][k]%mod);
		}
	}
	for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) b[i][j]=del(mod,b[i][j]);
	for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) c[i][j]=del(mod,c[i][j]);
	int res=1;
	for(int i=1;i<=n;i++){
		res=1ll*res*a[i][i]%mod;
		int inv=qpow(a[i][i],mod-2);
		for(int j=1;j<=n;j++) b[i][j]=1ll*b[i][j]*inv%mod,c[i][j]=1ll*c[i][j]*inv%mod;
		a[i][i]=1;
	}
	for(int i=1;i<=n;i++) for(int j=n+1;j<=n+n;j++) D[i][j]=(i==j-n);
	for(int i=n+1;i<=n+n;i++) for(int j=1;j<=n;j++) D[i][j]=c[i-n][j];
	for(int i=n+1;i<=n+n;i++) for(int j=n+1;j<=n+n;j++) D[i][j]=b[i-n][j-n];
	F=det(D,2*n);F=F*res;F=F<<cnt,F.init(min(F.len,2*n));
	if(fl) rev(F);
}
int n,m,k,a[N],b[N],dp[N][N],d[N][N],A[N][N],B[N][N],C[N][N],t[N][N],si[N],sj[N];
char ch[N][N];
signed main(){
//	freopen("a.in","r",stdin);
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++) cin>>a[i]; 
	for(int i=1;i<=m;i++) cin>>b[i];
	for(int i=1;i<=k;i++) cin>>(ch[i]+1);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=k;j++) for(int p=1;p<=k;p++) dp[j][p]=0;
		if(ch[1][a[i]]=='1') dp[1][a[i]]=1;
		for(int j=1;j<=k;j++) for(int p=1;p<=k;p++) if(dp[j][p]){
			if(ch[j+1][p]=='1') Add(dp[j+1][p],dp[j][p]);
			if(ch[j][p+1]=='1') Add(dp[j][p+1],dp[j][p]);
		}
		for(int j=1;j<=m;j++) d[i][j]=dp[k][b[j]];
	}
//	for(int i=1;i<=n;i++){
//		for(int j=1;j<=m;j++) cout<<d[i][j]<<' ';cout<<'\n'; 
//	}
	d[++n][++m]=1;
	for(int i=1;i<n;i++) for(int j=i+1;j<=n;j++){
		for(int p=1;p<=m;p++) si[p]=d[i][p],sj[p]=d[j][p];
		int x=0,y=0,z=0;
		for(int p=m;p;p--){
			Add(z,del(1ll*si[p]*y%mod,1ll*sj[p]*x%mod));
			Add(x,si[p]),Add(y,sj[p]);
		}
		t[i][j]=z,t[j][i]=del(0,z);
	}
	int nn=n;if(n&1) n++;
	for(int i=1;i<n;i++) for(int j=i+1;j<=n;j++){
		C[i][j]=iep(i+j+1);
		if(j<nn) A[i][j]=t[i][j];
		else if(j==nn) B[i][j]=t[i][j];
		C[j][i]=del(0,C[i][j]);B[j][i]=del(0,B[i][j]);A[j][i]=del(0,A[i][j]);
	}
	solve(A,B,C,n);
	int s=F.len;
	E[0]=1;
	for(int i=1;i<=s/2;i++){
		E[i]=F.v[i];
		for(int j=1;j<i;j++) Del(E[i],1ll*E[j]*E[i-j]%mod);
		E[i]=1ll*E[i]*inv2%mod; 
	}
	cout<<s/2<<' '<<E[s/2]<<'\n';
	return 0;
}

Details

Tip: Click on the bar to expand more detailed information

Subtask #1:

score: 5
Accepted

Test #1:

score: 5
Accepted
time: 1ms
memory: 5812kb

input:

7 7 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1111111
1111111
1111111
1111111
1111111
1111111
1111111

output:

7 1

result:

ok 2 number(s): "7 1"

Test #2:

score: 5
Accepted
time: 1ms
memory: 5844kb

input:

7 7 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1111111
1111111
1111111
1111111
1111111
1111111
1111111

output:

7 1

result:

ok 2 number(s): "7 1"

Test #3:

score: 5
Accepted
time: 1ms
memory: 7824kb

input:

7 7 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1111111
1111111
1111111
1111111
1111111
1111111
1111111

output:

7 1

result:

ok 2 number(s): "7 1"

Test #4:

score: 5
Accepted
time: 1ms
memory: 5800kb

input:

7 7 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1111111
1111111
1111111
1111111
1111111
1110111
1111111

output:

6 52

result:

ok 2 number(s): "6 52"

Test #5:

score: 5
Accepted
time: 1ms
memory: 5760kb

input:

7 7 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1111111
1111111
1111111
1111111
1111111
1110111
1111111

output:

6 52

result:

ok 2 number(s): "6 52"

Subtask #2:

score: 5
Accepted

Dependency #1:

100%
Accepted

Test #6:

score: 5
Accepted
time: 0ms
memory: 6064kb

input:

16 17 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
111111111111111111
111111111111111111
111011111111111111
111111111111111111
111111111111111111
111011110111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
1...

output:

14 328354990

result:

ok 2 number(s): "14 328354990"

Test #7:

score: 5
Accepted
time: 1ms
memory: 6116kb

input:

17 16 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111101111111111
111111111111111111
111111111111011111
...

output:

15 449998848

result:

ok 2 number(s): "15 449998848"

Test #8:

score: 5
Accepted
time: 0ms
memory: 6140kb

input:

16 18 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
111111111111110111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111110111111
111111111111111111
11111111111111111...

output:

15 844316215

result:

ok 2 number(s): "15 844316215"

Test #9:

score: 5
Accepted
time: 1ms
memory: 6088kb

input:

16 17 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
111111111111111111
111111111111111111
111011111111110111
111111111111111111
111111111111111111
111011111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
1...

output:

15 133840

result:

ok 2 number(s): "15 133840"

Test #10:

score: 5
Accepted
time: 1ms
memory: 6092kb

input:

18 18 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111111111111
111111111011111111
111111111111111111
111101111111111111
111111111111111111
11111111111...

output:

16 27330297

result:

ok 2 number(s): "16 27330297"

Subtask #3:

score: 10
Accepted

Dependency #2:

100%
Accepted

Test #11:

score: 10
Accepted
time: 6ms
memory: 7780kb

input:

10 377 400
1 2 3 4 5 6 7 8 9 10
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 ...

output:

10 843273461

result:

ok 2 number(s): "10 843273461"

Test #12:

score: 10
Accepted
time: 6ms
memory: 8076kb

input:

10 367 400
1 2 3 4 5 6 7 8 9 10
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104...

output:

10 273577493

result:

ok 2 number(s): "10 273577493"

Test #13:

score: 10
Accepted
time: 3ms
memory: 7896kb

input:

10 350 400
1 2 3 4 5 6 7 8 9 10
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 11...

output:

9 605707862

result:

ok 2 number(s): "9 605707862"

Test #14:

score: 10
Accepted
time: 3ms
memory: 9804kb

input:

10 375 400
1 2 3 4 5 6 7 8 9 10
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101...

output:

10 213051017

result:

ok 2 number(s): "10 213051017"

Test #15:

score: 10
Accepted
time: 3ms
memory: 8052kb

input:

10 330 400
1 2 3 4 5 6 7 8 9 10
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 ...

output:

9 320097125

result:

ok 2 number(s): "9 320097125"

Test #16:

score: 10
Accepted
time: 3ms
memory: 7836kb

input:

10 360 400
1 2 3 4 5 6 7 8 9 10
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107...

output:

10 195548453

result:

ok 2 number(s): "10 195548453"

Test #17:

score: 10
Accepted
time: 6ms
memory: 7840kb

input:

10 365 400
1 2 3 4 5 6 7 8 9 10
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10...

output:

10 20617593

result:

ok 2 number(s): "10 20617593"

Test #18:

score: 10
Accepted
time: 3ms
memory: 7840kb

input:

10 334 400
1 2 3 4 5 6 7 8 9 10
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 11...

output:

10 602177426

result:

ok 2 number(s): "10 602177426"

Test #19:

score: 10
Accepted
time: 6ms
memory: 9752kb

input:

10 323 400
1 2 3 4 5 6 7 8 9 10
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 1...

output:

9 619229914

result:

ok 2 number(s): "9 619229914"

Test #20:

score: 10
Accepted
time: 6ms
memory: 7896kb

input:

10 379 400
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 1...

output:

10 409116219

result:

ok 2 number(s): "10 409116219"

Subtask #4:

score: 25
Accepted

Dependency #3:

100%
Accepted

Test #21:

score: 25
Accepted
time: 69ms
memory: 12084kb

input:

100 322 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

85 207066474

result:

ok 2 number(s): "85 207066474"

Test #22:

score: 25
Accepted
time: 72ms
memory: 9860kb

input:

100 334 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

84 608992198

result:

ok 2 number(s): "84 608992198"

Test #23:

score: 25
Accepted
time: 68ms
memory: 12072kb

input:

100 373 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

87 22076236

result:

ok 2 number(s): "87 22076236"

Test #24:

score: 25
Accepted
time: 68ms
memory: 9816kb

input:

100 327 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

87 819624712

result:

ok 2 number(s): "87 819624712"

Test #25:

score: 25
Accepted
time: 69ms
memory: 12296kb

input:

100 326 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

89 339092727

result:

ok 2 number(s): "89 339092727"

Test #26:

score: 25
Accepted
time: 69ms
memory: 12368kb

input:

100 366 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

87 577188664

result:

ok 2 number(s): "87 577188664"

Test #27:

score: 25
Accepted
time: 65ms
memory: 9812kb

input:

100 394 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

86 909840591

result:

ok 2 number(s): "86 909840591"

Test #28:

score: 25
Accepted
time: 65ms
memory: 11428kb

input:

100 389 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

87 793712350

result:

ok 2 number(s): "87 793712350"

Test #29:

score: 25
Accepted
time: 72ms
memory: 11956kb

input:

100 334 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

89 8486281

result:

ok 2 number(s): "89 8486281"

Test #30:

score: 25
Accepted
time: 74ms
memory: 10632kb

input:

100 367 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

87 419573333

result:

ok 2 number(s): "87 419573333"

Subtask #5:

score: 10
Accepted

Test #31:

score: 10
Accepted
time: 41ms
memory: 9160kb

input:

73 73 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 ...

output:

73 849796347

result:

ok 2 number(s): "73 849796347"

Test #32:

score: 10
Accepted
time: 38ms
memory: 10244kb

input:

68 68 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152...

output:

68 334069950

result:

ok 2 number(s): "68 334069950"

Test #33:

score: 10
Accepted
time: 40ms
memory: 9560kb

input:

72 72 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133...

output:

72 180096245

result:

ok 2 number(s): "72 180096245"

Test #34:

score: 10
Accepted
time: 36ms
memory: 9532kb

input:

71 71 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 13...

output:

71 234343448

result:

ok 2 number(s): "71 234343448"

Test #35:

score: 10
Accepted
time: 30ms
memory: 9320kb

input:

68 68 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152...

output:

68 371509898

result:

ok 2 number(s): "68 371509898"

Test #36:

score: 10
Accepted
time: 264ms
memory: 14032kb

input:

200 200 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

200 852372194

result:

ok 2 number(s): "200 852372194"

Test #37:

score: 10
Accepted
time: 363ms
memory: 13084kb

input:

230 230 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

230 65874836

result:

ok 2 number(s): "230 65874836"

Test #38:

score: 10
Accepted
time: 488ms
memory: 15456kb

input:

260 260 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

260 272563656

result:

ok 2 number(s): "260 272563656"

Test #39:

score: 10
Accepted
time: 691ms
memory: 16616kb

input:

290 290 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

290 95450701

result:

ok 2 number(s): "290 95450701"

Test #40:

score: 10
Accepted
time: 909ms
memory: 17124kb

input:

320 320 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

320 266455174

result:

ok 2 number(s): "320 266455174"

Subtask #6:

score: 25
Accepted

Dependency #5:

100%
Accepted

Test #41:

score: 25
Accepted
time: 79ms
memory: 11380kb

input:

107 371 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

107 3979643

result:

ok 2 number(s): "107 3979643"

Test #42:

score: 25
Accepted
time: 67ms
memory: 9808kb

input:

101 351 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

101 372994325

result:

ok 2 number(s): "101 372994325"

Test #43:

score: 25
Accepted
time: 65ms
memory: 9860kb

input:

101 369 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

101 46156842

result:

ok 2 number(s): "101 46156842"

Test #44:

score: 25
Accepted
time: 72ms
memory: 10628kb

input:

101 386 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

101 634357614

result:

ok 2 number(s): "101 634357614"

Test #45:

score: 25
Accepted
time: 77ms
memory: 10044kb

input:

109 388 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

109 24613754

result:

ok 2 number(s): "109 24613754"

Test #46:

score: 25
Accepted
time: 283ms
memory: 13008kb

input:

200 399 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

200 342259639

result:

ok 2 number(s): "200 342259639"

Test #47:

score: 25
Accepted
time: 393ms
memory: 13428kb

input:

230 393 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

230 596706635

result:

ok 2 number(s): "230 596706635"

Test #48:

score: 25
Accepted
time: 535ms
memory: 14840kb

input:

260 393 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

260 569883617

result:

ok 2 number(s): "260 569883617"

Test #49:

score: 25
Accepted
time: 703ms
memory: 15700kb

input:

290 395 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

290 473037952

result:

ok 2 number(s): "290 473037952"

Test #50:

score: 25
Accepted
time: 932ms
memory: 19012kb

input:

320 397 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

320 375576485

result:

ok 2 number(s): "320 375576485"

Subtask #7:

score: 20
Accepted

Dependency #1:

100%
Accepted

Dependency #2:

100%
Accepted

Dependency #3:

100%
Accepted

Dependency #4:

100%
Accepted

Dependency #5:

100%
Accepted

Dependency #6:

100%
Accepted

Test #51:

score: 20
Accepted
time: 1027ms
memory: 18800kb

input:

400 375 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

0 1

result:

ok 2 number(s): "0 1"

Test #52:

score: 20
Accepted
time: 1303ms
memory: 20432kb

input:

400 346 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

44 259349435

result:

ok 2 number(s): "44 259349435"

Test #53:

score: 20
Accepted
time: 1464ms
memory: 18528kb

input:

400 368 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

92 934744081

result:

ok 2 number(s): "92 934744081"

Test #54:

score: 20
Accepted
time: 1535ms
memory: 21376kb

input:

400 331 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

118 819815069

result:

ok 2 number(s): "118 819815069"

Test #55:

score: 20
Accepted
time: 1201ms
memory: 20148kb

input:

355 385 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

154 827736761

result:

ok 2 number(s): "154 827736761"

Test #56:

score: 20
Accepted
time: 1609ms
memory: 18876kb

input:

400 380 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

165 936566720

result:

ok 2 number(s): "165 936566720"

Test #57:

score: 20
Accepted
time: 1456ms
memory: 20992kb

input:

382 335 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

164 615816056

result:

ok 2 number(s): "164 615816056"

Test #58:

score: 20
Accepted
time: 1616ms
memory: 18580kb

input:

400 324 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

180 258747176

result:

ok 2 number(s): "180 258747176"

Test #59:

score: 20
Accepted
time: 1624ms
memory: 18836kb

input:

400 326 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

191 245039016

result:

ok 2 number(s): "191 245039016"

Test #60:

score: 20
Accepted
time: 1028ms
memory: 17400kb

input:

333 388 400
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 ...

output:

212 219763298

result:

ok 2 number(s): "212 219763298"

Extra Test:

score: 0
Extra Test Passed