KiritoTRw
GitHub
parent
2d9cf4fdf2
commit
997ec50f19
|
|
@ -0,0 +1,30 @@
|
|||
#include<stdio.h>
|
||||
#include<math.h>
|
||||
int main()
|
||||
{
|
||||
double x1,x2,x3,y1,y2,y3,a,b,c,r;
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%lf%lf",&x1,&y1);
|
||||
r=sqrt(x1*x1+y1*y1);
|
||||
a=1;
|
||||
b=y1;
|
||||
c=r*r/4-x1*x1;
|
||||
y2=(-b-sqrt(b*b-4*a*c))/(2*a);
|
||||
y3=(-b+sqrt(b*b-4*a*c))/(2*a);
|
||||
if(fabs(x1-0)<1e-7)
|
||||
{
|
||||
x2=-sqrt(r*r-y2*y2);
|
||||
x3=sqrt(r*r-y3*y3);
|
||||
}
|
||||
else
|
||||
{
|
||||
x2=(-r*r/2-y1*y2)/x1;
|
||||
x3=(-r*r/2-y1*y3)/x1;
|
||||
}
|
||||
printf("%.3lf %.3lf %.3lf %.3lf\n",x2,y2,x3,y3);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{ double j,k;int n,i;
|
||||
cin>>n;
|
||||
while(n--)
|
||||
{
|
||||
cin>>j>>k;
|
||||
i=2;
|
||||
while(i>1)
|
||||
{
|
||||
if(int(k*i*0.01)-int(j*i*0.01)==1)
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
cout<<i<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,84 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stack>
|
||||
#include<queue>
|
||||
using namespace std;
|
||||
void que(int n)
|
||||
{
|
||||
int a,b;
|
||||
char str[5];
|
||||
queue<int>q;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
if(!strcmp(str,"IN"))
|
||||
{
|
||||
scanf("%d",&a);
|
||||
q.push(a);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(q.empty())
|
||||
printf("None\n");
|
||||
else
|
||||
{
|
||||
b=q.front();
|
||||
printf("%d\n",b);
|
||||
q.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
while(!q.empty())
|
||||
{
|
||||
q.pop();
|
||||
}
|
||||
}
|
||||
void sta(int n)
|
||||
{
|
||||
int a,b;
|
||||
char str[5];
|
||||
stack<int>s;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
if(!strcmp(str,"IN"))
|
||||
{
|
||||
scanf("%d",&a);
|
||||
s.push(a);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(s.empty())
|
||||
printf("None\n");
|
||||
else
|
||||
{
|
||||
b=s.top();
|
||||
printf("%d\n",b);
|
||||
s.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
while(!s.empty())
|
||||
{
|
||||
s.pop();
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,n,i,j;
|
||||
char s1[6];
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d %s",&n,s1);
|
||||
if(!strcmp(s1,"FIFO"))
|
||||
{
|
||||
que(n);
|
||||
}
|
||||
else
|
||||
{
|
||||
sta(n);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#include<stdio.h>
|
||||
int main(){
|
||||
int n;
|
||||
while(scanf("%d",&n)&&n){
|
||||
if(n==1||n==2){
|
||||
printf("%d\n",(n-1)*5); continue;
|
||||
}
|
||||
else if(n==3) printf("15\n");
|
||||
else printf("%d\n",(n*2-4)*5);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#include<stdio.h>
|
||||
#include<stdlib.h>
|
||||
#include<string.h>
|
||||
#include<math.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define M 505
|
||||
int a[M][M],n;
|
||||
void dfs(int x,int y)
|
||||
{
|
||||
int i,j;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
if(a[i][x]==1)
|
||||
{
|
||||
a[i][y]=1;
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(a[y][j]==1)
|
||||
a[i][j]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m,t,x,y,i,j,sum;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
sum=0;
|
||||
memset(a,0,sizeof(a));
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=1;i<=n;i++)
|
||||
a[i][i]=1;
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d",&x,&y);
|
||||
a[x][y]=1;
|
||||
dfs(x,y);
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
{
|
||||
if(a[i][j]==1)
|
||||
sum++;
|
||||
}
|
||||
}
|
||||
sum=n*(n+1)/2-sum;
|
||||
printf("%d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
struct point{
|
||||
int x,y;
|
||||
}p[3],m[3];
|
||||
int gcd(int a,int b){
|
||||
int c;
|
||||
while(b){
|
||||
c=a%b;
|
||||
a=b;
|
||||
b=c;
|
||||
}
|
||||
return a;
|
||||
}
|
||||
int abs(int x){
|
||||
return x>0?x:-x;
|
||||
}
|
||||
int S(point p1,point p2,point p0){
|
||||
return abs((p1.x-p0.x)*(p2.y-p0.y)-(p1.y-p0.y)*(p2.x-p0.x));
|
||||
}
|
||||
int main(){
|
||||
int sum,s,ans;
|
||||
while(~scanf("%d%d%d%d%d%d",&p[0].x,&p[0].y,&p[1].x,&p[1].y,&p[2].x,&p[2].y)){
|
||||
if(!p[0].x&&!p[0].y&&!p[1].x&&!p[1].y&&!p[2].x&&!p[2].y)break;
|
||||
m[0].x=abs(p[0].x-p[1].x);m[0].y=abs(p[0].y-p[1].y);
|
||||
m[1].x=abs(p[1].x-p[2].x);m[1].y=abs(p[1].y-p[2].y);
|
||||
m[2].x=abs(p[0].x-p[2].x);m[2].y=abs(p[0].y-p[2].y);
|
||||
sum=gcd(m[0].x,m[0].y)+gcd(m[1].x,m[1].y)+gcd(m[2].x,m[2].y);
|
||||
s=S(p[1],p[2],p[0]);
|
||||
ans=(s-sum+2)/2;
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
#include<stdio.h>
|
||||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
typedef struct
|
||||
{
|
||||
int timecheck[8][12];
|
||||
char name[30];
|
||||
}student;
|
||||
typedef struct
|
||||
{
|
||||
char Lname[30];
|
||||
}Lstudent;
|
||||
student book[201];
|
||||
Lstudent buf[201];
|
||||
bool c(Lstudent a,Lstudent b)
|
||||
{
|
||||
return (strcmp(a.Lname,b.Lname)<0);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n,i,b,t,k,l,x,b1,e1,count;
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
memset(book, 0, sizeof(book));
|
||||
memset(buf, 0, sizeof(buf));
|
||||
scanf("%d",&t);
|
||||
for(b=0;b<t;b++)
|
||||
{
|
||||
scanf("%s",book[b].name);
|
||||
scanf("%d",&k);
|
||||
for(l=0;l<k;l++)
|
||||
{
|
||||
scanf("%d%d%d",&x,&b1,&e1);
|
||||
for(int o=b1;o<=e1;o++)
|
||||
{
|
||||
book[b].timecheck[x][o]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
scanf("%d",&k);
|
||||
for(l=0;l<k;l++)
|
||||
{
|
||||
int first=1;
|
||||
count=0;
|
||||
scanf("%d%d%d",&x,&b1,&e1);
|
||||
for(b=0;b<t;b++)
|
||||
{
|
||||
for(int o=b1;o<=e1;o++)
|
||||
{
|
||||
if(book[b].timecheck[x][o]==1)
|
||||
{
|
||||
strcpy(buf[count].Lname,book[b].name);
|
||||
count++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(count==0)
|
||||
{
|
||||
printf("None\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
sort(buf,buf+count,c);
|
||||
for(int y=0;y<count;y++)
|
||||
{
|
||||
if(first)
|
||||
first=0;
|
||||
else
|
||||
printf(" ");
|
||||
printf("%s",buf[y].Lname);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
__int64 a1[26],f[55],a2[26];
|
||||
char s1[55],s2[55];
|
||||
int main()
|
||||
{
|
||||
int k,n,i,t,j;
|
||||
scanf("%d",&t);
|
||||
getchar();
|
||||
while(t--)
|
||||
{
|
||||
char ch='a';
|
||||
int p=1;
|
||||
memset(a1,0,sizeof(a1));
|
||||
memset(a2,0,sizeof(a2));
|
||||
scanf("%s%s%d",s1,s2,&k);
|
||||
for(i=0;i<strlen(s1);i++)
|
||||
{
|
||||
int d=s1[i]-'a';
|
||||
a1[d]++;
|
||||
}
|
||||
for(i=0;i<strlen(s2);i++)
|
||||
{
|
||||
int d=s2[i]-'a';
|
||||
a2[d]++;
|
||||
}
|
||||
for(i=0;i<26;i++)
|
||||
{
|
||||
f[0]=a1[i];
|
||||
f[1]=a2[i];
|
||||
for(j=2;j<=k;j++) f[j]=f[j-2]+f[j-1];
|
||||
a1[i]=f[k];
|
||||
}
|
||||
for(i=0;i<26;i++) printf("%c:%I64d\n",ch+i,a1[i]);
|
||||
printf("\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
const int N=1005;
|
||||
int pre[N],in[N],post[N];
|
||||
int n;
|
||||
void getpost(int pa,int pb,int ia,int ib,int la,int lb)
|
||||
{
|
||||
if(pa>pb||ia>ib||la>lb) return;
|
||||
int a,b,i;
|
||||
for (i=ia;i<=ib;i++)
|
||||
{
|
||||
if (in[i]==pre[pa])
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
a=i-ia;b=ib-i;
|
||||
post[lb]=in[i];
|
||||
getpost(pa+1,pa+a,ia,i-1,la,la+a-1);
|
||||
getpost(pb-b+1,pb,i+1,ib,lb-b,lb-1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for (int i=1;i<=n;i++)
|
||||
scanf("%d",&pre[i]);
|
||||
for (int i=1;i<=n;i++)
|
||||
scanf("%d",&in[i]);
|
||||
getpost(1,n,1,n,1,n);
|
||||
for (int i=1;i<n;i++)
|
||||
printf("%d ",post[i]);
|
||||
printf("%d\n",post[n]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
#include<stdio.h>
|
||||
int a[1000000],b[10000],t,n,m,i,j,flag=0,k=0;
|
||||
int main()
|
||||
{
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d%d",&n,&m);
|
||||
for(i=0;i<n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
for(i=0;i<m;i++)
|
||||
scanf("%d",&b[i]);
|
||||
i=0;
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
if(b[i]==a[j])
|
||||
i++;
|
||||
if(i==m)
|
||||
{
|
||||
printf("%d\n",j-m+2);
|
||||
flag=1;
|
||||
i=0;
|
||||
break;
|
||||
}
|
||||
else if(i!=m&&b[i-1]!=a[j])
|
||||
{
|
||||
j=k;
|
||||
k++;
|
||||
i=0;
|
||||
}
|
||||
}
|
||||
if(flag==0)
|
||||
printf("-1\n");
|
||||
flag=0;
|
||||
k=0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
int max(int x,int y)
|
||||
{
|
||||
if(x>=y)
|
||||
return x;
|
||||
return y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m,n,i,j,k,d[105],a[105][105];
|
||||
while(scanf("%d%d",&n,&m)==2)
|
||||
{
|
||||
if(m==0&&n==0) break;
|
||||
memset(d,0,sizeof(d));
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
scanf("%d",&a[i][j]);
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=m;j>=1;j--)
|
||||
{
|
||||
for(k=1;k<=j;k++)
|
||||
d[j]=max(d[j],d[j-k]+a[i][k]);
|
||||
}
|
||||
printf("%d\n",d[m]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include <iostream>
|
||||
#include <iomanip>
|
||||
#include <cmath>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
double a,b;
|
||||
double x,y;
|
||||
int n;
|
||||
cin >> n;
|
||||
while(n--&&cin >> a >> b >> x >> y)
|
||||
{
|
||||
y = y>0?y:-y;
|
||||
double f = y/x;
|
||||
double newx = sqrt(a*a*b*b/(b*b + f*f*a*a));
|
||||
double newy = f*newx;
|
||||
newx = newx/a*b;
|
||||
newy /= b;
|
||||
newx /= b;
|
||||
double t = acos(newx);
|
||||
double area = t * b * a / 2;
|
||||
cout << fixed << setprecision(2) << area << endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int a[5],tem;
|
||||
cin>>a[1]>>a[2]>>a[3]>>a[4];
|
||||
while(a[1]||a[2]||a[3]||a[4])
|
||||
{
|
||||
sort(a+1,a+5);
|
||||
tem=a[1];
|
||||
if(tem)
|
||||
cout<<a[1]<<a[2]<<a[3]<<a[4];
|
||||
while(next_permutation(a+1,a+5))
|
||||
{
|
||||
int i=1;
|
||||
if(a[1])
|
||||
{
|
||||
if(tem && a[i]==tem)
|
||||
cout<<" ";
|
||||
for(i=1; i<=4; i++)
|
||||
{
|
||||
if(a[i]!=tem && i==1 && tem)
|
||||
cout<<endl;
|
||||
cout<<a[i];
|
||||
}
|
||||
}
|
||||
tem=a[1];
|
||||
}
|
||||
cout<<endl;
|
||||
cin>>a[1]>>a[2]>>a[3]>>a[4];
|
||||
if(a[1]||a[2]||a[3]||a[4])
|
||||
cout<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
int gcd(int a,int b){
|
||||
return b==0?a:gcd(b,a%b);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
char str[20];
|
||||
int T;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
scanf("%s",str);
|
||||
int len = strlen(str);
|
||||
int i,j,a,b;
|
||||
int flag = 1;
|
||||
int ans1 = 0,ans2 = 0;
|
||||
int shi1 = 1,shi2 = 0;
|
||||
for(i = 2;i < len;i++)
|
||||
{
|
||||
if(str[i] == '(')
|
||||
{flag = 0;}
|
||||
if(str[i] >= '0'&&str[i] <= '9')
|
||||
{
|
||||
if(flag)
|
||||
{
|
||||
shi1 = shi1*10;
|
||||
ans1 = ans1*10+str[i]-'0';
|
||||
}
|
||||
else
|
||||
{
|
||||
shi2 = shi2*10+9;
|
||||
ans2 = ans2*10+str[i]-'0';
|
||||
}
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
{
|
||||
printf("%d/%d\n",ans1/gcd(ans1,shi1),shi1/gcd(ans1,shi1));
|
||||
}
|
||||
else
|
||||
{
|
||||
int cnt = gcd(ans2+shi2*ans1,shi2);
|
||||
a=(ans2+shi2*ans1)/cnt;
|
||||
b=shi2/cnt;
|
||||
int Cnt=gcd(a,b*shi1);
|
||||
printf("%d/%d\n",a/Cnt,b*shi1/Cnt);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
void main()
|
||||
{
|
||||
int a[101],i,num,num1,rank,mark1,mark;
|
||||
while(cin>>num)
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
while(cin>>num1>>mark1&&(num1!=0||mark1!=0))
|
||||
{
|
||||
if(num1==num)
|
||||
mark=mark1;
|
||||
a[mark1]++;
|
||||
}
|
||||
for(i=100,rank=0;i>mark;i--)
|
||||
rank+=a[i];
|
||||
cout<<rank+1<<endl;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
int main()
|
||||
{
|
||||
int a,b;
|
||||
while(scanf("%x%x",&a,&b)!=EOF){
|
||||
printf("%d\n",a+b);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int a[8];
|
||||
int main()
|
||||
{
|
||||
int x;
|
||||
while(cin>>x)
|
||||
{
|
||||
int sum1;
|
||||
int sum2;
|
||||
if(x==-1)
|
||||
break;
|
||||
a[0]=x;
|
||||
for(int i=1;i<=7;i++)
|
||||
{
|
||||
cin>>a[i];
|
||||
}
|
||||
sum1=a[0]+a[2]+a[5]+a[7];
|
||||
sum2=a[1]+a[3]+a[4]+a[6];
|
||||
if(sum1==sum2)
|
||||
cout<<"All the seeds can be cleared away!"<<endl;
|
||||
else
|
||||
cout<<"Sorry,it can't be cleared away!"<<endl;
|
||||
char c=getchar();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,m,a,b;
|
||||
while(cin>>n>>m)
|
||||
{
|
||||
a=n;
|
||||
b=m;
|
||||
while(a!=b)
|
||||
{
|
||||
if(a>b)
|
||||
a-=b;
|
||||
else
|
||||
b-=a;
|
||||
}
|
||||
cout<<n+m-a<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
int main()
|
||||
{ int a[50];
|
||||
int n,m;
|
||||
int i,j;
|
||||
while(cin>>n>>m && (n||m))
|
||||
{
|
||||
memset(a,0,sizeof(a));
|
||||
a[1]=1;
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=m;j++)
|
||||
if(i+j<=n)
|
||||
a[i+j]+=a[i];
|
||||
cout<<a[n]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <algorithm>
|
||||
#include <string>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <set>
|
||||
#include <map>
|
||||
using namespace std;
|
||||
double a,b,l,r;
|
||||
double F(double x)
|
||||
{
|
||||
return b*sqrt((1-x/a)*(1+x/a));
|
||||
}
|
||||
double simpson(double a,double b)
|
||||
{
|
||||
double c=(a+b)/2;
|
||||
return (F(a)+4*F(c)+F(b))*(b-a)/6.;
|
||||
}
|
||||
double asr(double a,double b,double eps,double A)
|
||||
{
|
||||
double c=(a+b)/2;
|
||||
double L=simpson(a,c),R=simpson(c,b);
|
||||
if(fabs(L+R-A)<=15*eps) return L+R+(L+R-A)/15.0;
|
||||
return asr(a,c,eps/2,L)+asr(c,b,eps/2,R);
|
||||
}
|
||||
double ASR(double a,double b,double eps)
|
||||
{
|
||||
return asr(a,b,eps,simpson(a,b));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int T_T;
|
||||
scanf("%d",&T_T);
|
||||
while(T_T--)
|
||||
{
|
||||
scanf("%lf%lf%lf%lf",&a,&b,&l,&r);
|
||||
printf("%.3lf\n",2.*ASR(l,r,1e-6));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
int order_mut[32];
|
||||
int function(int n)
|
||||
{
|
||||
int i;
|
||||
order_mut[0]=1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
order_mut[i]=order_mut[i-1]*i;
|
||||
if(order_mut[i]>n)break;
|
||||
}
|
||||
return i-1;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,t,n,m,ans;
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
scanf("%d",&n);
|
||||
int m=function(n);
|
||||
ans=0;
|
||||
for(i=m;i>=1;i--)
|
||||
{
|
||||
int temp=n/order_mut[i];
|
||||
ans+=temp;
|
||||
n-=temp*order_mut[i];
|
||||
if(n==0)break;
|
||||
}
|
||||
cout<<ans<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#define MAX 0x0f0f0f0f
|
||||
using namespace std;
|
||||
char s[105];
|
||||
int dp[105][105];
|
||||
int min(int a,int b){
|
||||
return a>b?b:a;
|
||||
}
|
||||
bool Judge(int a,int b){
|
||||
while(a<b){
|
||||
if(s[a]!=s[b]) return 0;
|
||||
a++,b--;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
int DFS(int a,int b){
|
||||
if(dp[a][b]!=MAX) return dp[a][b];
|
||||
if(Judge(a,b)) {dp[a][b] = 1;return 1;}
|
||||
for(int k = a;k<b;k++){
|
||||
dp[a][b]=min(dp[a][b],DFS(a,k)+DFS(k+1,b));
|
||||
}
|
||||
return dp[a][b];
|
||||
}
|
||||
int main(){
|
||||
while(~scanf("%s",s)){
|
||||
memset(dp,MAX,sizeof(dp));
|
||||
printf("%d\n",DFS(0,strlen(s)-1)-1);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<stdio.h>
|
||||
int main()
|
||||
{
|
||||
int a,b;
|
||||
char s[10][10]={"\0","one","two","three","four","five","six","seven","eight","nine"};
|
||||
char p[10][10]={"\0","\0","twenty","thirty","forty","fifty","sixty","seventy","eighty","ninety"};
|
||||
char q[20][10]={"\0","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"};
|
||||
while(scanf("%d",&a)!=EOF)
|
||||
{
|
||||
if(a==0){printf("zero\n");continue;}
|
||||
if(a/1000)
|
||||
{
|
||||
printf("%s thousand",s[a/1000]);
|
||||
b=a;
|
||||
a=a-b/1000*1000;
|
||||
if(a)printf(" and ");
|
||||
}
|
||||
if(a/100)
|
||||
{
|
||||
printf("%s hundred",s[a/100]);
|
||||
b=a;
|
||||
a=a-b/100*100;
|
||||
if(a)printf(" and ");
|
||||
}
|
||||
if(a<20)printf("%s",q[a]);
|
||||
else
|
||||
{
|
||||
if(a>=20)
|
||||
{printf("%s",p[a/10]);b=a;a=a-b/10*10;}
|
||||
if(a)printf("-%s",s[a]);
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,70 @@
|
|||
#include <iostream>
|
||||
#include <queue>
|
||||
#include <cstring>
|
||||
#define MAXN 100 + 10
|
||||
using namespace std;
|
||||
typedef struct{
|
||||
int x,y,turn;
|
||||
}coordinate;
|
||||
int m,n,k;
|
||||
queue<coordinate>Q;
|
||||
coordinate start,goal;
|
||||
char maze[MAXN][MAXN];
|
||||
bool vis[MAXN][MAXN];
|
||||
const int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};
|
||||
void Init(){
|
||||
memset(maze,0,sizeof(maze));
|
||||
memset(vis,false,sizeof(vis));
|
||||
}
|
||||
bool Judge(int x,int y){
|
||||
if(x<=0||x>m||y<=0||y>n||maze[x][y]=='*')
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
bool BFS(){
|
||||
coordinate now,next;
|
||||
while(!Q.empty())
|
||||
Q.pop();
|
||||
if(start.x==goal.x&&start.y==goal.y)
|
||||
return true;
|
||||
Q.push(start);
|
||||
vis[start.x][start.y]=true;
|
||||
while(!Q.empty()){
|
||||
now = Q.front();
|
||||
Q.pop();
|
||||
for(int i=0;i<4;i++){
|
||||
next.x = now.x + dx[i];
|
||||
next.y = now.y + dy[i];
|
||||
while(Judge(next.x,next.y)){
|
||||
if(!vis[next.x][next.y]){
|
||||
next.turn = now.turn + 1;
|
||||
vis[next.x][next.y] = true;
|
||||
Q.push(next);
|
||||
if(next.x==goal.x&&next.y==goal.y&&next.turn<=k)
|
||||
return true;
|
||||
}
|
||||
next.x += dx[i];
|
||||
next.y += dy[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
int main(){
|
||||
int T;
|
||||
cin>>T;
|
||||
while(T--){
|
||||
cin>>m>>n;
|
||||
Init();
|
||||
for(int i=1;i<=m;i++)
|
||||
for(int j=1;j<=n;j++)
|
||||
cin>>maze[i][j];
|
||||
cin>>k>>start.y>>start.x>>goal.y>>goal.x;
|
||||
start.turn=-1;
|
||||
if(BFS())
|
||||
cout<<"yes"<<endl;
|
||||
else
|
||||
cout<<"no"<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#define N 10005
|
||||
#define LL long long
|
||||
#define inf 1<<29
|
||||
#define eps 1e-7
|
||||
using namespace std;
|
||||
int get_sg(int s,int c){
|
||||
int q=sqrt((double)s);
|
||||
while(q+q*q>=s)
|
||||
q--;
|
||||
if(c>q) return s-c;
|
||||
else return get_sg(q,c);
|
||||
}
|
||||
int main(){
|
||||
int n,cas=0;
|
||||
while(scanf("%d",&n)!=EOF&&n){
|
||||
int s,c;
|
||||
printf("Case %d:\n",++cas);
|
||||
int ans=0;
|
||||
while(n--){
|
||||
scanf("%d%d",&s,&c);
|
||||
ans^=get_sg(s,c);
|
||||
}
|
||||
if(ans)
|
||||
puts("Yes");
|
||||
else
|
||||
puts("No");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<math.h>
|
||||
int main()
|
||||
{
|
||||
int n,m;
|
||||
int i;
|
||||
int ti,ji;
|
||||
int ans;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
ans=0;
|
||||
while(n--)
|
||||
{
|
||||
scanf("%d%d",&ti,&ji);
|
||||
ans^=abs(abs(ti-ji)-1);
|
||||
}
|
||||
printf("%s\n",ans==0?"BAD LUCK!":"I WIN!");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
#include<iostream>
|
||||
#include<queue>
|
||||
#include<cstdio>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
struct node
|
||||
{
|
||||
int x,y,x1,y1,x2,y2,x3,y3;
|
||||
int step;
|
||||
};
|
||||
bool vist[8][8][8][8][8][8][8][8];
|
||||
int n,m,t[4][2]= {1,0,-1,0,0,1,0,-1};
|
||||
int f[10][10],cnt;
|
||||
char s[10][10];
|
||||
queue<node>q;
|
||||
void bfs()
|
||||
{
|
||||
while(!q.empty())
|
||||
{
|
||||
node p=q.front();
|
||||
q.pop();
|
||||
if(f[p.x1][p.y1]&&f[p.x2][p.y2]&&f[p.x3][p.y3])
|
||||
{
|
||||
printf("%d\n",p.step);
|
||||
return;
|
||||
}
|
||||
for(int i=0; i<4; i++)
|
||||
{
|
||||
int mx=p.x+t[i][0];
|
||||
int my=p.y+t[i][1];
|
||||
int xx=p.x+2*t[i][0];
|
||||
int yy=p.y+2*t[i][1];
|
||||
if(mx>=0&&mx<n&&my>=0&&my<m&&s[mx][my]!='#')
|
||||
{
|
||||
if(!((mx==p.x1&&my==p.y1)||(mx==p.x2&&my==p.y2)||(mx==p.x3&&my==p.y3)))
|
||||
{
|
||||
node p1=p;
|
||||
p1.x=mx;
|
||||
p1.y=my;
|
||||
p1.step=p.step+1;
|
||||
if(!vist[p1.x][p1.y][p1.x1][p1.y1][p1.x2][p1.y2][p1.x3][p1.y3])
|
||||
{
|
||||
vist[p1.x][p1.y][p1.x1][p1.y1][p1.x2][p1.y2][p1.x3][p1.y3]=true;
|
||||
q.push(p1);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(xx>=0&&xx<n&&yy>=0&&yy<m&&s[xx][yy]!='#')
|
||||
{
|
||||
if(!((xx==p.x1&&yy==p.y1)||(xx==p.x2&&yy==p.y2)||(xx==p.x3&&yy==p.y3)))
|
||||
{
|
||||
node p1=p;
|
||||
p1.x=mx;
|
||||
p1.y=my;
|
||||
if(p1.x1==mx&&p1.y1==my)
|
||||
{
|
||||
p1.x1=xx;
|
||||
p1.y1=yy;
|
||||
}
|
||||
if(p1.x2==mx&&p1.y2==my)
|
||||
{
|
||||
p1.x2=xx;
|
||||
p1.y2=yy;
|
||||
}
|
||||
if(p1.x3==mx&&p1.y3==my)
|
||||
{
|
||||
p1.x3=xx;
|
||||
p1.y3=yy;
|
||||
}
|
||||
p1.step=p.step+1;
|
||||
if(!vist[p1.x][p1.y][p1.x1][p1.y1][p1.x2][p1.y2][p1.x3][p1.y3])
|
||||
{
|
||||
vist[p1.x][p1.y][p1.x1][p1.y1][p1.x2][p1.y2][p1.x3][p1.y3]=true;
|
||||
q.push(p1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("-1\n");
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&n,&m)>0)
|
||||
{
|
||||
memset(vist,false,sizeof(vist));
|
||||
memset(f,0,sizeof(f));
|
||||
while(!q.empty())
|
||||
q.pop();
|
||||
cnt=0;
|
||||
int w=0;
|
||||
node p;
|
||||
for(int i=0; i<n; i++)
|
||||
{
|
||||
scanf("%s",s[i]);
|
||||
for(int j=0; j<m; j++)
|
||||
{
|
||||
if(s[i][j]=='*'&&w==0)
|
||||
{
|
||||
w++;
|
||||
p.x1=i;
|
||||
p.y1=j;
|
||||
s[i][j]='.';
|
||||
}
|
||||
else if(s[i][j]=='*'&&w==1)
|
||||
{
|
||||
w++;
|
||||
p.x2=i;
|
||||
p.y2=j;
|
||||
s[i][j]='.';
|
||||
}
|
||||
else if(s[i][j]=='*'&&w==2)
|
||||
{
|
||||
w++;
|
||||
p.x3=i;
|
||||
p.y3=j;
|
||||
s[i][j]='.';
|
||||
}
|
||||
if(s[i][j]=='X')
|
||||
{
|
||||
p.x=i;
|
||||
p.y=j;
|
||||
s[i][j]='.';
|
||||
}
|
||||
if(s[i][j]=='@')
|
||||
{
|
||||
f[i][j]=1;
|
||||
s[i][j]='.';
|
||||
}
|
||||
}
|
||||
}
|
||||
p.step=0;
|
||||
vist[p.x][p.y][p.x1][p.y1][p.x2][p.y2][p.x3][p.y3]=true;
|
||||
q.push(p);
|
||||
bfs();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,221 @@
|
|||
#include <iostream>
|
||||
#include <cstdio>
|
||||
#include <memory.h>
|
||||
#include <algorithm>
|
||||
#define MAXN 20005
|
||||
#define Lim 75
|
||||
#define INF (1<<30)
|
||||
#define max(a,b) (a>b?a:b)
|
||||
#define min(a,b) (a<b?a:b)
|
||||
using namespace std;
|
||||
struct Node
|
||||
{
|
||||
int x,y;
|
||||
Node(int x1,int y1)
|
||||
{x=x1;y=y1;}
|
||||
Node(){}
|
||||
};
|
||||
struct edge
|
||||
{
|
||||
int u,v,w,next;
|
||||
}E[2000000];
|
||||
int head[MAXN],ecnt;
|
||||
int gap[MAXN],cur[MAXN],dis[MAXN],pre[MAXN];
|
||||
int N,M,scr,sink,vn,Ti,Sum,now;
|
||||
int ans;
|
||||
int dir[5][2]={0,1,0,-1,1,0,-1,0,0,0};
|
||||
char map[20][20];
|
||||
Node Q[200000];
|
||||
int Head,Tail;
|
||||
bool vis[20][20];
|
||||
void Insert(int u,int v,int w)
|
||||
{
|
||||
E[ecnt].u=u;
|
||||
E[ecnt].v=v;
|
||||
E[ecnt].w=w;
|
||||
E[ecnt].next=head[u];
|
||||
head[u]=ecnt++;
|
||||
E[ecnt].u=v;
|
||||
E[ecnt].v=u;
|
||||
E[ecnt].w=0;
|
||||
E[ecnt].next=head[v];
|
||||
head[v]=ecnt++;
|
||||
}
|
||||
bool BFS(Node s)
|
||||
{
|
||||
int i,j;
|
||||
Node u,v;
|
||||
memset(vis,false,sizeof(vis));
|
||||
Head=Tail=0;
|
||||
vis[s.x][s.y]=true;
|
||||
Q[Head++]=s;
|
||||
while(Head!=Tail)
|
||||
{
|
||||
u=Q[Tail++];
|
||||
if(map[u.x][u.y]=='@') return true;
|
||||
for(i=0;i<4;i++)
|
||||
{
|
||||
int dx=u.x+dir[i][0];
|
||||
int dy=u.y+dir[i][1];
|
||||
if(dx>=0&&dx<N&&dy>=0&&dy<M&&map[dx][dy]!='#'&&!vis[dx][dy])
|
||||
{
|
||||
vis[dx][dy]=true;
|
||||
Q[Head++]=Node(dx,dy);
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool OK()
|
||||
{
|
||||
bool ok=true;
|
||||
Node s;
|
||||
int i,j;
|
||||
for(i=0;i<N&&ok;i++)
|
||||
{
|
||||
for(j=0;j<M;j++)
|
||||
{
|
||||
if(map[i][j]=='X')
|
||||
{
|
||||
s.x=i;s.y=j;
|
||||
if(!BFS(s))
|
||||
{ok=false;break;}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ok;
|
||||
}
|
||||
void Init()
|
||||
{
|
||||
int i,j,u;
|
||||
memset(head,-1,sizeof(head));ecnt=0;
|
||||
for(i=0;i<N;i++)
|
||||
scanf("%s",map[i]);
|
||||
scr=0;sink=1;vn=2;
|
||||
Sum=0;
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
for(j=0;j<M;j++)
|
||||
{
|
||||
if(map[i][j]=='X')
|
||||
{
|
||||
Sum++;
|
||||
u=i*M+j+2;
|
||||
Insert(scr,u,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
now=(M*N);
|
||||
vn+=now;
|
||||
}
|
||||
int Sap(int s,int t,int n)
|
||||
{
|
||||
int ans=0,aug=INF;
|
||||
int i,v,u=pre[s]=s;
|
||||
for(i=0;i<=n;i++)
|
||||
{
|
||||
cur[i]=head[i];
|
||||
dis[i]=gap[i]=0;
|
||||
}
|
||||
gap[s]=n;
|
||||
bool flag;
|
||||
while(dis[s]<n)
|
||||
{
|
||||
flag=false;
|
||||
for(int &j=cur[u];j!=-1;j=E[j].next)
|
||||
{
|
||||
v=E[j].v;
|
||||
if(E[j].w>0&&dis[u]==dis[v]+1)
|
||||
{
|
||||
flag=true;
|
||||
aug=min(aug,E[j].w);
|
||||
pre[v]=u;
|
||||
u=v;
|
||||
if(u==t)
|
||||
{
|
||||
ans+=aug;
|
||||
while(u!=s)
|
||||
{
|
||||
u=pre[u];
|
||||
E[cur[u]].w-=aug;
|
||||
E[cur[u]^1].w+=aug;
|
||||
}
|
||||
aug=INF;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag) continue;
|
||||
int mindis=n;
|
||||
for(i=head[u];i!=-1;i=E[i].next)
|
||||
{
|
||||
v=E[i].v;
|
||||
if(E[i].w>0&&dis[v]<mindis)
|
||||
{
|
||||
mindis=dis[v];
|
||||
cur[u]=i;
|
||||
}
|
||||
}
|
||||
if((--gap[dis[u]])==0) break;
|
||||
gap[dis[u]=mindis+1]++;
|
||||
u=pre[u];
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
bool Judge(int Ti)
|
||||
{
|
||||
int i,j,k,u,v,a,b,dx,dy;
|
||||
for(i=0;i<N;i++)
|
||||
{
|
||||
for(j=0;j<M;j++)
|
||||
{
|
||||
if(map[i][j]=='#') continue;
|
||||
u=i*M+j+1;
|
||||
a=(Ti-1)*N*M;
|
||||
b=a+N*M;
|
||||
u=a+u+1;
|
||||
for(k=0;k<5;k++)
|
||||
{
|
||||
dx=i+dir[k][0];
|
||||
dy=j+dir[k][1];
|
||||
if(dx>=0&&dx<N&&dy>=0&&dy<M&&map[dx][dy]!='#')
|
||||
{
|
||||
v=dx*M+dy+1;
|
||||
v=b+v+1;
|
||||
Insert(u,v,1);
|
||||
}
|
||||
}
|
||||
if(map[i][j]=='@')
|
||||
{
|
||||
v=b+i*M+j+2;
|
||||
Insert(v,sink,1);
|
||||
}
|
||||
}
|
||||
}
|
||||
vn+=(N*M);
|
||||
now+=(N*M);
|
||||
int t=Sap(scr,sink,vn);
|
||||
ans+=t;
|
||||
return ans==Sum;
|
||||
}
|
||||
void Solve()
|
||||
{
|
||||
if(Sum==0) {printf("0\n");return;}
|
||||
if(!OK()) {printf("-1\n");return;}
|
||||
ans=Ti=0;
|
||||
while(true)
|
||||
{
|
||||
Ti++;
|
||||
if(Judge(Ti)) break;
|
||||
}
|
||||
printf("%d\n",Ti);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
while(scanf("%d%d",&N,&M)!=EOF)
|
||||
{
|
||||
Init();
|
||||
Solve();
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
#include <cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
#include<functional>
|
||||
using namespace std;
|
||||
int a[10001][101];
|
||||
int b[10001];
|
||||
int main()
|
||||
{
|
||||
int n,m,t,i,k,j,x,d;
|
||||
while(scanf("%d%d%d",&n,&m,&t)!=EOF)
|
||||
{
|
||||
x=0;
|
||||
for(i=0;i<n;i++)
|
||||
for(j=0;j<m;j++)
|
||||
{
|
||||
scanf("%d",&a[i][j]);
|
||||
if(a[i][j]==0)
|
||||
x++;
|
||||
}
|
||||
memset(b,0,sizeof(b));
|
||||
k=0;
|
||||
for(i=1;i<n;i++)
|
||||
{
|
||||
if(a[i][0]==0&&a[i][1]==0)
|
||||
{
|
||||
for(j=m-1;j>=0;j--)
|
||||
{
|
||||
if(a[i-1][j]==0)
|
||||
b[k]++;
|
||||
else
|
||||
break;
|
||||
}
|
||||
k++;
|
||||
}
|
||||
}
|
||||
for(i=m-1;i>=0;i--)
|
||||
{
|
||||
if(a[n-1][i]==0)
|
||||
x--;
|
||||
else
|
||||
break;
|
||||
}
|
||||
sort(b,b+k,greater<int>());
|
||||
for(i=0;i<t-1;i++)
|
||||
x-=b[i];
|
||||
printf("%d\n",x-2*t);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
|
||||
,
|
||||
.
|
||||
!
|
||||
|
||||
<<
|
||||
>>
|
||||
?
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
int zsh(char s[])
|
||||
{
|
||||
int p;
|
||||
for(p=0;p<strlen(s);p++)
|
||||
{
|
||||
if(s[p]=='.')
|
||||
break;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
int pd(char s[])
|
||||
{
|
||||
int l=0,flag=0;
|
||||
for(l=0;l<strlen(s);l++)
|
||||
{
|
||||
if(s[l]=='.')
|
||||
{
|
||||
flag=1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return flag;
|
||||
}
|
||||
void add(char as[],char bs[])
|
||||
{
|
||||
int l,j,az[405]={0},bz[405]={0},c[405]={0};
|
||||
for(l=0;l<strlen(as);l++)
|
||||
{
|
||||
az[l]=as[l]-48;
|
||||
bz[l]=bs[l]-48;
|
||||
}
|
||||
for(j=0;j<l;j++)
|
||||
{
|
||||
c[j]+=az[j]+bz[j];
|
||||
if(c[j]>=10)
|
||||
{
|
||||
c[j+1]++;
|
||||
c[j]-=10;
|
||||
}
|
||||
}
|
||||
if(c[l]>0)
|
||||
l++;
|
||||
for(j=0;j<l;j++)
|
||||
{
|
||||
as[j]=c[j]+48;
|
||||
}
|
||||
as[j]='\0';
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,lz,lx;
|
||||
char a[405],b[405];
|
||||
while(scanf("%s %s",a,b)!=EOF)
|
||||
{
|
||||
int lxa,lxb;
|
||||
lxa=pd(a)>0?(strlen(a)-zsh(a)-1):0;
|
||||
lxb=pd(b)>0?(strlen(b)-zsh(b)-1):0;
|
||||
char a1[405],b1[405];
|
||||
lx=lxa>lxb?lxa:lxb;
|
||||
lz=zsh(a)>zsh(b)?zsh(a):zsh(b);
|
||||
for(i=0;i<lx+lz;i++)
|
||||
{a1[i]='0';b1[i]='0';}
|
||||
a1[lx+lz]='\0';b1[lx+lz]='\0';
|
||||
for(i=0;i<zsh(a);i++)
|
||||
a1[lx+zsh(a)-i-1]=a[i];
|
||||
for(i=zsh(a)+1;i<strlen(a);i++)
|
||||
a1[lx-i+zsh(a)]=a[i];
|
||||
for(i=0;i<zsh(b);i++)
|
||||
b1[lx+zsh(b)-i-1]=b[i];
|
||||
for(i=zsh(b)+1;i<strlen(b);i++)
|
||||
b1[lx-i+zsh(b)]=b[i];
|
||||
add(a1,b1);
|
||||
for(i=0;i<strlen(a1);i++)
|
||||
{
|
||||
if(a1[i]!='0')
|
||||
break;
|
||||
}
|
||||
for(j=strlen(a1)-1;j>=lx;j--)
|
||||
printf("%c",a1[j]);
|
||||
if(i>=lx)
|
||||
printf("\n");
|
||||
else
|
||||
{
|
||||
printf(".");
|
||||
for(;j>=i;j--)
|
||||
printf("%c",a1[j]);
|
||||
printf("\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
#include <stdio.h>
|
||||
int main()
|
||||
{
|
||||
int sc[200001],i,j,k,mx,mi,a,b,m,n;
|
||||
char t;
|
||||
while(~scanf("%d%d",&n,&m))
|
||||
{
|
||||
mx = -1;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&sc[i]);
|
||||
if(mx<sc[i])
|
||||
{
|
||||
mx = sc[i];
|
||||
mi = i;
|
||||
}
|
||||
}
|
||||
for(i=0;i<m;i++)
|
||||
{
|
||||
scanf("%*c%c%d%d",&t,&a,&b);
|
||||
if(t=='Q')
|
||||
{
|
||||
if(a<=mi&&mi<=b&&sc[mi]==mx) k=mx;
|
||||
else
|
||||
{
|
||||
k=sc[a];
|
||||
for(j=a+1;j<=b;j++)
|
||||
if(k<sc[j]) k=sc[j];
|
||||
}
|
||||
printf("%d\n",k);
|
||||
}else
|
||||
{
|
||||
sc[a]=b;
|
||||
if(b>mx)
|
||||
{
|
||||
mx = b;
|
||||
mi = a;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int a[10],n;
|
||||
int num[40320*9];
|
||||
int getnum()
|
||||
{
|
||||
int res=0,i;
|
||||
for(i=1;i<=n;i++)
|
||||
res=res*10+a[i];
|
||||
return res;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m,k,x,i,t;
|
||||
bool flag;
|
||||
while(scanf("%d%d",&n,&m)!=EOF)
|
||||
{
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&a[i]);
|
||||
sort(a+1,a+1+n);
|
||||
t=0;
|
||||
if(a[1]!=0)
|
||||
num[t++]=getnum();
|
||||
while(next_permutation(a+1,a+1+n))
|
||||
{
|
||||
if(a[1]!=0)
|
||||
num[t++]=getnum();
|
||||
}
|
||||
while(m--)
|
||||
{
|
||||
scanf("%d%d",&x,&k);
|
||||
flag=true;
|
||||
for(i=0;i<t;i++)
|
||||
{
|
||||
if((num[i]+x)%k==0)
|
||||
{
|
||||
printf("%d\n",num[i]);
|
||||
flag=false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(flag)
|
||||
printf("None\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <map>
|
||||
#include <cmath>
|
||||
#include <algorithm>
|
||||
using namespace std;
|
||||
#define esp 1e-8
|
||||
#define ISZERO(a) (fabs(a)<1e-8)
|
||||
#define ADD 1001
|
||||
int n;
|
||||
struct Point
|
||||
{
|
||||
double x,y;
|
||||
}a[110],b;
|
||||
double chac(Point q,Point w,Point e,Point r)
|
||||
{
|
||||
return (((w.x-q.x)*(e.y-q.y)-(w.y-q.y)*(e.x-q.x)) * ((w.x-q.x)*(r.y-q.y)-(w.y-q.y)*(r.x-q.x)));
|
||||
}
|
||||
bool calc()
|
||||
{
|
||||
int i=0,ans;
|
||||
double c1,c2,c3;
|
||||
Point c;
|
||||
a[n]=a[0];
|
||||
while(i<n)
|
||||
{
|
||||
c.x=rand()+ADD;
|
||||
c.y=rand()+ADD;
|
||||
for(i=ans=0;i<n;i++)
|
||||
{
|
||||
c1=chac(b,c,a[i],a[i+1]);
|
||||
c2=chac(a[i],a[i+1],b,c);
|
||||
c3=chac(a[i+1],a[i],b,c);
|
||||
if(ISZERO(c1) && ISZERO(c2) && ISZERO(c3))return true;//杩浠ユ璇杈圭广
|
||||
if(ISZERO(c1))
|
||||
{
|
||||
if(!ISZERO(c2) || !ISZERO(c3))break;
|
||||
}
|
||||
if(c1<esp && c2<esp)ans++;
|
||||
}
|
||||
}
|
||||
return ans%2;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,j,m;
|
||||
while(~scanf("%d",&n))
|
||||
{
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%lf %lf",&a[i].x,&a[i].y);
|
||||
}
|
||||
scanf("%d",&m);
|
||||
while(m--)
|
||||
{
|
||||
scanf("%lf %lf",&b.x,&b.y);
|
||||
if(calc())printf("Yes\n");
|
||||
else printf("No\n");
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#define maxn 10
|
||||
struct matrix{
|
||||
int ma[maxn][maxn];
|
||||
matrix(){memset( ma, 0, sizeof(ma) );}
|
||||
};
|
||||
int k, m;
|
||||
matrix operator * (const matrix & a,const matrix & b){
|
||||
matrix t;
|
||||
for(int h = 0; h < maxn; h ++ ){
|
||||
for(int i = 0; i < maxn; i ++ ){
|
||||
for(int j = 0; j < maxn; j ++ ){
|
||||
t.ma[h][i] += a.ma[h][j] * b.ma[j][i] % m;
|
||||
}
|
||||
t.ma[h][i] %= m;
|
||||
}
|
||||
}
|
||||
return t;
|
||||
}
|
||||
matrix binary_multiply(int n,matrix a){
|
||||
matrix t;
|
||||
if( n == 1 )
|
||||
return a;
|
||||
if( n > 1 ){
|
||||
t = binary_multiply( n>>1, a );
|
||||
t = t * t;
|
||||
}
|
||||
if( n & 1 )
|
||||
t = t * a;
|
||||
return t;
|
||||
}
|
||||
int main(){
|
||||
int i;
|
||||
matrix a, t;
|
||||
while( ~scanf("%d%d", &k, &m ) ){
|
||||
for( i = 1; i < maxn; i ++ )
|
||||
a.ma[i][i-1] = 1;
|
||||
for( i = 0; i < maxn; i ++ )
|
||||
scanf("%d", &a.ma[0][i] );
|
||||
if( k < maxn )
|
||||
printf("%d\n", k % m );
|
||||
else{
|
||||
t = binary_multiply( k-9, a );
|
||||
for( k = i = 0; i < maxn; i ++ ){
|
||||
k += t.ma[0][i] * ( maxn - i - 1 );
|
||||
k %= m;
|
||||
}
|
||||
printf("%d\n", k );
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,72 @@
|
|||
#include <cstdlib>
|
||||
#include <stdio.h>
|
||||
#include <memory.h>
|
||||
#include <iostream>
|
||||
#include <string.h>
|
||||
#include <queue>
|
||||
using namespace std;
|
||||
#define MAXN 1005
|
||||
bool reach[MAXN][MAXN];
|
||||
int map[MAXN][MAXN];
|
||||
char s[1005];
|
||||
int d[MAXN],n;
|
||||
struct pt
|
||||
{
|
||||
int d,x;
|
||||
};
|
||||
void BFS(int x)
|
||||
{
|
||||
int i,j;
|
||||
pt now,next;
|
||||
queue<pt> q;
|
||||
now.x=x;
|
||||
now.d=0;
|
||||
d[now.x]=now.d;
|
||||
q.push(now);
|
||||
while(!q.empty())
|
||||
{
|
||||
now=q.front();
|
||||
q.pop();
|
||||
if (now.d>n+2) break;
|
||||
for(i=1;i<=map[now.x][0];i++)
|
||||
{
|
||||
next.x=map[now.x][i];
|
||||
next.d=now.d+1;
|
||||
if (next.d<d[next.x])
|
||||
{
|
||||
d[next.x]=next.d;
|
||||
q.push(next);
|
||||
reach[x][next.x]=1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int m,k,i,x,y,z,j,sum;
|
||||
while(scanf("%d %d %s",&n,&m,s)!=EOF)
|
||||
{
|
||||
memset(reach,0,sizeof(reach));
|
||||
for(i=1;i<=n;i++)
|
||||
reach[i][i]=1;
|
||||
memset(map,0,sizeof(map));
|
||||
for(i=1;i<=m;i++)
|
||||
{
|
||||
scanf("%d %d %d",&x,&y,&z);
|
||||
x++;y++;
|
||||
if (z>0) {reach[x][y]=1;map[x][++map[x][0]]=y;}
|
||||
}
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
for(j=1;j<=n;j++)
|
||||
d[j]=0x1fffff;
|
||||
BFS(i);
|
||||
}
|
||||
sum=0;
|
||||
for(i=1;i<=n;i++)
|
||||
for(j=1;j<=n;j++)
|
||||
sum+=reach[i][j];
|
||||
printf("%d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<map>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
#include<stdio.h>
|
||||
using namespace std;
|
||||
map<string,int>sg;
|
||||
map<string,bool>is;
|
||||
int n,m;
|
||||
bool judge(string str,int i,int j)
|
||||
{
|
||||
if(str[i * m + j] == '1' || str[i * m + j + 1] == '1' || str[i * m + m + j] == '1' || str[i * m + m + j + 1] == '1')
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
void input(string &str,int i,int j)
|
||||
{
|
||||
str[i * m + j]=str[i * m + j + 1]=str[i * m + m + j] = str[i * m + m + j + 1] = '1';
|
||||
}
|
||||
int DFS(string str)
|
||||
{
|
||||
if(is[str])
|
||||
return sg[str];
|
||||
for(int i = 0;i < n - 1;i++)
|
||||
{
|
||||
for(int j = 0;j < m - 1;j++)
|
||||
{
|
||||
if(judge(str,i,j))
|
||||
{
|
||||
string temp = str;
|
||||
input(temp,i,j);
|
||||
if(DFS(temp) == 0)
|
||||
{
|
||||
is[str] = 1;
|
||||
sg[str] = 1;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
is[str] = 1;
|
||||
sg[str] = 0;
|
||||
return 0;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
string str;
|
||||
string temp;
|
||||
while(scanf("%d %d",&n,&m)!=EOF)
|
||||
{
|
||||
str="";
|
||||
sg.clear();
|
||||
is.clear();
|
||||
for(int i = 0;i < n;i++)
|
||||
{
|
||||
cin >> temp;
|
||||
str += temp;
|
||||
}
|
||||
if(DFS(str))
|
||||
printf("Yes\n");
|
||||
else
|
||||
printf("No\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#include <stdlib.h>
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<string>
|
||||
#include<iostream>
|
||||
#include<map>
|
||||
#include<vector>
|
||||
using namespace std;
|
||||
typedef map<string, int> STRING2MAP;
|
||||
int main()
|
||||
{
|
||||
int n, m;
|
||||
int i, j;
|
||||
int k;
|
||||
char name[25], like[25], hate[25], go[25];
|
||||
map<string, STRING2MAP> t_map;
|
||||
map<string, STRING2MAP>::iterator it_t;
|
||||
map<string, bool> t_now;
|
||||
map<string, bool>::iterator it_n;
|
||||
STRING2MAP::iterator it_f;
|
||||
STRING2MAP S2M;
|
||||
string t_add[101], t_remove[101];
|
||||
int p_add, p_remove;
|
||||
int h, l;
|
||||
int geted;
|
||||
while (scanf("%d%d", &n, &m) != EOF)
|
||||
{
|
||||
t_map.clear();
|
||||
t_now.clear();
|
||||
for (i=0; i < n; i++)
|
||||
{
|
||||
scanf("%s", name);
|
||||
scanf("%d", &k);
|
||||
t_map[name] = S2M;
|
||||
it_t = t_map.find(name);
|
||||
for (j=0; j < k; j++)
|
||||
{
|
||||
scanf("%s", like);
|
||||
it_t->second.insert(STRING2MAP::value_type(like, 1));
|
||||
}
|
||||
scanf("%d", &k);
|
||||
for (j=0; j < k; j++)
|
||||
{
|
||||
scanf("%s", hate);
|
||||
it_t->second.insert(STRING2MAP::value_type(hate, 2));
|
||||
}
|
||||
}
|
||||
scanf("%d", &k);
|
||||
for (j=0; j < k; j++)
|
||||
{
|
||||
scanf("%s", go);
|
||||
t_now[go] = true;
|
||||
}
|
||||
for (i=0; i<m; i++)
|
||||
{
|
||||
p_add = 0;
|
||||
p_remove = 0;
|
||||
it_t=t_map.begin();
|
||||
for (; it_t != t_map.end(); it_t++)
|
||||
{
|
||||
it_n=t_now.begin();
|
||||
l=h=0;
|
||||
for (; it_n != t_now.end(); it_n++)
|
||||
{
|
||||
it_f = it_t->second.find(it_n->first);
|
||||
if (it_f != it_t->second.end())
|
||||
{
|
||||
geted = it_f->second;
|
||||
if (geted & 1) l++;
|
||||
if (geted & 1<<1) h++;
|
||||
if (l>0 && h>0) break;
|
||||
}
|
||||
}
|
||||
if (h == 0 && l > 0)
|
||||
t_add[p_add++] = it_t->first;
|
||||
if (h > 0 && l == 0)
|
||||
t_remove[p_remove++] = it_t->first;
|
||||
}
|
||||
if (p_remove == 0 && p_add == 0)
|
||||
break;
|
||||
for (j=0; j < p_remove; j++)
|
||||
t_now.erase(t_remove[j]);
|
||||
for (j=0; j <p_add; j++)
|
||||
t_now.insert(make_pair(t_add[j], true));
|
||||
}
|
||||
if (t_now.empty())
|
||||
{
|
||||
printf("None\n");
|
||||
continue;
|
||||
}
|
||||
it_n=t_now.begin();
|
||||
cout<< it_n->first;
|
||||
it_n++;
|
||||
for (; it_n != t_now.end(); it_n++)
|
||||
cout << " " << it_n->first;
|
||||
cout << endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#include<stdio.h>
|
||||
#include<algorithm>
|
||||
#include<math.h>
|
||||
#include<iostream>
|
||||
#include<string.h>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int m;
|
||||
int n,v;
|
||||
while(scanf("%d %d",&n,&v),n,v)
|
||||
{
|
||||
int i;
|
||||
m=0;
|
||||
int a;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
scanf("%d",&a);
|
||||
m=max(a,m);
|
||||
}
|
||||
printf("%.0lf\n",ceil(double(v)/m)*3);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#include <stdio.h>
|
||||
using namespace std;
|
||||
#define N 100000001
|
||||
int euler(int n)
|
||||
{
|
||||
int ans=1;
|
||||
int i;
|
||||
for(i=2;i*i<=n;i++)
|
||||
{
|
||||
if(n%i==0)
|
||||
{
|
||||
n/=i;
|
||||
ans*=i-1;
|
||||
while(n%i==0)
|
||||
{
|
||||
n/=i;
|
||||
ans*=i;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(n>1)
|
||||
ans*=n-1;
|
||||
return ans;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int n;
|
||||
while(scanf("%d",&n),n)
|
||||
{
|
||||
printf("%d\n",n-1-euler(n));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include<iostream>
|
||||
using namespace std;
|
||||
__int64 gcd(__int64 x,__int64 y)
|
||||
{
|
||||
if(x<y)
|
||||
{
|
||||
__int64 t=x;x=y;y=t;
|
||||
}
|
||||
while(y!=0)
|
||||
{
|
||||
__int64 t=x;
|
||||
x=y;
|
||||
y=t%y;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
__int64 work(__int64 x,__int64 y)
|
||||
{
|
||||
return x/gcd(x,y)*y;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
__int64 n,a;
|
||||
while(cin>>n>>a&&(n||a))
|
||||
{
|
||||
__int64 u,v;
|
||||
cin>>u;
|
||||
for(int i=1;i<n;i++)
|
||||
{
|
||||
cin>>v;
|
||||
u=work(u,v);
|
||||
}
|
||||
cout<<u-a<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,52 @@
|
|||
#include<iostream>
|
||||
#include<cstdio>
|
||||
#include<algorithm>
|
||||
#include<cstring>
|
||||
using namespace std;
|
||||
struct Work
|
||||
{
|
||||
int deadline;
|
||||
int score;
|
||||
}x[1002];
|
||||
bool cmp(Work a,Work b)
|
||||
{
|
||||
if(a.score==b.score)
|
||||
return a.deadline<b.deadline;
|
||||
return a.score>b.score;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int t,n,i,j,sum;
|
||||
bool a[10002];
|
||||
cin>>t;
|
||||
while(t--)
|
||||
{
|
||||
sum=0;
|
||||
cin>>n;
|
||||
for(i=0;i<n;++i)
|
||||
scanf("%d",&x[i].deadline);
|
||||
for(i=0;i<n;++i)
|
||||
scanf("%d",&x[i].score);
|
||||
sort(x,x+n,cmp);
|
||||
memset(a,0,sizeof(a));
|
||||
for(i=0;i<n;++i)
|
||||
if(!a[x[i].deadline])
|
||||
{
|
||||
a[x[i].deadline]=true;
|
||||
continue;
|
||||
}
|
||||
else
|
||||
{
|
||||
for(j=x[i].deadline-1;j>=1;--j)
|
||||
if(!a[j])
|
||||
{
|
||||
a[j]=true;
|
||||
break;
|
||||
}
|
||||
if(j==0)
|
||||
sum+=x[i].score;
|
||||
}
|
||||
printf("%d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#include <iostream>
|
||||
using namespace std;
|
||||
int main()
|
||||
{
|
||||
int n,m,s,k;
|
||||
while(cin>>n>>m)
|
||||
{
|
||||
s=n*m-n-m;
|
||||
cout<<s<<" "<<(n-1)*(m-1)/2<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#include<iostream>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
#define N 1010
|
||||
#define inf 0xfffffff
|
||||
int dp[N][N];
|
||||
int s[N][N];
|
||||
int sum[N],dia[N];
|
||||
int main(){
|
||||
int i,n,j,k,pos;
|
||||
while(scanf("%d",&n)!=EOF)
|
||||
{
|
||||
sum[0]=0;
|
||||
for(i=0;i<=n+1;i++)
|
||||
for(j=0;j<=n+1;j++)
|
||||
dp[i][j]=inf;
|
||||
for(i=1;i<=n;i++)
|
||||
scanf("%d",&pos);
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&dia[i]);
|
||||
sum[i]=sum[i-1]+dia[i];
|
||||
dp[i][i]=0;
|
||||
s[i][i]=i;
|
||||
}
|
||||
int des;
|
||||
for(k=2;k<=n;k++)
|
||||
{
|
||||
for(i=1;i+k-1<=n;i++)
|
||||
{
|
||||
des=i+k-1;
|
||||
for(j=s[i][des-1];j<=s[i+1][des];j++)
|
||||
{
|
||||
if(j==i)
|
||||
{
|
||||
if(dp[i][des]>=dp[j+1][des]+sum[des]-sum[j])
|
||||
{
|
||||
dp[i][des]=dp[j+1][des]+sum[des]-sum[j];
|
||||
s[i][des]=j;
|
||||
}
|
||||
}
|
||||
else if(j==des)
|
||||
{
|
||||
if(dp[i][des]>=dp[i][j-1]+sum[j-1]-sum[i-1])
|
||||
{
|
||||
dp[i][des]=dp[i][j-1]+sum[j-1]-sum[i-1];
|
||||
s[i][des]=j;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(dp[i][des]>=dp[i][j-1]+dp[j+1][des]+sum[j-1]-sum[i-1]+sum[des]-sum[j])
|
||||
{
|
||||
dp[i][des]=dp[i][j-1]+dp[j+1][des]+sum[j-1]-sum[i-1]+sum[des]-sum[j];
|
||||
s[i][des]=j;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
cout<<dp[1][n]<<endl;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,97 @@
|
|||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
int map[31][31],a[10010];
|
||||
struct op
|
||||
{
|
||||
int num,count;
|
||||
}p[31][31];
|
||||
struct ed
|
||||
{
|
||||
int x,y,cnt;
|
||||
}e[1000];
|
||||
int cmp(const void *a,const void *b)
|
||||
{
|
||||
return *(int *)b-*(int *)a;
|
||||
}
|
||||
int amp(const void *a,const void *b)
|
||||
{
|
||||
struct ed *c,*d;
|
||||
c=(ed *)a;
|
||||
d=(ed *)b;
|
||||
return d->cnt-c->cnt;
|
||||
}
|
||||
int MAX(int a,int b)
|
||||
{
|
||||
if(a>b)return a;
|
||||
return b;
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i,n,j,k,t,x,y,temp,m;
|
||||
__int64 sum;
|
||||
scanf("%d",&t);
|
||||
while(t--)
|
||||
{
|
||||
sum=0;
|
||||
scanf("%d",&n);
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
{
|
||||
scanf("%d",&map[i][j]);
|
||||
p[i][j].num=n-MAX(i,j);
|
||||
p[i][j].count=p[i][j].num;
|
||||
}
|
||||
}
|
||||
scanf("%d",&m);
|
||||
for(i=0;i<m;i++)
|
||||
scanf("%d",&a[i]);
|
||||
qsort(a,m,sizeof(a[0]),cmp);
|
||||
for(i=0;i<n-1;i++)
|
||||
{
|
||||
for(j=0;j<n-1;j++)
|
||||
{
|
||||
x=i+1;y=j+1;temp=1;
|
||||
while(x<n&&y<n)
|
||||
{
|
||||
p[x][y].count+=p[i][j].num-temp;
|
||||
k=x-1;
|
||||
while(k>=i)
|
||||
{
|
||||
p[k][y].count+=p[i][j].num-temp;
|
||||
k--;
|
||||
}
|
||||
k=y-1;
|
||||
while(k>=j)
|
||||
{
|
||||
p[x][k].count+=p[i][j].num-temp;
|
||||
k--;
|
||||
}
|
||||
x++;y++;
|
||||
temp++;
|
||||
}
|
||||
}
|
||||
}
|
||||
k=0;
|
||||
for(i=0;i<n;i++)
|
||||
{
|
||||
for(j=0;j<n;j++)
|
||||
if(map[i][j]==0)
|
||||
{
|
||||
e[k].x=i;
|
||||
e[k].y=j;
|
||||
e[k++].cnt=p[i][j].count;
|
||||
}
|
||||
}
|
||||
qsort(e,k,sizeof(e[0]),amp);
|
||||
for(i=0;i<k;i++)
|
||||
{
|
||||
x=e[i].x;
|
||||
y=e[i].y;
|
||||
sum+=p[x][y].count*a[i];
|
||||
}
|
||||
printf("%I64d\n",sum);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because one or more lines are too long
|
|
@ -0,0 +1,50 @@
|
|||
#include<cstdio>
|
||||
#include<cstring>
|
||||
#include<algorithm>
|
||||
using namespace std;
|
||||
int a[15];
|
||||
int n,m;
|
||||
int gcd(int a,int b)
|
||||
{
|
||||
if(!b)
|
||||
return a;
|
||||
else
|
||||
return gcd(b,a%b);
|
||||
}
|
||||
int ans;
|
||||
int kk;
|
||||
void dfs(int val,int s,int k,int cnt)
|
||||
{
|
||||
if(cnt>k)
|
||||
return;
|
||||
if(k==cnt)
|
||||
{
|
||||
if(cnt%2)
|
||||
ans+=m/val;
|
||||
else
|
||||
ans-=m/val;
|
||||
return;
|
||||
}
|
||||
for(int i=s+1;i<=kk;i++)
|
||||
dfs(val/gcd(a[i],val)*a[i],i,k,cnt+1);
|
||||
}
|
||||
int main()
|
||||
{
|
||||
int i;
|
||||
while(scanf("%d%d",&m,&n)!=EOF)
|
||||
{
|
||||
m--;
|
||||
kk=0;
|
||||
for(i=1;i<=n;i++)
|
||||
{
|
||||
scanf("%d",&a[i]);
|
||||
if(a[i])
|
||||
a[++kk]=a[i];
|
||||
}
|
||||
ans=0;
|
||||
for(i=1;i<=kk;i++)
|
||||
dfs(1,0,i,0);
|
||||
printf("%d\n",ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#include<cstdio>
|
||||
#include<cmath>
|
||||
#include<algorithm>
|
||||
#include<iostream>
|
||||
using namespace std;
|
||||
struct circle
|
||||
{
|
||||
double x,y,r;
|
||||
};
|
||||
double dist(circle a,circle b)
|
||||
{
|
||||
return sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));
|
||||
}
|
||||
int main()
|
||||
{
|
||||
circle a,b;
|
||||
double d,p,area,sb,sa;
|
||||
while(scanf("%lf%lf%lf%lf%lf%lf",&a.x,&a.y,&a.r,&b.x,&b.y,&b.r)!=EOF)
|
||||
{
|
||||
d=dist(a,b);
|
||||
double rr=min(a.r,b.r);
|
||||
if(d<=abs(a.r-b.r))
|
||||
area=acos(-1.0)*rr*rr;
|
||||
else
|
||||
if(d>=a.r+b.r)
|
||||
area=0.0;
|
||||
else{
|
||||
p=(a.r+b.r+d)/2.0;
|
||||
sa=acos((a.r*a.r+d*d-b.r*b.r)/(2.0*a.r*d));
|
||||
sb=acos((b.r*b.r+d*d-a.r*a.r)/(2.0*b.r*d));
|
||||
area=sa*a.r*a.r+sb*b.r*b.r-2*sqrt(p*(p-a.r)*(p-b.r)*(p-d));
|
||||
}
|
||||
printf("%.3lf\n",area);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#include<stdio.h>
|
||||
#define MAXN 2000+10
|
||||
int a[MAXN][MAXN]={0};
|
||||
int main()
|
||||
{
|
||||
int T,i,j;
|
||||
for(i=0;i<MAXN;i++)
|
||||
{
|
||||
a[i][i]=1;
|
||||
a[i][1]=i%1007;
|
||||
}
|
||||
for(i=2;i<MAXN;i++)
|
||||
for(j=1;j<i;j++)
|
||||
a[i][j]=(a[i-1][j-1]+a[i-1][j])%1007;
|
||||
scanf("%d",&T);
|
||||
while(T--)
|
||||
{
|
||||
int m,n;
|
||||
scanf("%d%d",&m,&n);
|
||||
printf("%d\n",a[n+1][m+1]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue